Merge remote-tracking branch 'origin/master' into llvm7

1 files changed, 494 insertions, 20 deletions

diff --git a/std/debug/index.zig b/std/debug/index.zig
index 39c41d4bc1..8db7c75d2c 100644
--- a/std/debug/index.zig
+++ b/std/debug/index.zig
@@ -4,8 +4,11 @@ const mem = std.mem;
 const io = std.io;
 const os = std.os;
 const elf = std.elf;
-const macho = std.macho;
 const DW = std.dwarf;
+const macho = std.macho;
+const coff = std.coff;
+const pdb = std.pdb;
+const windows = os.windows;
 const ArrayList = std.ArrayList;
 const builtin = @import("builtin");
 
@@ -17,6 +20,17 @@ pub const runtime_safety = switch (builtin.mode) {
     builtin.Mode.ReleaseFast, builtin.Mode.ReleaseSmall => false,
 };
 
+const Module = struct {
+    mod_info: pdb.ModInfo,
+    module_name: []u8,
+    obj_file_name: []u8,
+
+    populated: bool,
+    symbols: []u8,
+    subsect_info: []u8,
+    checksum_offset: ?usize,
+};
+
 /// Tries to write to stderr, unbuffered, and ignores any error returned.
 /// Does not append a newline.
 var stderr_file: os.File = undefined;
@@ -37,7 +51,7 @@ pub fn getStderrStream() !*io.OutStream(io.FileOutStream.Error) {
         return st;
     } else {
         stderr_file = try io.getStdErr();
-        stderr_file_out_stream = io.FileOutStream.init(&stderr_file);
+        stderr_file_out_stream = io.FileOutStream.init(stderr_file);
         const st = &stderr_file_out_stream.stream;
         stderr_stream = st;
         return st;
@@ -70,7 +84,7 @@ pub fn dumpCurrentStackTrace(start_addr: ?usize) void {
         stderr.print("Unable to dump stack trace: Unable to open debug info: {}\n", @errorName(err)) catch return;
         return;
     };
-    writeCurrentStackTrace(stderr, getDebugInfoAllocator(), debug_info, wantTtyColor(), start_addr) catch |err| {
+    writeCurrentStackTrace(stderr, debug_info, wantTtyColor(), start_addr) catch |err| {
         stderr.print("Unable to dump stack trace: {}\n", @errorName(err)) catch return;
         return;
     };
@@ -191,7 +205,11 @@ pub inline fn getReturnAddress(frame_count: usize) usize {
     return @intToPtr(*const usize, fp + @sizeOf(usize)).*;
 }
 
-pub fn writeCurrentStackTrace(out_stream: var, allocator: *mem.Allocator, debug_info: *DebugInfo, tty_color: bool, start_addr: ?usize) !void {
+pub fn writeCurrentStackTrace(out_stream: var, debug_info: *DebugInfo, tty_color: bool, start_addr: ?usize) !void {
+    switch (builtin.os) {
+        builtin.Os.windows => return writeCurrentStackTraceWindows(out_stream, debug_info, tty_color, start_addr),
+        else => {},
+    }
     const AddressState = union(enum) {
         NotLookingForStartAddress,
         LookingForStartAddress: usize,
@@ -224,18 +242,296 @@ pub fn writeCurrentStackTrace(out_stream: var, allocator: *mem.Allocator, debug_
     }
 }
 
+pub fn writeCurrentStackTraceWindows(out_stream: var, debug_info: *DebugInfo,
+    tty_color: bool, start_addr: ?usize) !void
+{
+    var addr_buf: [1024]usize = undefined;
+    const casted_len = @intCast(u32, addr_buf.len); // TODO shouldn't need this cast
+    const n = windows.RtlCaptureStackBackTrace(0, casted_len, @ptrCast(**c_void, &addr_buf), null);
+    const addrs = addr_buf[0..n];
+    var start_i: usize = if (start_addr) |saddr| blk: {
+        for (addrs) |addr, i| {
+            if (addr == saddr) break :blk i;
+        }
+        return;
+    } else 0;
+    for (addrs[start_i..]) |addr| {
+        try printSourceAtAddress(debug_info, out_stream, addr, tty_color);
+    }
+}
+
 pub fn printSourceAtAddress(debug_info: *DebugInfo, out_stream: var, address: usize, tty_color: bool) !void {
     switch (builtin.os) {
         builtin.Os.macosx => return printSourceAtAddressMacOs(debug_info, out_stream, address, tty_color),
         builtin.Os.linux => return printSourceAtAddressLinux(debug_info, out_stream, address, tty_color),
-        builtin.Os.windows => {
-            // TODO https://github.com/ziglang/zig/issues/721
-            return error.UnsupportedOperatingSystem;
-        },
+        builtin.Os.windows => return printSourceAtAddressWindows(debug_info, out_stream, address, tty_color),
         else => return error.UnsupportedOperatingSystem,
     }
 }
 
+fn printSourceAtAddressWindows(di: *DebugInfo, out_stream: var, relocated_address: usize, tty_color: bool) !void {
+    const allocator = getDebugInfoAllocator();
+    const base_address = os.getBaseAddress();
+    const relative_address = relocated_address - base_address;
+
+    var coff_section: *coff.Section = undefined;
+    const mod_index = for (di.sect_contribs) |sect_contrib| {
+        if (sect_contrib.Section >= di.coff.sections.len) continue;
+        coff_section = &di.coff.sections.toSlice()[sect_contrib.Section];
+
+        const vaddr_start = coff_section.header.virtual_address + sect_contrib.Offset;
+        const vaddr_end = vaddr_start + sect_contrib.Size;
+        if (relative_address >= vaddr_start and relative_address < vaddr_end) {
+            break sect_contrib.ModuleIndex;
+        }
+    } else {
+        // we have no information to add to the address
+        if (tty_color) {
+            try out_stream.print("???:?:?: ");
+            setTtyColor(TtyColor.Dim);
+            try out_stream.print("0x{x} in ??? (???)", relocated_address);
+            setTtyColor(TtyColor.Reset);
+            try out_stream.print("\n\n\n");
+        } else {
+            try out_stream.print("???:?:?: 0x{x} in ??? (???)\n\n\n", relocated_address);
+        }
+        return;
+    };
+
+    const mod = &di.modules[mod_index];
+    try populateModule(di, mod);
+    const obj_basename = os.path.basename(mod.obj_file_name);
+
+    var symbol_i: usize = 0;
+    const symbol_name = while (symbol_i != mod.symbols.len) {
+        const prefix = @ptrCast(*pdb.RecordPrefix, &mod.symbols[symbol_i]);
+        if (prefix.RecordLen < 2)
+            return error.InvalidDebugInfo;
+        switch (prefix.RecordKind) {
+            pdb.SymbolKind.S_LPROC32 => {
+                const proc_sym = @ptrCast(*pdb.ProcSym, &mod.symbols[symbol_i + @sizeOf(pdb.RecordPrefix)]);
+                const vaddr_start = coff_section.header.virtual_address + proc_sym.CodeOffset;
+                const vaddr_end = vaddr_start + proc_sym.CodeSize;
+                if (relative_address >= vaddr_start and relative_address < vaddr_end) {
+                    break mem.toSliceConst(u8, @ptrCast([*]u8, proc_sym) + @sizeOf(pdb.ProcSym));
+                }
+            },
+            else => {},
+        }
+        symbol_i += prefix.RecordLen + @sizeOf(u16);
+        if (symbol_i > mod.symbols.len)
+            return error.InvalidDebugInfo;
+    } else "???";
+
+    const subsect_info = mod.subsect_info;
+
+    var sect_offset: usize = 0;
+    var skip_len: usize = undefined;
+    const opt_line_info = subsections: {
+        const checksum_offset = mod.checksum_offset orelse break :subsections null;
+        while (sect_offset != subsect_info.len) : (sect_offset += skip_len) {
+            const subsect_hdr = @ptrCast(*pdb.DebugSubsectionHeader, &subsect_info[sect_offset]);
+            skip_len = subsect_hdr.Length;
+            sect_offset += @sizeOf(pdb.DebugSubsectionHeader);
+
+            switch (subsect_hdr.Kind) {
+                pdb.DebugSubsectionKind.Lines => {
+                    var line_index: usize = sect_offset;
+
+                    const line_hdr = @ptrCast(*pdb.LineFragmentHeader, &subsect_info[line_index]);
+                    if (line_hdr.RelocSegment == 0) return error.MissingDebugInfo;
+                    line_index += @sizeOf(pdb.LineFragmentHeader);
+
+                    const block_hdr = @ptrCast(*pdb.LineBlockFragmentHeader, &subsect_info[line_index]);
+                    line_index += @sizeOf(pdb.LineBlockFragmentHeader);
+
+                    const has_column = line_hdr.Flags.LF_HaveColumns;
+
+                    const frag_vaddr_start = coff_section.header.virtual_address + line_hdr.RelocOffset;
+                    const frag_vaddr_end = frag_vaddr_start + line_hdr.CodeSize;
+                    if (relative_address >= frag_vaddr_start and relative_address < frag_vaddr_end) {
+                        var line_i: usize = 0;
+                        const start_line_index = line_index;
+                        while (line_i < block_hdr.NumLines) : (line_i += 1) {
+                            const line_num_entry = @ptrCast(*pdb.LineNumberEntry, &subsect_info[line_index]);
+                            line_index += @sizeOf(pdb.LineNumberEntry);
+                            const flags = @ptrCast(*pdb.LineNumberEntry.Flags, &line_num_entry.Flags);
+                            const vaddr_start = frag_vaddr_start + line_num_entry.Offset;
+                            const vaddr_end = if (flags.End == 0) frag_vaddr_end else vaddr_start + flags.End;
+                            if (relative_address >= vaddr_start and relative_address < vaddr_end) {
+                                const subsect_index = checksum_offset + block_hdr.NameIndex;
+                                const chksum_hdr = @ptrCast(*pdb.FileChecksumEntryHeader, &mod.subsect_info[subsect_index]);
+                                const strtab_offset = @sizeOf(pdb.PDBStringTableHeader) + chksum_hdr.FileNameOffset;
+                                try di.pdb.string_table.seekTo(strtab_offset);
+                                const source_file_name = try di.pdb.string_table.readNullTermString(allocator);
+                                const line = flags.Start;
+                                const column = if (has_column) blk: {
+                                    line_index = start_line_index + @sizeOf(pdb.LineNumberEntry) * block_hdr.NumLines;
+                                    line_index += @sizeOf(pdb.ColumnNumberEntry) * line_i;
+                                    const col_num_entry = @ptrCast(*pdb.ColumnNumberEntry, &subsect_info[line_index]);
+                                    break :blk col_num_entry.StartColumn;
+                                } else 0;
+                                break :subsections LineInfo{
+                                    .allocator = allocator,
+                                    .file_name = source_file_name,
+                                    .line = line,
+                                    .column = column,
+                                };
+                            }
+                        }
+                        break :subsections null;
+                    }
+                },
+                else => {},
+            }
+
+            if (sect_offset > subsect_info.len)
+                return error.InvalidDebugInfo;
+        } else {
+            break :subsections null;
+        }
+    };
+    
+    if (tty_color) {
+        setTtyColor(TtyColor.White);
+        if (opt_line_info) |li| {
+            try out_stream.print("{}:{}:{}", li.file_name, li.line, li.column);
+        } else {
+            try out_stream.print("???:?:?");
+        }
+        setTtyColor(TtyColor.Reset);
+        try out_stream.print(": ");
+        setTtyColor(TtyColor.Dim);
+        try out_stream.print("0x{x} in {} ({})", relocated_address, symbol_name, obj_basename);
+        setTtyColor(TtyColor.Reset);
+
+        if (opt_line_info) |line_info| {
+            try out_stream.print("\n");
+            if (printLineFromFile(out_stream, line_info)) {
+                if (line_info.column == 0) {
+                    try out_stream.write("\n");
+                } else {
+                    {
+                        var col_i: usize = 1;
+                        while (col_i < line_info.column) : (col_i += 1) {
+                            try out_stream.writeByte(' ');
+                        }
+                    }
+                    setTtyColor(TtyColor.Green);
+                    try out_stream.write("^");
+                    setTtyColor(TtyColor.Reset);
+                    try out_stream.write("\n");
+                }
+            } else |err| switch (err) {
+                error.EndOfFile => {},
+                else => return err,
+            }
+        } else {
+            try out_stream.print("\n\n\n");
+        }
+    } else {
+        if (opt_line_info) |li| {
+            try out_stream.print("{}:{}:{}: 0x{x} in {} ({})\n\n\n", li.file_name, li.line, li.column, relocated_address, symbol_name, obj_basename);
+        } else {
+            try out_stream.print("???:?:?: 0x{x} in {} ({})\n\n\n", relocated_address, symbol_name, obj_basename);
+        }
+    }
+}
+
+const TtyColor = enum{
+    Red,
+    Green,
+    Cyan,
+    White,
+    Dim,
+    Bold,
+    Reset,
+};
+
+/// TODO this is a special case hack right now. clean it up and maybe make it part of std.fmt
+fn setTtyColor(tty_color: TtyColor) void {
+    const S = struct {
+        var attrs: windows.WORD = undefined;
+        var init_attrs = false;
+    };
+    if (!S.init_attrs) {
+        S.init_attrs = true;
+        var info: windows.CONSOLE_SCREEN_BUFFER_INFO = undefined;
+        // TODO handle error
+        _ = windows.GetConsoleScreenBufferInfo(stderr_file.handle, &info);
+        S.attrs = info.wAttributes;
+    }
+
+    // TODO handle errors
+    switch (tty_color) {
+        TtyColor.Red => {
+            _ = windows.SetConsoleTextAttribute(stderr_file.handle, windows.FOREGROUND_RED|windows.FOREGROUND_INTENSITY);
+        },
+        TtyColor.Green => {
+            _ = windows.SetConsoleTextAttribute(stderr_file.handle, windows.FOREGROUND_GREEN|windows.FOREGROUND_INTENSITY);
+        },
+        TtyColor.Cyan => {
+            _ = windows.SetConsoleTextAttribute(stderr_file.handle,
+                windows.FOREGROUND_GREEN|windows.FOREGROUND_BLUE|windows.FOREGROUND_INTENSITY);
+        },
+        TtyColor.White, TtyColor.Bold => {
+            _ = windows.SetConsoleTextAttribute(stderr_file.handle,
+                windows.FOREGROUND_RED|windows.FOREGROUND_GREEN|windows.FOREGROUND_BLUE|windows.FOREGROUND_INTENSITY);
+        },
+        TtyColor.Dim => {
+            _ = windows.SetConsoleTextAttribute(stderr_file.handle, windows.FOREGROUND_INTENSITY);
+        },
+        TtyColor.Reset => {
+            _ = windows.SetConsoleTextAttribute(stderr_file.handle, S.attrs);
+        },
+    }
+}
+
+fn populateModule(di: *DebugInfo, mod: *Module) !void {
+    if (mod.populated)
+        return;
+    const allocator = getDebugInfoAllocator();
+
+    if (mod.mod_info.C11ByteSize != 0)
+        return error.InvalidDebugInfo;
+
+    if (mod.mod_info.C13ByteSize == 0)
+        return error.MissingDebugInfo;
+
+    const modi = di.pdb.getStreamById(mod.mod_info.ModuleSymStream) orelse return error.MissingDebugInfo;
+
+    const signature = try modi.stream.readIntLe(u32);
+    if (signature != 4)
+        return error.InvalidDebugInfo;
+
+    mod.symbols = try allocator.alloc(u8, mod.mod_info.SymByteSize - 4);
+    try modi.stream.readNoEof(mod.symbols);
+
+    mod.subsect_info = try allocator.alloc(u8, mod.mod_info.C13ByteSize);
+    try modi.stream.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 = @ptrCast(*pdb.DebugSubsectionHeader, &mod.subsect_info[sect_offset]);
+        skip_len = subsect_hdr.Length;
+        sect_offset += @sizeOf(pdb.DebugSubsectionHeader);
+
+        switch (subsect_hdr.Kind) {
+            pdb.DebugSubsectionKind.FileChecksums => {
+                mod.checksum_offset = sect_offset;
+                break;
+            },
+            else => {},
+        }
+
+        if (sect_offset > mod.subsect_info.len)
+            return error.InvalidDebugInfo;
+    }
+
+    mod.populated = true;
+}
+
 fn machoSearchSymbols(symbols: []const MachoSymbol, address: usize) ?*const MachoSymbol {
     var min: usize = 0;
     var max: usize = symbols.len - 1; // Exclude sentinel.
@@ -372,14 +668,185 @@ pub fn openSelfDebugInfo(allocator: *mem.Allocator) !DebugInfo {
     switch (builtin.os) {
         builtin.Os.linux => return openSelfDebugInfoLinux(allocator),
         builtin.Os.macosx, builtin.Os.ios => return openSelfDebugInfoMacOs(allocator),
-        builtin.Os.windows => {
-            // TODO: https://github.com/ziglang/zig/issues/721
-            return error.UnsupportedOperatingSystem;
-        },
+        builtin.Os.windows => return openSelfDebugInfoWindows(allocator),
         else => return error.UnsupportedOperatingSystem,
     }
 }
 
+fn openSelfDebugInfoWindows(allocator: *mem.Allocator) !DebugInfo {
+    const self_file = try os.openSelfExe();
+    defer self_file.close();
+
+    const coff_obj = try allocator.createOne(coff.Coff);
+    coff_obj.* = coff.Coff{
+        .in_file = self_file,
+        .allocator = allocator,
+        .coff_header = undefined,
+        .pe_header = undefined,
+        .sections = undefined,
+        .guid = undefined,
+        .age = undefined,
+    };
+
+    var di = DebugInfo{
+        .coff = coff_obj,
+        .pdb = undefined,
+        .sect_contribs = undefined,
+        .modules = undefined,
+    };
+
+    try di.coff.loadHeader();
+
+    var path_buf: [windows.MAX_PATH]u8 = undefined;
+    const len = try di.coff.getPdbPath(path_buf[0..]);
+    const raw_path = path_buf[0..len];
+
+    const path = try os.path.resolve(allocator, raw_path);
+
+    try di.pdb.openFile(di.coff, path);
+
+    var pdb_stream = di.pdb.getStream(pdb.StreamType.Pdb) orelse return error.InvalidDebugInfo;
+    const version = try pdb_stream.stream.readIntLe(u32);
+    const signature = try pdb_stream.stream.readIntLe(u32);
+    const age = try pdb_stream.stream.readIntLe(u32);
+    var guid: [16]u8 = undefined;
+    try pdb_stream.stream.readNoEof(guid[0..]);
+    if (!mem.eql(u8, di.coff.guid, guid) or di.coff.age != age)
+        return error.InvalidDebugInfo;
+    // We validated the executable and pdb match.
+
+    const string_table_index = str_tab_index: {
+        const name_bytes_len = try pdb_stream.stream.readIntLe(u32);
+        const name_bytes = try allocator.alloc(u8, name_bytes_len);
+        try pdb_stream.stream.readNoEof(name_bytes);
+
+        const HashTableHeader = packed struct {
+            Size: u32,
+            Capacity: u32,
+
+            fn maxLoad(cap: u32) u32 {
+                return cap * 2 / 3 + 1;
+            }
+        };
+        var hash_tbl_hdr: HashTableHeader = undefined;
+        try pdb_stream.stream.readStruct(HashTableHeader, &hash_tbl_hdr);
+        if (hash_tbl_hdr.Capacity == 0)
+            return error.InvalidDebugInfo;
+
+        if (hash_tbl_hdr.Size > HashTableHeader.maxLoad(hash_tbl_hdr.Capacity))
+            return error.InvalidDebugInfo;
+
+        const present = try readSparseBitVector(&pdb_stream.stream, allocator);
+        if (present.len != hash_tbl_hdr.Size)
+            return error.InvalidDebugInfo;
+        const deleted = try readSparseBitVector(&pdb_stream.stream, allocator);
+
+        const Bucket = struct {
+            first: u32,
+            second: u32,
+        };
+        const bucket_list = try allocator.alloc(Bucket, present.len);
+        for (present) |_| {
+            const name_offset = try pdb_stream.stream.readIntLe(u32);
+            const name_index = try pdb_stream.stream.readIntLe(u32);
+            const name = mem.toSlice(u8, name_bytes.ptr + name_offset);
+            if (mem.eql(u8, name, "/names")) {
+                break :str_tab_index name_index;
+            }
+        }
+        return error.MissingDebugInfo;
+    };
+
+    di.pdb.string_table = di.pdb.getStreamById(string_table_index) orelse return error.InvalidDebugInfo;
+    di.pdb.dbi = di.pdb.getStream(pdb.StreamType.Dbi) orelse return error.MissingDebugInfo;
+
+    const dbi = di.pdb.dbi;
+
+    // Dbi Header
+    var dbi_stream_header: pdb.DbiStreamHeader = undefined;
+    try dbi.stream.readStruct(pdb.DbiStreamHeader, &dbi_stream_header);
+    const mod_info_size = dbi_stream_header.ModInfoSize;
+    const section_contrib_size = dbi_stream_header.SectionContributionSize;
+
+    var modules = ArrayList(Module).init(allocator);
+
+    // Module Info Substream
+    var mod_info_offset: usize = 0;
+    while (mod_info_offset != mod_info_size) {
+        var mod_info: pdb.ModInfo = undefined;
+        try dbi.stream.readStruct(pdb.ModInfo, &mod_info);
+        var this_record_len: usize = @sizeOf(pdb.ModInfo);
+
+        const module_name = try dbi.readNullTermString(allocator);
+        this_record_len += module_name.len + 1;
+
+        const obj_file_name = try dbi.readNullTermString(allocator);
+        this_record_len += obj_file_name.len + 1;
+
+        const march_forward_bytes = this_record_len % 4;
+        if (march_forward_bytes != 0) {
+            try dbi.seekForward(march_forward_bytes);
+            this_record_len += march_forward_bytes;
+        }
+
+        try modules.append(Module{
+            .mod_info = mod_info,
+            .module_name = module_name,
+            .obj_file_name = obj_file_name,
+
+            .populated = false,
+            .symbols = undefined,
+            .subsect_info = undefined,
+            .checksum_offset = null,
+        });
+
+        mod_info_offset += this_record_len;
+        if (mod_info_offset > mod_info_size)
+            return error.InvalidDebugInfo;
+    }
+
+    di.modules = modules.toOwnedSlice();
+
+    // Section Contribution Substream
+    var sect_contribs = ArrayList(pdb.SectionContribEntry).init(allocator);
+    var sect_cont_offset: usize = 0;
+    if (section_contrib_size != 0) {
+        const ver = @intToEnum(pdb.SectionContrSubstreamVersion, try dbi.stream.readIntLe(u32));
+        if (ver != pdb.SectionContrSubstreamVersion.Ver60)
+            return error.InvalidDebugInfo;
+        sect_cont_offset += @sizeOf(u32);
+    }
+    while (sect_cont_offset != section_contrib_size) {
+        const entry = try sect_contribs.addOne();
+        try dbi.stream.readStruct(pdb.SectionContribEntry, entry);
+        sect_cont_offset += @sizeOf(pdb.SectionContribEntry);
+
+        if (sect_cont_offset > section_contrib_size)
+            return error.InvalidDebugInfo;
+    }
+
+    di.sect_contribs = sect_contribs.toOwnedSlice();
+
+    return di;
+}
+
+fn readSparseBitVector(stream: var, allocator: *mem.Allocator) ![]usize {
+    const num_words = try stream.readIntLe(u32);
+    var word_i: usize = 0;
+    var list = ArrayList(usize).init(allocator);
+    while (word_i != num_words) : (word_i += 1) {
+        const word = try stream.readIntLe(u32);
+        var bit_i: u5 = 0;
+        while (true) : (bit_i += 1) {
+            if (word & (u32(1) << bit_i) != 0) {
+                try list.append(word_i * 32 + bit_i);
+            }
+            if (bit_i == @maxValue(u5)) break;
+        }
+    }
+    return list.toOwnedSlice();
+}
+
 fn openSelfDebugInfoLinux(allocator: *mem.Allocator) !DebugInfo {
     var di = DebugInfo{
         .self_exe_file = undefined,
@@ -395,7 +862,7 @@ fn openSelfDebugInfoLinux(allocator: *mem.Allocator) !DebugInfo {
     di.self_exe_file = try os.openSelfExe();
     errdefer di.self_exe_file.close();
 
-    try di.elf.openFile(allocator, &di.self_exe_file);
+    try di.elf.openFile(allocator, di.self_exe_file);
     errdefer di.elf.close();
 
     di.debug_info = (try di.elf.findSection(".debug_info")) orelse return error.MissingDebugInfo;
@@ -578,7 +1045,13 @@ pub const DebugInfo = switch (builtin.os) {
             return self.ofiles.allocator;
         }
     },
-    else => struct {
+    builtin.Os.windows => struct {
+        pdb: pdb.Pdb,
+        coff: *coff.Coff,
+        sect_contribs: []pdb.SectionContribEntry,
+        modules: []Module,
+    },
+    builtin.Os.linux => struct {
         self_exe_file: os.File,
         elf: elf.Elf,
         debug_info: *elf.SectionHeader,
@@ -594,7 +1067,7 @@ pub const DebugInfo = switch (builtin.os) {
         }
 
         pub fn readString(self: *DebugInfo) ![]u8 {
-            var in_file_stream = io.FileInStream.init(&self.self_exe_file);
+            var in_file_stream = io.FileInStream.init(self.self_exe_file);
             const in_stream = &in_file_stream.stream;
             return readStringRaw(self.allocator(), in_stream);
         }
@@ -604,6 +1077,7 @@ pub const DebugInfo = switch (builtin.os) {
             self.elf.close();
         }
     },
+    else => @compileError("Unsupported OS"),
 };
 
 const PcRange = struct {
@@ -929,7 +1403,7 @@ fn parseFormValue(allocator: *mem.Allocator, in_stream: var, form_id: u64, is_64
 }
 
 fn parseAbbrevTable(st: *DebugInfo) !AbbrevTable {
-    const in_file = &st.self_exe_file;
+    const in_file = st.self_exe_file;
     var in_file_stream = io.FileInStream.init(in_file);
     const in_stream = &in_file_stream.stream;
     var result = AbbrevTable.init(st.allocator());
@@ -980,7 +1454,7 @@ fn getAbbrevTableEntry(abbrev_table: *const AbbrevTable, abbrev_code: u64) ?*con
 }
 
 fn parseDie(st: *DebugInfo, abbrev_table: *const AbbrevTable, is_64: bool) !Die {
-    const in_file = &st.self_exe_file;
+    const in_file = st.self_exe_file;
     var in_file_stream = io.FileInStream.init(in_file);
     const in_stream = &in_file_stream.stream;
     const abbrev_code = try readULeb128(in_stream);
@@ -1202,7 +1676,7 @@ fn getLineNumberInfoMacOs(di: *DebugInfo, symbol: MachoSymbol, target_address: u
 fn getLineNumberInfoLinux(di: *DebugInfo, compile_unit: *const CompileUnit, target_address: usize) !LineInfo {
     const compile_unit_cwd = try compile_unit.die.getAttrString(di, DW.AT_comp_dir);
 
-    const in_file = &di.self_exe_file;
+    const in_file = di.self_exe_file;
     const debug_line_end = di.debug_line.offset + di.debug_line.size;
     var this_offset = di.debug_line.offset;
     var this_index: usize = 0;
@@ -1382,7 +1856,7 @@ fn scanAllCompileUnits(st: *DebugInfo) !void {
     var this_unit_offset = st.debug_info.offset;
     var cu_index: usize = 0;
 
-    var in_file_stream = io.FileInStream.init(&st.self_exe_file);
+    var in_file_stream = io.FileInStream.init(st.self_exe_file);
     const in_stream = &in_file_stream.stream;
 
     while (this_unit_offset < debug_info_end) {
@@ -1448,7 +1922,7 @@ fn scanAllCompileUnits(st: *DebugInfo) !void {
 }
 
 fn findCompileUnit(st: *DebugInfo, target_address: u64) !*const CompileUnit {
-    var in_file_stream = io.FileInStream.init(&st.self_exe_file);
+    var in_file_stream = io.FileInStream.init(st.self_exe_file);
     const in_stream = &in_file_stream.stream;
     for (st.compile_unit_list.toSlice()) |*compile_unit| {
         if (compile_unit.pc_range) |range| {