diff --git a/std/io.zig b/std/io.zig
index 48cec478e4..815aa21616 100644
--- a/std/io.zig
+++ b/std/io.zig
@@ -195,8 +195,8 @@ pub fn InStream(comptime ReadError: type) type {
             return mem.readVarInt(ReturnType, bytes, endian);
         }
 
-        pub fn skipBytes(self: *Self, num_bytes: usize) !void {
-            var i: usize = 0;
+        pub fn skipBytes(self: *Self, num_bytes: u64) !void {
+            var i: u64 = 0;
             while (i < num_bytes) : (i += 1) {
                 _ = try self.readByte();
             }
@@ -232,9 +232,9 @@ pub fn OutStream(comptime WriteError: type) type {
             return self.writeFn(self, slice);
         }
 
-        pub fn writeByteNTimes(self: *Self, byte: u8, n: usize) Error!void {
+        pub fn writeByteNTimes(self: *Self, byte: u8, n: u64) Error!void {
             const slice = (*const [1]u8)(&byte)[0..];
-            var i: usize = 0;
+            var i: u64 = 0;
             while (i < n) : (i += 1) {
                 try self.writeFn(self, slice);
             }
@@ -743,7 +743,7 @@ pub fn CountingOutStream(comptime OutStreamError: type) type {
         pub const Error = OutStreamError;
 
         pub stream: Stream,
-        pub bytes_written: usize,
+        pub bytes_written: u64,
         child_stream: *Stream,
 
         pub fn init(child_stream: *Stream) Self {
diff --git a/std/io/seekable_stream.zig b/std/io/seekable_stream.zig
index 5529e42ff1..baf479891c 100644
--- a/std/io/seekable_stream.zig
+++ b/std/io/seekable_stream.zig
@@ -7,25 +7,25 @@ pub fn SeekableStream(comptime SeekErrorType: type, comptime GetSeekPosErrorType
         pub const SeekError = SeekErrorType;
         pub const GetSeekPosError = GetSeekPosErrorType;
 
-        seekToFn: fn (self: *Self, pos: usize) SeekError!void,
-        seekForwardFn: fn (self: *Self, pos: isize) SeekError!void,
+        seekToFn: fn (self: *Self, pos: u64) SeekError!void,
+        seekForwardFn: fn (self: *Self, pos: i64) SeekError!void,
 
-        getPosFn: fn (self: *Self) GetSeekPosError!usize,
-        getEndPosFn: fn (self: *Self) GetSeekPosError!usize,
+        getPosFn: fn (self: *Self) GetSeekPosError!u64,
+        getEndPosFn: fn (self: *Self) GetSeekPosError!u64,
 
-        pub fn seekTo(self: *Self, pos: usize) SeekError!void {
+        pub fn seekTo(self: *Self, pos: u64) SeekError!void {
             return self.seekToFn(self, pos);
         }
 
-        pub fn seekForward(self: *Self, amt: isize) SeekError!void {
+        pub fn seekForward(self: *Self, amt: i64) SeekError!void {
             return self.seekForwardFn(self, amt);
         }
 
-        pub fn getEndPos(self: *Self) GetSeekPosError!usize {
+        pub fn getEndPos(self: *Self) GetSeekPosError!u64 {
             return self.getEndPosFn(self);
         }
 
-        pub fn getPos(self: *Self) GetSeekPosError!usize {
+        pub fn getPos(self: *Self) GetSeekPosError!u64 {
             return self.getPosFn(self);
         }
     };
diff --git a/std/os/file.zig b/std/os/file.zig
index c9a0e2b696..4f7bda0837 100644
--- a/std/os/file.zig
+++ b/std/os/file.zig
@@ -235,7 +235,7 @@ pub const File = struct {
         Unexpected,
     };
 
-    pub fn seekForward(self: File, amount: isize) SeekError!void {
+    pub fn seekForward(self: File, amount: i64) SeekError!void {
         switch (builtin.os) {
             Os.linux, Os.macosx, Os.ios, Os.freebsd, Os.netbsd => {
                 const result = posix.lseek(self.handle, amount, posix.SEEK_CUR);
@@ -266,7 +266,7 @@ pub const File = struct {
         }
     }
 
-    pub fn seekTo(self: File, pos: usize) SeekError!void {
+    pub fn seekTo(self: File, pos: u64) SeekError!void {
         switch (builtin.os) {
             Os.linux, Os.macosx, Os.ios, Os.freebsd, Os.netbsd => {
                 const ipos = try math.cast(isize, pos);
@@ -307,7 +307,7 @@ pub const File = struct {
         Unexpected,
     };
 
-    pub fn getPos(self: File) GetSeekPosError!usize {
+    pub fn getPos(self: File) GetSeekPosError!u64 {
         switch (builtin.os) {
             Os.linux, Os.macosx, Os.ios, Os.freebsd, Os.netbsd => {
                 const result = posix.lseek(self.handle, 0, posix.SEEK_CUR);
@@ -324,7 +324,7 @@ pub const File = struct {
                         else => os.unexpectedErrorPosix(err),
                     };
                 }
-                return result;
+                return @intCast(u64, result);
             },
             Os.windows => {
                 var pos: windows.LARGE_INTEGER = undefined;
@@ -337,16 +337,16 @@ pub const File = struct {
                 }
 
                 assert(pos >= 0);
-                return math.cast(usize, pos);
+                return math.cast(u64, pos);
             },
             else => @compileError("unsupported OS"),
         }
     }
 
-    pub fn getEndPos(self: File) GetSeekPosError!usize {
+    pub fn getEndPos(self: File) GetSeekPosError!u64 {
         if (is_posix) {
             const stat = try os.posixFStat(self.handle);
-            return @intCast(usize, stat.size);
+            return @intCast(u64, stat.size);
         } else if (is_windows) {
             var file_size: windows.LARGE_INTEGER = undefined;
             if (windows.GetFileSizeEx(self.handle, &file_size) == 0) {
@@ -357,7 +357,7 @@ pub const File = struct {
             }
             if (file_size < 0)
                 return error.Overflow;
-            return math.cast(usize, @intCast(u64, file_size));
+            return @intCast(u64, file_size);
         } else {
             @compileError("TODO support getEndPos on this OS");
         }
@@ -492,22 +492,22 @@ pub const File = struct {
 
         pub const Stream = io.SeekableStream(SeekError, GetSeekPosError);
 
-        pub fn seekToFn(seekable_stream: *Stream, pos: usize) SeekError!void {
+        pub fn seekToFn(seekable_stream: *Stream, pos: u64) SeekError!void {
             const self = @fieldParentPtr(SeekableStream, "stream", seekable_stream);
             return self.file.seekTo(pos);
         }
 
-        pub fn seekForwardFn(seekable_stream: *Stream, amt: isize) SeekError!void {
+        pub fn seekForwardFn(seekable_stream: *Stream, amt: i64) SeekError!void {
             const self = @fieldParentPtr(SeekableStream, "stream", seekable_stream);
             return self.file.seekForward(amt);
         }
 
-        pub fn getEndPosFn(seekable_stream: *Stream) GetSeekPosError!usize {
+        pub fn getEndPosFn(seekable_stream: *Stream) GetSeekPosError!u64 {
             const self = @fieldParentPtr(SeekableStream, "stream", seekable_stream);
             return self.file.getEndPos();
         }
 
-        pub fn getPosFn(seekable_stream: *Stream) GetSeekPosError!usize {
+        pub fn getPosFn(seekable_stream: *Stream) GetSeekPosError!u64 {
             const self = @fieldParentPtr(SeekableStream, "stream", seekable_stream);
             return self.file.getPos();
         }
diff --git a/std/pdb.zig b/std/pdb.zig
index 2b02a84871..043be2bcf4 100644
--- a/std/pdb.zig
+++ b/std/pdb.zig
@@ -588,7 +588,7 @@ const SuperBlock = packed struct {
 
 const MsfStream = struct {
     in_file: os.File,
-    pos: usize,
+    pos: u64,
     blocks: []u32,
     block_size: u32,
 
@@ -598,7 +598,7 @@ const MsfStream = struct {
     pub const Error = @typeOf(read).ReturnType.ErrorSet;
     pub const Stream = io.InStream(Error);
 
-    fn init(block_size: u32, block_count: u32, pos: usize, file: os.File, allocator: *mem.Allocator) !MsfStream {
+    fn init(block_size: u32, block_count: u32, pos: u64, file: os.File, allocator: *mem.Allocator) !MsfStream {
         var stream = MsfStream{
             .in_file = file,
             .pos = 0,
@@ -660,23 +660,24 @@ const MsfStream = struct {
         return size;
     }
 
-    fn seekForward(self: *MsfStream, len: usize) !void {
+    // XXX: The `len` parameter should be signed
+    fn seekForward(self: *MsfStream, len: u64) !void {
         self.pos += len;
         if (self.pos >= self.blocks.len * self.block_size)
             return error.EOF;
     }
 
-    fn seekTo(self: *MsfStream, len: usize) !void {
+    fn seekTo(self: *MsfStream, len: u64) !void {
         self.pos = len;
         if (self.pos >= self.blocks.len * self.block_size)
             return error.EOF;
     }
 
-    fn getSize(self: *const MsfStream) usize {
+    fn getSize(self: *const MsfStream) u64 {
         return self.blocks.len * self.block_size;
     }
 
-    fn getFilePos(self: MsfStream) usize {
+    fn getFilePos(self: MsfStream) u64 {
         const block_id = self.pos / self.block_size;
         const block = self.blocks[block_id];
         const offset = self.pos % self.block_size;