From bf0d4360879d203025d6618e693feda768246ea8 Mon Sep 17 00:00:00 2001 From: Evan Haas Date: Thu, 26 Aug 2021 10:19:31 -0700 Subject: [PATCH 1/2] stdlib: Add Intel HEX support to InstallRawStep This allows writing HEX files with `exe.installRaw`, where `exe` is a `LibExeObjStep`. A HEX file will be written if the file extension is `.hex` or `.ihex`, otherwise a binfile will be written. The output format can be explicitly chosen with `exe.installRawWithFormat("filename", .hex);` (or `.bin`) Part of #2826 Co-authored-by: Akbar Dhanaliwala --- lib/std/build.zig | 15 ++- lib/std/build/InstallRawStep.zig | 221 ++++++++++++++++++++++++++++++- 2 files changed, 230 insertions(+), 6 deletions(-) diff --git a/lib/std/build.zig b/lib/std/build.zig index 1124cde2cb..7ac41d1bb0 100644 --- a/lib/std/build.zig +++ b/lib/std/build.zig @@ -989,10 +989,15 @@ pub const Builder = struct { self.getInstallStep().dependOn(&self.addInstallFileWithDir(.{ .path = src_path }, .lib, dest_rel_path).step); } + /// Output format (BIN vs Intel HEX) determined by filename pub fn installRaw(self: *Builder, artifact: *LibExeObjStep, dest_filename: []const u8) void { self.getInstallStep().dependOn(&self.addInstallRaw(artifact, dest_filename).step); } + pub fn installRawWithFormat(self: *Builder, artifact: *LibExeObjStep, dest_filename: []const u8, format: InstallRawStep.RawFormat) void { + self.getInstallStep().dependOn(&self.addInstallRawWithFormat(artifact, dest_filename, format).step); + } + ///`dest_rel_path` is relative to install prefix path pub fn addInstallFile(self: *Builder, source: FileSource, dest_rel_path: []const u8) *InstallFileStep { return self.addInstallFileWithDir(source.dupe(self), .prefix, dest_rel_path); @@ -1009,7 +1014,11 @@ pub const Builder = struct { } pub fn addInstallRaw(self: *Builder, artifact: *LibExeObjStep, dest_filename: []const u8) *InstallRawStep { - return InstallRawStep.create(self, artifact, dest_filename); + return InstallRawStep.create(self, artifact, dest_filename, null); + } + + pub fn addInstallRawWithFormat(self: *Builder, artifact: *LibExeObjStep, dest_filename: []const u8, format: InstallRawStep.RawFormat) *InstallRawStep { + return InstallRawStep.create(self, artifact, dest_filename, format); } pub fn addInstallFileWithDir( @@ -1709,6 +1718,10 @@ pub const LibExeObjStep = struct { self.builder.installRaw(self, dest_filename); } + pub fn installRawWithFormat(self: *LibExeObjStep, dest_filename: []const u8, format: InstallRawStep.RawFormat) void { + self.builder.installRawWithFormat(self, dest_filename, format); + } + /// Creates a `RunStep` with an executable built with `addExecutable`. /// Add command line arguments with `addArg`. pub fn run(exe: *LibExeObjStep) *RunStep { diff --git a/lib/std/build/InstallRawStep.zig b/lib/std/build/InstallRawStep.zig index 39a2d29845..79475c4679 100644 --- a/lib/std/build/InstallRawStep.zig +++ b/lib/std/build/InstallRawStep.zig @@ -159,7 +159,147 @@ fn writeBinaryElfSection(elf_file: File, out_file: File, section: *BinaryElfSect }); } -fn emitRaw(allocator: *Allocator, elf_path: []const u8, raw_path: []const u8) !void { +const HexWriter = struct { + prev_addr: ?u32 = null, + out_file: File, + + /// Max data bytes per line of output + const MAX_PAYLOAD_LEN: u8 = 16; + + fn addressParts(address: u16) [2]u8 { + const msb = @truncate(u8, address >> 8); + const lsb = @truncate(u8, address); + return [2]u8{ msb, lsb }; + } + + const Record = struct { + const Type = enum(u8) { + Data = 0, + EOF = 1, + ExtendedSegmentAddress = 2, + ExtendedLinearAddress = 4, + }; + + address: u16, + payload: union(Type) { + Data: []const u8, + EOF: void, + ExtendedSegmentAddress: [2]u8, + ExtendedLinearAddress: [2]u8, + }, + + fn EOF() Record { + return Record{ + .address = 0, + .payload = .EOF, + }; + } + + fn Data(address: u32, data: []const u8) Record { + return Record{ + .address = @intCast(u16, address % 0x10000), + .payload = .{ .Data = data }, + }; + } + + fn Address(address: u32) Record { + std.debug.assert(address > 0xFFFF); + const segment = @intCast(u16, address / 0x10000); + if (address > 0xFFFFF) { + return Record{ + .address = 0, + .payload = .{ .ExtendedLinearAddress = addressParts(segment) }, + }; + } else { + return Record{ + .address = 0, + .payload = .{ .ExtendedSegmentAddress = addressParts(segment << 12) }, + }; + } + } + + fn getPayloadBytes(self: Record) []const u8 { + return switch (self.payload) { + .Data => |d| d, + .EOF => @as([]const u8, &.{}), + .ExtendedSegmentAddress, .ExtendedLinearAddress => |*seg| seg, + }; + } + + fn checksum(self: Record) u8 { + const payload_bytes = self.getPayloadBytes(); + + var sum: u8 = @intCast(u8, payload_bytes.len); + const parts = addressParts(self.address); + sum +%= parts[0]; + sum +%= parts[1]; + sum +%= @enumToInt(self.payload); + for (payload_bytes) |byte| { + sum +%= byte; + } + return (sum ^ 0xFF) +% 1; + } + + fn write(self: Record, file: File) File.WriteError!void { + const linesep = "\r\n"; + // colon, (length, address, type, payload, checksum) as hex, CRLF + const BUFSIZE = 1 + (1 + 2 + 1 + MAX_PAYLOAD_LEN + 1) * 2 + linesep.len; + var outbuf: [BUFSIZE]u8 = undefined; + const payload_bytes = self.getPayloadBytes(); + std.debug.assert(payload_bytes.len <= MAX_PAYLOAD_LEN); + + const line = try std.fmt.bufPrint(&outbuf, ":{0X:0>2}{1X:0>4}{2X:0>2}{3s}{4X:0>2}" ++ linesep, .{ + @intCast(u8, payload_bytes.len), + self.address, + @enumToInt(self.payload), + std.fmt.fmtSliceHexUpper(payload_bytes), + self.checksum(), + }); + try file.writeAll(line); + } + }; + + pub fn writeSegment(self: *HexWriter, segment: *const BinaryElfSegment, elf_file: File) !void { + var buf: [MAX_PAYLOAD_LEN]u8 = undefined; + var bytes_read: usize = 0; + while (bytes_read < segment.fileSize) { + const row_address = @intCast(u32, segment.physicalAddress + bytes_read); + + const remaining = segment.fileSize - bytes_read; + const to_read = @minimum(remaining, MAX_PAYLOAD_LEN); + const did_read = try elf_file.preadAll(buf[0..to_read], segment.elfOffset + bytes_read); + if (did_read < to_read) return error.UnexpectedEOF; + + try self.writeDataRow(row_address, buf[0..did_read]); + + bytes_read += did_read; + } + } + + fn writeDataRow(self: *HexWriter, address: u32, data: []const u8) File.WriteError!void { + const record = Record.Data(address, data); + if (address > 0xFFFF and (self.prev_addr == null or record.address != self.prev_addr.?)) { + try Record.Address(address).write(self.out_file); + } + try record.write(self.out_file); + self.prev_addr = @intCast(u32, record.address + data.len); + } + + fn writeEOF(self: HexWriter) File.WriteError!void { + try Record.EOF().write(self.out_file); + } +}; + +fn containsValidAddressRange(segments: []*BinaryElfSegment) bool { + const max_address = std.math.maxInt(u32); + for (segments) |segment| { + if (segment.fileSize > max_address or + segment.physicalAddress > max_address - segment.fileSize) return false; + } + return true; +} + +fn emitRaw(allocator: *Allocator, elf_path: []const u8, raw_path: []const u8, format: RawFormat) !void { var elf_file = try fs.cwd().openFile(elf_path, .{}); defer elf_file.close(); @@ -169,8 +309,26 @@ fn emitRaw(allocator: *Allocator, elf_path: []const u8, raw_path: []const u8) !v var binary_elf_output = try BinaryElfOutput.parse(allocator, elf_file); defer binary_elf_output.deinit(); - for (binary_elf_output.sections.items) |section| { - try writeBinaryElfSection(elf_file, out_file, section); + switch (format) { + .bin => { + for (binary_elf_output.sections.items) |section| { + try writeBinaryElfSection(elf_file, out_file, section); + } + }, + .hex => { + if (binary_elf_output.segments.items.len == 0) return; + if (!containsValidAddressRange(binary_elf_output.segments.items)) { + return error.InvalidHexfileAddressRange; + } + + var hex_writer = HexWriter{ .out_file = out_file }; + for (binary_elf_output.sections.items) |section| { + if (section.segment) |segment| { + try hex_writer.writeSegment(segment, elf_file); + } + } + try hex_writer.writeEOF(); + }, } } @@ -178,13 +336,26 @@ const InstallRawStep = @This(); pub const base_id = .install_raw; +pub const RawFormat = enum { + bin, + hex, +}; + step: Step, builder: *Builder, artifact: *LibExeObjStep, dest_dir: InstallDir, dest_filename: []const u8, +format: RawFormat, -pub fn create(builder: *Builder, artifact: *LibExeObjStep, dest_filename: []const u8) *InstallRawStep { +fn detectFormat(filename: []const u8) RawFormat { + if (std.mem.endsWith(u8, filename, ".hex") or std.mem.endsWith(u8, filename, ".ihex")) { + return .hex; + } + return .bin; +} + +pub fn create(builder: *Builder, artifact: *LibExeObjStep, dest_filename: []const u8, format: ?RawFormat) *InstallRawStep { const self = builder.allocator.create(InstallRawStep) catch unreachable; self.* = InstallRawStep{ .step = Step.init(.install_raw, builder.fmt("install raw binary {s}", .{artifact.step.name}), builder.allocator, make), @@ -197,6 +368,7 @@ pub fn create(builder: *Builder, artifact: *LibExeObjStep, dest_filename: []cons .lib => unreachable, }, .dest_filename = dest_filename, + .format = format orelse detectFormat(dest_filename), }; self.step.dependOn(&artifact.step); @@ -217,9 +389,48 @@ fn make(step: *Step) !void { const full_dest_path = builder.getInstallPath(self.dest_dir, self.dest_filename); fs.cwd().makePath(builder.getInstallPath(self.dest_dir, "")) catch unreachable; - try emitRaw(builder.allocator, full_src_path, full_dest_path); + try emitRaw(builder.allocator, full_src_path, full_dest_path, self.format); } test { std.testing.refAllDecls(InstallRawStep); } + +test "Detect format from filename" { + try std.testing.expectEqual(RawFormat.hex, detectFormat("foo.hex")); + try std.testing.expectEqual(RawFormat.hex, detectFormat("foo.ihex")); + try std.testing.expectEqual(RawFormat.bin, detectFormat("foo.bin")); + try std.testing.expectEqual(RawFormat.bin, detectFormat("foo.bar")); + try std.testing.expectEqual(RawFormat.bin, detectFormat("a")); +} + +test "containsValidAddressRange" { + var segment = BinaryElfSegment{ + .physicalAddress = 0, + .virtualAddress = 0, + .elfOffset = 0, + .binaryOffset = 0, + .fileSize = 0, + .firstSection = null, + }; + var buf: [1]*BinaryElfSegment = .{&segment}; + + // segment too big + segment.fileSize = std.math.maxInt(u32) + 1; + try std.testing.expect(!containsValidAddressRange(&buf)); + + // start address too big + segment.physicalAddress = std.math.maxInt(u32) + 1; + segment.fileSize = 2; + try std.testing.expect(!containsValidAddressRange(&buf)); + + // max address too big + segment.physicalAddress = std.math.maxInt(u32) - 1; + segment.fileSize = 2; + try std.testing.expect(!containsValidAddressRange(&buf)); + + // is ok + segment.physicalAddress = std.math.maxInt(u32) - 1; + segment.fileSize = 1; + try std.testing.expect(containsValidAddressRange(&buf)); +} From 742fe65f3ea4390acf7ed6beec95f910f56e1246 Mon Sep 17 00:00:00 2001 From: Evan Haas Date: Fri, 27 Aug 2021 14:58:28 -0700 Subject: [PATCH 2/2] stdlib: Add test for generating HEX files. Co-authored-by: Akbar Dhanaliwala --- lib/std/build/InstallRawStep.zig | 7 + test/standalone.zig | 1 + test/standalone/install_raw_hex/build.zig | 173 ++++++++++++++++++++++ test/standalone/install_raw_hex/main.zig | 3 + 4 files changed, 184 insertions(+) create mode 100644 test/standalone/install_raw_hex/build.zig create mode 100644 test/standalone/install_raw_hex/main.zig diff --git a/lib/std/build/InstallRawStep.zig b/lib/std/build/InstallRawStep.zig index 79475c4679..ed01a6ea6e 100644 --- a/lib/std/build/InstallRawStep.zig +++ b/lib/std/build/InstallRawStep.zig @@ -347,6 +347,7 @@ artifact: *LibExeObjStep, dest_dir: InstallDir, dest_filename: []const u8, format: RawFormat, +output_file: std.build.GeneratedFile, fn detectFormat(filename: []const u8) RawFormat { if (std.mem.endsWith(u8, filename, ".hex") or std.mem.endsWith(u8, filename, ".ihex")) { @@ -369,6 +370,7 @@ pub fn create(builder: *Builder, artifact: *LibExeObjStep, dest_filename: []cons }, .dest_filename = dest_filename, .format = format orelse detectFormat(dest_filename), + .output_file = std.build.GeneratedFile{ .step = &self.step }, }; self.step.dependOn(&artifact.step); @@ -376,6 +378,10 @@ pub fn create(builder: *Builder, artifact: *LibExeObjStep, dest_filename: []cons return self; } +pub fn getOutputSource(self: *const InstallRawStep) std.build.FileSource { + return std.build.FileSource{ .generated = &self.output_file }; +} + fn make(step: *Step) !void { const self = @fieldParentPtr(InstallRawStep, "step", step); const builder = self.builder; @@ -390,6 +396,7 @@ fn make(step: *Step) !void { fs.cwd().makePath(builder.getInstallPath(self.dest_dir, "")) catch unreachable; try emitRaw(builder.allocator, full_src_path, full_dest_path, self.format); + self.output_file.path = full_dest_path; } test { diff --git a/test/standalone.zig b/test/standalone.zig index 85957923b7..3302f0c46d 100644 --- a/test/standalone.zig +++ b/test/standalone.zig @@ -26,6 +26,7 @@ pub fn addCases(cases: *tests.StandaloneContext) void { cases.addBuildFile("test/standalone/brace_expansion/build.zig", .{}); cases.addBuildFile("test/standalone/empty_env/build.zig", .{}); cases.addBuildFile("test/standalone/issue_7030/build.zig", .{}); + cases.addBuildFile("test/standalone/install_raw_hex/build.zig", .{}); if (std.Target.current.os.tag != .wasi) { cases.addBuildFile("test/standalone/load_dynamic_library/build.zig", .{}); } diff --git a/test/standalone/install_raw_hex/build.zig b/test/standalone/install_raw_hex/build.zig new file mode 100644 index 0000000000..e019431080 --- /dev/null +++ b/test/standalone/install_raw_hex/build.zig @@ -0,0 +1,173 @@ +const Builder = @import("std").build.Builder; +const builtin = @import("builtin"); +const std = @import("std"); +const CheckFileStep = std.build.CheckFileStep; + +pub fn build(b: *Builder) void { + const target = .{ + .cpu_arch = .thumb, + .cpu_model = .{ .explicit = &std.Target.arm.cpu.cortex_m4 }, + .os_tag = .freestanding, + .abi = .gnueabihf, + }; + + const mode = b.standardReleaseOptions(); + + const elf = b.addExecutable("zig-nrf52-blink.elf", "main.zig"); + elf.setTarget(target); + elf.setBuildMode(mode); + + const test_step = b.step("test", "Test the program"); + b.default_step.dependOn(test_step); + + const hex_step = b.addInstallRaw(elf, "hello.hex"); + test_step.dependOn(&hex_step.step); + + const explicit_format_hex_step = b.addInstallRawWithFormat(elf, "hello.foo", .hex); + test_step.dependOn(&explicit_format_hex_step.step); + + const expected_hex = &[_][]const u8{ + ":020000021000EC", + ":1000D400D001010001000000D20101000100000074", + ":1000E40028020100010000002402010001000000B8", + ":1000F4003A02010001000000E202010001000000D8", + ":100104000C03010001000000A50202000000000031", + ":1001140000000000000000000000000000000000DB", + ":1001240000000000000000000000000000000000CB", + ":1001340000000000000000000000000000000000BB", + ":10014400AF02020098020100090000004D02010004", + ":100154000900000001000000000000000000000091", + ":100164000004000100C0800000020000080000003C", + ":100174000000000000000000000000001E0000005D", + ":1001840048010100000040888080FF000A14002913", + ":1001940000C0B00000020090080000000000000051", + ":1001A40000000000000000001E000000000000002D", + ":1001B400000000000000000000000000000000003B", + ":1001C400000000000000000000000000000000002B", + ":1001D400000000000000000000000000000000001B", + ":1001E400000000000000000000000000000000000B", + ":1001F4000000000000000000000000008702010071", + ":1002040010000000200201002C0000006B0201001D", + ":100214001B000000570201001300000072656D61AD", + ":10022400696E646572206469766973696F6E2062B1", + ":1002340079207A65726F206F72206E6567617469C8", + ":1002440076652076616C756500636F727465782DD0", + ":100254006D3400696E646578206F7574206F662054", + ":10026400626F756E647300696E746567657220638E", + ":10027400617374207472756E63617465642062695D", + ":100284007473006469766973696F6E206279207A89", + ":1002940065726F00636F727465785F6D340000007F", + ":1002A40081B00091FFE700BEFDE7D0B502AF90B08A", + ":1002B4000391029007A800F029F803990020069002", + ":1002C40048680490FFE704990698019088420FD289", + ":1002D400FFE7019903980068405C07F8310C17F8B0", + ":1002E400311C07A800F021F8019801300690EAE7D4", + ":1002F400029807A9B1E80C50A0E80C5091E81C50F2", + ":1003040080E81C5010B0D0BDFFE7FEE7D0B502AFC7", + ":1003140040F2DC11C0F20101B1E80C50A0E80C502D", + ":1003240091E81C5080E81C50D0BD80B56F4688B061", + ":1003340006906FF35F2127F80A1C37F80A0C049023", + ":10034400012038B9FFE740F20020C0F2010000218B", + ":10035400FFF7A6FF0498C0F3431027F8020C37F800", + ":100364000A0C0390002038B9FFE7039800F01F003F", + ":100374000290012038B914E040F20820C0F20100D4", + ":100384000021FFF78DFF029800F01F0007F8030C0F", + ":100394000698009037F8020C0146019109280ED303", + ":1003A40006E040F21020C0F201000021FFF778FFC0", + ":1003B40040F21820C0F201000021FFF771FF0099FC", + ":1003C400019A51F8220017F803CC012303FA0CF325", + ":1003D400184341F8220008B080BD81B000F03F000E", + ":1003E4008DF802009DF80200103000F03F00022852", + ":1003F40004D3FFE700208DF8030003E001208DF80B", + ":100404000300FFE79DF8030001B070470A000000F5", + ":1004140012000000020071001200000066000000DB", + ":1004240003007D0C06000000000000000001110123", + ":10043400250E1305030E10171B0EB44219110112D9", + ":0604440006000002340076", + ":020000021000EC", + ":1000D400D001010001000000D20101000100000074", + ":1000E40028020100010000002402010001000000B8", + ":1000F4003A02010001000000E202010001000000D8", + ":100104000C03010001000000A50202000000000031", + ":1001140000000000000000000000000000000000DB", + ":1001240000000000000000000000000000000000CB", + ":1001340000000000000000000000000000000000BB", + ":10014400AF02020098020100090000004D02010004", + ":100154000900000001000000000000000000000091", + ":100164000004000100C0800000020000080000003C", + ":100174000000000000000000000000001E0000005D", + ":1001840048010100000040888080FF000A14002913", + ":1001940000C0B00000020090080000000000000051", + ":1001A40000000000000000001E000000000000002D", + ":1001B400000000000000000000000000000000003B", + ":1001C400000000000000000000000000000000002B", + ":1001D400000000000000000000000000000000001B", + ":1001E400000000000000000000000000000000000B", + ":1001F4000000000000000000000000008702010071", + ":1002040010000000200201002C0000006B0201001D", + ":100214001B000000570201001300000072656D61AD", + ":10022400696E646572206469766973696F6E2062B1", + ":1002340079207A65726F206F72206E6567617469C8", + ":1002440076652076616C756500636F727465782DD0", + ":100254006D3400696E646578206F7574206F662054", + ":10026400626F756E647300696E746567657220638E", + ":10027400617374207472756E63617465642062695D", + ":100284007473006469766973696F6E206279207A89", + ":1002940065726F00636F727465785F6D340000007F", + ":1002A40081B00091FFE700BEFDE7D0B502AF90B08A", + ":1002B4000391029007A800F029F803990020069002", + ":1002C40048680490FFE704990698019088420FD289", + ":1002D400FFE7019903980068405C07F8310C17F8B0", + ":1002E400311C07A800F021F8019801300690EAE7D4", + ":1002F400029807A9B1E80C50A0E80C5091E81C50F2", + ":1003040080E81C5010B0D0BDFFE7FEE7D0B502AFC7", + ":1003140040F2DC11C0F20101B1E80C50A0E80C502D", + ":1003240091E81C5080E81C50D0BD80B56F4688B061", + ":1003340006906FF35F2127F80A1C37F80A0C049023", + ":10034400012038B9FFE740F20020C0F2010000218B", + ":10035400FFF7A6FF0498C0F3431027F8020C37F800", + ":100364000A0C0390002038B9FFE7039800F01F003F", + ":100374000290012038B914E040F20820C0F20100D4", + ":100384000021FFF78DFF029800F01F0007F8030C0F", + ":100394000698009037F8020C0146019109280ED303", + ":1003A40006E040F21020C0F201000021FFF778FFC0", + ":1003B40040F21820C0F201000021FFF771FF0099FC", + ":1003C400019A51F8220017F803CC012303FA0CF325", + ":1003D400184341F8220008B080BD81B000F03F000E", + ":1003E4008DF802009DF80200103000F03F00022852", + ":1003F40004D3FFE700208DF8030003E001208DF80B", + ":100404000300FFE79DF8030001B070470A000000F5", + ":1004140012000000020071001200000066000000DB", + ":1004240003007D0C06000000000000000001110123", + ":10043400250E1305030E10171B0EB44219110112D9", + ":0604440006000002340076", + ":020000022000DC", + ":1002A40081B00091FFE700BEFDE7D0B502AF90B08A", + ":1002B4000391029007A800F029F803990020069002", + ":1002C40048680490FFE704990698019088420FD289", + ":1002D400FFE7019903980068405C07F8310C17F8B0", + ":1002E400311C07A800F021F8019801300690EAE7D4", + ":1002F400029807A9B1E80C50A0E80C5091E81C50F2", + ":1003040080E81C5010B0D0BDFFE7FEE7D0B502AFC7", + ":1003140040F2DC11C0F20101B1E80C50A0E80C502D", + ":1003240091E81C5080E81C50D0BD80B56F4688B061", + ":1003340006906FF35F2127F80A1C37F80A0C049023", + ":10034400012038B9FFE740F20020C0F2010000218B", + ":10035400FFF7A6FF0498C0F3431027F8020C37F800", + ":100364000A0C0390002038B9FFE7039800F01F003F", + ":100374000290012038B914E040F20820C0F20100D4", + ":100384000021FFF78DFF029800F01F0007F8030C0F", + ":100394000698009037F8020C0146019109280ED303", + ":1003A40006E040F21020C0F201000021FFF778FFC0", + ":1003B40040F21820C0F201000021FFF771FF0099FC", + ":1003C400019A51F8220017F803CC012303FA0CF325", + ":1003D400184341F8220008B080BD81B000F03F000E", + ":1003E4008DF802009DF80200103000F03F00022852", + ":1003F40004D3FFE700208DF8030003E001208DF80B", + ":0C0404000300FFE79DF8030001B0704703", + ":00000001FF", + }; + + test_step.dependOn(&CheckFileStep.create(b, hex_step.getOutputSource(), expected_hex).step); + test_step.dependOn(&CheckFileStep.create(b, explicit_format_hex_step.getOutputSource(), expected_hex).step); +} diff --git a/test/standalone/install_raw_hex/main.zig b/test/standalone/install_raw_hex/main.zig new file mode 100644 index 0000000000..d44d213dd9 --- /dev/null +++ b/test/standalone/install_raw_hex/main.zig @@ -0,0 +1,3 @@ +export fn _start() callconv(.C) noreturn { + while (true) {} +}