std.builtin.Endian: make the tags lower case

Let's take this breaking change opportunity to fix the style of this
enum.

23 files changed, 245 insertions, 245 deletions

diff --git a/src/link/Coff.zig b/src/link/Coff.zig
index affc7406b7..fd2415bff5 100644
--- a/src/link/Coff.zig
+++ b/src/link/Coff.zig
@@ -856,12 +856,12 @@ fn writeOffsetTableEntry(self: *Coff, index: usize) !void {
     switch (self.ptr_width) {
         .p32 => {
             var buf: [4]u8 = undefined;
-            mem.writeInt(u32, &buf, @as(u32, @intCast(entry_value + self.getImageBase())), .Little);
+            mem.writeInt(u32, &buf, @as(u32, @intCast(entry_value + self.getImageBase())), .little);
             try self.base.file.?.pwriteAll(&buf, file_offset);
         },
         .p64 => {
             var buf: [8]u8 = undefined;
-            mem.writeInt(u64, &buf, entry_value + self.getImageBase(), .Little);
+            mem.writeInt(u64, &buf, entry_value + self.getImageBase(), .little);
             try self.base.file.?.pwriteAll(&buf, file_offset);
         },
     }
@@ -889,14 +889,14 @@ fn writeOffsetTableEntry(self: *Coff, index: usize) !void {
             switch (self.ptr_width) {
                 .p32 => {
                     var buf: [4]u8 = undefined;
-                    mem.writeInt(u32, &buf, @as(u32, @intCast(entry_value + slide)), .Little);
+                    mem.writeInt(u32, &buf, @as(u32, @intCast(entry_value + slide)), .little);
                     writeMem(handle, pvaddr, &buf) catch |err| {
                         log.warn("writing to protected memory failed with error: {s}", .{@errorName(err)});
                     };
                 },
                 .p64 => {
                     var buf: [8]u8 = undefined;
-                    mem.writeInt(u64, &buf, entry_value + slide, .Little);
+                    mem.writeInt(u64, &buf, entry_value + slide, .little);
                     writeMem(handle, pvaddr, &buf) catch |err| {
                         log.warn("writing to protected memory failed with error: {s}", .{@errorName(err)});
                     };
@@ -2076,7 +2076,7 @@ fn writeImportTables(self: *Coff) !void {
             lookup_table_offset += lookup_entry_size;
 
             // Names table entry
-            mem.writeInt(u16, buffer.items[names_table_offset..][0..2], 0, .Little); // Hint set to 0 until we learn how to parse DLLs
+            mem.writeInt(u16, buffer.items[names_table_offset..][0..2], 0, .little); // Hint set to 0 until we learn how to parse DLLs
             names_table_offset += 2;
             @memcpy(buffer.items[names_table_offset..][0..import_name.len], import_name);
             names_table_offset += @as(u32, @intCast(import_name.len));
@@ -2089,7 +2089,7 @@ fn writeImportTables(self: *Coff) !void {
         }
 
         // IAT sentinel
-        mem.writeInt(u64, buffer.items[iat_offset..][0..lookup_entry_size], 0, .Little);
+        mem.writeInt(u64, buffer.items[iat_offset..][0..lookup_entry_size], 0, .little);
         iat_offset += 8;
 
         // Lookup table sentinel
@@ -2157,7 +2157,7 @@ fn writeStrtab(self: *Coff) !void {
     buffer.appendSliceAssumeCapacity(self.strtab.items());
     // Here, we do a trick in that we do not commit the size of the strtab to strtab buffer, instead
     // we write the length of the strtab to a temporary buffer that goes to file.
-    mem.writeInt(u32, buffer.items[0..4], @as(u32, @intCast(self.strtab.len())), .Little);
+    mem.writeInt(u32, buffer.items[0..4], @as(u32, @intCast(self.strtab.len())), .little);
 
     try self.base.file.?.pwriteAll(buffer.items, self.strtab_offset.?);
 }
@@ -2180,7 +2180,7 @@ fn writeHeader(self: *Coff) !void {
 
     try buffer.ensureTotalCapacity(self.getSizeOfHeaders());
     writer.writeAll(msdos_stub) catch unreachable;
-    mem.writeInt(u32, buffer.items[0x3c..][0..4], msdos_stub.len, .Little);
+    mem.writeInt(u32, buffer.items[0x3c..][0..4], msdos_stub.len, .little);
 
     writer.writeAll("PE\x00\x00") catch unreachable;
     var flags = coff.CoffHeaderFlags{
@@ -2548,7 +2548,7 @@ fn setSymbolName(self: *Coff, symbol: *coff.Symbol, name: []const u8) !void {
     }
     const offset = try self.strtab.insert(self.base.allocator, name);
     @memset(symbol.name[0..4], 0);
-    mem.writeInt(u32, symbol.name[4..8], offset, .Little);
+    mem.writeInt(u32, symbol.name[4..8], offset, .little);
 }
 
 fn logSymAttributes(sym: *const coff.Symbol, buf: *[4]u8) []const u8 {
diff --git a/src/link/Coff/Relocation.zig b/src/link/Coff/Relocation.zig
index 050ab0d9be..84cfcdc18a 100644
--- a/src/link/Coff/Relocation.zig
+++ b/src/link/Coff/Relocation.zig
@@ -137,7 +137,7 @@ fn resolveAarch64(self: Relocation, ctx: Context) void {
             };
             inst.pc_relative_address.immhi = @as(u19, @truncate(pages >> 2));
             inst.pc_relative_address.immlo = @as(u2, @truncate(pages));
-            mem.writeInt(u32, buffer[0..4], inst.toU32(), .Little);
+            mem.writeInt(u32, buffer[0..4], inst.toU32(), .little);
         },
         .got_pageoff, .import_pageoff, .pageoff => {
             assert(!self.pcrel);
@@ -151,7 +151,7 @@ fn resolveAarch64(self: Relocation, ctx: Context) void {
                     ), buffer[0..4]),
                 };
                 inst.add_subtract_immediate.imm12 = narrowed;
-                mem.writeInt(u32, buffer[0..4], inst.toU32(), .Little);
+                mem.writeInt(u32, buffer[0..4], inst.toU32(), .little);
             } else {
                 var inst = aarch64.Instruction{
                     .load_store_register = mem.bytesToValue(meta.TagPayload(
@@ -173,7 +173,7 @@ fn resolveAarch64(self: Relocation, ctx: Context) void {
                     }
                 };
                 inst.load_store_register.offset = offset;
-                mem.writeInt(u32, buffer[0..4], inst.toU32(), .Little);
+                mem.writeInt(u32, buffer[0..4], inst.toU32(), .little);
             }
         },
         .direct => {
@@ -183,9 +183,9 @@ fn resolveAarch64(self: Relocation, ctx: Context) void {
                     u32,
                     buffer[0..4],
                     @as(u32, @truncate(ctx.target_vaddr + ctx.image_base)),
-                    .Little,
+                    .little,
                 ),
-                3 => mem.writeInt(u64, buffer[0..8], ctx.target_vaddr + ctx.image_base, .Little),
+                3 => mem.writeInt(u64, buffer[0..8], ctx.target_vaddr + ctx.image_base, .little),
                 else => unreachable,
             }
         },
@@ -208,17 +208,17 @@ fn resolveX86(self: Relocation, ctx: Context) void {
         .got, .import => {
             assert(self.pcrel);
             const disp = @as(i32, @intCast(ctx.target_vaddr)) - @as(i32, @intCast(ctx.source_vaddr)) - 4;
-            mem.writeInt(i32, buffer[0..4], disp, .Little);
+            mem.writeInt(i32, buffer[0..4], disp, .little);
         },
         .direct => {
             if (self.pcrel) {
                 const disp = @as(i32, @intCast(ctx.target_vaddr)) - @as(i32, @intCast(ctx.source_vaddr)) - 4;
-                mem.writeInt(i32, buffer[0..4], disp, .Little);
+                mem.writeInt(i32, buffer[0..4], disp, .little);
             } else switch (ctx.ptr_width) {
-                .p32 => mem.writeInt(u32, buffer[0..4], @as(u32, @intCast(ctx.target_vaddr + ctx.image_base)), .Little),
+                .p32 => mem.writeInt(u32, buffer[0..4], @as(u32, @intCast(ctx.target_vaddr + ctx.image_base)), .little),
                 .p64 => switch (self.length) {
-                    2 => mem.writeInt(u32, buffer[0..4], @as(u32, @truncate(ctx.target_vaddr + ctx.image_base)), .Little),
-                    3 => mem.writeInt(u64, buffer[0..8], ctx.target_vaddr + ctx.image_base, .Little),
+                    2 => mem.writeInt(u32, buffer[0..4], @as(u32, @truncate(ctx.target_vaddr + ctx.image_base)), .little),
+                    3 => mem.writeInt(u64, buffer[0..8], ctx.target_vaddr + ctx.image_base, .little),
                     else => unreachable,
                 },
             }
diff --git a/src/link/Elf.zig b/src/link/Elf.zig
index d368e95edc..63642d4c6a 100644
--- a/src/link/Elf.zig
+++ b/src/link/Elf.zig
@@ -2719,8 +2719,8 @@ fn writeHeader(self: *Elf) !void {
 
     const endian = self.base.options.target.cpu.arch.endian();
     hdr_buf[index] = switch (endian) {
-        .Little => elf.ELFDATA2LSB,
-        .Big => elf.ELFDATA2MSB,
+        .little => elf.ELFDATA2LSB,
+        .big => elf.ELFDATA2MSB,
     };
     index += 1;
 
diff --git a/src/link/Elf/Atom.zig b/src/link/Elf/Atom.zig
index f3b41f2e10..7527b61988 100644
--- a/src/link/Elf/Atom.zig
+++ b/src/link/Elf/Atom.zig
@@ -786,43 +786,43 @@ pub fn resolveRelocsAlloc(self: Atom, elf_file: *Elf, code: []u8) !void {
 
             elf.R_X86_64_PLT32,
             elf.R_X86_64_PC32,
-            => try cwriter.writeInt(i32, @as(i32, @intCast(S + A - P)), .Little),
+            => try cwriter.writeInt(i32, @as(i32, @intCast(S + A - P)), .little),
 
-            elf.R_X86_64_GOTPCREL => try cwriter.writeInt(i32, @as(i32, @intCast(G + GOT + A - P)), .Little),
-            elf.R_X86_64_GOTPC32 => try cwriter.writeInt(i32, @as(i32, @intCast(GOT + A - P)), .Little),
-            elf.R_X86_64_GOTPC64 => try cwriter.writeInt(i64, GOT + A - P, .Little),
+            elf.R_X86_64_GOTPCREL => try cwriter.writeInt(i32, @as(i32, @intCast(G + GOT + A - P)), .little),
+            elf.R_X86_64_GOTPC32 => try cwriter.writeInt(i32, @as(i32, @intCast(GOT + A - P)), .little),
+            elf.R_X86_64_GOTPC64 => try cwriter.writeInt(i64, GOT + A - P, .little),
 
             elf.R_X86_64_GOTPCRELX => {
                 if (!target.flags.import and !target.isIFunc(elf_file) and !target.isAbs(elf_file)) blk: {
                     x86_64.relaxGotpcrelx(code[r_offset - 2 ..]) catch break :blk;
-                    try cwriter.writeInt(i32, @as(i32, @intCast(S + A - P)), .Little);
+                    try cwriter.writeInt(i32, @as(i32, @intCast(S + A - P)), .little);
                     continue;
                 }
-                try cwriter.writeInt(i32, @as(i32, @intCast(G + GOT + A - P)), .Little);
+                try cwriter.writeInt(i32, @as(i32, @intCast(G + GOT + A - P)), .little);
             },
 
             elf.R_X86_64_REX_GOTPCRELX => {
                 if (!target.flags.import and !target.isIFunc(elf_file) and !target.isAbs(elf_file)) blk: {
                     x86_64.relaxRexGotpcrelx(code[r_offset - 3 ..]) catch break :blk;
-                    try cwriter.writeInt(i32, @as(i32, @intCast(S + A - P)), .Little);
+                    try cwriter.writeInt(i32, @as(i32, @intCast(S + A - P)), .little);
                     continue;
                 }
-                try cwriter.writeInt(i32, @as(i32, @intCast(G + GOT + A - P)), .Little);
+                try cwriter.writeInt(i32, @as(i32, @intCast(G + GOT + A - P)), .little);
             },
 
-            elf.R_X86_64_32 => try cwriter.writeInt(u32, @as(u32, @truncate(@as(u64, @intCast(S + A)))), .Little),
-            elf.R_X86_64_32S => try cwriter.writeInt(i32, @as(i32, @truncate(S + A)), .Little),
+            elf.R_X86_64_32 => try cwriter.writeInt(u32, @as(u32, @truncate(@as(u64, @intCast(S + A)))), .little),
+            elf.R_X86_64_32S => try cwriter.writeInt(i32, @as(i32, @truncate(S + A)), .little),
 
-            elf.R_X86_64_TPOFF32 => try cwriter.writeInt(i32, @as(i32, @truncate(S + A - TP)), .Little),
-            elf.R_X86_64_TPOFF64 => try cwriter.writeInt(i64, S + A - TP, .Little),
+            elf.R_X86_64_TPOFF32 => try cwriter.writeInt(i32, @as(i32, @truncate(S + A - TP)), .little),
+            elf.R_X86_64_TPOFF64 => try cwriter.writeInt(i64, S + A - TP, .little),
 
-            elf.R_X86_64_DTPOFF32 => try cwriter.writeInt(i32, @as(i32, @truncate(S + A - DTP)), .Little),
-            elf.R_X86_64_DTPOFF64 => try cwriter.writeInt(i64, S + A - DTP, .Little),
+            elf.R_X86_64_DTPOFF32 => try cwriter.writeInt(i32, @as(i32, @truncate(S + A - DTP)), .little),
+            elf.R_X86_64_DTPOFF64 => try cwriter.writeInt(i64, S + A - DTP, .little),
 
             elf.R_X86_64_TLSGD => {
                 if (target.flags.has_tlsgd) {
                     const S_ = @as(i64, @intCast(target.tlsGdAddress(elf_file)));
-                    try cwriter.writeInt(i32, @as(i32, @intCast(S_ + A - P)), .Little);
+                    try cwriter.writeInt(i32, @as(i32, @intCast(S_ + A - P)), .little);
                 } else if (target.flags.has_gottp) {
                     const S_ = @as(i64, @intCast(target.gotTpAddress(elf_file)));
                     try x86_64.relaxTlsGdToIe(self, rels[i .. i + 2], @intCast(S_ - P), elf_file, &stream);
@@ -843,7 +843,7 @@ pub fn resolveRelocsAlloc(self: Atom, elf_file: *Elf, code: []u8) !void {
                 if (elf_file.got.tlsld_index) |entry_index| {
                     const tlsld_entry = elf_file.got.entries.items[entry_index];
                     const S_ = @as(i64, @intCast(tlsld_entry.address(elf_file)));
-                    try cwriter.writeInt(i32, @as(i32, @intCast(S_ + A - P)), .Little);
+                    try cwriter.writeInt(i32, @as(i32, @intCast(S_ + A - P)), .little);
                 } else {
                     try x86_64.relaxTlsLdToLe(
                         self,
@@ -859,10 +859,10 @@ pub fn resolveRelocsAlloc(self: Atom, elf_file: *Elf, code: []u8) !void {
             elf.R_X86_64_GOTPC32_TLSDESC => {
                 if (target.flags.has_tlsdesc) {
                     const S_ = @as(i64, @intCast(target.tlsDescAddress(elf_file)));
-                    try cwriter.writeInt(i32, @as(i32, @intCast(S_ + A - P)), .Little);
+                    try cwriter.writeInt(i32, @as(i32, @intCast(S_ + A - P)), .little);
                 } else {
                     try x86_64.relaxGotPcTlsDesc(code[r_offset - 3 ..]);
-                    try cwriter.writeInt(i32, @as(i32, @intCast(S - TP)), .Little);
+                    try cwriter.writeInt(i32, @as(i32, @intCast(S - TP)), .little);
                 }
             },
 
@@ -874,18 +874,18 @@ pub fn resolveRelocsAlloc(self: Atom, elf_file: *Elf, code: []u8) !void {
             elf.R_X86_64_GOTTPOFF => {
                 if (target.flags.has_gottp) {
                     const S_ = @as(i64, @intCast(target.gotTpAddress(elf_file)));
-                    try cwriter.writeInt(i32, @as(i32, @intCast(S_ + A - P)), .Little);
+                    try cwriter.writeInt(i32, @as(i32, @intCast(S_ + A - P)), .little);
                 } else {
                     x86_64.relaxGotTpOff(code[r_offset - 3 ..]) catch unreachable;
-                    try cwriter.writeInt(i32, @as(i32, @intCast(S - TP)), .Little);
+                    try cwriter.writeInt(i32, @as(i32, @intCast(S - TP)), .little);
                 }
             },
 
-            elf.R_X86_64_GOT32 => try cwriter.writeInt(i32, @as(i32, @intCast(G + GOT + A)), .Little),
+            elf.R_X86_64_GOT32 => try cwriter.writeInt(i32, @as(i32, @intCast(G + GOT + A)), .little),
 
             // Zig custom relocations
-            Elf.R_X86_64_ZIG_GOT32 => try cwriter.writeInt(u32, @as(u32, @intCast(ZIG_GOT + A)), .Little),
-            Elf.R_X86_64_ZIG_GOTPCREL => try cwriter.writeInt(i32, @as(i32, @intCast(ZIG_GOT + A - P)), .Little),
+            Elf.R_X86_64_ZIG_GOT32 => try cwriter.writeInt(u32, @as(u32, @intCast(ZIG_GOT + A)), .little),
+            Elf.R_X86_64_ZIG_GOTPCREL => try cwriter.writeInt(i32, @as(i32, @intCast(ZIG_GOT + A - P)), .little),
 
             else => {},
         }
@@ -920,7 +920,7 @@ fn resolveDynAbsReloc(
         .copyrel,
         .cplt,
         .none,
-        => try writer.writeInt(i32, @as(i32, @truncate(S + A)), .Little),
+        => try writer.writeInt(i32, @as(i32, @truncate(S + A)), .little),
 
         .dyn_copyrel => {
             if (is_writeable or elf_file.base.options.z_nocopyreloc) {
@@ -932,7 +932,7 @@ fn resolveDynAbsReloc(
                 });
                 try applyDynamicReloc(A, elf_file, writer);
             } else {
-                try writer.writeInt(i32, @as(i32, @truncate(S + A)), .Little);
+                try writer.writeInt(i32, @as(i32, @truncate(S + A)), .little);
             }
         },
 
@@ -946,7 +946,7 @@ fn resolveDynAbsReloc(
                 });
                 try applyDynamicReloc(A, elf_file, writer);
             } else {
-                try writer.writeInt(i32, @as(i32, @truncate(S + A)), .Little);
+                try writer.writeInt(i32, @as(i32, @truncate(S + A)), .little);
             }
         },
 
@@ -984,7 +984,7 @@ fn resolveDynAbsReloc(
 fn applyDynamicReloc(value: i64, elf_file: *Elf, writer: anytype) !void {
     _ = elf_file;
     // if (elf_file.options.apply_dynamic_relocs) {
-    try writer.writeInt(i64, value, .Little);
+    try writer.writeInt(i64, value, .little);
     // }
 }
 
@@ -1058,22 +1058,22 @@ pub fn resolveRelocsNonAlloc(self: Atom, elf_file: *Elf, code: []u8, undefs: any
 
         switch (r_type) {
             elf.R_X86_64_NONE => unreachable,
-            elf.R_X86_64_8 => try cwriter.writeInt(u8, @as(u8, @bitCast(@as(i8, @intCast(S + A)))), .Little),
-            elf.R_X86_64_16 => try cwriter.writeInt(u16, @as(u16, @bitCast(@as(i16, @intCast(S + A)))), .Little),
-            elf.R_X86_64_32 => try cwriter.writeInt(u32, @as(u32, @bitCast(@as(i32, @intCast(S + A)))), .Little),
-            elf.R_X86_64_32S => try cwriter.writeInt(i32, @as(i32, @intCast(S + A)), .Little),
-            elf.R_X86_64_64 => try cwriter.writeInt(i64, S + A, .Little),
-            elf.R_X86_64_DTPOFF32 => try cwriter.writeInt(i32, @as(i32, @intCast(S + A - DTP)), .Little),
-            elf.R_X86_64_DTPOFF64 => try cwriter.writeInt(i64, S + A - DTP, .Little),
-            elf.R_X86_64_GOTOFF64 => try cwriter.writeInt(i64, S + A - GOT, .Little),
-            elf.R_X86_64_GOTPC64 => try cwriter.writeInt(i64, GOT + A, .Little),
+            elf.R_X86_64_8 => try cwriter.writeInt(u8, @as(u8, @bitCast(@as(i8, @intCast(S + A)))), .little),
+            elf.R_X86_64_16 => try cwriter.writeInt(u16, @as(u16, @bitCast(@as(i16, @intCast(S + A)))), .little),
+            elf.R_X86_64_32 => try cwriter.writeInt(u32, @as(u32, @bitCast(@as(i32, @intCast(S + A)))), .little),
+            elf.R_X86_64_32S => try cwriter.writeInt(i32, @as(i32, @intCast(S + A)), .little),
+            elf.R_X86_64_64 => try cwriter.writeInt(i64, S + A, .little),
+            elf.R_X86_64_DTPOFF32 => try cwriter.writeInt(i32, @as(i32, @intCast(S + A - DTP)), .little),
+            elf.R_X86_64_DTPOFF64 => try cwriter.writeInt(i64, S + A - DTP, .little),
+            elf.R_X86_64_GOTOFF64 => try cwriter.writeInt(i64, S + A - GOT, .little),
+            elf.R_X86_64_GOTPC64 => try cwriter.writeInt(i64, GOT + A, .little),
             elf.R_X86_64_SIZE32 => {
                 const size = @as(i64, @intCast(target.elfSym(elf_file).st_size));
-                try cwriter.writeInt(u32, @as(u32, @bitCast(@as(i32, @intCast(size + A)))), .Little);
+                try cwriter.writeInt(u32, @as(u32, @bitCast(@as(i32, @intCast(size + A)))), .little);
             },
             elf.R_X86_64_SIZE64 => {
                 const size = @as(i64, @intCast(target.elfSym(elf_file).st_size));
-                try cwriter.writeInt(i64, @as(i64, @intCast(size + A)), .Little);
+                try cwriter.writeInt(i64, @as(i64, @intCast(size + A)), .little);
             },
             else => try self.reportUnhandledRelocError(rel, elf_file),
         }
@@ -1254,7 +1254,7 @@ const x86_64 = struct {
                     0x64, 0x48, 0x8b, 0x04, 0x25, 0, 0, 0, 0, // movq %fs:0,%rax
                     0x48, 0x03, 0x05, 0, 0, 0, 0, // add foo@gottpoff(%rip), %rax
                 };
-                std.mem.writeInt(i32, insts[12..][0..4], value - 12, .Little);
+                std.mem.writeInt(i32, insts[12..][0..4], value - 12, .little);
                 try stream.seekBy(-4);
                 try writer.writeAll(&insts);
             },
@@ -1292,7 +1292,7 @@ const x86_64 = struct {
                     0x64, 0x48, 0x8b, 0, // mov %fs:(%rax), %rax
                     0x48, 0x2d, 0, 0, 0, 0, // sub $tls_size, %rax
                 };
-                std.mem.writeInt(i32, insts[8..][0..4], value, .Little);
+                std.mem.writeInt(i32, insts[8..][0..4], value, .little);
                 try stream.seekBy(-3);
                 try writer.writeAll(&insts);
             },
@@ -1306,7 +1306,7 @@ const x86_64 = struct {
                     0x48, 0x2d, 0, 0, 0, 0, // sub $tls_size, %rax
                     0x90, // nop
                 };
-                std.mem.writeInt(i32, insts[8..][0..4], value, .Little);
+                std.mem.writeInt(i32, insts[8..][0..4], value, .little);
                 try stream.seekBy(-3);
                 try writer.writeAll(&insts);
             },
@@ -1392,7 +1392,7 @@ const x86_64 = struct {
                     0x64, 0x48, 0x8b, 0x04, 0x25, 0, 0, 0, 0, // movq %fs:0,%rax
                     0x48, 0x81, 0xc0, 0, 0, 0, 0, // add $tp_offset, %rax
                 };
-                std.mem.writeInt(i32, insts[12..][0..4], value, .Little);
+                std.mem.writeInt(i32, insts[12..][0..4], value, .little);
                 try stream.seekBy(-4);
                 try writer.writeAll(&insts);
                 relocs_log.debug("    relaxing {} and {}", .{
diff --git a/src/link/Elf/eh_frame.zig b/src/link/Elf/eh_frame.zig
index 3f291f9a77..caf6f9a051 100644
--- a/src/link/Elf/eh_frame.zig
+++ b/src/link/Elf/eh_frame.zig
@@ -33,7 +33,7 @@ pub const Fde = struct {
 
     pub fn ciePointer(fde: Fde, elf_file: *Elf) u32 {
         const fde_data = fde.data(elf_file);
-        return std.mem.readInt(u32, fde_data[4..8], .Little);
+        return std.mem.readInt(u32, fde_data[4..8], .little);
     }
 
     pub fn calcSize(fde: Fde) usize {
@@ -217,10 +217,10 @@ pub const Iterator = struct {
         var stream = std.io.fixedBufferStream(it.data[it.pos..]);
         const reader = stream.reader();
 
-        var size = try reader.readInt(u32, .Little);
+        var size = try reader.readInt(u32, .little);
         if (size == 0xFFFFFFFF) @panic("TODO");
 
-        const id = try reader.readInt(u32, .Little);
+        const id = try reader.readInt(u32, .little);
         const record = Record{
             .tag = if (id == 0) .cie else .fde,
             .offset = it.pos,
@@ -298,10 +298,10 @@ fn resolveReloc(rec: anytype, sym: *const Symbol, rel: elf.Elf64_Rela, elf_file:
 
     var where = contents[offset..];
     switch (rel.r_type()) {
-        elf.R_X86_64_32 => std.mem.writeInt(i32, where[0..4], @as(i32, @truncate(S + A)), .Little),
-        elf.R_X86_64_64 => std.mem.writeInt(i64, where[0..8], S + A, .Little),
-        elf.R_X86_64_PC32 => std.mem.writeInt(i32, where[0..4], @as(i32, @intCast(S - P + A)), .Little),
-        elf.R_X86_64_PC64 => std.mem.writeInt(i64, where[0..8], S - P + A, .Little),
+        elf.R_X86_64_32 => std.mem.writeInt(i32, where[0..4], @as(i32, @truncate(S + A)), .little),
+        elf.R_X86_64_64 => std.mem.writeInt(i64, where[0..8], S + A, .little),
+        elf.R_X86_64_PC32 => std.mem.writeInt(i32, where[0..4], @as(i32, @intCast(S - P + A)), .little),
+        elf.R_X86_64_PC64 => std.mem.writeInt(i64, where[0..8], S - P + A, .little),
         else => unreachable,
     }
 }
@@ -342,7 +342,7 @@ pub fn writeEhFrame(elf_file: *Elf, writer: anytype) !void {
                 i32,
                 contents[4..8],
                 @truncate(@as(i64, @intCast(fde.out_offset + 4)) - @as(i64, @intCast(fde.cie(elf_file).out_offset))),
-                .Little,
+                .little,
             );
 
             for (fde.relocs(elf_file)) |rel| {
@@ -354,7 +354,7 @@ pub fn writeEhFrame(elf_file: *Elf, writer: anytype) !void {
         }
     }
 
-    try writer.writeInt(u32, 0, .Little);
+    try writer.writeInt(u32, 0, .little);
 }
 
 pub fn writeEhFrameHdr(elf_file: *Elf, writer: anytype) !void {
@@ -372,9 +372,9 @@ pub fn writeEhFrameHdr(elf_file: *Elf, writer: anytype) !void {
             i32,
             @truncate(@as(i64, @intCast(eh_frame_shdr.sh_addr)) - @as(i64, @intCast(eh_frame_hdr_shdr.sh_addr)) - 4),
         ))),
-        .Little,
+        .little,
     );
-    try writer.writeInt(u32, num_fdes, .Little);
+    try writer.writeInt(u32, num_fdes, .little);
 
     const Entry = struct {
         init_addr: u32,
diff --git a/src/link/Elf/synthetic_sections.zig b/src/link/Elf/synthetic_sections.zig
index 0d78aea322..cfc2064fbe 100644
--- a/src/link/Elf/synthetic_sections.zig
+++ b/src/link/Elf/synthetic_sections.zig
@@ -878,9 +878,9 @@ pub const PltSection = struct {
             0xff, 0x25, 0x00, 0x00, 0x00, 0x00, // jmp qword ptr [rip] -> .got.plt[2]
         };
         var disp = @as(i64, @intCast(got_plt_addr + 8)) - @as(i64, @intCast(plt_addr + 8)) - 4;
-        mem.writeInt(i32, preamble[8..][0..4], @as(i32, @intCast(disp)), .Little);
+        mem.writeInt(i32, preamble[8..][0..4], @as(i32, @intCast(disp)), .little);
         disp = @as(i64, @intCast(got_plt_addr + 16)) - @as(i64, @intCast(plt_addr + 14)) - 4;
-        mem.writeInt(i32, preamble[14..][0..4], @as(i32, @intCast(disp)), .Little);
+        mem.writeInt(i32, preamble[14..][0..4], @as(i32, @intCast(disp)), .little);
         try writer.writeAll(&preamble);
         try writer.writeByteNTimes(0xcc, preamble_size - preamble.len);
 
@@ -894,8 +894,8 @@ pub const PltSection = struct {
                 0x41, 0xbb, 0x00, 0x00, 0x00, 0x00, // mov r11d, N
                 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, // jmp qword ptr [rip] -> .got.plt[N]
             };
-            mem.writeInt(i32, entry[6..][0..4], @as(i32, @intCast(i)), .Little);
-            mem.writeInt(i32, entry[12..][0..4], @as(i32, @intCast(disp)), .Little);
+            mem.writeInt(i32, entry[6..][0..4], @as(i32, @intCast(i)), .little);
+            mem.writeInt(i32, entry[12..][0..4], @as(i32, @intCast(disp)), .little);
             try writer.writeAll(&entry);
         }
     }
@@ -971,17 +971,17 @@ pub const GotPltSection = struct {
         {
             // [0]: _DYNAMIC
             const symbol = elf_file.symbol(elf_file.dynamic_index.?);
-            try writer.writeInt(u64, symbol.value, .Little);
+            try writer.writeInt(u64, symbol.value, .little);
         }
         // [1]: 0x0
         // [2]: 0x0
-        try writer.writeInt(u64, 0x0, .Little);
-        try writer.writeInt(u64, 0x0, .Little);
+        try writer.writeInt(u64, 0x0, .little);
+        try writer.writeInt(u64, 0x0, .little);
         if (elf_file.plt_section_index) |shndx| {
             const plt_addr = elf_file.shdrs.items[shndx].sh_addr;
             for (0..elf_file.plt.symbols.items.len) |_| {
                 // [N]: .plt
-                try writer.writeInt(u64, plt_addr, .Little);
+                try writer.writeInt(u64, plt_addr, .little);
             }
         }
     }
@@ -1023,7 +1023,7 @@ pub const PltGotSection = struct {
                 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, // jmp qword ptr [rip] -> .got[N]
                 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
             };
-            mem.writeInt(i32, entry[6..][0..4], @as(i32, @intCast(disp)), .Little);
+            mem.writeInt(i32, entry[6..][0..4], @as(i32, @intCast(disp)), .little);
             try writer.writeAll(&entry);
         }
     }
@@ -1258,8 +1258,8 @@ pub const HashSection = struct {
         }
 
         try hs.buffer.ensureTotalCapacityPrecise(gpa, (2 + nsyms * 2) * 4);
-        hs.buffer.writer(gpa).writeInt(u32, @as(u32, @intCast(nsyms)), .Little) catch unreachable;
-        hs.buffer.writer(gpa).writeInt(u32, @as(u32, @intCast(nsyms)), .Little) catch unreachable;
+        hs.buffer.writer(gpa).writeInt(u32, @as(u32, @intCast(nsyms)), .little) catch unreachable;
+        hs.buffer.writer(gpa).writeInt(u32, @as(u32, @intCast(nsyms)), .little) catch unreachable;
         hs.buffer.writer(gpa).writeAll(mem.sliceAsBytes(buckets)) catch unreachable;
         hs.buffer.writer(gpa).writeAll(mem.sliceAsBytes(chains)) catch unreachable;
     }
@@ -1322,10 +1322,10 @@ pub const GnuHashSection = struct {
         var counting = std.io.countingWriter(writer);
         const cwriter = counting.writer();
 
-        try cwriter.writeInt(u32, hash.num_buckets, .Little);
-        try cwriter.writeInt(u32, export_off, .Little);
-        try cwriter.writeInt(u32, hash.num_bloom, .Little);
-        try cwriter.writeInt(u32, bloom_shift, .Little);
+        try cwriter.writeInt(u32, hash.num_buckets, .little);
+        try cwriter.writeInt(u32, export_off, .little);
+        try cwriter.writeInt(u32, hash.num_bloom, .little);
+        try cwriter.writeInt(u32, bloom_shift, .little);
 
         const gpa = elf_file.base.allocator;
         const hashes = try gpa.alloc(u32, exports.len);
diff --git a/src/link/MachO.zig b/src/link/MachO.zig
index 55b9c617b1..5a246bcfd1 100644
--- a/src/link/MachO.zig
+++ b/src/link/MachO.zig
@@ -1222,7 +1222,7 @@ fn writeOffsetTableEntry(self: *MachO, index: usize) !void {
     log.debug("writing GOT entry {d}: @{x} => {x}", .{ index, vmaddr, entry_value });
 
     var buf: [@sizeOf(u64)]u8 = undefined;
-    mem.writeInt(u64, &buf, entry_value, .Little);
+    mem.writeInt(u64, &buf, entry_value, .little);
     try self.base.file.?.pwriteAll(&buf, file_offset);
 
     if (is_hot_update_compatible) {
@@ -1329,7 +1329,7 @@ fn writeStubTableEntry(self: *MachO, index: usize) !void {
 
     {
         var buf: [@sizeOf(u64)]u8 = undefined;
-        mem.writeInt(u64, &buf, stub_helper_addr, .Little);
+        mem.writeInt(u64, &buf, stub_helper_addr, .little);
         const off = laptr_header.offset + @sizeOf(u64) * index;
         try self.base.file.?.pwriteAll(&buf, off);
     }
@@ -3773,7 +3773,7 @@ fn collectBindData(self: *MachO, bind: anytype, raw_bindings: anytype) !void {
                 const base_offset = sym.n_value - segment.vmaddr;
                 const rel_offset = @as(u32, @intCast(rel.r_address - ctx.base_offset));
                 const offset = @as(u64, @intCast(base_offset + rel_offset));
-                const addend = mem.readInt(i64, code[rel_offset..][0..8], .Little);
+                const addend = mem.readInt(i64, code[rel_offset..][0..8], .little);
 
                 const dylib_ordinal = @divTrunc(@as(i16, @bitCast(bind_sym.n_desc)), macho.N_SYMBOL_RESOLVER);
                 log.debug("    | bind at {x}, import('{s}') in dylib({d})", .{
@@ -4502,7 +4502,7 @@ pub fn writeDysymtab(self: *MachO, ctx: SymtabCtx) !void {
             if (!self.stub_table.lookup.contains(entry)) continue;
             const target_sym = self.getSymbol(entry);
             assert(target_sym.undf());
-            try writer.writeInt(u32, iundefsym + ctx.imports_table.get(entry).?, .Little);
+            try writer.writeInt(u32, iundefsym + ctx.imports_table.get(entry).?, .little);
         }
     }
 
@@ -4513,9 +4513,9 @@ pub fn writeDysymtab(self: *MachO, ctx: SymtabCtx) !void {
             if (!self.got_table.lookup.contains(entry)) continue;
             const target_sym = self.getSymbol(entry);
             if (target_sym.undf()) {
-                try writer.writeInt(u32, iundefsym + ctx.imports_table.get(entry).?, .Little);
+                try writer.writeInt(u32, iundefsym + ctx.imports_table.get(entry).?, .little);
             } else {
-                try writer.writeInt(u32, macho.INDIRECT_SYMBOL_LOCAL, .Little);
+                try writer.writeInt(u32, macho.INDIRECT_SYMBOL_LOCAL, .little);
             }
         }
     }
@@ -4527,7 +4527,7 @@ pub fn writeDysymtab(self: *MachO, ctx: SymtabCtx) !void {
             if (!self.stub_table.lookup.contains(entry)) continue;
             const target_sym = self.getSymbol(entry);
             assert(target_sym.undf());
-            try writer.writeInt(u32, iundefsym + ctx.imports_table.get(entry).?, .Little);
+            try writer.writeInt(u32, iundefsym + ctx.imports_table.get(entry).?, .little);
         }
     }
 
diff --git a/src/link/MachO/Archive.zig b/src/link/MachO/Archive.zig
index fec7ce65ef..6bdc6d916d 100644
--- a/src/link/MachO/Archive.zig
+++ b/src/link/MachO/Archive.zig
@@ -123,7 +123,7 @@ fn parseName(allocator: Allocator, name_or_length: ar_hdr.NameOrLength, reader:
 }
 
 fn parseTableOfContents(self: *Archive, allocator: Allocator, reader: anytype) !void {
-    const symtab_size = try reader.readInt(u32, .Little);
+    const symtab_size = try reader.readInt(u32, .little);
     var symtab = try allocator.alloc(u8, symtab_size);
     defer allocator.free(symtab);
 
@@ -132,7 +132,7 @@ fn parseTableOfContents(self: *Archive, allocator: Allocator, reader: anytype) !
         return error.MalformedArchive;
     };
 
-    const strtab_size = try reader.readInt(u32, .Little);
+    const strtab_size = try reader.readInt(u32, .little);
     var strtab = try allocator.alloc(u8, strtab_size);
     defer allocator.free(strtab);
 
@@ -145,11 +145,11 @@ fn parseTableOfContents(self: *Archive, allocator: Allocator, reader: anytype) !
     var symtab_reader = symtab_stream.reader();
 
     while (true) {
-        const n_strx = symtab_reader.readInt(u32, .Little) catch |err| switch (err) {
+        const n_strx = symtab_reader.readInt(u32, .little) catch |err| switch (err) {
             error.EndOfStream => break,
             else => |e| return e,
         };
-        const object_offset = try symtab_reader.readInt(u32, .Little);
+        const object_offset = try symtab_reader.readInt(u32, .little);
 
         const sym_name = mem.sliceTo(@as([*:0]const u8, @ptrCast(strtab.ptr + n_strx)), 0);
         const owned_name = try allocator.dupe(u8, sym_name);
diff --git a/src/link/MachO/Atom.zig b/src/link/MachO/Atom.zig
index 4c8fc03e3c..290c67c45e 100644
--- a/src/link/MachO/Atom.zig
+++ b/src/link/MachO/Atom.zig
@@ -443,9 +443,9 @@ pub fn parseRelocTarget(macho_file: *MachO, ctx: struct {
 
         const address_in_section = if (ctx.rel.r_pcrel == 0) blk: {
             break :blk if (ctx.rel.r_length == 3)
-                mem.readInt(u64, ctx.code[rel_offset..][0..8], .Little)
+                mem.readInt(u64, ctx.code[rel_offset..][0..8], .little)
             else
-                mem.readInt(u32, ctx.code[rel_offset..][0..4], .Little);
+                mem.readInt(u32, ctx.code[rel_offset..][0..4], .little);
         } else blk: {
             assert(macho_file.base.options.target.cpu.arch == .x86_64);
             const correction: u3 = switch (@as(macho.reloc_type_x86_64, @enumFromInt(ctx.rel.r_type))) {
@@ -455,7 +455,7 @@ pub fn parseRelocTarget(macho_file: *MachO, ctx: struct {
                 .X86_64_RELOC_SIGNED_4 => 4,
                 else => unreachable,
             };
-            const addend = mem.readInt(i32, ctx.code[rel_offset..][0..4], .Little);
+            const addend = mem.readInt(i32, ctx.code[rel_offset..][0..4], .little);
             const target_address = @as(i64, @intCast(ctx.base_addr)) + ctx.rel.r_address + 4 + correction + addend;
             break :blk @as(u64, @intCast(target_address));
         };
@@ -781,7 +781,7 @@ fn resolveRelocsArm64(
                     ), code),
                 };
                 inst.unconditional_branch_immediate.imm26 = @as(u26, @truncate(@as(u28, @bitCast(displacement >> 2))));
-                mem.writeInt(u32, code, inst.toU32(), .Little);
+                mem.writeInt(u32, code, inst.toU32(), .little);
             },
 
             .ARM64_RELOC_PAGE21,
@@ -802,7 +802,7 @@ fn resolveRelocsArm64(
                 };
                 inst.pc_relative_address.immhi = @as(u19, @truncate(pages >> 2));
                 inst.pc_relative_address.immlo = @as(u2, @truncate(pages));
-                mem.writeInt(u32, code, inst.toU32(), .Little);
+                mem.writeInt(u32, code, inst.toU32(), .little);
                 addend = null;
             },
 
@@ -821,7 +821,7 @@ fn resolveRelocsArm64(
                         ), code),
                     };
                     inst.add_subtract_immediate.imm12 = off;
-                    mem.writeInt(u32, code, inst.toU32(), .Little);
+                    mem.writeInt(u32, code, inst.toU32(), .little);
                 } else {
                     var inst = aarch64.Instruction{
                         .load_store_register = mem.bytesToValue(meta.TagPayload(
@@ -839,7 +839,7 @@ fn resolveRelocsArm64(
                         3 => .load_store_64,
                     });
                     inst.load_store_register.offset = off;
-                    mem.writeInt(u32, code, inst.toU32(), .Little);
+                    mem.writeInt(u32, code, inst.toU32(), .little);
                 }
                 addend = null;
             },
@@ -858,7 +858,7 @@ fn resolveRelocsArm64(
                     ), code),
                 };
                 inst.load_store_register.offset = off;
-                mem.writeInt(u32, code, inst.toU32(), .Little);
+                mem.writeInt(u32, code, inst.toU32(), .little);
                 addend = null;
             },
 
@@ -918,7 +918,7 @@ fn resolveRelocsArm64(
                         .sf = @as(u1, @truncate(reg_info.size)),
                     },
                 };
-                mem.writeInt(u32, code, inst.toU32(), .Little);
+                mem.writeInt(u32, code, inst.toU32(), .little);
                 addend = null;
             },
 
@@ -926,14 +926,14 @@ fn resolveRelocsArm64(
                 relocs_log.debug("    | target_addr = 0x{x}", .{target_addr});
                 const result = math.cast(i32, @as(i64, @intCast(target_addr)) - @as(i64, @intCast(source_addr))) orelse
                     return error.Overflow;
-                mem.writeInt(u32, atom_code[rel_offset..][0..4], @as(u32, @bitCast(result)), .Little);
+                mem.writeInt(u32, atom_code[rel_offset..][0..4], @as(u32, @bitCast(result)), .little);
             },
 
             .ARM64_RELOC_UNSIGNED => {
                 var ptr_addend = if (rel.r_length == 3)
-                    mem.readInt(i64, atom_code[rel_offset..][0..8], .Little)
+                    mem.readInt(i64, atom_code[rel_offset..][0..8], .little)
                 else
-                    mem.readInt(i32, atom_code[rel_offset..][0..4], .Little);
+                    mem.readInt(i32, atom_code[rel_offset..][0..4], .little);
 
                 if (rel.r_extern == 0) {
                     const base_addr = if (target.sym_index >= object.source_address_lookup.len)
@@ -954,9 +954,9 @@ fn resolveRelocsArm64(
                 relocs_log.debug("    | target_addr = 0x{x}", .{result});
 
                 if (rel.r_length == 3) {
-                    mem.writeInt(u64, atom_code[rel_offset..][0..8], @as(u64, @bitCast(result)), .Little);
+                    mem.writeInt(u64, atom_code[rel_offset..][0..8], @as(u64, @bitCast(result)), .little);
                 } else {
-                    mem.writeInt(u32, atom_code[rel_offset..][0..4], @as(u32, @truncate(@as(u64, @bitCast(result)))), .Little);
+                    mem.writeInt(u32, atom_code[rel_offset..][0..4], @as(u32, @truncate(@as(u64, @bitCast(result)))), .little);
                 }
 
                 subtractor = null;
@@ -1045,25 +1045,25 @@ fn resolveRelocsX86(
 
         switch (rel_type) {
             .X86_64_RELOC_BRANCH => {
-                const addend = mem.readInt(i32, atom_code[rel_offset..][0..4], .Little);
+                const addend = mem.readInt(i32, atom_code[rel_offset..][0..4], .little);
                 const adjusted_target_addr = @as(u64, @intCast(@as(i64, @intCast(target_addr)) + addend));
                 relocs_log.debug("    | target_addr = 0x{x}", .{adjusted_target_addr});
                 const disp = try Relocation.calcPcRelativeDisplacementX86(source_addr, adjusted_target_addr, 0);
-                mem.writeInt(i32, atom_code[rel_offset..][0..4], disp, .Little);
+                mem.writeInt(i32, atom_code[rel_offset..][0..4], disp, .little);
             },
 
             .X86_64_RELOC_GOT,
             .X86_64_RELOC_GOT_LOAD,
             => {
-                const addend = mem.readInt(i32, atom_code[rel_offset..][0..4], .Little);
+                const addend = mem.readInt(i32, atom_code[rel_offset..][0..4], .little);
                 const adjusted_target_addr = @as(u64, @intCast(@as(i64, @intCast(target_addr)) + addend));
                 relocs_log.debug("    | target_addr = 0x{x}", .{adjusted_target_addr});
                 const disp = try Relocation.calcPcRelativeDisplacementX86(source_addr, adjusted_target_addr, 0);
-                mem.writeInt(i32, atom_code[rel_offset..][0..4], disp, .Little);
+                mem.writeInt(i32, atom_code[rel_offset..][0..4], disp, .little);
             },
 
             .X86_64_RELOC_TLV => {
-                const addend = mem.readInt(i32, atom_code[rel_offset..][0..4], .Little);
+                const addend = mem.readInt(i32, atom_code[rel_offset..][0..4], .little);
                 const adjusted_target_addr = @as(u64, @intCast(@as(i64, @intCast(target_addr)) + addend));
                 relocs_log.debug("    | target_addr = 0x{x}", .{adjusted_target_addr});
                 const disp = try Relocation.calcPcRelativeDisplacementX86(source_addr, adjusted_target_addr, 0);
@@ -1073,7 +1073,7 @@ fn resolveRelocsX86(
                     atom_code[rel_offset - 2] = 0x8d;
                 }
 
-                mem.writeInt(i32, atom_code[rel_offset..][0..4], disp, .Little);
+                mem.writeInt(i32, atom_code[rel_offset..][0..4], disp, .little);
             },
 
             .X86_64_RELOC_SIGNED,
@@ -1088,7 +1088,7 @@ fn resolveRelocsX86(
                     .X86_64_RELOC_SIGNED_4 => 4,
                     else => unreachable,
                 };
-                var addend = mem.readInt(i32, atom_code[rel_offset..][0..4], .Little) + correction;
+                var addend = mem.readInt(i32, atom_code[rel_offset..][0..4], .little) + correction;
 
                 if (rel.r_extern == 0) {
                     const base_addr = if (target.sym_index >= object.source_address_lookup.len)
@@ -1104,14 +1104,14 @@ fn resolveRelocsX86(
                 relocs_log.debug("    | target_addr = 0x{x}", .{adjusted_target_addr});
 
                 const disp = try Relocation.calcPcRelativeDisplacementX86(source_addr, adjusted_target_addr, correction);
-                mem.writeInt(i32, atom_code[rel_offset..][0..4], disp, .Little);
+                mem.writeInt(i32, atom_code[rel_offset..][0..4], disp, .little);
             },
 
             .X86_64_RELOC_UNSIGNED => {
                 var addend = if (rel.r_length == 3)
-                    mem.readInt(i64, atom_code[rel_offset..][0..8], .Little)
+                    mem.readInt(i64, atom_code[rel_offset..][0..8], .little)
                 else
-                    mem.readInt(i32, atom_code[rel_offset..][0..4], .Little);
+                    mem.readInt(i32, atom_code[rel_offset..][0..4], .little);
 
                 if (rel.r_extern == 0) {
                     const base_addr = if (target.sym_index >= object.source_address_lookup.len)
@@ -1132,9 +1132,9 @@ fn resolveRelocsX86(
                 relocs_log.debug("    | target_addr = 0x{x}", .{result});
 
                 if (rel.r_length == 3) {
-                    mem.writeInt(u64, atom_code[rel_offset..][0..8], @as(u64, @bitCast(result)), .Little);
+                    mem.writeInt(u64, atom_code[rel_offset..][0..8], @as(u64, @bitCast(result)), .little);
                 } else {
-                    mem.writeInt(u32, atom_code[rel_offset..][0..4], @as(u32, @truncate(@as(u64, @bitCast(result)))), .Little);
+                    mem.writeInt(u32, atom_code[rel_offset..][0..4], @as(u32, @truncate(@as(u64, @bitCast(result)))), .little);
                 }
 
                 subtractor = null;
diff --git a/src/link/MachO/CodeSignature.zig b/src/link/MachO/CodeSignature.zig
index 35538b4e97..0f49ee6a64 100644
--- a/src/link/MachO/CodeSignature.zig
+++ b/src/link/MachO/CodeSignature.zig
@@ -115,14 +115,14 @@ pub fn writeAdhocSignature(
     self.code_directory.inner.length = self.code_directory.size();
     header.length += self.code_directory.size();
 
-    try writer.writeInt(u32, header.magic, .Big);
-    try writer.writeInt(u32, header.length, .Big);
-    try writer.writeInt(u32, header.count, .Big);
+    try writer.writeInt(u32, header.magic, .big);
+    try writer.writeInt(u32, header.length, .big);
+    try writer.writeInt(u32, header.count, .big);
 
     var offset: u32 = @sizeOf(macho.SuperBlob) + @sizeOf(macho.BlobIndex) * @as(u32, @intCast(blobs.items.len));
     for (blobs.items) |blob| {
-        try writer.writeInt(u32, blob.slotType(), .Big);
-        try writer.writeInt(u32, offset, .Big);
+        try writer.writeInt(u32, blob.slotType(), .big);
+        try writer.writeInt(u32, offset, .big);
         offset += blob.size();
     }
 
@@ -272,27 +272,27 @@ const CodeDirectory = struct {
     }
 
     fn write(self: CodeDirectory, writer: anytype) !void {
-        try writer.writeInt(u32, self.inner.magic, .Big);
-        try writer.writeInt(u32, self.inner.length, .Big);
-        try writer.writeInt(u32, self.inner.version, .Big);
-        try writer.writeInt(u32, self.inner.flags, .Big);
-        try writer.writeInt(u32, self.inner.hashOffset, .Big);
-        try writer.writeInt(u32, self.inner.identOffset, .Big);
-        try writer.writeInt(u32, self.inner.nSpecialSlots, .Big);
-        try writer.writeInt(u32, self.inner.nCodeSlots, .Big);
-        try writer.writeInt(u32, self.inner.codeLimit, .Big);
+        try writer.writeInt(u32, self.inner.magic, .big);
+        try writer.writeInt(u32, self.inner.length, .big);
+        try writer.writeInt(u32, self.inner.version, .big);
+        try writer.writeInt(u32, self.inner.flags, .big);
+        try writer.writeInt(u32, self.inner.hashOffset, .big);
+        try writer.writeInt(u32, self.inner.identOffset, .big);
+        try writer.writeInt(u32, self.inner.nSpecialSlots, .big);
+        try writer.writeInt(u32, self.inner.nCodeSlots, .big);
+        try writer.writeInt(u32, self.inner.codeLimit, .big);
         try writer.writeByte(self.inner.hashSize);
         try writer.writeByte(self.inner.hashType);
         try writer.writeByte(self.inner.platform);
         try writer.writeByte(self.inner.pageSize);
-        try writer.writeInt(u32, self.inner.spare2, .Big);
-        try writer.writeInt(u32, self.inner.scatterOffset, .Big);
-        try writer.writeInt(u32, self.inner.teamOffset, .Big);
-        try writer.writeInt(u32, self.inner.spare3, .Big);
-        try writer.writeInt(u64, self.inner.codeLimit64, .Big);
-        try writer.writeInt(u64, self.inner.execSegBase, .Big);
-        try writer.writeInt(u64, self.inner.execSegLimit, .Big);
-        try writer.writeInt(u64, self.inner.execSegFlags, .Big);
+        try writer.writeInt(u32, self.inner.spare2, .big);
+        try writer.writeInt(u32, self.inner.scatterOffset, .big);
+        try writer.writeInt(u32, self.inner.teamOffset, .big);
+        try writer.writeInt(u32, self.inner.spare3, .big);
+        try writer.writeInt(u64, self.inner.codeLimit64, .big);
+        try writer.writeInt(u64, self.inner.execSegBase, .big);
+        try writer.writeInt(u64, self.inner.execSegLimit, .big);
+        try writer.writeInt(u64, self.inner.execSegFlags, .big);
 
         try writer.writeAll(self.ident);
         try writer.writeByte(0);
@@ -325,9 +325,9 @@ const Requirements = struct {
     }
 
     fn write(self: Requirements, writer: anytype) !void {
-        try writer.writeInt(u32, macho.CSMAGIC_REQUIREMENTS, .Big);
-        try writer.writeInt(u32, self.size(), .Big);
-        try writer.writeInt(u32, 0, .Big);
+        try writer.writeInt(u32, macho.CSMAGIC_REQUIREMENTS, .big);
+        try writer.writeInt(u32, self.size(), .big);
+        try writer.writeInt(u32, 0, .big);
     }
 };
 
@@ -348,8 +348,8 @@ const Entitlements = struct {
     }
 
     fn write(self: Entitlements, writer: anytype) !void {
-        try writer.writeInt(u32, macho.CSMAGIC_EMBEDDED_ENTITLEMENTS, .Big);
-        try writer.writeInt(u32, self.size(), .Big);
+        try writer.writeInt(u32, macho.CSMAGIC_EMBEDDED_ENTITLEMENTS, .big);
+        try writer.writeInt(u32, self.size(), .big);
         try writer.writeAll(self.inner);
     }
 };
@@ -371,8 +371,8 @@ const Signature = struct {
     }
 
     fn write(self: Signature, writer: anytype) !void {
-        try writer.writeInt(u32, macho.CSMAGIC_BLOBWRAPPER, .Big);
-        try writer.writeInt(u32, self.size(), .Big);
+        try writer.writeInt(u32, macho.CSMAGIC_BLOBWRAPPER, .big);
+        try writer.writeInt(u32, self.size(), .big);
     }
 };
 
diff --git a/src/link/MachO/DwarfInfo.zig b/src/link/MachO/DwarfInfo.zig
index 0db0238e54..a1e0ae458a 100644
--- a/src/link/MachO/DwarfInfo.zig
+++ b/src/link/MachO/DwarfInfo.zig
@@ -121,19 +121,19 @@ pub const CompileUnit = struct {
         address_size: u8,
 
         fn read(reader: anytype) !Header {
-            var length: u64 = try reader.readInt(u32, .Little);
+            var length: u64 = try reader.readInt(u32, .little);
 
             const is_64bit = length == 0xffffffff;
             if (is_64bit) {
-                length = try reader.readInt(u64, .Little);
+                length = try reader.readInt(u64, .little);
             }
 
-            const version = try reader.readInt(u16, .Little);
+            const version = try reader.readInt(u16, .little);
             const debug_abbrev_offset = if (is_64bit)
-                try reader.readInt(u64, .Little)
+                try reader.readInt(u64, .little)
             else
-                try reader.readInt(u32, .Little);
-            const address_size = try reader.readInt(u8, .Little);
+                try reader.readInt(u32, .little);
+            const address_size = try reader.readInt(u8, .little);
 
             return Header{
                 .is_64bit = is_64bit,
@@ -251,9 +251,9 @@ pub const Attribute = struct {
             },
             dwarf.FORM.strp => {
                 const off = if (cuh.is_64bit)
-                    mem.readInt(u64, debug_info[0..8], .Little)
+                    mem.readInt(u64, debug_info[0..8], .little)
                 else
-                    mem.readInt(u32, debug_info[0..4], .Little);
+                    mem.readInt(u32, debug_info[0..4], .little);
                 return ctx.getString(off);
             },
             else => return null,
@@ -267,9 +267,9 @@ pub const Attribute = struct {
 
         return switch (self.form) {
             dwarf.FORM.data1 => debug_info[0],
-            dwarf.FORM.data2 => mem.readInt(u16, debug_info[0..2], .Little),
-            dwarf.FORM.data4 => mem.readInt(u32, debug_info[0..4], .Little),
-            dwarf.FORM.data8 => mem.readInt(u64, debug_info[0..8], .Little),
+            dwarf.FORM.data2 => mem.readInt(u16, debug_info[0..2], .little),
+            dwarf.FORM.data4 => mem.readInt(u32, debug_info[0..4], .little),
+            dwarf.FORM.data8 => mem.readInt(u64, debug_info[0..8], .little),
             dwarf.FORM.udata => try leb.readULEB128(u64, reader),
             dwarf.FORM.sdata => try leb.readILEB128(i64, reader),
             else => null,
@@ -281,9 +281,9 @@ pub const Attribute = struct {
         const debug_info = self.getDebugInfo(ctx);
         return switch (cuh.address_size) {
             1 => debug_info[0],
-            2 => mem.readInt(u16, debug_info[0..2], .Little),
-            4 => mem.readInt(u32, debug_info[0..4], .Little),
-            8 => mem.readInt(u64, debug_info[0..8], .Little),
+            2 => mem.readInt(u16, debug_info[0..2], .little),
+            4 => mem.readInt(u32, debug_info[0..4], .little),
+            8 => mem.readInt(u64, debug_info[0..8], .little),
             else => unreachable,
         };
     }
@@ -380,9 +380,9 @@ fn findFormSize(self: DwarfInfo, form: u64, di_off: usize, cuh: CompileUnit.Head
         dwarf.FORM.block,
         => {
             const len: u64 = switch (form) {
-                dwarf.FORM.block1 => try reader.readInt(u8, .Little),
-                dwarf.FORM.block2 => try reader.readInt(u16, .Little),
-                dwarf.FORM.block4 => try reader.readInt(u32, .Little),
+                dwarf.FORM.block1 => try reader.readInt(u8, .little),
+                dwarf.FORM.block2 => try reader.readInt(u16, .little),
+                dwarf.FORM.block4 => try reader.readInt(u32, .little),
                 dwarf.FORM.block => try leb.readULEB128(u64, reader),
                 else => unreachable,
             };
diff --git a/src/link/MachO/Relocation.zig b/src/link/MachO/Relocation.zig
index 447e19be38..74be9eb0d5 100644
--- a/src/link/MachO/Relocation.zig
+++ b/src/link/MachO/Relocation.zig
@@ -128,7 +128,7 @@ fn resolveAarch64(self: Relocation, source_addr: u64, target_addr: i64, code: []
                 ), buffer[0..4]),
             };
             inst.unconditional_branch_immediate.imm26 = @as(u26, @truncate(@as(u28, @bitCast(displacement >> 2))));
-            mem.writeInt(u32, buffer[0..4], inst.toU32(), .Little);
+            mem.writeInt(u32, buffer[0..4], inst.toU32(), .little);
         },
         .page, .got_page => {
             const source_page = @as(i32, @intCast(source_addr >> 12));
@@ -142,7 +142,7 @@ fn resolveAarch64(self: Relocation, source_addr: u64, target_addr: i64, code: []
             };
             inst.pc_relative_address.immhi = @as(u19, @truncate(pages >> 2));
             inst.pc_relative_address.immlo = @as(u2, @truncate(pages));
-            mem.writeInt(u32, buffer[0..4], inst.toU32(), .Little);
+            mem.writeInt(u32, buffer[0..4], inst.toU32(), .little);
         },
         .pageoff, .got_pageoff => {
             const narrowed = @as(u12, @truncate(@as(u64, @intCast(target_addr))));
@@ -154,7 +154,7 @@ fn resolveAarch64(self: Relocation, source_addr: u64, target_addr: i64, code: []
                     ), buffer[0..4]),
                 };
                 inst.add_subtract_immediate.imm12 = narrowed;
-                mem.writeInt(u32, buffer[0..4], inst.toU32(), .Little);
+                mem.writeInt(u32, buffer[0..4], inst.toU32(), .little);
             } else {
                 var inst = aarch64.Instruction{
                     .load_store_register = mem.bytesToValue(meta.TagPayload(
@@ -176,12 +176,12 @@ fn resolveAarch64(self: Relocation, source_addr: u64, target_addr: i64, code: []
                     }
                 };
                 inst.load_store_register.offset = offset;
-                mem.writeInt(u32, buffer[0..4], inst.toU32(), .Little);
+                mem.writeInt(u32, buffer[0..4], inst.toU32(), .little);
             }
         },
         .tlv_initializer, .unsigned => switch (self.length) {
-            2 => mem.writeInt(u32, buffer[0..4], @as(u32, @truncate(@as(u64, @bitCast(target_addr)))), .Little),
-            3 => mem.writeInt(u64, buffer[0..8], @as(u64, @bitCast(target_addr)), .Little),
+            2 => mem.writeInt(u32, buffer[0..4], @as(u32, @truncate(@as(u64, @bitCast(target_addr)))), .little),
+            3 => mem.writeInt(u64, buffer[0..8], @as(u64, @bitCast(target_addr)), .little),
             else => unreachable,
         },
         .got, .signed, .tlv => unreachable, // Invalid target architecture.
@@ -192,15 +192,15 @@ fn resolveX8664(self: Relocation, source_addr: u64, target_addr: i64, code: []u8
     switch (self.type) {
         .branch, .got, .tlv, .signed => {
             const displacement = @as(i32, @intCast(@as(i64, @intCast(target_addr)) - @as(i64, @intCast(source_addr)) - 4));
-            mem.writeInt(u32, code[self.offset..][0..4], @as(u32, @bitCast(displacement)), .Little);
+            mem.writeInt(u32, code[self.offset..][0..4], @as(u32, @bitCast(displacement)), .little);
         },
         .tlv_initializer, .unsigned => {
             switch (self.length) {
                 2 => {
-                    mem.writeInt(u32, code[self.offset..][0..4], @as(u32, @truncate(@as(u64, @bitCast(target_addr)))), .Little);
+                    mem.writeInt(u32, code[self.offset..][0..4], @as(u32, @truncate(@as(u64, @bitCast(target_addr)))), .little);
                 },
                 3 => {
-                    mem.writeInt(u64, code[self.offset..][0..8], @as(u64, @bitCast(target_addr)), .Little);
+                    mem.writeInt(u64, code[self.offset..][0..8], @as(u64, @bitCast(target_addr)), .little);
                 },
                 else => unreachable,
             }
diff --git a/src/link/MachO/UnwindInfo.zig b/src/link/MachO/UnwindInfo.zig
index e8c4a918ef..c588b65ea3 100644
--- a/src/link/MachO/UnwindInfo.zig
+++ b/src/link/MachO/UnwindInfo.zig
@@ -149,7 +149,7 @@ const Page = struct {
 
                 for (page.page_encodings[0..page.page_encodings_count]) |record_id| {
                     const enc = info.records.items[record_id].compactUnwindEncoding;
-                    try writer.writeInt(u32, enc, .Little);
+                    try writer.writeInt(u32, enc, .little);
                 }
 
                 assert(page.count > 0);
diff --git a/src/link/MachO/eh_frame.zig b/src/link/MachO/eh_frame.zig
index 12516db7a1..189d9b25cd 100644
--- a/src/link/MachO/eh_frame.zig
+++ b/src/link/MachO/eh_frame.zig
@@ -209,7 +209,7 @@ pub fn write(macho_file: *MachO, unwind_info: *UnwindInfo) !void {
     const writer = buffer.writer();
 
     for (eh_records.values()) |record| {
-        try writer.writeInt(u32, record.size, .Little);
+        try writer.writeInt(u32, record.size, .little);
         try buffer.appendSlice(record.data);
     }
 
@@ -259,7 +259,7 @@ pub fn EhFrameRecord(comptime is_mutable: bool) type {
             base_offset: u64,
         }) u64 {
             assert(rec.tag == .fde);
-            const addend = mem.readInt(i64, rec.data[4..][0..8], .Little);
+            const addend = mem.readInt(i64, rec.data[4..][0..8], .little);
             return @as(u64, @intCast(@as(i64, @intCast(ctx.base_addr + ctx.base_offset + 8)) + addend));
         }
 
@@ -269,7 +269,7 @@ pub fn EhFrameRecord(comptime is_mutable: bool) type {
         }) !void {
             assert(rec.tag == .fde);
             const addend = @as(i64, @intCast(value)) - @as(i64, @intCast(ctx.base_addr + ctx.base_offset + 8));
-            mem.writeInt(i64, rec.data[4..][0..8], addend, .Little);
+            mem.writeInt(i64, rec.data[4..][0..8], addend, .little);
         }
 
         pub fn getPersonalityPointerReloc(
@@ -343,13 +343,13 @@ pub fn EhFrameRecord(comptime is_mutable: bool) type {
                                 const target_addr = macho_file.getGotEntryAddress(target).?;
                                 const result = math.cast(i32, @as(i64, @intCast(target_addr)) - @as(i64, @intCast(source_addr))) orelse
                                     return error.Overflow;
-                                mem.writeInt(i32, rec.data[rel_offset..][0..4], result, .Little);
+                                mem.writeInt(i32, rec.data[rel_offset..][0..4], result, .little);
                             },
                             .ARM64_RELOC_UNSIGNED => {
                                 assert(rel.r_extern == 1);
                                 const target_addr = Atom.getRelocTargetAddress(macho_file, target, false);
                                 const result = @as(i64, @intCast(target_addr)) - @as(i64, @intCast(source_addr));
-                                mem.writeInt(i64, rec.data[rel_offset..][0..8], @as(i64, @intCast(result)), .Little);
+                                mem.writeInt(i64, rec.data[rel_offset..][0..8], @as(i64, @intCast(result)), .little);
                             },
                             else => unreachable,
                         }
@@ -359,10 +359,10 @@ pub fn EhFrameRecord(comptime is_mutable: bool) type {
                         switch (rel_type) {
                             .X86_64_RELOC_GOT => {
                                 const target_addr = macho_file.getGotEntryAddress(target).?;
-                                const addend = mem.readInt(i32, rec.data[rel_offset..][0..4], .Little);
+                                const addend = mem.readInt(i32, rec.data[rel_offset..][0..4], .little);
                                 const adjusted_target_addr = @as(u64, @intCast(@as(i64, @intCast(target_addr)) + addend));
                                 const disp = try Relocation.calcPcRelativeDisplacementX86(source_addr, adjusted_target_addr, 0);
-                                mem.writeInt(i32, rec.data[rel_offset..][0..4], disp, .Little);
+                                mem.writeInt(i32, rec.data[rel_offset..][0..4], disp, .little);
                             },
                             else => unreachable,
                         }
@@ -375,7 +375,7 @@ pub fn EhFrameRecord(comptime is_mutable: bool) type {
         pub fn getCiePointerSource(rec: Record, object_id: u32, macho_file: *MachO, offset: u32) u32 {
             assert(rec.tag == .fde);
             const cpu_arch = macho_file.base.options.target.cpu.arch;
-            const addend = mem.readInt(u32, rec.data[0..4], .Little);
+            const addend = mem.readInt(u32, rec.data[0..4], .little);
             switch (cpu_arch) {
                 .aarch64 => {
                     const relocs = getRelocs(macho_file, object_id, offset);
@@ -397,12 +397,12 @@ pub fn EhFrameRecord(comptime is_mutable: bool) type {
 
         pub fn getCiePointer(rec: Record) u32 {
             assert(rec.tag == .fde);
-            return mem.readInt(u32, rec.data[0..4], .Little);
+            return mem.readInt(u32, rec.data[0..4], .little);
         }
 
         pub fn setCiePointer(rec: *Record, ptr: u32) void {
             assert(rec.tag == .fde);
-            mem.writeInt(u32, rec.data[0..4], ptr, .Little);
+            mem.writeInt(u32, rec.data[0..4], ptr, .little);
         }
 
         pub fn getAugmentationString(rec: Record) []const u8 {
@@ -509,14 +509,14 @@ pub fn EhFrameRecord(comptime is_mutable: bool) type {
             if (enc == EH_PE.omit) return null;
 
             var ptr: i64 = switch (enc & 0x0F) {
-                EH_PE.absptr => @as(i64, @bitCast(try reader.readInt(u64, .Little))),
-                EH_PE.udata2 => @as(i16, @bitCast(try reader.readInt(u16, .Little))),
-                EH_PE.udata4 => @as(i32, @bitCast(try reader.readInt(u32, .Little))),
-                EH_PE.udata8 => @as(i64, @bitCast(try reader.readInt(u64, .Little))),
+                EH_PE.absptr => @as(i64, @bitCast(try reader.readInt(u64, .little))),
+                EH_PE.udata2 => @as(i16, @bitCast(try reader.readInt(u16, .little))),
+                EH_PE.udata4 => @as(i32, @bitCast(try reader.readInt(u32, .little))),
+                EH_PE.udata8 => @as(i64, @bitCast(try reader.readInt(u64, .little))),
                 EH_PE.uleb128 => @as(i64, @bitCast(try leb.readULEB128(u64, reader))),
-                EH_PE.sdata2 => try reader.readInt(i16, .Little),
-                EH_PE.sdata4 => try reader.readInt(i32, .Little),
-                EH_PE.sdata8 => try reader.readInt(i64, .Little),
+                EH_PE.sdata2 => try reader.readInt(i16, .little),
+                EH_PE.sdata4 => try reader.readInt(i32, .little),
+                EH_PE.sdata8 => try reader.readInt(i64, .little),
                 EH_PE.sleb128 => try leb.readILEB128(i64, reader),
                 else => return null,
             };
@@ -552,14 +552,14 @@ pub fn EhFrameRecord(comptime is_mutable: bool) type {
             }
 
             switch (enc & 0x0F) {
-                EH_PE.absptr => try writer.writeInt(u64, @as(u64, @bitCast(actual)), .Little),
-                EH_PE.udata2 => try writer.writeInt(u16, @as(u16, @bitCast(@as(i16, @intCast(actual)))), .Little),
-                EH_PE.udata4 => try writer.writeInt(u32, @as(u32, @bitCast(@as(i32, @intCast(actual)))), .Little),
-                EH_PE.udata8 => try writer.writeInt(u64, @as(u64, @bitCast(actual)), .Little),
+                EH_PE.absptr => try writer.writeInt(u64, @as(u64, @bitCast(actual)), .little),
+                EH_PE.udata2 => try writer.writeInt(u16, @as(u16, @bitCast(@as(i16, @intCast(actual)))), .little),
+                EH_PE.udata4 => try writer.writeInt(u32, @as(u32, @bitCast(@as(i32, @intCast(actual)))), .little),
+                EH_PE.udata8 => try writer.writeInt(u64, @as(u64, @bitCast(actual)), .little),
                 EH_PE.uleb128 => try leb.writeULEB128(writer, @as(u64, @bitCast(actual))),
-                EH_PE.sdata2 => try writer.writeInt(i16, @as(i16, @intCast(actual)), .Little),
-                EH_PE.sdata4 => try writer.writeInt(i32, @as(i32, @intCast(actual)), .Little),
-                EH_PE.sdata8 => try writer.writeInt(i64, actual, .Little),
+                EH_PE.sdata2 => try writer.writeInt(i16, @as(i16, @intCast(actual)), .little),
+                EH_PE.sdata4 => try writer.writeInt(i32, @as(i32, @intCast(actual)), .little),
+                EH_PE.sdata8 => try writer.writeInt(i64, actual, .little),
                 EH_PE.sleb128 => try leb.writeILEB128(writer, actual),
                 else => unreachable,
             }
@@ -586,13 +586,13 @@ pub const Iterator = struct {
         var stream = std.io.fixedBufferStream(it.data[it.pos..]);
         const reader = stream.reader();
 
-        var size = try reader.readInt(u32, .Little);
+        var size = try reader.readInt(u32, .little);
         if (size == 0xFFFFFFFF) {
             log.debug("MachO doesn't support 64bit DWARF CFI __eh_frame records", .{});
             return error.BadDwarfCfi;
         }
 
-        const id = try reader.readInt(u32, .Little);
+        const id = try reader.readInt(u32, .little);
         const tag: EhFrameRecordTag = if (id == 0) .cie else .fde;
         const offset: u32 = 4;
         const record = EhFrameRecord(false){
diff --git a/src/link/MachO/stubs.zig b/src/link/MachO/stubs.zig
index 6d947983f6..925aeaa61f 100644
--- a/src/link/MachO/stubs.zig
+++ b/src/link/MachO/stubs.zig
@@ -53,7 +53,7 @@ pub fn writeStubHelperPreambleCode(args: struct {
                     args.dyld_private_addr,
                     0,
                 );
-                try writer.writeInt(i32, disp, .Little);
+                try writer.writeInt(i32, disp, .little);
             }
             try writer.writeAll(&.{ 0x41, 0x53, 0xff, 0x25 });
             {
@@ -62,27 +62,27 @@ pub fn writeStubHelperPreambleCode(args: struct {
                     args.dyld_stub_binder_got_addr,
                     0,
                 );
-                try writer.writeInt(i32, disp, .Little);
+                try writer.writeInt(i32, disp, .little);
             }
         },
         .aarch64 => {
             {
                 const pages = Relocation.calcNumberOfPages(args.source_addr, args.dyld_private_addr);
-                try writer.writeInt(u32, aarch64.Instruction.adrp(.x17, pages).toU32(), .Little);
+                try writer.writeInt(u32, aarch64.Instruction.adrp(.x17, pages).toU32(), .little);
             }
             {
                 const off = try Relocation.calcPageOffset(args.dyld_private_addr, .arithmetic);
-                try writer.writeInt(u32, aarch64.Instruction.add(.x17, .x17, off, false).toU32(), .Little);
+                try writer.writeInt(u32, aarch64.Instruction.add(.x17, .x17, off, false).toU32(), .little);
             }
             try writer.writeInt(u32, aarch64.Instruction.stp(
                 .x16,
                 .x17,
                 aarch64.Register.sp,
                 aarch64.Instruction.LoadStorePairOffset.pre_index(-16),
-            ).toU32(), .Little);
+            ).toU32(), .little);
             {
                 const pages = Relocation.calcNumberOfPages(args.source_addr + 12, args.dyld_stub_binder_got_addr);
-                try writer.writeInt(u32, aarch64.Instruction.adrp(.x16, pages).toU32(), .Little);
+                try writer.writeInt(u32, aarch64.Instruction.adrp(.x16, pages).toU32(), .little);
             }
             {
                 const off = try Relocation.calcPageOffset(args.dyld_stub_binder_got_addr, .load_store_64);
@@ -90,9 +90,9 @@ pub fn writeStubHelperPreambleCode(args: struct {
                     .x16,
                     .x16,
                     aarch64.Instruction.LoadStoreOffset.imm(off),
-                ).toU32(), .Little);
+                ).toU32(), .little);
             }
-            try writer.writeInt(u32, aarch64.Instruction.br(.x16).toU32(), .Little);
+            try writer.writeInt(u32, aarch64.Instruction.br(.x16).toU32(), .little);
         },
         else => unreachable,
     }
@@ -108,7 +108,7 @@ pub fn writeStubHelperCode(args: struct {
             try writer.writeAll(&.{ 0x68, 0x0, 0x0, 0x0, 0x0, 0xe9 });
             {
                 const disp = try Relocation.calcPcRelativeDisplacementX86(args.source_addr + 6, args.target_addr, 0);
-                try writer.writeInt(i32, disp, .Little);
+                try writer.writeInt(i32, disp, .little);
             }
         },
         .aarch64 => {
@@ -120,10 +120,10 @@ pub fn writeStubHelperCode(args: struct {
             try writer.writeInt(u32, aarch64.Instruction.ldrLiteral(
                 .w16,
                 literal,
-            ).toU32(), .Little);
+            ).toU32(), .little);
             {
                 const disp = try Relocation.calcPcRelativeDisplacementArm64(args.source_addr + 4, args.target_addr);
-                try writer.writeInt(u32, aarch64.Instruction.b(disp).toU32(), .Little);
+                try writer.writeInt(u32, aarch64.Instruction.b(disp).toU32(), .little);
             }
             try writer.writeAll(&.{ 0x0, 0x0, 0x0, 0x0 });
         },
@@ -141,13 +141,13 @@ pub fn writeStubCode(args: struct {
             try writer.writeAll(&.{ 0xff, 0x25 });
             {
                 const disp = try Relocation.calcPcRelativeDisplacementX86(args.source_addr + 2, args.target_addr, 0);
-                try writer.writeInt(i32, disp, .Little);
+                try writer.writeInt(i32, disp, .little);
             }
         },
         .aarch64 => {
             {
                 const pages = Relocation.calcNumberOfPages(args.source_addr, args.target_addr);
-                try writer.writeInt(u32, aarch64.Instruction.adrp(.x16, pages).toU32(), .Little);
+                try writer.writeInt(u32, aarch64.Instruction.adrp(.x16, pages).toU32(), .little);
             }
             {
                 const off = try Relocation.calcPageOffset(args.target_addr, .load_store_64);
@@ -155,9 +155,9 @@ pub fn writeStubCode(args: struct {
                     .x16,
                     .x16,
                     aarch64.Instruction.LoadStoreOffset.imm(off),
-                ).toU32(), .Little);
+                ).toU32(), .little);
             }
-            try writer.writeInt(u32, aarch64.Instruction.br(.x16).toU32(), .Little);
+            try writer.writeInt(u32, aarch64.Instruction.br(.x16).toU32(), .little);
         },
         else => unreachable,
     }
diff --git a/src/link/MachO/thunks.zig b/src/link/MachO/thunks.zig
index 21f5d2f410..774a8f7344 100644
--- a/src/link/MachO/thunks.zig
+++ b/src/link/MachO/thunks.zig
@@ -349,10 +349,10 @@ pub fn writeThunkCode(macho_file: *MachO, thunk: *const Thunk, writer: anytype)
             .atom => macho_file.getSymbol(target).n_value,
         };
         const pages = Relocation.calcNumberOfPages(source_addr, target_addr);
-        try writer.writeInt(u32, aarch64.Instruction.adrp(.x16, pages).toU32(), .Little);
+        try writer.writeInt(u32, aarch64.Instruction.adrp(.x16, pages).toU32(), .little);
         const off = try Relocation.calcPageOffset(target_addr, .arithmetic);
-        try writer.writeInt(u32, aarch64.Instruction.add(.x16, .x16, off, false).toU32(), .Little);
-        try writer.writeInt(u32, aarch64.Instruction.br(.x16).toU32(), .Little);
+        try writer.writeInt(u32, aarch64.Instruction.add(.x16, .x16, off, false).toU32(), .little);
+        try writer.writeInt(u32, aarch64.Instruction.br(.x16).toU32(), .little);
     }
 }
 
diff --git a/src/link/MachO/zld.zig b/src/link/MachO/zld.zig
index ed1d3f0258..b94da1d284 100644
--- a/src/link/MachO/zld.zig
+++ b/src/link/MachO/zld.zig
@@ -796,7 +796,7 @@ fn writePointerEntries(macho_file: *MachO, sect_id: u8, table: anytype) !void {
     defer buffer.deinit();
     for (table.entries.items) |entry| {
         const sym = macho_file.getSymbol(entry);
-        buffer.writer().writeInt(u64, sym.n_value, .Little) catch unreachable;
+        buffer.writer().writeInt(u64, sym.n_value, .little) catch unreachable;
     }
     log.debug("writing __DATA_CONST,__got contents at file offset 0x{x}", .{header.offset});
     try macho_file.base.file.?.pwriteAll(buffer.items, header.offset);
@@ -880,7 +880,7 @@ fn writeLaSymbolPtrs(macho_file: *MachO) !void {
     for (0..macho_file.stub_table.count()) |index| {
         const target_addr = stub_helper_header.addr + stubs.stubHelperPreambleSize(cpu_arch) +
             stubs.stubHelperSize(cpu_arch) * index;
-        buffer.writer().writeInt(u64, target_addr, .Little) catch unreachable;
+        buffer.writer().writeInt(u64, target_addr, .little) catch unreachable;
     }
 
     log.debug("writing __DATA,__la_symbol_ptr contents at file offset 0x{x}", .{
diff --git a/src/link/Plan9.zig b/src/link/Plan9.zig
index 04c8c9abe7..d8b6f39f76 100644
--- a/src/link/Plan9.zig
+++ b/src/link/Plan9.zig
@@ -348,7 +348,7 @@ fn putFn(self: *Plan9, decl_index: Module.Decl.Index, out: FnDeclOutput) !void {
         // every 'z' starts with 0
         try a.append(0);
         // path component value of '/'
-        try a.writer().writeInt(u16, 1, .Big);
+        try a.writer().writeInt(u16, 1, .big);
 
         // getting the full file path
         var buf: [std.fs.MAX_PATH_BYTES]u8 = undefined;
@@ -381,11 +381,11 @@ fn addPathComponents(self: *Plan9, path: []const u8, a: *std.ArrayList(u8)) !voi
     var it = std.mem.tokenizeScalar(u8, path, sep);
     while (it.next()) |component| {
         if (self.file_segments.get(component)) |num| {
-            try a.writer().writeInt(u16, num, .Big);
+            try a.writer().writeInt(u16, num, .big);
         } else {
             self.file_segments_i += 1;
             try self.file_segments.put(self.base.allocator, component, self.file_segments_i);
-            try a.writer().writeInt(u16, self.file_segments_i, .Big);
+            try a.writer().writeInt(u16, self.file_segments_i, .big);
         }
     }
 }
@@ -607,7 +607,7 @@ pub fn changeLine(l: *std.ArrayList(u8), delta_line: i32) !void {
         try l.append(toadd);
     } else if (delta_line != 0) {
         try l.append(0);
-        try l.writer().writeInt(i32, delta_line, .Big);
+        try l.writer().writeInt(i32, delta_line, .big);
     }
 }
 
@@ -922,7 +922,7 @@ pub fn flushModule(self: *Plan9, comp: *Compilation, prog_node: *std.Progress.No
     @memcpy(hdr_slice, self.hdr.toU8s()[0..hdr_size]);
     // write the fat header for 64 bit entry points
     if (self.sixtyfour_bit) {
-        mem.writeInt(u64, hdr_buf[32..40], self.entry_val.?, .Big);
+        mem.writeInt(u64, hdr_buf[32..40], self.entry_val.?, .big);
     }
     // perform the relocs
     {
@@ -1311,9 +1311,9 @@ pub fn writeSym(self: *Plan9, w: anytype, sym: aout.Sym) !void {
     // log.debug("write sym{{name: {s}, value: {x}}}", .{ sym.name, sym.value });
     if (sym.type == .bad) return; // we don't want to write free'd symbols
     if (!self.sixtyfour_bit) {
-        try w.writeInt(u32, @as(u32, @intCast(sym.value)), .Big);
+        try w.writeInt(u32, @as(u32, @intCast(sym.value)), .big);
     } else {
-        try w.writeInt(u64, sym.value, .Big);
+        try w.writeInt(u64, sym.value, .big);
     }
     try w.writeByte(@intFromEnum(sym.type));
     try w.writeAll(sym.name);
diff --git a/src/link/Plan9/aout.zig b/src/link/Plan9/aout.zig
index 8879a4832f..12dfc45873 100644
--- a/src/link/Plan9/aout.zig
+++ b/src/link/Plan9/aout.zig
@@ -21,7 +21,7 @@ pub const ExecHdr = extern struct {
         var buf: [40]u8 = undefined;
         var i: u8 = 0;
         inline for (std.meta.fields(@This())) |f| {
-            std.mem.writeInt(u32, buf[i..][0..4], @field(self, f.name), .Big);
+            std.mem.writeInt(u32, buf[i..][0..4], @field(self, f.name), .big);
             i += 4;
         }
         return buf;
diff --git a/src/link/Wasm.zig b/src/link/Wasm.zig
index 2be90fa15b..fdac89f837 100644
--- a/src/link/Wasm.zig
+++ b/src/link/Wasm.zig
@@ -2380,7 +2380,7 @@ fn setupErrorsLen(wasm: *Wasm) !void {
     atom.* = Atom.empty;
     atom.sym_index = loc.index;
     atom.size = 2;
-    try atom.code.writer(wasm.base.allocator).writeInt(u16, @intCast(errors_len), .Little);
+    try atom.code.writer(wasm.base.allocator).writeInt(u16, @intCast(errors_len), .little);
 
     try wasm.parseAtom(atom_index, .{ .data = .read_only });
 }
@@ -3151,7 +3151,7 @@ fn populateErrorNameTable(wasm: *Wasm) !void {
         const offset = @as(u32, @intCast(atom.code.items.len));
         // first we create the data for the slice of the name
         try atom.code.appendNTimes(wasm.base.allocator, 0, 4); // ptr to name, will be relocated
-        try atom.code.writer(wasm.base.allocator).writeInt(u32, len - 1, .Little);
+        try atom.code.writer(wasm.base.allocator).writeInt(u32, len - 1, .little);
         // create relocation to the error name
         try atom.relocs.append(wasm.base.allocator, .{
             .index = names_atom.sym_index,
@@ -4286,11 +4286,11 @@ fn emitInit(writer: anytype, init_expr: std.wasm.InitExpression) !void {
         },
         .f32_const => |val| {
             try writer.writeByte(std.wasm.opcode(.f32_const));
-            try writer.writeInt(u32, @bitCast(val), .Little);
+            try writer.writeInt(u32, @bitCast(val), .little);
         },
         .f64_const => |val| {
             try writer.writeByte(std.wasm.opcode(.f64_const));
-            try writer.writeInt(u64, @bitCast(val), .Little);
+            try writer.writeInt(u64, @bitCast(val), .little);
         },
         .global_get => |val| {
             try writer.writeByte(std.wasm.opcode(.global_get));
diff --git a/src/link/Wasm/Archive.zig b/src/link/Wasm/Archive.zig
index 91e92ae36d..a618aaebbf 100644
--- a/src/link/Wasm/Archive.zig
+++ b/src/link/Wasm/Archive.zig
@@ -141,11 +141,11 @@ fn parseTableOfContents(archive: *Archive, allocator: Allocator, reader: anytype
     const size_trimmed = mem.trim(u8, &archive.header.ar_size, " ");
     const sym_tab_size = try std.fmt.parseInt(u32, size_trimmed, 10);
 
-    const num_symbols = try reader.readInt(u32, .Big);
+    const num_symbols = try reader.readInt(u32, .big);
     const symbol_positions = try allocator.alloc(u32, num_symbols);
     defer allocator.free(symbol_positions);
     for (symbol_positions) |*index| {
-        index.* = try reader.readInt(u32, .Big);
+        index.* = try reader.readInt(u32, .big);
     }
 
     const sym_tab = try allocator.alloc(u8, sym_tab_size - 4 - (4 * num_symbols));
diff --git a/src/link/Wasm/Atom.zig b/src/link/Wasm/Atom.zig
index 65e92ed140..60727b6af1 100644
--- a/src/link/Wasm/Atom.zig
+++ b/src/link/Wasm/Atom.zig
@@ -114,10 +114,10 @@ pub fn resolveRelocs(atom: *Atom, wasm_bin: *const Wasm) void {
             .R_WASM_GLOBAL_INDEX_I32,
             .R_WASM_MEMORY_ADDR_I32,
             .R_WASM_SECTION_OFFSET_I32,
-            => std.mem.writeInt(u32, atom.code.items[reloc.offset..][0..4], @as(u32, @intCast(value)), .Little),
+            => std.mem.writeInt(u32, atom.code.items[reloc.offset..][0..4], @as(u32, @intCast(value)), .little),
             .R_WASM_TABLE_INDEX_I64,
             .R_WASM_MEMORY_ADDR_I64,
-            => std.mem.writeInt(u64, atom.code.items[reloc.offset..][0..8], value, .Little),
+            => std.mem.writeInt(u64, atom.code.items[reloc.offset..][0..8], value, .little),
             .R_WASM_GLOBAL_INDEX_LEB,
             .R_WASM_EVENT_INDEX_LEB,
             .R_WASM_FUNCTION_INDEX_LEB,
diff --git a/src/link/Wasm/Object.zig b/src/link/Wasm/Object.zig
index 6517d7ec20..359ff20d94 100644
--- a/src/link/Wasm/Object.zig
+++ b/src/link/Wasm/Object.zig
@@ -344,7 +344,7 @@ fn Parser(comptime ReaderType: type) type {
         fn parseObject(parser: *ObjectParser, gpa: Allocator, is_object_file: *bool) Error!void {
             errdefer parser.object.deinit(gpa);
             try parser.verifyMagicBytes();
-            const version = try parser.reader.reader().readInt(u32, .Little);
+            const version = try parser.reader.reader().readInt(u32, .little);
 
             parser.object.version = version;
             var relocatable_data = std.ArrayList(RelocatableData).init(gpa);