+
@@ -218,6 +218,8 @@
\n");
+ includes = true;
}
- }
-
- fn freeListEligible(self: TextBlock, elf_file: ElfFile) bool {
- // No need to keep a free list node for the last block.
- const next = self.next orelse return false;
- const self_sym = elf_file.local_symbols.items[self.local_sym_index];
- const next_sym = elf_file.local_symbols.items[next.local_sym_index];
- const cap = next_sym.st_value - self_sym.st_value;
- const ideal_cap = self_sym.st_size * alloc_num / alloc_den;
- if (cap <= ideal_cap) return false;
- const surplus = cap - ideal_cap;
- return surplus >= min_text_capacity;
- }
- };
-
- pub const Export = struct {
- sym_index: ?u32 = null,
- };
-
- pub fn deinit(self: *ElfFile) void {
- self.sections.deinit(self.allocator);
- self.program_headers.deinit(self.allocator);
- self.shstrtab.deinit(self.allocator);
- self.local_symbols.deinit(self.allocator);
- self.global_symbols.deinit(self.allocator);
- self.global_symbol_free_list.deinit(self.allocator);
- self.local_symbol_free_list.deinit(self.allocator);
- self.offset_table_free_list.deinit(self.allocator);
- self.text_block_free_list.deinit(self.allocator);
- self.offset_table.deinit(self.allocator);
- if (self.owns_file_handle) {
- if (self.file) |f| f.close();
- }
- }
-
- pub fn makeExecutable(self: *ElfFile) !void {
- assert(self.owns_file_handle);
- if (self.file) |f| {
- f.close();
+ if (self.need_stdint) {
+ try writer.writeAll("#include \n");
+ includes = true;
+ }
+ if (includes) {
+ try writer.writeByte('\n');
+ }
+ if (self.header.items.len > 0) {
+ try writer.print("{}\n", .{self.header.items});
+ }
+ if (self.constants.items.len > 0) {
+ try writer.print("{}\n", .{self.constants.items});
+ }
+ if (self.main.items.len > 1) {
+ const last_two = self.main.items[self.main.items.len - 2 ..];
+ if (std.mem.eql(u8, last_two, "\n\n")) {
+ self.main.items.len -= 1;
+ }
+ }
+ try writer.writeAll(self.main.items);
+ self.file.?.close();
self.file = null;
}
- }
+ };
- pub fn makeWritable(self: *ElfFile, dir: fs.Dir, sub_path: []const u8) !void {
- assert(self.owns_file_handle);
- if (self.file != null) return;
- self.file = try dir.createFile(sub_path, .{
- .truncate = false,
- .read = true,
- .mode = determineMode(self.options),
- });
- }
+ pub const Elf = struct {
+ pub const base_tag: Tag = .Elf;
+ base: File = File{ .tag = base_tag },
- /// Returns end pos of collision, if any.
- fn detectAllocCollision(self: *ElfFile, start: u64, size: u64) ?u64 {
- const small_ptr = self.options.target.cpu.arch.ptrBitWidth() == 32;
- const ehdr_size: u64 = if (small_ptr) @sizeOf(elf.Elf32_Ehdr) else @sizeOf(elf.Elf64_Ehdr);
- if (start < ehdr_size)
- return ehdr_size;
+ allocator: *Allocator,
+ file: ?fs.File,
+ owns_file_handle: bool,
+ options: Options,
+ ptr_width: enum { p32, p64 },
- const end = start + satMul(size, alloc_num) / alloc_den;
+ /// Stored in native-endian format, depending on target endianness needs to be bswapped on read/write.
+ /// Same order as in the file.
+ sections: std.ArrayListUnmanaged(elf.Elf64_Shdr) = std.ArrayListUnmanaged(elf.Elf64_Shdr){},
+ shdr_table_offset: ?u64 = null,
- if (self.shdr_table_offset) |off| {
- const shdr_size: u64 = if (small_ptr) @sizeOf(elf.Elf32_Shdr) else @sizeOf(elf.Elf64_Shdr);
- const tight_size = self.sections.items.len * shdr_size;
- const increased_size = satMul(tight_size, alloc_num) / alloc_den;
- const test_end = off + increased_size;
- if (end > off and start < test_end) {
- return test_end;
- }
- }
+ /// Stored in native-endian format, depending on target endianness needs to be bswapped on read/write.
+ /// Same order as in the file.
+ program_headers: std.ArrayListUnmanaged(elf.Elf64_Phdr) = std.ArrayListUnmanaged(elf.Elf64_Phdr){},
+ phdr_table_offset: ?u64 = null,
+ /// The index into the program headers of a PT_LOAD program header with Read and Execute flags
+ phdr_load_re_index: ?u16 = null,
+ /// The index into the program headers of the global offset table.
+ /// It needs PT_LOAD and Read flags.
+ phdr_got_index: ?u16 = null,
+ entry_addr: ?u64 = null,
- if (self.phdr_table_offset) |off| {
- const phdr_size: u64 = if (small_ptr) @sizeOf(elf.Elf32_Phdr) else @sizeOf(elf.Elf64_Phdr);
- const tight_size = self.sections.items.len * phdr_size;
- const increased_size = satMul(tight_size, alloc_num) / alloc_den;
- const test_end = off + increased_size;
- if (end > off and start < test_end) {
- return test_end;
- }
- }
+ shstrtab: std.ArrayListUnmanaged(u8) = std.ArrayListUnmanaged(u8){},
+ shstrtab_index: ?u16 = null,
- for (self.sections.items) |section| {
- const increased_size = satMul(section.sh_size, alloc_num) / alloc_den;
- const test_end = section.sh_offset + increased_size;
- if (end > section.sh_offset and start < test_end) {
- return test_end;
- }
- }
- for (self.program_headers.items) |program_header| {
- const increased_size = satMul(program_header.p_filesz, alloc_num) / alloc_den;
- const test_end = program_header.p_offset + increased_size;
- if (end > program_header.p_offset and start < test_end) {
- return test_end;
- }
- }
- return null;
- }
+ text_section_index: ?u16 = null,
+ symtab_section_index: ?u16 = null,
+ got_section_index: ?u16 = null,
- fn allocatedSize(self: *ElfFile, start: u64) u64 {
- var min_pos: u64 = std.math.maxInt(u64);
- if (self.shdr_table_offset) |off| {
- if (off > start and off < min_pos) min_pos = off;
- }
- if (self.phdr_table_offset) |off| {
- if (off > start and off < min_pos) min_pos = off;
- }
- for (self.sections.items) |section| {
- if (section.sh_offset <= start) continue;
- if (section.sh_offset < min_pos) min_pos = section.sh_offset;
- }
- for (self.program_headers.items) |program_header| {
- if (program_header.p_offset <= start) continue;
- if (program_header.p_offset < min_pos) min_pos = program_header.p_offset;
- }
- return min_pos - start;
- }
+ /// The same order as in the file. ELF requires global symbols to all be after the
+ /// local symbols, they cannot be mixed. So we must buffer all the global symbols and
+ /// write them at the end. These are only the local symbols. The length of this array
+ /// is the value used for sh_info in the .symtab section.
+ local_symbols: std.ArrayListUnmanaged(elf.Elf64_Sym) = std.ArrayListUnmanaged(elf.Elf64_Sym){},
+ global_symbols: std.ArrayListUnmanaged(elf.Elf64_Sym) = std.ArrayListUnmanaged(elf.Elf64_Sym){},
- fn findFreeSpace(self: *ElfFile, object_size: u64, min_alignment: u16) u64 {
- var start: u64 = 0;
- while (self.detectAllocCollision(start, object_size)) |item_end| {
- start = mem.alignForwardGeneric(u64, item_end, min_alignment);
- }
- return start;
- }
+ local_symbol_free_list: std.ArrayListUnmanaged(u32) = std.ArrayListUnmanaged(u32){},
+ global_symbol_free_list: std.ArrayListUnmanaged(u32) = std.ArrayListUnmanaged(u32){},
+ offset_table_free_list: std.ArrayListUnmanaged(u32) = std.ArrayListUnmanaged(u32){},
- fn makeString(self: *ElfFile, bytes: []const u8) !u32 {
- try self.shstrtab.ensureCapacity(self.allocator, self.shstrtab.items.len + bytes.len + 1);
- const result = self.shstrtab.items.len;
- self.shstrtab.appendSliceAssumeCapacity(bytes);
- self.shstrtab.appendAssumeCapacity(0);
- return @intCast(u32, result);
- }
+ /// Same order as in the file. The value is the absolute vaddr value.
+ /// If the vaddr of the executable program header changes, the entire
+ /// offset table needs to be rewritten.
+ offset_table: std.ArrayListUnmanaged(u64) = std.ArrayListUnmanaged(u64){},
- fn getString(self: *ElfFile, str_off: u32) []const u8 {
- assert(str_off < self.shstrtab.items.len);
- return mem.spanZ(@ptrCast([*:0]const u8, self.shstrtab.items.ptr + str_off));
- }
+ phdr_table_dirty: bool = false,
+ shdr_table_dirty: bool = false,
+ shstrtab_dirty: bool = false,
+ offset_table_count_dirty: bool = false,
- fn updateString(self: *ElfFile, old_str_off: u32, new_name: []const u8) !u32 {
- const existing_name = self.getString(old_str_off);
- if (mem.eql(u8, existing_name, new_name)) {
- return old_str_off;
- }
- return self.makeString(new_name);
- }
+ error_flags: ErrorFlags = ErrorFlags{},
- pub fn populateMissingMetadata(self: *ElfFile) !void {
- const small_ptr = switch (self.ptr_width) {
- .p32 => true,
- .p64 => false,
- };
- const ptr_size: u8 = switch (self.ptr_width) {
- .p32 => 4,
- .p64 => 8,
- };
- if (self.phdr_load_re_index == null) {
- self.phdr_load_re_index = @intCast(u16, self.program_headers.items.len);
- const file_size = self.options.program_code_size_hint;
- const p_align = 0x1000;
- const off = self.findFreeSpace(file_size, p_align);
- //std.debug.warn("found PT_LOAD free space 0x{x} to 0x{x}\n", .{ off, off + file_size });
- try self.program_headers.append(self.allocator, .{
- .p_type = elf.PT_LOAD,
- .p_offset = off,
- .p_filesz = file_size,
- .p_vaddr = default_entry_addr,
- .p_paddr = default_entry_addr,
- .p_memsz = file_size,
- .p_align = p_align,
- .p_flags = elf.PF_X | elf.PF_R,
- });
- self.entry_addr = null;
- self.phdr_table_dirty = true;
- }
- if (self.phdr_got_index == null) {
- self.phdr_got_index = @intCast(u16, self.program_headers.items.len);
- const file_size = @as(u64, ptr_size) * self.options.symbol_count_hint;
- // We really only need ptr alignment but since we are using PROGBITS, linux requires
- // page align.
- const p_align = 0x1000;
- const off = self.findFreeSpace(file_size, p_align);
- //std.debug.warn("found PT_LOAD free space 0x{x} to 0x{x}\n", .{ off, off + file_size });
- // TODO instead of hard coding the vaddr, make a function to find a vaddr to put things at.
- // we'll need to re-use that function anyway, in case the GOT grows and overlaps something
- // else in virtual memory.
- const default_got_addr = 0x4000000;
- try self.program_headers.append(self.allocator, .{
- .p_type = elf.PT_LOAD,
- .p_offset = off,
- .p_filesz = file_size,
- .p_vaddr = default_got_addr,
- .p_paddr = default_got_addr,
- .p_memsz = file_size,
- .p_align = p_align,
- .p_flags = elf.PF_R,
- });
- self.phdr_table_dirty = true;
- }
- if (self.shstrtab_index == null) {
- self.shstrtab_index = @intCast(u16, self.sections.items.len);
- assert(self.shstrtab.items.len == 0);
- try self.shstrtab.append(self.allocator, 0); // need a 0 at position 0
- const off = self.findFreeSpace(self.shstrtab.items.len, 1);
- //std.debug.warn("found shstrtab free space 0x{x} to 0x{x}\n", .{ off, off + self.shstrtab.items.len });
- try self.sections.append(self.allocator, .{
- .sh_name = try self.makeString(".shstrtab"),
- .sh_type = elf.SHT_STRTAB,
- .sh_flags = 0,
- .sh_addr = 0,
- .sh_offset = off,
- .sh_size = self.shstrtab.items.len,
- .sh_link = 0,
- .sh_info = 0,
- .sh_addralign = 1,
- .sh_entsize = 0,
- });
- self.shstrtab_dirty = true;
- self.shdr_table_dirty = true;
- }
- if (self.text_section_index == null) {
- self.text_section_index = @intCast(u16, self.sections.items.len);
- const phdr = &self.program_headers.items[self.phdr_load_re_index.?];
+ /// A list of text blocks that have surplus capacity. This list can have false
+ /// positives, as functions grow and shrink over time, only sometimes being added
+ /// or removed from the freelist.
+ ///
+ /// A text block has surplus capacity when its overcapacity value is greater than
+ /// minimum_text_block_size * alloc_num / alloc_den. That is, when it has so
+ /// much extra capacity, that we could fit a small new symbol in it, itself with
+ /// ideal_capacity or more.
+ ///
+ /// Ideal capacity is defined by size * alloc_num / alloc_den.
+ ///
+ /// Overcapacity is measured by actual_capacity - ideal_capacity. Note that
+ /// overcapacity can be negative. A simple way to have negative overcapacity is to
+ /// allocate a fresh text block, which will have ideal capacity, and then grow it
+ /// by 1 byte. It will then have -1 overcapacity.
+ text_block_free_list: std.ArrayListUnmanaged(*TextBlock) = std.ArrayListUnmanaged(*TextBlock){},
+ last_text_block: ?*TextBlock = null,
- try self.sections.append(self.allocator, .{
- .sh_name = try self.makeString(".text"),
- .sh_type = elf.SHT_PROGBITS,
- .sh_flags = elf.SHF_ALLOC | elf.SHF_EXECINSTR,
- .sh_addr = phdr.p_vaddr,
- .sh_offset = phdr.p_offset,
- .sh_size = phdr.p_filesz,
- .sh_link = 0,
- .sh_info = 0,
- .sh_addralign = phdr.p_align,
- .sh_entsize = 0,
- });
- self.shdr_table_dirty = true;
- }
- if (self.got_section_index == null) {
- self.got_section_index = @intCast(u16, self.sections.items.len);
- const phdr = &self.program_headers.items[self.phdr_got_index.?];
+ /// `alloc_num / alloc_den` is the factor of padding when allocating.
+ const alloc_num = 4;
+ const alloc_den = 3;
- try self.sections.append(self.allocator, .{
- .sh_name = try self.makeString(".got"),
- .sh_type = elf.SHT_PROGBITS,
- .sh_flags = elf.SHF_ALLOC,
- .sh_addr = phdr.p_vaddr,
- .sh_offset = phdr.p_offset,
- .sh_size = phdr.p_filesz,
- .sh_link = 0,
- .sh_info = 0,
- .sh_addralign = phdr.p_align,
- .sh_entsize = 0,
- });
- self.shdr_table_dirty = true;
- }
- if (self.symtab_section_index == null) {
- self.symtab_section_index = @intCast(u16, self.sections.items.len);
- const min_align: u16 = if (small_ptr) @alignOf(elf.Elf32_Sym) else @alignOf(elf.Elf64_Sym);
- const each_size: u64 = if (small_ptr) @sizeOf(elf.Elf32_Sym) else @sizeOf(elf.Elf64_Sym);
- const file_size = self.options.symbol_count_hint * each_size;
- const off = self.findFreeSpace(file_size, min_align);
- //std.debug.warn("found symtab free space 0x{x} to 0x{x}\n", .{ off, off + file_size });
+ /// In order for a slice of bytes to be considered eligible to keep metadata pointing at
+ /// it as a possible place to put new symbols, it must have enough room for this many bytes
+ /// (plus extra for reserved capacity).
+ const minimum_text_block_size = 64;
+ const min_text_capacity = minimum_text_block_size * alloc_num / alloc_den;
- try self.sections.append(self.allocator, .{
- .sh_name = try self.makeString(".symtab"),
- .sh_type = elf.SHT_SYMTAB,
- .sh_flags = 0,
- .sh_addr = 0,
- .sh_offset = off,
- .sh_size = file_size,
- // The section header index of the associated string table.
- .sh_link = self.shstrtab_index.?,
- .sh_info = @intCast(u32, self.local_symbols.items.len),
- .sh_addralign = min_align,
- .sh_entsize = each_size,
- });
- self.shdr_table_dirty = true;
- try self.writeSymbol(0);
- }
- const shsize: u64 = switch (self.ptr_width) {
- .p32 => @sizeOf(elf.Elf32_Shdr),
- .p64 => @sizeOf(elf.Elf64_Shdr),
- };
- const shalign: u16 = switch (self.ptr_width) {
- .p32 => @alignOf(elf.Elf32_Shdr),
- .p64 => @alignOf(elf.Elf64_Shdr),
- };
- if (self.shdr_table_offset == null) {
- self.shdr_table_offset = self.findFreeSpace(self.sections.items.len * shsize, shalign);
- self.shdr_table_dirty = true;
- }
- const phsize: u64 = switch (self.ptr_width) {
- .p32 => @sizeOf(elf.Elf32_Phdr),
- .p64 => @sizeOf(elf.Elf64_Phdr),
- };
- const phalign: u16 = switch (self.ptr_width) {
- .p32 => @alignOf(elf.Elf32_Phdr),
- .p64 => @alignOf(elf.Elf64_Phdr),
- };
- if (self.phdr_table_offset == null) {
- self.phdr_table_offset = self.findFreeSpace(self.program_headers.items.len * phsize, phalign);
- self.phdr_table_dirty = true;
- }
- {
- // Iterate over symbols, populating free_list and last_text_block.
- if (self.local_symbols.items.len != 1) {
- @panic("TODO implement setting up free_list and last_text_block from existing ELF file");
- }
- // We are starting with an empty file. The default values are correct, null and empty list.
- }
- }
+ pub const TextBlock = struct {
+ /// Each decl always gets a local symbol with the fully qualified name.
+ /// The vaddr and size are found here directly.
+ /// The file offset is found by computing the vaddr offset from the section vaddr
+ /// the symbol references, and adding that to the file offset of the section.
+ /// If this field is 0, it means the codegen size = 0 and there is no symbol or
+ /// offset table entry.
+ local_sym_index: u32,
+ /// This field is undefined for symbols with size = 0.
+ offset_table_index: u32,
+ /// Points to the previous and next neighbors, based on the `text_offset`.
+ /// This can be used to find, for example, the capacity of this `TextBlock`.
+ prev: ?*TextBlock,
+ next: ?*TextBlock,
- /// Commit pending changes and write headers.
- pub fn flush(self: *ElfFile) !void {
- const foreign_endian = self.options.target.cpu.arch.endian() != std.Target.current.cpu.arch.endian();
-
- // Unfortunately these have to be buffered and done at the end because ELF does not allow
- // mixing local and global symbols within a symbol table.
- try self.writeAllGlobalSymbols();
-
- if (self.phdr_table_dirty) {
- const phsize: u64 = switch (self.ptr_width) {
- .p32 => @sizeOf(elf.Elf32_Phdr),
- .p64 => @sizeOf(elf.Elf64_Phdr),
+ pub const empty = TextBlock{
+ .local_sym_index = 0,
+ .offset_table_index = undefined,
+ .prev = null,
+ .next = null,
};
- const phalign: u16 = switch (self.ptr_width) {
- .p32 => @alignOf(elf.Elf32_Phdr),
- .p64 => @alignOf(elf.Elf64_Phdr),
+
+ /// Returns how much room there is to grow in virtual address space.
+ /// File offset relocation happens transparently, so it is not included in
+ /// this calculation.
+ fn capacity(self: TextBlock, elf_file: Elf) u64 {
+ const self_sym = elf_file.local_symbols.items[self.local_sym_index];
+ if (self.next) |next| {
+ const next_sym = elf_file.local_symbols.items[next.local_sym_index];
+ return next_sym.st_value - self_sym.st_value;
+ } else {
+ // We are the last block. The capacity is limited only by virtual address space.
+ return std.math.maxInt(u32) - self_sym.st_value;
+ }
+ }
+
+ fn freeListEligible(self: TextBlock, elf_file: Elf) bool {
+ // No need to keep a free list node for the last block.
+ const next = self.next orelse return false;
+ const self_sym = elf_file.local_symbols.items[self.local_sym_index];
+ const next_sym = elf_file.local_symbols.items[next.local_sym_index];
+ const cap = next_sym.st_value - self_sym.st_value;
+ const ideal_cap = self_sym.st_size * alloc_num / alloc_den;
+ if (cap <= ideal_cap) return false;
+ const surplus = cap - ideal_cap;
+ return surplus >= min_text_capacity;
+ }
+ };
+
+ pub const Export = struct {
+ sym_index: ?u32 = null,
+ };
+
+ pub fn deinit(self: *Elf) void {
+ self.sections.deinit(self.allocator);
+ self.program_headers.deinit(self.allocator);
+ self.shstrtab.deinit(self.allocator);
+ self.local_symbols.deinit(self.allocator);
+ self.global_symbols.deinit(self.allocator);
+ self.global_symbol_free_list.deinit(self.allocator);
+ self.local_symbol_free_list.deinit(self.allocator);
+ self.offset_table_free_list.deinit(self.allocator);
+ self.text_block_free_list.deinit(self.allocator);
+ self.offset_table.deinit(self.allocator);
+ if (self.owns_file_handle) {
+ if (self.file) |f| f.close();
+ }
+ }
+
+ pub fn makeExecutable(self: *Elf) !void {
+ assert(self.owns_file_handle);
+ if (self.file) |f| {
+ f.close();
+ self.file = null;
+ }
+ }
+
+ pub fn makeWritable(self: *Elf, dir: fs.Dir, sub_path: []const u8) !void {
+ assert(self.owns_file_handle);
+ if (self.file != null) return;
+ self.file = try dir.createFile(sub_path, .{
+ .truncate = false,
+ .read = true,
+ .mode = determineMode(self.options),
+ });
+ }
+
+ /// Returns end pos of collision, if any.
+ fn detectAllocCollision(self: *Elf, start: u64, size: u64) ?u64 {
+ const small_ptr = self.options.target.cpu.arch.ptrBitWidth() == 32;
+ const ehdr_size: u64 = if (small_ptr) @sizeOf(elf.Elf32_Ehdr) else @sizeOf(elf.Elf64_Ehdr);
+ if (start < ehdr_size)
+ return ehdr_size;
+
+ const end = start + satMul(size, alloc_num) / alloc_den;
+
+ if (self.shdr_table_offset) |off| {
+ const shdr_size: u64 = if (small_ptr) @sizeOf(elf.Elf32_Shdr) else @sizeOf(elf.Elf64_Shdr);
+ const tight_size = self.sections.items.len * shdr_size;
+ const increased_size = satMul(tight_size, alloc_num) / alloc_den;
+ const test_end = off + increased_size;
+ if (end > off and start < test_end) {
+ return test_end;
+ }
+ }
+
+ if (self.phdr_table_offset) |off| {
+ const phdr_size: u64 = if (small_ptr) @sizeOf(elf.Elf32_Phdr) else @sizeOf(elf.Elf64_Phdr);
+ const tight_size = self.sections.items.len * phdr_size;
+ const increased_size = satMul(tight_size, alloc_num) / alloc_den;
+ const test_end = off + increased_size;
+ if (end > off and start < test_end) {
+ return test_end;
+ }
+ }
+
+ for (self.sections.items) |section| {
+ const increased_size = satMul(section.sh_size, alloc_num) / alloc_den;
+ const test_end = section.sh_offset + increased_size;
+ if (end > section.sh_offset and start < test_end) {
+ return test_end;
+ }
+ }
+ for (self.program_headers.items) |program_header| {
+ const increased_size = satMul(program_header.p_filesz, alloc_num) / alloc_den;
+ const test_end = program_header.p_offset + increased_size;
+ if (end > program_header.p_offset and start < test_end) {
+ return test_end;
+ }
+ }
+ return null;
+ }
+
+ fn allocatedSize(self: *Elf, start: u64) u64 {
+ var min_pos: u64 = std.math.maxInt(u64);
+ if (self.shdr_table_offset) |off| {
+ if (off > start and off < min_pos) min_pos = off;
+ }
+ if (self.phdr_table_offset) |off| {
+ if (off > start and off < min_pos) min_pos = off;
+ }
+ for (self.sections.items) |section| {
+ if (section.sh_offset <= start) continue;
+ if (section.sh_offset < min_pos) min_pos = section.sh_offset;
+ }
+ for (self.program_headers.items) |program_header| {
+ if (program_header.p_offset <= start) continue;
+ if (program_header.p_offset < min_pos) min_pos = program_header.p_offset;
+ }
+ return min_pos - start;
+ }
+
+ fn findFreeSpace(self: *Elf, object_size: u64, min_alignment: u16) u64 {
+ var start: u64 = 0;
+ while (self.detectAllocCollision(start, object_size)) |item_end| {
+ start = mem.alignForwardGeneric(u64, item_end, min_alignment);
+ }
+ return start;
+ }
+
+ fn makeString(self: *Elf, bytes: []const u8) !u32 {
+ try self.shstrtab.ensureCapacity(self.allocator, self.shstrtab.items.len + bytes.len + 1);
+ const result = self.shstrtab.items.len;
+ self.shstrtab.appendSliceAssumeCapacity(bytes);
+ self.shstrtab.appendAssumeCapacity(0);
+ return @intCast(u32, result);
+ }
+
+ fn getString(self: *Elf, str_off: u32) []const u8 {
+ assert(str_off < self.shstrtab.items.len);
+ return mem.spanZ(@ptrCast([*:0]const u8, self.shstrtab.items.ptr + str_off));
+ }
+
+ fn updateString(self: *Elf, old_str_off: u32, new_name: []const u8) !u32 {
+ const existing_name = self.getString(old_str_off);
+ if (mem.eql(u8, existing_name, new_name)) {
+ return old_str_off;
+ }
+ return self.makeString(new_name);
+ }
+
+ pub fn populateMissingMetadata(self: *Elf) !void {
+ const small_ptr = switch (self.ptr_width) {
+ .p32 => true,
+ .p64 => false,
};
- const allocated_size = self.allocatedSize(self.phdr_table_offset.?);
- const needed_size = self.program_headers.items.len * phsize;
-
- if (needed_size > allocated_size) {
- self.phdr_table_offset = null; // free the space
- self.phdr_table_offset = self.findFreeSpace(needed_size, phalign);
+ const ptr_size: u8 = switch (self.ptr_width) {
+ .p32 => 4,
+ .p64 => 8,
+ };
+ if (self.phdr_load_re_index == null) {
+ self.phdr_load_re_index = @intCast(u16, self.program_headers.items.len);
+ const file_size = self.options.program_code_size_hint;
+ const p_align = 0x1000;
+ const off = self.findFreeSpace(file_size, p_align);
+ std.log.debug(.link, "found PT_LOAD free space 0x{x} to 0x{x}\n", .{ off, off + file_size });
+ try self.program_headers.append(self.allocator, .{
+ .p_type = elf.PT_LOAD,
+ .p_offset = off,
+ .p_filesz = file_size,
+ .p_vaddr = default_entry_addr,
+ .p_paddr = default_entry_addr,
+ .p_memsz = file_size,
+ .p_align = p_align,
+ .p_flags = elf.PF_X | elf.PF_R,
+ });
+ self.entry_addr = null;
+ self.phdr_table_dirty = true;
}
-
- switch (self.ptr_width) {
- .p32 => {
- const buf = try self.allocator.alloc(elf.Elf32_Phdr, self.program_headers.items.len);
- defer self.allocator.free(buf);
-
- for (buf) |*phdr, i| {
- phdr.* = progHeaderTo32(self.program_headers.items[i]);
- if (foreign_endian) {
- bswapAllFields(elf.Elf32_Phdr, phdr);
- }
- }
- try self.file.?.pwriteAll(mem.sliceAsBytes(buf), self.phdr_table_offset.?);
- },
- .p64 => {
- const buf = try self.allocator.alloc(elf.Elf64_Phdr, self.program_headers.items.len);
- defer self.allocator.free(buf);
-
- for (buf) |*phdr, i| {
- phdr.* = self.program_headers.items[i];
- if (foreign_endian) {
- bswapAllFields(elf.Elf64_Phdr, phdr);
- }
- }
- try self.file.?.pwriteAll(mem.sliceAsBytes(buf), self.phdr_table_offset.?);
- },
+ if (self.phdr_got_index == null) {
+ self.phdr_got_index = @intCast(u16, self.program_headers.items.len);
+ const file_size = @as(u64, ptr_size) * self.options.symbol_count_hint;
+ // We really only need ptr alignment but since we are using PROGBITS, linux requires
+ // page align.
+ const p_align = 0x1000;
+ const off = self.findFreeSpace(file_size, p_align);
+ std.log.debug(.link, "found PT_LOAD free space 0x{x} to 0x{x}\n", .{ off, off + file_size });
+ // TODO instead of hard coding the vaddr, make a function to find a vaddr to put things at.
+ // we'll need to re-use that function anyway, in case the GOT grows and overlaps something
+ // else in virtual memory.
+ const default_got_addr = 0x4000000;
+ try self.program_headers.append(self.allocator, .{
+ .p_type = elf.PT_LOAD,
+ .p_offset = off,
+ .p_filesz = file_size,
+ .p_vaddr = default_got_addr,
+ .p_paddr = default_got_addr,
+ .p_memsz = file_size,
+ .p_align = p_align,
+ .p_flags = elf.PF_R,
+ });
+ self.phdr_table_dirty = true;
}
- self.phdr_table_dirty = false;
- }
-
- {
- const shstrtab_sect = &self.sections.items[self.shstrtab_index.?];
- if (self.shstrtab_dirty or self.shstrtab.items.len != shstrtab_sect.sh_size) {
- const allocated_size = self.allocatedSize(shstrtab_sect.sh_offset);
- const needed_size = self.shstrtab.items.len;
-
- if (needed_size > allocated_size) {
- shstrtab_sect.sh_size = 0; // free the space
- shstrtab_sect.sh_offset = self.findFreeSpace(needed_size, 1);
- }
- shstrtab_sect.sh_size = needed_size;
- //std.debug.warn("shstrtab start=0x{x} end=0x{x}\n", .{ shstrtab_sect.sh_offset, shstrtab_sect.sh_offset + needed_size });
-
- try self.file.?.pwriteAll(self.shstrtab.items, shstrtab_sect.sh_offset);
- if (!self.shdr_table_dirty) {
- // Then it won't get written with the others and we need to do it.
- try self.writeSectHeader(self.shstrtab_index.?);
- }
- self.shstrtab_dirty = false;
+ if (self.shstrtab_index == null) {
+ self.shstrtab_index = @intCast(u16, self.sections.items.len);
+ assert(self.shstrtab.items.len == 0);
+ try self.shstrtab.append(self.allocator, 0); // need a 0 at position 0
+ const off = self.findFreeSpace(self.shstrtab.items.len, 1);
+ std.log.debug(.link, "found shstrtab free space 0x{x} to 0x{x}\n", .{ off, off + self.shstrtab.items.len });
+ try self.sections.append(self.allocator, .{
+ .sh_name = try self.makeString(".shstrtab"),
+ .sh_type = elf.SHT_STRTAB,
+ .sh_flags = 0,
+ .sh_addr = 0,
+ .sh_offset = off,
+ .sh_size = self.shstrtab.items.len,
+ .sh_link = 0,
+ .sh_info = 0,
+ .sh_addralign = 1,
+ .sh_entsize = 0,
+ });
+ self.shstrtab_dirty = true;
+ self.shdr_table_dirty = true;
+ }
+ if (self.text_section_index == null) {
+ self.text_section_index = @intCast(u16, self.sections.items.len);
+ const phdr = &self.program_headers.items[self.phdr_load_re_index.?];
+
+ try self.sections.append(self.allocator, .{
+ .sh_name = try self.makeString(".text"),
+ .sh_type = elf.SHT_PROGBITS,
+ .sh_flags = elf.SHF_ALLOC | elf.SHF_EXECINSTR,
+ .sh_addr = phdr.p_vaddr,
+ .sh_offset = phdr.p_offset,
+ .sh_size = phdr.p_filesz,
+ .sh_link = 0,
+ .sh_info = 0,
+ .sh_addralign = phdr.p_align,
+ .sh_entsize = 0,
+ });
+ self.shdr_table_dirty = true;
+ }
+ if (self.got_section_index == null) {
+ self.got_section_index = @intCast(u16, self.sections.items.len);
+ const phdr = &self.program_headers.items[self.phdr_got_index.?];
+
+ try self.sections.append(self.allocator, .{
+ .sh_name = try self.makeString(".got"),
+ .sh_type = elf.SHT_PROGBITS,
+ .sh_flags = elf.SHF_ALLOC,
+ .sh_addr = phdr.p_vaddr,
+ .sh_offset = phdr.p_offset,
+ .sh_size = phdr.p_filesz,
+ .sh_link = 0,
+ .sh_info = 0,
+ .sh_addralign = phdr.p_align,
+ .sh_entsize = 0,
+ });
+ self.shdr_table_dirty = true;
+ }
+ if (self.symtab_section_index == null) {
+ self.symtab_section_index = @intCast(u16, self.sections.items.len);
+ const min_align: u16 = if (small_ptr) @alignOf(elf.Elf32_Sym) else @alignOf(elf.Elf64_Sym);
+ const each_size: u64 = if (small_ptr) @sizeOf(elf.Elf32_Sym) else @sizeOf(elf.Elf64_Sym);
+ const file_size = self.options.symbol_count_hint * each_size;
+ const off = self.findFreeSpace(file_size, min_align);
+ std.log.debug(.link, "found symtab free space 0x{x} to 0x{x}\n", .{ off, off + file_size });
+
+ try self.sections.append(self.allocator, .{
+ .sh_name = try self.makeString(".symtab"),
+ .sh_type = elf.SHT_SYMTAB,
+ .sh_flags = 0,
+ .sh_addr = 0,
+ .sh_offset = off,
+ .sh_size = file_size,
+ // The section header index of the associated string table.
+ .sh_link = self.shstrtab_index.?,
+ .sh_info = @intCast(u32, self.local_symbols.items.len),
+ .sh_addralign = min_align,
+ .sh_entsize = each_size,
+ });
+ self.shdr_table_dirty = true;
+ try self.writeSymbol(0);
}
- }
- if (self.shdr_table_dirty) {
const shsize: u64 = switch (self.ptr_width) {
.p32 => @sizeOf(elf.Elf32_Shdr),
.p64 => @sizeOf(elf.Elf64_Shdr),
@@ -605,763 +706,874 @@ pub const ElfFile = struct {
.p32 => @alignOf(elf.Elf32_Shdr),
.p64 => @alignOf(elf.Elf64_Shdr),
};
- const allocated_size = self.allocatedSize(self.shdr_table_offset.?);
- const needed_size = self.sections.items.len * shsize;
-
- if (needed_size > allocated_size) {
- self.shdr_table_offset = null; // free the space
- self.shdr_table_offset = self.findFreeSpace(needed_size, shalign);
+ if (self.shdr_table_offset == null) {
+ self.shdr_table_offset = self.findFreeSpace(self.sections.items.len * shsize, shalign);
+ self.shdr_table_dirty = true;
}
+ const phsize: u64 = switch (self.ptr_width) {
+ .p32 => @sizeOf(elf.Elf32_Phdr),
+ .p64 => @sizeOf(elf.Elf64_Phdr),
+ };
+ const phalign: u16 = switch (self.ptr_width) {
+ .p32 => @alignOf(elf.Elf32_Phdr),
+ .p64 => @alignOf(elf.Elf64_Phdr),
+ };
+ if (self.phdr_table_offset == null) {
+ self.phdr_table_offset = self.findFreeSpace(self.program_headers.items.len * phsize, phalign);
+ self.phdr_table_dirty = true;
+ }
+ {
+ // Iterate over symbols, populating free_list and last_text_block.
+ if (self.local_symbols.items.len != 1) {
+ @panic("TODO implement setting up free_list and last_text_block from existing ELF file");
+ }
+ // We are starting with an empty file. The default values are correct, null and empty list.
+ }
+ }
+
+ /// Commit pending changes and write headers.
+ pub fn flush(self: *Elf) !void {
+ const foreign_endian = self.options.target.cpu.arch.endian() != std.Target.current.cpu.arch.endian();
+
+ // Unfortunately these have to be buffered and done at the end because ELF does not allow
+ // mixing local and global symbols within a symbol table.
+ try self.writeAllGlobalSymbols();
+
+ if (self.phdr_table_dirty) {
+ const phsize: u64 = switch (self.ptr_width) {
+ .p32 => @sizeOf(elf.Elf32_Phdr),
+ .p64 => @sizeOf(elf.Elf64_Phdr),
+ };
+ const phalign: u16 = switch (self.ptr_width) {
+ .p32 => @alignOf(elf.Elf32_Phdr),
+ .p64 => @alignOf(elf.Elf64_Phdr),
+ };
+ const allocated_size = self.allocatedSize(self.phdr_table_offset.?);
+ const needed_size = self.program_headers.items.len * phsize;
+
+ if (needed_size > allocated_size) {
+ self.phdr_table_offset = null; // free the space
+ self.phdr_table_offset = self.findFreeSpace(needed_size, phalign);
+ }
+
+ switch (self.ptr_width) {
+ .p32 => {
+ const buf = try self.allocator.alloc(elf.Elf32_Phdr, self.program_headers.items.len);
+ defer self.allocator.free(buf);
+
+ for (buf) |*phdr, i| {
+ phdr.* = progHeaderTo32(self.program_headers.items[i]);
+ if (foreign_endian) {
+ bswapAllFields(elf.Elf32_Phdr, phdr);
+ }
+ }
+ try self.file.?.pwriteAll(mem.sliceAsBytes(buf), self.phdr_table_offset.?);
+ },
+ .p64 => {
+ const buf = try self.allocator.alloc(elf.Elf64_Phdr, self.program_headers.items.len);
+ defer self.allocator.free(buf);
+
+ for (buf) |*phdr, i| {
+ phdr.* = self.program_headers.items[i];
+ if (foreign_endian) {
+ bswapAllFields(elf.Elf64_Phdr, phdr);
+ }
+ }
+ try self.file.?.pwriteAll(mem.sliceAsBytes(buf), self.phdr_table_offset.?);
+ },
+ }
+ self.phdr_table_dirty = false;
+ }
+
+ {
+ const shstrtab_sect = &self.sections.items[self.shstrtab_index.?];
+ if (self.shstrtab_dirty or self.shstrtab.items.len != shstrtab_sect.sh_size) {
+ const allocated_size = self.allocatedSize(shstrtab_sect.sh_offset);
+ const needed_size = self.shstrtab.items.len;
+
+ if (needed_size > allocated_size) {
+ shstrtab_sect.sh_size = 0; // free the space
+ shstrtab_sect.sh_offset = self.findFreeSpace(needed_size, 1);
+ }
+ shstrtab_sect.sh_size = needed_size;
+ std.log.debug(.link, "shstrtab start=0x{x} end=0x{x}\n", .{ shstrtab_sect.sh_offset, shstrtab_sect.sh_offset + needed_size });
+
+ try self.file.?.pwriteAll(self.shstrtab.items, shstrtab_sect.sh_offset);
+ if (!self.shdr_table_dirty) {
+ // Then it won't get written with the others and we need to do it.
+ try self.writeSectHeader(self.shstrtab_index.?);
+ }
+ self.shstrtab_dirty = false;
+ }
+ }
+ if (self.shdr_table_dirty) {
+ const shsize: u64 = switch (self.ptr_width) {
+ .p32 => @sizeOf(elf.Elf32_Shdr),
+ .p64 => @sizeOf(elf.Elf64_Shdr),
+ };
+ const shalign: u16 = switch (self.ptr_width) {
+ .p32 => @alignOf(elf.Elf32_Shdr),
+ .p64 => @alignOf(elf.Elf64_Shdr),
+ };
+ const allocated_size = self.allocatedSize(self.shdr_table_offset.?);
+ const needed_size = self.sections.items.len * shsize;
+
+ if (needed_size > allocated_size) {
+ self.shdr_table_offset = null; // free the space
+ self.shdr_table_offset = self.findFreeSpace(needed_size, shalign);
+ }
+
+ switch (self.ptr_width) {
+ .p32 => {
+ const buf = try self.allocator.alloc(elf.Elf32_Shdr, self.sections.items.len);
+ defer self.allocator.free(buf);
+
+ for (buf) |*shdr, i| {
+ shdr.* = sectHeaderTo32(self.sections.items[i]);
+ if (foreign_endian) {
+ bswapAllFields(elf.Elf32_Shdr, shdr);
+ }
+ }
+ try self.file.?.pwriteAll(mem.sliceAsBytes(buf), self.shdr_table_offset.?);
+ },
+ .p64 => {
+ const buf = try self.allocator.alloc(elf.Elf64_Shdr, self.sections.items.len);
+ defer self.allocator.free(buf);
+
+ for (buf) |*shdr, i| {
+ shdr.* = self.sections.items[i];
+ std.log.debug(.link, "writing section {}\n", .{shdr.*});
+ if (foreign_endian) {
+ bswapAllFields(elf.Elf64_Shdr, shdr);
+ }
+ }
+ try self.file.?.pwriteAll(mem.sliceAsBytes(buf), self.shdr_table_offset.?);
+ },
+ }
+ self.shdr_table_dirty = false;
+ }
+ if (self.entry_addr == null and self.options.output_mode == .Exe) {
+ std.log.debug(.link, "no_entry_point_found = true\n", .{});
+ self.error_flags.no_entry_point_found = true;
+ } else {
+ self.error_flags.no_entry_point_found = false;
+ try self.writeElfHeader();
+ }
+
+ // The point of flush() is to commit changes, so nothing should be dirty after this.
+ assert(!self.phdr_table_dirty);
+ assert(!self.shdr_table_dirty);
+ assert(!self.shstrtab_dirty);
+ assert(!self.offset_table_count_dirty);
+ const syms_sect = &self.sections.items[self.symtab_section_index.?];
+ assert(syms_sect.sh_info == self.local_symbols.items.len);
+ }
+
+ fn writeElfHeader(self: *Elf) !void {
+ var hdr_buf: [@sizeOf(elf.Elf64_Ehdr)]u8 = undefined;
+
+ var index: usize = 0;
+ hdr_buf[0..4].* = "\x7fELF".*;
+ index += 4;
+
+ hdr_buf[index] = switch (self.ptr_width) {
+ .p32 => elf.ELFCLASS32,
+ .p64 => elf.ELFCLASS64,
+ };
+ index += 1;
+
+ const endian = self.options.target.cpu.arch.endian();
+ hdr_buf[index] = switch (endian) {
+ .Little => elf.ELFDATA2LSB,
+ .Big => elf.ELFDATA2MSB,
+ };
+ index += 1;
+
+ hdr_buf[index] = 1; // ELF version
+ index += 1;
+
+ // OS ABI, often set to 0 regardless of target platform
+ // ABI Version, possibly used by glibc but not by static executables
+ // padding
+ mem.set(u8, hdr_buf[index..][0..9], 0);
+ index += 9;
+
+ assert(index == 16);
+
+ const elf_type = switch (self.options.output_mode) {
+ .Exe => elf.ET.EXEC,
+ .Obj => elf.ET.REL,
+ .Lib => switch (self.options.link_mode) {
+ .Static => elf.ET.REL,
+ .Dynamic => elf.ET.DYN,
+ },
+ };
+ mem.writeInt(u16, hdr_buf[index..][0..2], @enumToInt(elf_type), endian);
+ index += 2;
+
+ const machine = self.options.target.cpu.arch.toElfMachine();
+ mem.writeInt(u16, hdr_buf[index..][0..2], @enumToInt(machine), endian);
+ index += 2;
+
+ // ELF Version, again
+ mem.writeInt(u32, hdr_buf[index..][0..4], 1, endian);
+ index += 4;
+
+ const e_entry = if (elf_type == .REL) 0 else self.entry_addr.?;
switch (self.ptr_width) {
.p32 => {
- const buf = try self.allocator.alloc(elf.Elf32_Shdr, self.sections.items.len);
- defer self.allocator.free(buf);
+ mem.writeInt(u32, hdr_buf[index..][0..4], @intCast(u32, e_entry), endian);
+ index += 4;
- for (buf) |*shdr, i| {
- shdr.* = sectHeaderTo32(self.sections.items[i]);
- if (foreign_endian) {
- bswapAllFields(elf.Elf32_Shdr, shdr);
- }
- }
- try self.file.?.pwriteAll(mem.sliceAsBytes(buf), self.shdr_table_offset.?);
+ // e_phoff
+ mem.writeInt(u32, hdr_buf[index..][0..4], @intCast(u32, self.phdr_table_offset.?), endian);
+ index += 4;
+
+ // e_shoff
+ mem.writeInt(u32, hdr_buf[index..][0..4], @intCast(u32, self.shdr_table_offset.?), endian);
+ index += 4;
},
.p64 => {
- const buf = try self.allocator.alloc(elf.Elf64_Shdr, self.sections.items.len);
- defer self.allocator.free(buf);
+ // e_entry
+ mem.writeInt(u64, hdr_buf[index..][0..8], e_entry, endian);
+ index += 8;
- for (buf) |*shdr, i| {
- shdr.* = self.sections.items[i];
- //std.debug.warn("writing section {}\n", .{shdr.*});
- if (foreign_endian) {
- bswapAllFields(elf.Elf64_Shdr, shdr);
- }
- }
- try self.file.?.pwriteAll(mem.sliceAsBytes(buf), self.shdr_table_offset.?);
+ // e_phoff
+ mem.writeInt(u64, hdr_buf[index..][0..8], self.phdr_table_offset.?, endian);
+ index += 8;
+
+ // e_shoff
+ mem.writeInt(u64, hdr_buf[index..][0..8], self.shdr_table_offset.?, endian);
+ index += 8;
},
}
- self.shdr_table_dirty = false;
- }
- if (self.entry_addr == null and self.options.output_mode == .Exe) {
- self.error_flags.no_entry_point_found = true;
- } else {
- self.error_flags.no_entry_point_found = false;
- try self.writeElfHeader();
+
+ const e_flags = 0;
+ mem.writeInt(u32, hdr_buf[index..][0..4], e_flags, endian);
+ index += 4;
+
+ const e_ehsize: u16 = switch (self.ptr_width) {
+ .p32 => @sizeOf(elf.Elf32_Ehdr),
+ .p64 => @sizeOf(elf.Elf64_Ehdr),
+ };
+ mem.writeInt(u16, hdr_buf[index..][0..2], e_ehsize, endian);
+ index += 2;
+
+ const e_phentsize: u16 = switch (self.ptr_width) {
+ .p32 => @sizeOf(elf.Elf32_Phdr),
+ .p64 => @sizeOf(elf.Elf64_Phdr),
+ };
+ mem.writeInt(u16, hdr_buf[index..][0..2], e_phentsize, endian);
+ index += 2;
+
+ const e_phnum = @intCast(u16, self.program_headers.items.len);
+ mem.writeInt(u16, hdr_buf[index..][0..2], e_phnum, endian);
+ index += 2;
+
+ const e_shentsize: u16 = switch (self.ptr_width) {
+ .p32 => @sizeOf(elf.Elf32_Shdr),
+ .p64 => @sizeOf(elf.Elf64_Shdr),
+ };
+ mem.writeInt(u16, hdr_buf[index..][0..2], e_shentsize, endian);
+ index += 2;
+
+ const e_shnum = @intCast(u16, self.sections.items.len);
+ mem.writeInt(u16, hdr_buf[index..][0..2], e_shnum, endian);
+ index += 2;
+
+ mem.writeInt(u16, hdr_buf[index..][0..2], self.shstrtab_index.?, endian);
+ index += 2;
+
+ assert(index == e_ehsize);
+
+ try self.file.?.pwriteAll(hdr_buf[0..index], 0);
}
- // The point of flush() is to commit changes, so nothing should be dirty after this.
- assert(!self.phdr_table_dirty);
- assert(!self.shdr_table_dirty);
- assert(!self.shstrtab_dirty);
- assert(!self.offset_table_count_dirty);
- const syms_sect = &self.sections.items[self.symtab_section_index.?];
- assert(syms_sect.sh_info == self.local_symbols.items.len);
- }
-
- fn writeElfHeader(self: *ElfFile) !void {
- var hdr_buf: [@sizeOf(elf.Elf64_Ehdr)]u8 = undefined;
-
- var index: usize = 0;
- hdr_buf[0..4].* = "\x7fELF".*;
- index += 4;
-
- hdr_buf[index] = switch (self.ptr_width) {
- .p32 => elf.ELFCLASS32,
- .p64 => elf.ELFCLASS64,
- };
- index += 1;
-
- const endian = self.options.target.cpu.arch.endian();
- hdr_buf[index] = switch (endian) {
- .Little => elf.ELFDATA2LSB,
- .Big => elf.ELFDATA2MSB,
- };
- index += 1;
-
- hdr_buf[index] = 1; // ELF version
- index += 1;
-
- // OS ABI, often set to 0 regardless of target platform
- // ABI Version, possibly used by glibc but not by static executables
- // padding
- mem.set(u8, hdr_buf[index..][0..9], 0);
- index += 9;
-
- assert(index == 16);
-
- const elf_type = switch (self.options.output_mode) {
- .Exe => elf.ET.EXEC,
- .Obj => elf.ET.REL,
- .Lib => switch (self.options.link_mode) {
- .Static => elf.ET.REL,
- .Dynamic => elf.ET.DYN,
- },
- };
- mem.writeInt(u16, hdr_buf[index..][0..2], @enumToInt(elf_type), endian);
- index += 2;
-
- const machine = self.options.target.cpu.arch.toElfMachine();
- mem.writeInt(u16, hdr_buf[index..][0..2], @enumToInt(machine), endian);
- index += 2;
-
- // ELF Version, again
- mem.writeInt(u32, hdr_buf[index..][0..4], 1, endian);
- index += 4;
-
- const e_entry = if (elf_type == .REL) 0 else self.entry_addr.?;
-
- switch (self.ptr_width) {
- .p32 => {
- mem.writeInt(u32, hdr_buf[index..][0..4], @intCast(u32, e_entry), endian);
- index += 4;
-
- // e_phoff
- mem.writeInt(u32, hdr_buf[index..][0..4], @intCast(u32, self.phdr_table_offset.?), endian);
- index += 4;
-
- // e_shoff
- mem.writeInt(u32, hdr_buf[index..][0..4], @intCast(u32, self.shdr_table_offset.?), endian);
- index += 4;
- },
- .p64 => {
- // e_entry
- mem.writeInt(u64, hdr_buf[index..][0..8], e_entry, endian);
- index += 8;
-
- // e_phoff
- mem.writeInt(u64, hdr_buf[index..][0..8], self.phdr_table_offset.?, endian);
- index += 8;
-
- // e_shoff
- mem.writeInt(u64, hdr_buf[index..][0..8], self.shdr_table_offset.?, endian);
- index += 8;
- },
- }
-
- const e_flags = 0;
- mem.writeInt(u32, hdr_buf[index..][0..4], e_flags, endian);
- index += 4;
-
- const e_ehsize: u16 = switch (self.ptr_width) {
- .p32 => @sizeOf(elf.Elf32_Ehdr),
- .p64 => @sizeOf(elf.Elf64_Ehdr),
- };
- mem.writeInt(u16, hdr_buf[index..][0..2], e_ehsize, endian);
- index += 2;
-
- const e_phentsize: u16 = switch (self.ptr_width) {
- .p32 => @sizeOf(elf.Elf32_Phdr),
- .p64 => @sizeOf(elf.Elf64_Phdr),
- };
- mem.writeInt(u16, hdr_buf[index..][0..2], e_phentsize, endian);
- index += 2;
-
- const e_phnum = @intCast(u16, self.program_headers.items.len);
- mem.writeInt(u16, hdr_buf[index..][0..2], e_phnum, endian);
- index += 2;
-
- const e_shentsize: u16 = switch (self.ptr_width) {
- .p32 => @sizeOf(elf.Elf32_Shdr),
- .p64 => @sizeOf(elf.Elf64_Shdr),
- };
- mem.writeInt(u16, hdr_buf[index..][0..2], e_shentsize, endian);
- index += 2;
-
- const e_shnum = @intCast(u16, self.sections.items.len);
- mem.writeInt(u16, hdr_buf[index..][0..2], e_shnum, endian);
- index += 2;
-
- mem.writeInt(u16, hdr_buf[index..][0..2], self.shstrtab_index.?, endian);
- index += 2;
-
- assert(index == e_ehsize);
-
- try self.file.?.pwriteAll(hdr_buf[0..index], 0);
- }
-
- fn freeTextBlock(self: *ElfFile, text_block: *TextBlock) void {
- var already_have_free_list_node = false;
- {
- var i: usize = 0;
- while (i < self.text_block_free_list.items.len) {
- if (self.text_block_free_list.items[i] == text_block) {
- _ = self.text_block_free_list.swapRemove(i);
- continue;
- }
- if (self.text_block_free_list.items[i] == text_block.prev) {
- already_have_free_list_node = true;
- }
- i += 1;
- }
- }
-
- if (self.last_text_block == text_block) {
- // TODO shrink the .text section size here
- self.last_text_block = text_block.prev;
- }
-
- if (text_block.prev) |prev| {
- prev.next = text_block.next;
-
- if (!already_have_free_list_node and prev.freeListEligible(self.*)) {
- // The free list is heuristics, it doesn't have to be perfect, so we can
- // ignore the OOM here.
- self.text_block_free_list.append(self.allocator, prev) catch {};
- }
- } else {
- text_block.prev = null;
- }
-
- if (text_block.next) |next| {
- next.prev = text_block.prev;
- } else {
- text_block.next = null;
- }
- }
-
- fn shrinkTextBlock(self: *ElfFile, text_block: *TextBlock, new_block_size: u64) void {
- // TODO check the new capacity, and if it crosses the size threshold into a big enough
- // capacity, insert a free list node for it.
- }
-
- fn growTextBlock(self: *ElfFile, text_block: *TextBlock, new_block_size: u64, alignment: u64) !u64 {
- const sym = self.local_symbols.items[text_block.local_sym_index];
- const align_ok = mem.alignBackwardGeneric(u64, sym.st_value, alignment) == sym.st_value;
- const need_realloc = !align_ok or new_block_size > text_block.capacity(self.*);
- if (!need_realloc) return sym.st_value;
- return self.allocateTextBlock(text_block, new_block_size, alignment);
- }
-
- fn allocateTextBlock(self: *ElfFile, text_block: *TextBlock, new_block_size: u64, alignment: u64) !u64 {
- const phdr = &self.program_headers.items[self.phdr_load_re_index.?];
- const shdr = &self.sections.items[self.text_section_index.?];
- const new_block_ideal_capacity = new_block_size * alloc_num / alloc_den;
-
- // We use these to indicate our intention to update metadata, placing the new block,
- // and possibly removing a free list node.
- // It would be simpler to do it inside the for loop below, but that would cause a
- // problem if an error was returned later in the function. So this action
- // is actually carried out at the end of the function, when errors are no longer possible.
- var block_placement: ?*TextBlock = null;
- var free_list_removal: ?usize = null;
-
- // First we look for an appropriately sized free list node.
- // The list is unordered. We'll just take the first thing that works.
- const vaddr = blk: {
- var i: usize = 0;
- while (i < self.text_block_free_list.items.len) {
- const big_block = self.text_block_free_list.items[i];
- // We now have a pointer to a live text block that has too much capacity.
- // Is it enough that we could fit this new text block?
- const sym = self.local_symbols.items[big_block.local_sym_index];
- const capacity = big_block.capacity(self.*);
- const ideal_capacity = capacity * alloc_num / alloc_den;
- const ideal_capacity_end_vaddr = sym.st_value + ideal_capacity;
- const capacity_end_vaddr = sym.st_value + capacity;
- const new_start_vaddr_unaligned = capacity_end_vaddr - new_block_ideal_capacity;
- const new_start_vaddr = mem.alignBackwardGeneric(u64, new_start_vaddr_unaligned, alignment);
- if (new_start_vaddr < ideal_capacity_end_vaddr) {
- // Additional bookkeeping here to notice if this free list node
- // should be deleted because the block that it points to has grown to take up
- // more of the extra capacity.
- if (!big_block.freeListEligible(self.*)) {
+ fn freeTextBlock(self: *Elf, text_block: *TextBlock) void {
+ var already_have_free_list_node = false;
+ {
+ var i: usize = 0;
+ while (i < self.text_block_free_list.items.len) {
+ if (self.text_block_free_list.items[i] == text_block) {
_ = self.text_block_free_list.swapRemove(i);
- } else {
- i += 1;
+ continue;
}
- continue;
+ if (self.text_block_free_list.items[i] == text_block.prev) {
+ already_have_free_list_node = true;
+ }
+ i += 1;
}
- // At this point we know that we will place the new block here. But the
- // remaining question is whether there is still yet enough capacity left
- // over for there to still be a free list node.
- const remaining_capacity = new_start_vaddr - ideal_capacity_end_vaddr;
- const keep_free_list_node = remaining_capacity >= min_text_capacity;
-
- // Set up the metadata to be updated, after errors are no longer possible.
- block_placement = big_block;
- if (!keep_free_list_node) {
- free_list_removal = i;
- }
- break :blk new_start_vaddr;
- } else if (self.last_text_block) |last| {
- const sym = self.local_symbols.items[last.local_sym_index];
- const ideal_capacity = sym.st_size * alloc_num / alloc_den;
- const ideal_capacity_end_vaddr = sym.st_value + ideal_capacity;
- const new_start_vaddr = mem.alignForwardGeneric(u64, ideal_capacity_end_vaddr, alignment);
- // Set up the metadata to be updated, after errors are no longer possible.
- block_placement = last;
- break :blk new_start_vaddr;
- } else {
- break :blk phdr.p_vaddr;
}
- };
- const expand_text_section = block_placement == null or block_placement.?.next == null;
- if (expand_text_section) {
- const text_capacity = self.allocatedSize(shdr.sh_offset);
- const needed_size = (vaddr + new_block_size) - phdr.p_vaddr;
- if (needed_size > text_capacity) {
- // Must move the entire text section.
- const new_offset = self.findFreeSpace(needed_size, 0x1000);
- const text_size = if (self.last_text_block) |last| blk: {
+ if (self.last_text_block == text_block) {
+ // TODO shrink the .text section size here
+ self.last_text_block = text_block.prev;
+ }
+
+ if (text_block.prev) |prev| {
+ prev.next = text_block.next;
+
+ if (!already_have_free_list_node and prev.freeListEligible(self.*)) {
+ // The free list is heuristics, it doesn't have to be perfect, so we can
+ // ignore the OOM here.
+ self.text_block_free_list.append(self.allocator, prev) catch {};
+ }
+ } else {
+ text_block.prev = null;
+ }
+
+ if (text_block.next) |next| {
+ next.prev = text_block.prev;
+ } else {
+ text_block.next = null;
+ }
+ }
+
+ fn shrinkTextBlock(self: *Elf, text_block: *TextBlock, new_block_size: u64) void {
+ // TODO check the new capacity, and if it crosses the size threshold into a big enough
+ // capacity, insert a free list node for it.
+ }
+
+ fn growTextBlock(self: *Elf, text_block: *TextBlock, new_block_size: u64, alignment: u64) !u64 {
+ const sym = self.local_symbols.items[text_block.local_sym_index];
+ const align_ok = mem.alignBackwardGeneric(u64, sym.st_value, alignment) == sym.st_value;
+ const need_realloc = !align_ok or new_block_size > text_block.capacity(self.*);
+ if (!need_realloc) return sym.st_value;
+ return self.allocateTextBlock(text_block, new_block_size, alignment);
+ }
+
+ fn allocateTextBlock(self: *Elf, text_block: *TextBlock, new_block_size: u64, alignment: u64) !u64 {
+ const phdr = &self.program_headers.items[self.phdr_load_re_index.?];
+ const shdr = &self.sections.items[self.text_section_index.?];
+ const new_block_ideal_capacity = new_block_size * alloc_num / alloc_den;
+
+ // We use these to indicate our intention to update metadata, placing the new block,
+ // and possibly removing a free list node.
+ // It would be simpler to do it inside the for loop below, but that would cause a
+ // problem if an error was returned later in the function. So this action
+ // is actually carried out at the end of the function, when errors are no longer possible.
+ var block_placement: ?*TextBlock = null;
+ var free_list_removal: ?usize = null;
+
+ // First we look for an appropriately sized free list node.
+ // The list is unordered. We'll just take the first thing that works.
+ const vaddr = blk: {
+ var i: usize = 0;
+ while (i < self.text_block_free_list.items.len) {
+ const big_block = self.text_block_free_list.items[i];
+ // We now have a pointer to a live text block that has too much capacity.
+ // Is it enough that we could fit this new text block?
+ const sym = self.local_symbols.items[big_block.local_sym_index];
+ const capacity = big_block.capacity(self.*);
+ const ideal_capacity = capacity * alloc_num / alloc_den;
+ const ideal_capacity_end_vaddr = sym.st_value + ideal_capacity;
+ const capacity_end_vaddr = sym.st_value + capacity;
+ const new_start_vaddr_unaligned = capacity_end_vaddr - new_block_ideal_capacity;
+ const new_start_vaddr = mem.alignBackwardGeneric(u64, new_start_vaddr_unaligned, alignment);
+ if (new_start_vaddr < ideal_capacity_end_vaddr) {
+ // Additional bookkeeping here to notice if this free list node
+ // should be deleted because the block that it points to has grown to take up
+ // more of the extra capacity.
+ if (!big_block.freeListEligible(self.*)) {
+ _ = self.text_block_free_list.swapRemove(i);
+ } else {
+ i += 1;
+ }
+ continue;
+ }
+ // At this point we know that we will place the new block here. But the
+ // remaining question is whether there is still yet enough capacity left
+ // over for there to still be a free list node.
+ const remaining_capacity = new_start_vaddr - ideal_capacity_end_vaddr;
+ const keep_free_list_node = remaining_capacity >= min_text_capacity;
+
+ // Set up the metadata to be updated, after errors are no longer possible.
+ block_placement = big_block;
+ if (!keep_free_list_node) {
+ free_list_removal = i;
+ }
+ break :blk new_start_vaddr;
+ } else if (self.last_text_block) |last| {
const sym = self.local_symbols.items[last.local_sym_index];
- break :blk (sym.st_value + sym.st_size) - phdr.p_vaddr;
- } else 0;
- const amt = try self.file.?.copyRangeAll(shdr.sh_offset, self.file.?, new_offset, text_size);
- if (amt != text_size) return error.InputOutput;
- shdr.sh_offset = new_offset;
- phdr.p_offset = new_offset;
- }
- self.last_text_block = text_block;
-
- shdr.sh_size = needed_size;
- phdr.p_memsz = needed_size;
- phdr.p_filesz = needed_size;
-
- self.phdr_table_dirty = true; // TODO look into making only the one program header dirty
- self.shdr_table_dirty = true; // TODO look into making only the one section dirty
- }
-
- // This function can also reallocate a text block.
- // In this case we need to "unplug" it from its previous location before
- // plugging it in to its new location.
- if (text_block.prev) |prev| {
- prev.next = text_block.next;
- }
- if (text_block.next) |next| {
- next.prev = text_block.prev;
- }
-
- if (block_placement) |big_block| {
- text_block.prev = big_block;
- text_block.next = big_block.next;
- big_block.next = text_block;
- } else {
- text_block.prev = null;
- text_block.next = null;
- }
- if (free_list_removal) |i| {
- _ = self.text_block_free_list.swapRemove(i);
- }
- return vaddr;
- }
-
- pub fn allocateDeclIndexes(self: *ElfFile, decl: *Module.Decl) !void {
- if (decl.link.local_sym_index != 0) return;
-
- // Here we also ensure capacity for the free lists so that they can be appended to without fail.
- try self.local_symbols.ensureCapacity(self.allocator, self.local_symbols.items.len + 1);
- try self.local_symbol_free_list.ensureCapacity(self.allocator, self.local_symbols.items.len);
- try self.offset_table.ensureCapacity(self.allocator, self.offset_table.items.len + 1);
- try self.offset_table_free_list.ensureCapacity(self.allocator, self.local_symbols.items.len);
-
- if (self.local_symbol_free_list.popOrNull()) |i| {
- //std.debug.warn("reusing symbol index {} for {}\n", .{i, decl.name});
- decl.link.local_sym_index = i;
- } else {
- //std.debug.warn("allocating symbol index {} for {}\n", .{self.local_symbols.items.len, decl.name});
- decl.link.local_sym_index = @intCast(u32, self.local_symbols.items.len);
- _ = self.local_symbols.addOneAssumeCapacity();
- }
-
- if (self.offset_table_free_list.popOrNull()) |i| {
- decl.link.offset_table_index = i;
- } else {
- decl.link.offset_table_index = @intCast(u32, self.offset_table.items.len);
- _ = self.offset_table.addOneAssumeCapacity();
- self.offset_table_count_dirty = true;
- }
-
- const phdr = &self.program_headers.items[self.phdr_load_re_index.?];
-
- self.local_symbols.items[decl.link.local_sym_index] = .{
- .st_name = 0,
- .st_info = 0,
- .st_other = 0,
- .st_shndx = 0,
- .st_value = phdr.p_vaddr,
- .st_size = 0,
- };
- self.offset_table.items[decl.link.offset_table_index] = 0;
- }
-
- pub fn freeDecl(self: *ElfFile, decl: *Module.Decl) void {
- self.freeTextBlock(&decl.link);
- if (decl.link.local_sym_index != 0) {
- self.local_symbol_free_list.appendAssumeCapacity(decl.link.local_sym_index);
- self.offset_table_free_list.appendAssumeCapacity(decl.link.offset_table_index);
-
- self.local_symbols.items[decl.link.local_sym_index].st_info = 0;
-
- decl.link.local_sym_index = 0;
- }
- }
-
- pub fn updateDecl(self: *ElfFile, module: *Module, decl: *Module.Decl) !void {
- var code_buffer = std.ArrayList(u8).init(self.allocator);
- defer code_buffer.deinit();
-
- const typed_value = decl.typed_value.most_recent.typed_value;
- const code = switch (try codegen.generateSymbol(self, decl.src, typed_value, &code_buffer)) {
- .externally_managed => |x| x,
- .appended => code_buffer.items,
- .fail => |em| {
- decl.analysis = .codegen_failure;
- _ = try module.failed_decls.put(decl, em);
- return;
- },
- };
-
- const required_alignment = typed_value.ty.abiAlignment(self.options.target);
-
- const stt_bits: u8 = switch (typed_value.ty.zigTypeTag()) {
- .Fn => elf.STT_FUNC,
- else => elf.STT_OBJECT,
- };
-
- assert(decl.link.local_sym_index != 0); // Caller forgot to allocateDeclIndexes()
- const local_sym = &self.local_symbols.items[decl.link.local_sym_index];
- if (local_sym.st_size != 0) {
- const capacity = decl.link.capacity(self.*);
- const need_realloc = code.len > capacity or
- !mem.isAlignedGeneric(u64, local_sym.st_value, required_alignment);
- if (need_realloc) {
- const vaddr = try self.growTextBlock(&decl.link, code.len, required_alignment);
- //std.debug.warn("growing {} from 0x{x} to 0x{x}\n", .{ decl.name, local_sym.st_value, vaddr });
- if (vaddr != local_sym.st_value) {
- local_sym.st_value = vaddr;
-
- //std.debug.warn(" (writing new offset table entry)\n", .{});
- self.offset_table.items[decl.link.offset_table_index] = vaddr;
- try self.writeOffsetTableEntry(decl.link.offset_table_index);
+ const ideal_capacity = sym.st_size * alloc_num / alloc_den;
+ const ideal_capacity_end_vaddr = sym.st_value + ideal_capacity;
+ const new_start_vaddr = mem.alignForwardGeneric(u64, ideal_capacity_end_vaddr, alignment);
+ // Set up the metadata to be updated, after errors are no longer possible.
+ block_placement = last;
+ break :blk new_start_vaddr;
+ } else {
+ break :blk phdr.p_vaddr;
}
- } else if (code.len < local_sym.st_size) {
- self.shrinkTextBlock(&decl.link, code.len);
- }
- local_sym.st_size = code.len;
- local_sym.st_name = try self.updateString(local_sym.st_name, mem.spanZ(decl.name));
- local_sym.st_info = (elf.STB_LOCAL << 4) | stt_bits;
- local_sym.st_other = 0;
- local_sym.st_shndx = self.text_section_index.?;
- // TODO this write could be avoided if no fields of the symbol were changed.
- try self.writeSymbol(decl.link.local_sym_index);
- } else {
- const decl_name = mem.spanZ(decl.name);
- const name_str_index = try self.makeString(decl_name);
- const vaddr = try self.allocateTextBlock(&decl.link, code.len, required_alignment);
- //std.debug.warn("allocated text block for {} at 0x{x}\n", .{ decl_name, vaddr });
- errdefer self.freeTextBlock(&decl.link);
-
- local_sym.* = .{
- .st_name = name_str_index,
- .st_info = (elf.STB_LOCAL << 4) | stt_bits,
- .st_other = 0,
- .st_shndx = self.text_section_index.?,
- .st_value = vaddr,
- .st_size = code.len,
};
- self.offset_table.items[decl.link.offset_table_index] = vaddr;
- try self.writeSymbol(decl.link.local_sym_index);
- try self.writeOffsetTableEntry(decl.link.offset_table_index);
- }
-
- const section_offset = local_sym.st_value - self.program_headers.items[self.phdr_load_re_index.?].p_vaddr;
- const file_offset = self.sections.items[self.text_section_index.?].sh_offset + section_offset;
- try self.file.?.pwriteAll(code, file_offset);
-
- // Since we updated the vaddr and the size, each corresponding export symbol also needs to be updated.
- const decl_exports = module.decl_exports.getValue(decl) orelse &[0]*Module.Export{};
- return self.updateDeclExports(module, decl, decl_exports);
- }
-
- /// Must be called only after a successful call to `updateDecl`.
- pub fn updateDeclExports(
- self: *ElfFile,
- module: *Module,
- decl: *const Module.Decl,
- exports: []const *Module.Export,
- ) !void {
- // In addition to ensuring capacity for global_symbols, we also ensure capacity for freeing all of
- // them, so that deleting exports is guaranteed to succeed.
- try self.global_symbols.ensureCapacity(self.allocator, self.global_symbols.items.len + exports.len);
- try self.global_symbol_free_list.ensureCapacity(self.allocator, self.global_symbols.items.len);
- const typed_value = decl.typed_value.most_recent.typed_value;
- if (decl.link.local_sym_index == 0) return;
- const decl_sym = self.local_symbols.items[decl.link.local_sym_index];
-
- for (exports) |exp| {
- if (exp.options.section) |section_name| {
- if (!mem.eql(u8, section_name, ".text")) {
- try module.failed_exports.ensureCapacity(module.failed_exports.size + 1);
- module.failed_exports.putAssumeCapacityNoClobber(
- exp,
- try Module.ErrorMsg.create(self.allocator, 0, "Unimplemented: ExportOptions.section", .{}),
- );
- continue;
+ const expand_text_section = block_placement == null or block_placement.?.next == null;
+ if (expand_text_section) {
+ const text_capacity = self.allocatedSize(shdr.sh_offset);
+ const needed_size = (vaddr + new_block_size) - phdr.p_vaddr;
+ if (needed_size > text_capacity) {
+ // Must move the entire text section.
+ const new_offset = self.findFreeSpace(needed_size, 0x1000);
+ const text_size = if (self.last_text_block) |last| blk: {
+ const sym = self.local_symbols.items[last.local_sym_index];
+ break :blk (sym.st_value + sym.st_size) - phdr.p_vaddr;
+ } else 0;
+ const amt = try self.file.?.copyRangeAll(shdr.sh_offset, self.file.?, new_offset, text_size);
+ if (amt != text_size) return error.InputOutput;
+ shdr.sh_offset = new_offset;
+ phdr.p_offset = new_offset;
}
+ self.last_text_block = text_block;
+
+ shdr.sh_size = needed_size;
+ phdr.p_memsz = needed_size;
+ phdr.p_filesz = needed_size;
+
+ self.phdr_table_dirty = true; // TODO look into making only the one program header dirty
+ self.shdr_table_dirty = true; // TODO look into making only the one section dirty
}
- const stb_bits: u8 = switch (exp.options.linkage) {
- .Internal => elf.STB_LOCAL,
- .Strong => blk: {
- if (mem.eql(u8, exp.options.name, "_start")) {
- self.entry_addr = decl_sym.st_value;
- }
- break :blk elf.STB_GLOBAL;
- },
- .Weak => elf.STB_WEAK,
- .LinkOnce => {
- try module.failed_exports.ensureCapacity(module.failed_exports.size + 1);
- module.failed_exports.putAssumeCapacityNoClobber(
- exp,
- try Module.ErrorMsg.create(self.allocator, 0, "Unimplemented: GlobalLinkage.LinkOnce", .{}),
- );
- continue;
- },
- };
- const stt_bits: u8 = @truncate(u4, decl_sym.st_info);
- if (exp.link.sym_index) |i| {
- const sym = &self.global_symbols.items[i];
- sym.* = .{
- .st_name = try self.updateString(sym.st_name, exp.options.name),
- .st_info = (stb_bits << 4) | stt_bits,
- .st_other = 0,
- .st_shndx = self.text_section_index.?,
- .st_value = decl_sym.st_value,
- .st_size = decl_sym.st_size,
- };
+
+ // This function can also reallocate a text block.
+ // In this case we need to "unplug" it from its previous location before
+ // plugging it in to its new location.
+ if (text_block.prev) |prev| {
+ prev.next = text_block.next;
+ }
+ if (text_block.next) |next| {
+ next.prev = text_block.prev;
+ }
+
+ if (block_placement) |big_block| {
+ text_block.prev = big_block;
+ text_block.next = big_block.next;
+ big_block.next = text_block;
} else {
- const name = try self.makeString(exp.options.name);
- const i = if (self.global_symbol_free_list.popOrNull()) |i| i else blk: {
- _ = self.global_symbols.addOneAssumeCapacity();
- break :blk self.global_symbols.items.len - 1;
- };
- self.global_symbols.items[i] = .{
- .st_name = name,
- .st_info = (stb_bits << 4) | stt_bits,
+ text_block.prev = null;
+ text_block.next = null;
+ }
+ if (free_list_removal) |i| {
+ _ = self.text_block_free_list.swapRemove(i);
+ }
+ return vaddr;
+ }
+
+ pub fn allocateDeclIndexes(self: *Elf, decl: *Module.Decl) !void {
+ if (decl.link.local_sym_index != 0) return;
+
+ // Here we also ensure capacity for the free lists so that they can be appended to without fail.
+ try self.local_symbols.ensureCapacity(self.allocator, self.local_symbols.items.len + 1);
+ try self.local_symbol_free_list.ensureCapacity(self.allocator, self.local_symbols.items.len);
+ try self.offset_table.ensureCapacity(self.allocator, self.offset_table.items.len + 1);
+ try self.offset_table_free_list.ensureCapacity(self.allocator, self.local_symbols.items.len);
+
+ if (self.local_symbol_free_list.popOrNull()) |i| {
+ std.log.debug(.link, "reusing symbol index {} for {}\n", .{ i, decl.name });
+ decl.link.local_sym_index = i;
+ } else {
+ std.log.debug(.link, "allocating symbol index {} for {}\n", .{ self.local_symbols.items.len, decl.name });
+ decl.link.local_sym_index = @intCast(u32, self.local_symbols.items.len);
+ _ = self.local_symbols.addOneAssumeCapacity();
+ }
+
+ if (self.offset_table_free_list.popOrNull()) |i| {
+ decl.link.offset_table_index = i;
+ } else {
+ decl.link.offset_table_index = @intCast(u32, self.offset_table.items.len);
+ _ = self.offset_table.addOneAssumeCapacity();
+ self.offset_table_count_dirty = true;
+ }
+
+ const phdr = &self.program_headers.items[self.phdr_load_re_index.?];
+
+ self.local_symbols.items[decl.link.local_sym_index] = .{
+ .st_name = 0,
+ .st_info = 0,
+ .st_other = 0,
+ .st_shndx = 0,
+ .st_value = phdr.p_vaddr,
+ .st_size = 0,
+ };
+ self.offset_table.items[decl.link.offset_table_index] = 0;
+ }
+
+ pub fn freeDecl(self: *Elf, decl: *Module.Decl) void {
+ self.freeTextBlock(&decl.link);
+ if (decl.link.local_sym_index != 0) {
+ self.local_symbol_free_list.appendAssumeCapacity(decl.link.local_sym_index);
+ self.offset_table_free_list.appendAssumeCapacity(decl.link.offset_table_index);
+
+ self.local_symbols.items[decl.link.local_sym_index].st_info = 0;
+
+ decl.link.local_sym_index = 0;
+ }
+ }
+
+ pub fn updateDecl(self: *Elf, module: *Module, decl: *Module.Decl) !void {
+ var code_buffer = std.ArrayList(u8).init(self.allocator);
+ defer code_buffer.deinit();
+
+ const typed_value = decl.typed_value.most_recent.typed_value;
+ const code = switch (try codegen.generateSymbol(self, decl.src(), typed_value, &code_buffer)) {
+ .externally_managed => |x| x,
+ .appended => code_buffer.items,
+ .fail => |em| {
+ decl.analysis = .codegen_failure;
+ try module.failed_decls.put(module.gpa, decl, em);
+ return;
+ },
+ };
+
+ const required_alignment = typed_value.ty.abiAlignment(self.options.target);
+
+ const stt_bits: u8 = switch (typed_value.ty.zigTypeTag()) {
+ .Fn => elf.STT_FUNC,
+ else => elf.STT_OBJECT,
+ };
+
+ assert(decl.link.local_sym_index != 0); // Caller forgot to allocateDeclIndexes()
+ const local_sym = &self.local_symbols.items[decl.link.local_sym_index];
+ if (local_sym.st_size != 0) {
+ const capacity = decl.link.capacity(self.*);
+ const need_realloc = code.len > capacity or
+ !mem.isAlignedGeneric(u64, local_sym.st_value, required_alignment);
+ if (need_realloc) {
+ const vaddr = try self.growTextBlock(&decl.link, code.len, required_alignment);
+ std.log.debug(.link, "growing {} from 0x{x} to 0x{x}\n", .{ decl.name, local_sym.st_value, vaddr });
+ if (vaddr != local_sym.st_value) {
+ local_sym.st_value = vaddr;
+
+ std.log.debug(.link, " (writing new offset table entry)\n", .{});
+ self.offset_table.items[decl.link.offset_table_index] = vaddr;
+ try self.writeOffsetTableEntry(decl.link.offset_table_index);
+ }
+ } else if (code.len < local_sym.st_size) {
+ self.shrinkTextBlock(&decl.link, code.len);
+ }
+ local_sym.st_size = code.len;
+ local_sym.st_name = try self.updateString(local_sym.st_name, mem.spanZ(decl.name));
+ local_sym.st_info = (elf.STB_LOCAL << 4) | stt_bits;
+ local_sym.st_other = 0;
+ local_sym.st_shndx = self.text_section_index.?;
+ // TODO this write could be avoided if no fields of the symbol were changed.
+ try self.writeSymbol(decl.link.local_sym_index);
+ } else {
+ const decl_name = mem.spanZ(decl.name);
+ const name_str_index = try self.makeString(decl_name);
+ const vaddr = try self.allocateTextBlock(&decl.link, code.len, required_alignment);
+ std.log.debug(.link, "allocated text block for {} at 0x{x}\n", .{ decl_name, vaddr });
+ errdefer self.freeTextBlock(&decl.link);
+
+ local_sym.* = .{
+ .st_name = name_str_index,
+ .st_info = (elf.STB_LOCAL << 4) | stt_bits,
.st_other = 0,
.st_shndx = self.text_section_index.?,
- .st_value = decl_sym.st_value,
- .st_size = decl_sym.st_size,
+ .st_value = vaddr,
+ .st_size = code.len,
};
+ self.offset_table.items[decl.link.offset_table_index] = vaddr;
- exp.link.sym_index = @intCast(u32, i);
+ try self.writeSymbol(decl.link.local_sym_index);
+ try self.writeOffsetTableEntry(decl.link.offset_table_index);
+ }
+
+ const section_offset = local_sym.st_value - self.program_headers.items[self.phdr_load_re_index.?].p_vaddr;
+ const file_offset = self.sections.items[self.text_section_index.?].sh_offset + section_offset;
+ try self.file.?.pwriteAll(code, file_offset);
+
+ // Since we updated the vaddr and the size, each corresponding export symbol also needs to be updated.
+ const decl_exports = module.decl_exports.get(decl) orelse &[0]*Module.Export{};
+ return self.updateDeclExports(module, decl, decl_exports);
+ }
+
+ /// Must be called only after a successful call to `updateDecl`.
+ pub fn updateDeclExports(
+ self: *Elf,
+ module: *Module,
+ decl: *const Module.Decl,
+ exports: []const *Module.Export,
+ ) !void {
+ // In addition to ensuring capacity for global_symbols, we also ensure capacity for freeing all of
+ // them, so that deleting exports is guaranteed to succeed.
+ try self.global_symbols.ensureCapacity(self.allocator, self.global_symbols.items.len + exports.len);
+ try self.global_symbol_free_list.ensureCapacity(self.allocator, self.global_symbols.items.len);
+ const typed_value = decl.typed_value.most_recent.typed_value;
+ if (decl.link.local_sym_index == 0) return;
+ const decl_sym = self.local_symbols.items[decl.link.local_sym_index];
+
+ for (exports) |exp| {
+ if (exp.options.section) |section_name| {
+ if (!mem.eql(u8, section_name, ".text")) {
+ try module.failed_exports.ensureCapacity(module.gpa, module.failed_exports.items().len + 1);
+ module.failed_exports.putAssumeCapacityNoClobber(
+ exp,
+ try Module.ErrorMsg.create(self.allocator, 0, "Unimplemented: ExportOptions.section", .{}),
+ );
+ continue;
+ }
+ }
+ const stb_bits: u8 = switch (exp.options.linkage) {
+ .Internal => elf.STB_LOCAL,
+ .Strong => blk: {
+ if (mem.eql(u8, exp.options.name, "_start")) {
+ self.entry_addr = decl_sym.st_value;
+ }
+ break :blk elf.STB_GLOBAL;
+ },
+ .Weak => elf.STB_WEAK,
+ .LinkOnce => {
+ try module.failed_exports.ensureCapacity(module.gpa, module.failed_exports.items().len + 1);
+ module.failed_exports.putAssumeCapacityNoClobber(
+ exp,
+ try Module.ErrorMsg.create(self.allocator, 0, "Unimplemented: GlobalLinkage.LinkOnce", .{}),
+ );
+ continue;
+ },
+ };
+ const stt_bits: u8 = @truncate(u4, decl_sym.st_info);
+ if (exp.link.sym_index) |i| {
+ const sym = &self.global_symbols.items[i];
+ sym.* = .{
+ .st_name = try self.updateString(sym.st_name, exp.options.name),
+ .st_info = (stb_bits << 4) | stt_bits,
+ .st_other = 0,
+ .st_shndx = self.text_section_index.?,
+ .st_value = decl_sym.st_value,
+ .st_size = decl_sym.st_size,
+ };
+ } else {
+ const name = try self.makeString(exp.options.name);
+ const i = if (self.global_symbol_free_list.popOrNull()) |i| i else blk: {
+ _ = self.global_symbols.addOneAssumeCapacity();
+ break :blk self.global_symbols.items.len - 1;
+ };
+ self.global_symbols.items[i] = .{
+ .st_name = name,
+ .st_info = (stb_bits << 4) | stt_bits,
+ .st_other = 0,
+ .st_shndx = self.text_section_index.?,
+ .st_value = decl_sym.st_value,
+ .st_size = decl_sym.st_size,
+ };
+
+ exp.link.sym_index = @intCast(u32, i);
+ }
}
}
- }
- pub fn deleteExport(self: *ElfFile, exp: Export) void {
- const sym_index = exp.sym_index orelse return;
- self.global_symbol_free_list.appendAssumeCapacity(sym_index);
- self.global_symbols.items[sym_index].st_info = 0;
- }
-
- fn writeProgHeader(self: *ElfFile, index: usize) !void {
- const foreign_endian = self.options.target.cpu.arch.endian() != std.Target.current.cpu.arch.endian();
- const offset = self.program_headers.items[index].p_offset;
- switch (self.options.target.cpu.arch.ptrBitWidth()) {
- 32 => {
- var phdr = [1]elf.Elf32_Phdr{progHeaderTo32(self.program_headers.items[index])};
- if (foreign_endian) {
- bswapAllFields(elf.Elf32_Phdr, &phdr[0]);
- }
- return self.file.?.pwriteAll(mem.sliceAsBytes(&phdr), offset);
- },
- 64 => {
- var phdr = [1]elf.Elf64_Phdr{self.program_headers.items[index]};
- if (foreign_endian) {
- bswapAllFields(elf.Elf64_Phdr, &phdr[0]);
- }
- return self.file.?.pwriteAll(mem.sliceAsBytes(&phdr), offset);
- },
- else => return error.UnsupportedArchitecture,
+ pub fn deleteExport(self: *Elf, exp: Export) void {
+ const sym_index = exp.sym_index orelse return;
+ self.global_symbol_free_list.appendAssumeCapacity(sym_index);
+ self.global_symbols.items[sym_index].st_info = 0;
}
- }
- fn writeSectHeader(self: *ElfFile, index: usize) !void {
- const foreign_endian = self.options.target.cpu.arch.endian() != std.Target.current.cpu.arch.endian();
- const offset = self.sections.items[index].sh_offset;
- switch (self.options.target.cpu.arch.ptrBitWidth()) {
- 32 => {
- var shdr: [1]elf.Elf32_Shdr = undefined;
- shdr[0] = sectHeaderTo32(self.sections.items[index]);
- if (foreign_endian) {
- bswapAllFields(elf.Elf32_Shdr, &shdr[0]);
- }
- return self.file.?.pwriteAll(mem.sliceAsBytes(&shdr), offset);
- },
- 64 => {
- var shdr = [1]elf.Elf64_Shdr{self.sections.items[index]};
- if (foreign_endian) {
- bswapAllFields(elf.Elf64_Shdr, &shdr[0]);
- }
- return self.file.?.pwriteAll(mem.sliceAsBytes(&shdr), offset);
- },
- else => return error.UnsupportedArchitecture,
- }
- }
-
- fn writeOffsetTableEntry(self: *ElfFile, index: usize) !void {
- const shdr = &self.sections.items[self.got_section_index.?];
- const phdr = &self.program_headers.items[self.phdr_got_index.?];
- const entry_size: u16 = switch (self.ptr_width) {
- .p32 => 4,
- .p64 => 8,
- };
- if (self.offset_table_count_dirty) {
- // TODO Also detect virtual address collisions.
- const allocated_size = self.allocatedSize(shdr.sh_offset);
- const needed_size = self.local_symbols.items.len * entry_size;
- if (needed_size > allocated_size) {
- // Must move the entire got section.
- const new_offset = self.findFreeSpace(needed_size, entry_size);
- const amt = try self.file.?.copyRangeAll(shdr.sh_offset, self.file.?, new_offset, shdr.sh_size);
- if (amt != shdr.sh_size) return error.InputOutput;
- shdr.sh_offset = new_offset;
- phdr.p_offset = new_offset;
+ fn writeProgHeader(self: *Elf, index: usize) !void {
+ const foreign_endian = self.options.target.cpu.arch.endian() != std.Target.current.cpu.arch.endian();
+ const offset = self.program_headers.items[index].p_offset;
+ switch (self.options.target.cpu.arch.ptrBitWidth()) {
+ 32 => {
+ var phdr = [1]elf.Elf32_Phdr{progHeaderTo32(self.program_headers.items[index])};
+ if (foreign_endian) {
+ bswapAllFields(elf.Elf32_Phdr, &phdr[0]);
+ }
+ return self.file.?.pwriteAll(mem.sliceAsBytes(&phdr), offset);
+ },
+ 64 => {
+ var phdr = [1]elf.Elf64_Phdr{self.program_headers.items[index]};
+ if (foreign_endian) {
+ bswapAllFields(elf.Elf64_Phdr, &phdr[0]);
+ }
+ return self.file.?.pwriteAll(mem.sliceAsBytes(&phdr), offset);
+ },
+ else => return error.UnsupportedArchitecture,
}
- shdr.sh_size = needed_size;
- phdr.p_memsz = needed_size;
- phdr.p_filesz = needed_size;
-
- self.shdr_table_dirty = true; // TODO look into making only the one section dirty
- self.phdr_table_dirty = true; // TODO look into making only the one program header dirty
-
- self.offset_table_count_dirty = false;
}
- const endian = self.options.target.cpu.arch.endian();
- const off = shdr.sh_offset + @as(u64, entry_size) * index;
- switch (self.ptr_width) {
- .p32 => {
- var buf: [4]u8 = undefined;
- mem.writeInt(u32, &buf, @intCast(u32, self.offset_table.items[index]), endian);
- try self.file.?.pwriteAll(&buf, off);
- },
- .p64 => {
- var buf: [8]u8 = undefined;
- mem.writeInt(u64, &buf, self.offset_table.items[index], endian);
- try self.file.?.pwriteAll(&buf, off);
- },
- }
- }
- fn writeSymbol(self: *ElfFile, index: usize) !void {
- const syms_sect = &self.sections.items[self.symtab_section_index.?];
- // Make sure we are not pointlessly writing symbol data that will have to get relocated
- // due to running out of space.
- if (self.local_symbols.items.len != syms_sect.sh_info) {
+ fn writeSectHeader(self: *Elf, index: usize) !void {
+ const foreign_endian = self.options.target.cpu.arch.endian() != std.Target.current.cpu.arch.endian();
+ const offset = self.sections.items[index].sh_offset;
+ switch (self.options.target.cpu.arch.ptrBitWidth()) {
+ 32 => {
+ var shdr: [1]elf.Elf32_Shdr = undefined;
+ shdr[0] = sectHeaderTo32(self.sections.items[index]);
+ if (foreign_endian) {
+ bswapAllFields(elf.Elf32_Shdr, &shdr[0]);
+ }
+ return self.file.?.pwriteAll(mem.sliceAsBytes(&shdr), offset);
+ },
+ 64 => {
+ var shdr = [1]elf.Elf64_Shdr{self.sections.items[index]};
+ if (foreign_endian) {
+ bswapAllFields(elf.Elf64_Shdr, &shdr[0]);
+ }
+ return self.file.?.pwriteAll(mem.sliceAsBytes(&shdr), offset);
+ },
+ else => return error.UnsupportedArchitecture,
+ }
+ }
+
+ fn writeOffsetTableEntry(self: *Elf, index: usize) !void {
+ const shdr = &self.sections.items[self.got_section_index.?];
+ const phdr = &self.program_headers.items[self.phdr_got_index.?];
+ const entry_size: u16 = switch (self.ptr_width) {
+ .p32 => 4,
+ .p64 => 8,
+ };
+ if (self.offset_table_count_dirty) {
+ // TODO Also detect virtual address collisions.
+ const allocated_size = self.allocatedSize(shdr.sh_offset);
+ const needed_size = self.local_symbols.items.len * entry_size;
+ if (needed_size > allocated_size) {
+ // Must move the entire got section.
+ const new_offset = self.findFreeSpace(needed_size, entry_size);
+ const amt = try self.file.?.copyRangeAll(shdr.sh_offset, self.file.?, new_offset, shdr.sh_size);
+ if (amt != shdr.sh_size) return error.InputOutput;
+ shdr.sh_offset = new_offset;
+ phdr.p_offset = new_offset;
+ }
+ shdr.sh_size = needed_size;
+ phdr.p_memsz = needed_size;
+ phdr.p_filesz = needed_size;
+
+ self.shdr_table_dirty = true; // TODO look into making only the one section dirty
+ self.phdr_table_dirty = true; // TODO look into making only the one program header dirty
+
+ self.offset_table_count_dirty = false;
+ }
+ const endian = self.options.target.cpu.arch.endian();
+ const off = shdr.sh_offset + @as(u64, entry_size) * index;
+ switch (self.ptr_width) {
+ .p32 => {
+ var buf: [4]u8 = undefined;
+ mem.writeInt(u32, &buf, @intCast(u32, self.offset_table.items[index]), endian);
+ try self.file.?.pwriteAll(&buf, off);
+ },
+ .p64 => {
+ var buf: [8]u8 = undefined;
+ mem.writeInt(u64, &buf, self.offset_table.items[index], endian);
+ try self.file.?.pwriteAll(&buf, off);
+ },
+ }
+ }
+
+ fn writeSymbol(self: *Elf, index: usize) !void {
+ const syms_sect = &self.sections.items[self.symtab_section_index.?];
+ // Make sure we are not pointlessly writing symbol data that will have to get relocated
+ // due to running out of space.
+ if (self.local_symbols.items.len != syms_sect.sh_info) {
+ const sym_size: u64 = switch (self.ptr_width) {
+ .p32 => @sizeOf(elf.Elf32_Sym),
+ .p64 => @sizeOf(elf.Elf64_Sym),
+ };
+ const sym_align: u16 = switch (self.ptr_width) {
+ .p32 => @alignOf(elf.Elf32_Sym),
+ .p64 => @alignOf(elf.Elf64_Sym),
+ };
+ const needed_size = (self.local_symbols.items.len + self.global_symbols.items.len) * sym_size;
+ if (needed_size > self.allocatedSize(syms_sect.sh_offset)) {
+ // Move all the symbols to a new file location.
+ const new_offset = self.findFreeSpace(needed_size, sym_align);
+ const existing_size = @as(u64, syms_sect.sh_info) * sym_size;
+ const amt = try self.file.?.copyRangeAll(syms_sect.sh_offset, self.file.?, new_offset, existing_size);
+ if (amt != existing_size) return error.InputOutput;
+ syms_sect.sh_offset = new_offset;
+ }
+ syms_sect.sh_info = @intCast(u32, self.local_symbols.items.len);
+ syms_sect.sh_size = needed_size; // anticipating adding the global symbols later
+ self.shdr_table_dirty = true; // TODO look into only writing one section
+ }
+ const foreign_endian = self.options.target.cpu.arch.endian() != std.Target.current.cpu.arch.endian();
+ switch (self.ptr_width) {
+ .p32 => {
+ var sym = [1]elf.Elf32_Sym{
+ .{
+ .st_name = self.local_symbols.items[index].st_name,
+ .st_value = @intCast(u32, self.local_symbols.items[index].st_value),
+ .st_size = @intCast(u32, self.local_symbols.items[index].st_size),
+ .st_info = self.local_symbols.items[index].st_info,
+ .st_other = self.local_symbols.items[index].st_other,
+ .st_shndx = self.local_symbols.items[index].st_shndx,
+ },
+ };
+ if (foreign_endian) {
+ bswapAllFields(elf.Elf32_Sym, &sym[0]);
+ }
+ const off = syms_sect.sh_offset + @sizeOf(elf.Elf32_Sym) * index;
+ try self.file.?.pwriteAll(mem.sliceAsBytes(sym[0..1]), off);
+ },
+ .p64 => {
+ var sym = [1]elf.Elf64_Sym{self.local_symbols.items[index]};
+ if (foreign_endian) {
+ bswapAllFields(elf.Elf64_Sym, &sym[0]);
+ }
+ const off = syms_sect.sh_offset + @sizeOf(elf.Elf64_Sym) * index;
+ try self.file.?.pwriteAll(mem.sliceAsBytes(sym[0..1]), off);
+ },
+ }
+ }
+
+ fn writeAllGlobalSymbols(self: *Elf) !void {
+ const syms_sect = &self.sections.items[self.symtab_section_index.?];
const sym_size: u64 = switch (self.ptr_width) {
.p32 => @sizeOf(elf.Elf32_Sym),
.p64 => @sizeOf(elf.Elf64_Sym),
};
- const sym_align: u16 = switch (self.ptr_width) {
- .p32 => @alignOf(elf.Elf32_Sym),
- .p64 => @alignOf(elf.Elf64_Sym),
- };
- const needed_size = (self.local_symbols.items.len + self.global_symbols.items.len) * sym_size;
- if (needed_size > self.allocatedSize(syms_sect.sh_offset)) {
- // Move all the symbols to a new file location.
- const new_offset = self.findFreeSpace(needed_size, sym_align);
- const existing_size = @as(u64, syms_sect.sh_info) * sym_size;
- const amt = try self.file.?.copyRangeAll(syms_sect.sh_offset, self.file.?, new_offset, existing_size);
- if (amt != existing_size) return error.InputOutput;
- syms_sect.sh_offset = new_offset;
+ const foreign_endian = self.options.target.cpu.arch.endian() != std.Target.current.cpu.arch.endian();
+ const global_syms_off = syms_sect.sh_offset + self.local_symbols.items.len * sym_size;
+ switch (self.ptr_width) {
+ .p32 => {
+ const buf = try self.allocator.alloc(elf.Elf32_Sym, self.global_symbols.items.len);
+ defer self.allocator.free(buf);
+
+ for (buf) |*sym, i| {
+ sym.* = .{
+ .st_name = self.global_symbols.items[i].st_name,
+ .st_value = @intCast(u32, self.global_symbols.items[i].st_value),
+ .st_size = @intCast(u32, self.global_symbols.items[i].st_size),
+ .st_info = self.global_symbols.items[i].st_info,
+ .st_other = self.global_symbols.items[i].st_other,
+ .st_shndx = self.global_symbols.items[i].st_shndx,
+ };
+ if (foreign_endian) {
+ bswapAllFields(elf.Elf32_Sym, sym);
+ }
+ }
+ try self.file.?.pwriteAll(mem.sliceAsBytes(buf), global_syms_off);
+ },
+ .p64 => {
+ const buf = try self.allocator.alloc(elf.Elf64_Sym, self.global_symbols.items.len);
+ defer self.allocator.free(buf);
+
+ for (buf) |*sym, i| {
+ sym.* = .{
+ .st_name = self.global_symbols.items[i].st_name,
+ .st_value = self.global_symbols.items[i].st_value,
+ .st_size = self.global_symbols.items[i].st_size,
+ .st_info = self.global_symbols.items[i].st_info,
+ .st_other = self.global_symbols.items[i].st_other,
+ .st_shndx = self.global_symbols.items[i].st_shndx,
+ };
+ if (foreign_endian) {
+ bswapAllFields(elf.Elf64_Sym, sym);
+ }
+ }
+ try self.file.?.pwriteAll(mem.sliceAsBytes(buf), global_syms_off);
+ },
}
- syms_sect.sh_info = @intCast(u32, self.local_symbols.items.len);
- syms_sect.sh_size = needed_size; // anticipating adding the global symbols later
- self.shdr_table_dirty = true; // TODO look into only writing one section
}
- const foreign_endian = self.options.target.cpu.arch.endian() != std.Target.current.cpu.arch.endian();
- switch (self.ptr_width) {
- .p32 => {
- var sym = [1]elf.Elf32_Sym{
- .{
- .st_name = self.local_symbols.items[index].st_name,
- .st_value = @intCast(u32, self.local_symbols.items[index].st_value),
- .st_size = @intCast(u32, self.local_symbols.items[index].st_size),
- .st_info = self.local_symbols.items[index].st_info,
- .st_other = self.local_symbols.items[index].st_other,
- .st_shndx = self.local_symbols.items[index].st_shndx,
- },
- };
- if (foreign_endian) {
- bswapAllFields(elf.Elf32_Sym, &sym[0]);
- }
- const off = syms_sect.sh_offset + @sizeOf(elf.Elf32_Sym) * index;
- try self.file.?.pwriteAll(mem.sliceAsBytes(sym[0..1]), off);
- },
- .p64 => {
- var sym = [1]elf.Elf64_Sym{self.local_symbols.items[index]};
- if (foreign_endian) {
- bswapAllFields(elf.Elf64_Sym, &sym[0]);
- }
- const off = syms_sect.sh_offset + @sizeOf(elf.Elf64_Sym) * index;
- try self.file.?.pwriteAll(mem.sliceAsBytes(sym[0..1]), off);
- },
- }
- }
-
- fn writeAllGlobalSymbols(self: *ElfFile) !void {
- const syms_sect = &self.sections.items[self.symtab_section_index.?];
- const sym_size: u64 = switch (self.ptr_width) {
- .p32 => @sizeOf(elf.Elf32_Sym),
- .p64 => @sizeOf(elf.Elf64_Sym),
- };
- //std.debug.warn("symtab start=0x{x} end=0x{x}\n", .{ syms_sect.sh_offset, syms_sect.sh_offset + needed_size });
- const foreign_endian = self.options.target.cpu.arch.endian() != std.Target.current.cpu.arch.endian();
- const global_syms_off = syms_sect.sh_offset + self.local_symbols.items.len * sym_size;
- switch (self.ptr_width) {
- .p32 => {
- const buf = try self.allocator.alloc(elf.Elf32_Sym, self.global_symbols.items.len);
- defer self.allocator.free(buf);
-
- for (buf) |*sym, i| {
- sym.* = .{
- .st_name = self.global_symbols.items[i].st_name,
- .st_value = @intCast(u32, self.global_symbols.items[i].st_value),
- .st_size = @intCast(u32, self.global_symbols.items[i].st_size),
- .st_info = self.global_symbols.items[i].st_info,
- .st_other = self.global_symbols.items[i].st_other,
- .st_shndx = self.global_symbols.items[i].st_shndx,
- };
- if (foreign_endian) {
- bswapAllFields(elf.Elf32_Sym, sym);
- }
- }
- try self.file.?.pwriteAll(mem.sliceAsBytes(buf), global_syms_off);
- },
- .p64 => {
- const buf = try self.allocator.alloc(elf.Elf64_Sym, self.global_symbols.items.len);
- defer self.allocator.free(buf);
-
- for (buf) |*sym, i| {
- sym.* = .{
- .st_name = self.global_symbols.items[i].st_name,
- .st_value = self.global_symbols.items[i].st_value,
- .st_size = self.global_symbols.items[i].st_size,
- .st_info = self.global_symbols.items[i].st_info,
- .st_other = self.global_symbols.items[i].st_other,
- .st_shndx = self.global_symbols.items[i].st_shndx,
- };
- if (foreign_endian) {
- bswapAllFields(elf.Elf64_Sym, sym);
- }
- }
- try self.file.?.pwriteAll(mem.sliceAsBytes(buf), global_syms_off);
- },
- }
- }
+ };
};
/// Truncates the existing file contents and overwrites the contents.
/// Returns an error if `file` is not already open with +read +write +seek abilities.
-pub fn createElfFile(allocator: *Allocator, file: fs.File, options: Options) !ElfFile {
+pub fn createElfFile(allocator: *Allocator, file: fs.File, options: Options) !File.Elf {
switch (options.output_mode) {
.Exe => {},
.Obj => {},
.Lib => return error.TODOImplementWritingLibFiles,
}
switch (options.object_format) {
+ .c => unreachable,
.unknown => unreachable, // TODO remove this tag from the enum
.coff => return error.TODOImplementWritingCOFF,
.elf => {},
@@ -1369,7 +1581,7 @@ pub fn createElfFile(allocator: *Allocator, file: fs.File, options: Options) !El
.wasm => return error.TODOImplementWritingWasmObjects,
}
- var self: ElfFile = .{
+ var self: File.Elf = .{
.allocator = allocator,
.file = file,
.options = options,
@@ -1413,7 +1625,7 @@ pub fn createElfFile(allocator: *Allocator, file: fs.File, options: Options) !El
}
/// Returns error.IncrFailed if incremental update could not be performed.
-fn openBinFileInner(allocator: *Allocator, file: fs.File, options: Options) !ElfFile {
+fn openBinFileInner(allocator: *Allocator, file: fs.File, options: Options) !File.Elf {
switch (options.output_mode) {
.Exe => {},
.Obj => {},
@@ -1421,12 +1633,13 @@ fn openBinFileInner(allocator: *Allocator, file: fs.File, options: Options) !Elf
}
switch (options.object_format) {
.unknown => unreachable, // TODO remove this tag from the enum
+ .c => unreachable,
.coff => return error.IncrFailed,
.elf => {},
.macho => return error.IncrFailed,
.wasm => return error.IncrFailed,
}
- var self: ElfFile = .{
+ var self: File.Elf = .{
.allocator = allocator,
.file = file,
.owns_file_handle = false,
@@ -1446,7 +1659,7 @@ fn openBinFileInner(allocator: *Allocator, file: fs.File, options: Options) !Elf
}
/// Saturating multiplication
-fn satMul(a: var, b: var) @TypeOf(a, b) {
+fn satMul(a: anytype, b: anytype) @TypeOf(a, b) {
const T = @TypeOf(a, b);
return std.math.mul(T, a, b) catch std.math.maxInt(T);
}
diff --git a/src-self-hosted/liveness.zig b/src-self-hosted/liveness.zig
new file mode 100644
index 0000000000..a06a4dd1d1
--- /dev/null
+++ b/src-self-hosted/liveness.zig
@@ -0,0 +1,158 @@
+const std = @import("std");
+const ir = @import("ir.zig");
+const trace = @import("tracy.zig").trace;
+
+/// Perform Liveness Analysis over the `Body`. Each `Inst` will have its `deaths` field populated.
+pub fn analyze(
+ /// Used for temporary storage during the analysis.
+ gpa: *std.mem.Allocator,
+ /// Used to tack on extra allocations in the same lifetime as the existing instructions.
+ arena: *std.mem.Allocator,
+ body: ir.Body,
+) error{OutOfMemory}!void {
+ const tracy = trace(@src());
+ defer tracy.end();
+
+ var table = std.AutoHashMap(*ir.Inst, void).init(gpa);
+ defer table.deinit();
+ try table.ensureCapacity(body.instructions.len);
+ try analyzeWithTable(arena, &table, body);
+}
+
+fn analyzeWithTable(arena: *std.mem.Allocator, table: *std.AutoHashMap(*ir.Inst, void), body: ir.Body) error{OutOfMemory}!void {
+ var i: usize = body.instructions.len;
+
+ while (i != 0) {
+ i -= 1;
+ const base = body.instructions[i];
+ try analyzeInstGeneric(arena, table, base);
+ }
+}
+
+fn analyzeInstGeneric(arena: *std.mem.Allocator, table: *std.AutoHashMap(*ir.Inst, void), base: *ir.Inst) error{OutOfMemory}!void {
+ // Obtain the corresponding instruction type based on the tag type.
+ inline for (std.meta.declarations(ir.Inst)) |decl| {
+ switch (decl.data) {
+ .Type => |T| {
+ if (@typeInfo(T) == .Struct and @hasDecl(T, "base_tag")) {
+ if (T.base_tag == base.tag) {
+ return analyzeInst(arena, table, T, @fieldParentPtr(T, "base", base));
+ }
+ }
+ },
+ else => {},
+ }
+ }
+ unreachable;
+}
+
+fn analyzeInst(arena: *std.mem.Allocator, table: *std.AutoHashMap(*ir.Inst, void), comptime T: type, inst: *T) error{OutOfMemory}!void {
+ if (table.contains(&inst.base)) {
+ inst.base.deaths = 0;
+ } else {
+ // No tombstone for this instruction means it is never referenced,
+ // and its birth marks its own death. Very metal 🤘
+ inst.base.deaths = 1 << ir.Inst.unreferenced_bit_index;
+ }
+
+ switch (T) {
+ ir.Inst.Constant => return,
+ ir.Inst.Block => {
+ try analyzeWithTable(arena, table, inst.args.body);
+ // We let this continue so that it can possibly mark the block as
+ // unreferenced below.
+ },
+ ir.Inst.CondBr => {
+ var true_table = std.AutoHashMap(*ir.Inst, void).init(table.allocator);
+ defer true_table.deinit();
+ try true_table.ensureCapacity(inst.args.true_body.instructions.len);
+ try analyzeWithTable(arena, &true_table, inst.args.true_body);
+
+ var false_table = std.AutoHashMap(*ir.Inst, void).init(table.allocator);
+ defer false_table.deinit();
+ try false_table.ensureCapacity(inst.args.false_body.instructions.len);
+ try analyzeWithTable(arena, &false_table, inst.args.false_body);
+
+ // Each death that occurs inside one branch, but not the other, needs
+ // to be added as a death immediately upon entering the other branch.
+ // During the iteration of the table, we additionally propagate the
+ // deaths to the parent table.
+ var true_entry_deaths = std.ArrayList(*ir.Inst).init(table.allocator);
+ defer true_entry_deaths.deinit();
+ var false_entry_deaths = std.ArrayList(*ir.Inst).init(table.allocator);
+ defer false_entry_deaths.deinit();
+ {
+ var it = false_table.iterator();
+ while (it.next()) |entry| {
+ const false_death = entry.key;
+ if (!true_table.contains(false_death)) {
+ try true_entry_deaths.append(false_death);
+ // Here we are only adding to the parent table if the following iteration
+ // would miss it.
+ try table.putNoClobber(false_death, {});
+ }
+ }
+ }
+ {
+ var it = true_table.iterator();
+ while (it.next()) |entry| {
+ const true_death = entry.key;
+ try table.putNoClobber(true_death, {});
+ if (!false_table.contains(true_death)) {
+ try false_entry_deaths.append(true_death);
+ }
+ }
+ }
+ inst.true_death_count = std.math.cast(@TypeOf(inst.true_death_count), true_entry_deaths.items.len) catch return error.OutOfMemory;
+ inst.false_death_count = std.math.cast(@TypeOf(inst.false_death_count), false_entry_deaths.items.len) catch return error.OutOfMemory;
+ const allocated_slice = try arena.alloc(*ir.Inst, true_entry_deaths.items.len + false_entry_deaths.items.len);
+ inst.deaths = allocated_slice.ptr;
+
+ // Continue on with the instruction analysis. The following code will find the condition
+ // instruction, and the deaths flag for the CondBr instruction will indicate whether the
+ // condition's lifetime ends immediately before entering any branch.
+ },
+ ir.Inst.Call => {
+ // Call instructions have a runtime-known number of operands so we have to handle them ourselves here.
+ const needed_bits = 1 + inst.args.args.len;
+ if (needed_bits <= ir.Inst.deaths_bits) {
+ var bit_i: ir.Inst.DeathsBitIndex = 0;
+ {
+ const prev = try table.fetchPut(inst.args.func, {});
+ if (prev == null) inst.base.deaths |= @as(ir.Inst.DeathsInt, 1) << bit_i;
+ bit_i += 1;
+ }
+ for (inst.args.args) |arg| {
+ const prev = try table.fetchPut(arg, {});
+ if (prev == null) inst.base.deaths |= @as(ir.Inst.DeathsInt, 1) << bit_i;
+ bit_i += 1;
+ }
+ } else {
+ @panic("Handle liveness analysis for function calls with many parameters");
+ }
+ },
+ else => {},
+ }
+
+ const Args = ir.Inst.Args(T);
+ if (Args == void) {
+ return;
+ }
+
+ comptime var arg_index: usize = 0;
+ inline for (std.meta.fields(Args)) |field| {
+ if (field.field_type == *ir.Inst) {
+ if (arg_index >= 6) {
+ @compileError("out of bits to mark deaths of operands");
+ }
+ const prev = try table.fetchPut(@field(inst.args, field.name), {});
+ if (prev == null) {
+ // Death.
+ inst.base.deaths |= 1 << arg_index;
+ }
+ arg_index += 1;
+ }
+ }
+
+ std.log.debug(.liveness, "analyze {}: 0b{b}\n", .{ inst.base.tag, inst.base.deaths });
+}
diff --git a/src-self-hosted/main.zig b/src-self-hosted/main.zig
index eda9dcfc31..f63e915c25 100644
--- a/src-self-hosted/main.zig
+++ b/src-self-hosted/main.zig
@@ -38,6 +38,32 @@ const usage =
\\
;
+pub fn log(
+ comptime level: std.log.Level,
+ comptime scope: @TypeOf(.EnumLiteral),
+ comptime format: []const u8,
+ args: anytype,
+) void {
+ if (@enumToInt(level) > @enumToInt(std.log.level))
+ return;
+
+ const scope_prefix = "(" ++ switch (scope) {
+ // Uncomment to hide logs
+ //.compiler,
+ .module,
+ .liveness,
+ .link,
+ => return,
+
+ else => @tagName(scope),
+ } ++ "): ";
+
+ const prefix = "[" ++ @tagName(level) ++ "] " ++ scope_prefix;
+
+ // Print the message to stderr, silently ignoring any errors
+ std.debug.print(prefix ++ format, args);
+}
+
pub fn main() !void {
// TODO general purpose allocator in the zig std lib
const gpa = if (std.builtin.link_libc) std.heap.c_allocator else std.heap.page_allocator;
@@ -48,7 +74,7 @@ pub fn main() !void {
const args = try process.argsAlloc(arena);
if (args.len <= 1) {
- std.debug.warn("expected command argument\n\n{}", .{usage});
+ std.debug.print("expected command argument\n\n{}", .{usage});
process.exit(1);
}
@@ -68,14 +94,14 @@ pub fn main() !void {
return @import("print_targets.zig").cmdTargets(arena, cmd_args, stdout, info.target);
} else if (mem.eql(u8, cmd, "version")) {
// Need to set up the build script to give the version as a comptime value.
- std.debug.warn("TODO version command not implemented yet\n", .{});
+ std.debug.print("TODO version command not implemented yet\n", .{});
return error.Unimplemented;
} else if (mem.eql(u8, cmd, "zen")) {
try io.getStdOut().writeAll(info_zen);
} else if (mem.eql(u8, cmd, "help")) {
try io.getStdOut().writeAll(usage);
} else {
- std.debug.warn("unknown command: {}\n\n{}", .{ args[1], usage });
+ std.debug.print("unknown command: {}\n\n{}", .{ args[1], usage });
process.exit(1);
}
}
@@ -86,7 +112,7 @@ const usage_build_generic =
\\ zig build-obj [files]
\\
\\Supported file types:
- \\ (planned) .zig Zig source code
+ \\ .zig Zig source code
\\ .zir Zig Intermediate Representation code
\\ (planned) .o ELF object file
\\ (planned) .o MACH-O (macOS) object file
@@ -169,6 +195,7 @@ fn buildOutputType(
var target_arch_os_abi: []const u8 = "native";
var target_mcpu: ?[]const u8 = null;
var target_dynamic_linker: ?[]const u8 = null;
+ var object_format: ?std.builtin.ObjectFormat = null;
var system_libs = std.ArrayList([]const u8).init(gpa);
defer system_libs.deinit();
@@ -183,7 +210,7 @@ fn buildOutputType(
process.exit(0);
} else if (mem.eql(u8, arg, "--color")) {
if (i + 1 >= args.len) {
- std.debug.warn("expected [auto|on|off] after --color\n", .{});
+ std.debug.print("expected [auto|on|off] after --color\n", .{});
process.exit(1);
}
i += 1;
@@ -195,12 +222,12 @@ fn buildOutputType(
} else if (mem.eql(u8, next_arg, "off")) {
color = .Off;
} else {
- std.debug.warn("expected [auto|on|off] after --color, found '{}'\n", .{next_arg});
+ std.debug.print("expected [auto|on|off] after --color, found '{}'\n", .{next_arg});
process.exit(1);
}
} else if (mem.eql(u8, arg, "--mode")) {
if (i + 1 >= args.len) {
- std.debug.warn("expected [Debug|ReleaseSafe|ReleaseFast|ReleaseSmall] after --mode\n", .{});
+ std.debug.print("expected [Debug|ReleaseSafe|ReleaseFast|ReleaseSmall] after --mode\n", .{});
process.exit(1);
}
i += 1;
@@ -214,52 +241,58 @@ fn buildOutputType(
} else if (mem.eql(u8, next_arg, "ReleaseSmall")) {
build_mode = .ReleaseSmall;
} else {
- std.debug.warn("expected [Debug|ReleaseSafe|ReleaseFast|ReleaseSmall] after --mode, found '{}'\n", .{next_arg});
+ std.debug.print("expected [Debug|ReleaseSafe|ReleaseFast|ReleaseSmall] after --mode, found '{}'\n", .{next_arg});
process.exit(1);
}
} else if (mem.eql(u8, arg, "--name")) {
if (i + 1 >= args.len) {
- std.debug.warn("expected parameter after --name\n", .{});
+ std.debug.print("expected parameter after --name\n", .{});
process.exit(1);
}
i += 1;
provided_name = args[i];
} else if (mem.eql(u8, arg, "--library")) {
if (i + 1 >= args.len) {
- std.debug.warn("expected parameter after --library\n", .{});
+ std.debug.print("expected parameter after --library\n", .{});
process.exit(1);
}
i += 1;
try system_libs.append(args[i]);
} else if (mem.eql(u8, arg, "--version")) {
if (i + 1 >= args.len) {
- std.debug.warn("expected parameter after --version\n", .{});
+ std.debug.print("expected parameter after --version\n", .{});
process.exit(1);
}
i += 1;
version = std.builtin.Version.parse(args[i]) catch |err| {
- std.debug.warn("unable to parse --version '{}': {}\n", .{ args[i], @errorName(err) });
+ std.debug.print("unable to parse --version '{}': {}\n", .{ args[i], @errorName(err) });
process.exit(1);
};
} else if (mem.eql(u8, arg, "-target")) {
if (i + 1 >= args.len) {
- std.debug.warn("expected parameter after -target\n", .{});
+ std.debug.print("expected parameter after -target\n", .{});
process.exit(1);
}
i += 1;
target_arch_os_abi = args[i];
} else if (mem.eql(u8, arg, "-mcpu")) {
if (i + 1 >= args.len) {
- std.debug.warn("expected parameter after -mcpu\n", .{});
+ std.debug.print("expected parameter after -mcpu\n", .{});
process.exit(1);
}
i += 1;
target_mcpu = args[i];
+ } else if (mem.eql(u8, arg, "--c")) {
+ if (object_format) |old| {
+ std.debug.print("attempted to override object format {} with C\n", .{old});
+ process.exit(1);
+ }
+ object_format = .c;
} else if (mem.startsWith(u8, arg, "-mcpu=")) {
target_mcpu = arg["-mcpu=".len..];
} else if (mem.eql(u8, arg, "--dynamic-linker")) {
if (i + 1 >= args.len) {
- std.debug.warn("expected parameter after --dynamic-linker\n", .{});
+ std.debug.print("expected parameter after --dynamic-linker\n", .{});
process.exit(1);
}
i += 1;
@@ -301,39 +334,39 @@ fn buildOutputType(
} else if (mem.startsWith(u8, arg, "-l")) {
try system_libs.append(arg[2..]);
} else {
- std.debug.warn("unrecognized parameter: '{}'", .{arg});
+ std.debug.print("unrecognized parameter: '{}'", .{arg});
process.exit(1);
}
} else if (mem.endsWith(u8, arg, ".s") or mem.endsWith(u8, arg, ".S")) {
- std.debug.warn("assembly files not supported yet", .{});
+ std.debug.print("assembly files not supported yet", .{});
process.exit(1);
} else if (mem.endsWith(u8, arg, ".o") or
mem.endsWith(u8, arg, ".obj") or
mem.endsWith(u8, arg, ".a") or
mem.endsWith(u8, arg, ".lib"))
{
- std.debug.warn("object files and static libraries not supported yet", .{});
+ std.debug.print("object files and static libraries not supported yet", .{});
process.exit(1);
} else if (mem.endsWith(u8, arg, ".c") or
mem.endsWith(u8, arg, ".cpp"))
{
- std.debug.warn("compilation of C and C++ source code requires LLVM extensions which are not implemented yet", .{});
+ std.debug.print("compilation of C and C++ source code requires LLVM extensions which are not implemented yet", .{});
process.exit(1);
} else if (mem.endsWith(u8, arg, ".so") or
mem.endsWith(u8, arg, ".dylib") or
mem.endsWith(u8, arg, ".dll"))
{
- std.debug.warn("linking against dynamic libraries not yet supported", .{});
+ std.debug.print("linking against dynamic libraries not yet supported", .{});
process.exit(1);
} else if (mem.endsWith(u8, arg, ".zig") or mem.endsWith(u8, arg, ".zir")) {
if (root_src_file) |other| {
- std.debug.warn("found another zig file '{}' after root source file '{}'", .{ arg, other });
+ std.debug.print("found another zig file '{}' after root source file '{}'", .{ arg, other });
process.exit(1);
} else {
root_src_file = arg;
}
} else {
- std.debug.warn("unrecognized file extension of parameter '{}'", .{arg});
+ std.debug.print("unrecognized file extension of parameter '{}'", .{arg});
}
}
}
@@ -344,13 +377,13 @@ fn buildOutputType(
var it = mem.split(basename, ".");
break :blk it.next() orelse basename;
} else {
- std.debug.warn("--name [name] not provided and unable to infer\n", .{});
+ std.debug.print("--name [name] not provided and unable to infer\n", .{});
process.exit(1);
}
};
if (system_libs.items.len != 0) {
- std.debug.warn("linking against system libraries not yet supported", .{});
+ std.debug.print("linking against system libraries not yet supported", .{});
process.exit(1);
}
@@ -362,17 +395,17 @@ fn buildOutputType(
.diagnostics = &diags,
}) catch |err| switch (err) {
error.UnknownCpuModel => {
- std.debug.warn("Unknown CPU: '{}'\nAvailable CPUs for architecture '{}':\n", .{
+ std.debug.print("Unknown CPU: '{}'\nAvailable CPUs for architecture '{}':\n", .{
diags.cpu_name.?,
@tagName(diags.arch.?),
});
for (diags.arch.?.allCpuModels()) |cpu| {
- std.debug.warn(" {}\n", .{cpu.name});
+ std.debug.print(" {}\n", .{cpu.name});
}
process.exit(1);
},
error.UnknownCpuFeature => {
- std.debug.warn(
+ std.debug.print(
\\Unknown CPU feature: '{}'
\\Available CPU features for architecture '{}':
\\
@@ -381,47 +414,36 @@ fn buildOutputType(
@tagName(diags.arch.?),
});
for (diags.arch.?.allFeaturesList()) |feature| {
- std.debug.warn(" {}: {}\n", .{ feature.name, feature.description });
+ std.debug.print(" {}: {}\n", .{ feature.name, feature.description });
}
process.exit(1);
},
else => |e| return e,
};
- const object_format: ?std.builtin.ObjectFormat = null;
var target_info = try std.zig.system.NativeTargetInfo.detect(gpa, cross_target);
if (target_info.cpu_detection_unimplemented) {
// TODO We want to just use detected_info.target but implementing
// CPU model & feature detection is todo so here we rely on LLVM.
- std.debug.warn("CPU features detection is not yet available for this system without LLVM extensions\n", .{});
+ std.debug.print("CPU features detection is not yet available for this system without LLVM extensions\n", .{});
process.exit(1);
}
const src_path = root_src_file orelse {
- std.debug.warn("expected at least one file argument", .{});
+ std.debug.print("expected at least one file argument", .{});
process.exit(1);
};
const bin_path = switch (emit_bin) {
.no => {
- std.debug.warn("-fno-emit-bin not supported yet", .{});
+ std.debug.print("-fno-emit-bin not supported yet", .{});
process.exit(1);
},
- .yes_default_path => switch (output_mode) {
- .Exe => try std.fmt.allocPrint(arena, "{}{}", .{ root_name, target_info.target.exeFileExt() }),
- .Lib => blk: {
- const suffix = switch (link_mode orelse .Static) {
- .Static => target_info.target.staticLibSuffix(),
- .Dynamic => target_info.target.dynamicLibSuffix(),
- };
- break :blk try std.fmt.allocPrint(arena, "{}{}{}", .{
- target_info.target.libPrefix(),
- root_name,
- suffix,
- });
- },
- .Obj => try std.fmt.allocPrint(arena, "{}{}", .{ root_name, target_info.target.oFileExt() }),
- },
+ .yes_default_path => if (object_format != null and object_format.? == .c)
+ try std.fmt.allocPrint(arena, "{}.c", .{root_name})
+ else
+ try std.zig.binNameAlloc(arena, root_name, target_info.target, output_mode, link_mode),
+
.yes => |p| p,
};
@@ -450,6 +472,7 @@ fn buildOutputType(
.link_mode = link_mode,
.object_format = object_format,
.optimize_mode = build_mode,
+ .keep_source_files_loaded = zir_out_path != null,
});
defer module.deinit();
@@ -487,20 +510,24 @@ fn buildOutputType(
}
fn updateModule(gpa: *Allocator, module: *Module, zir_out_path: ?[]const u8) !void {
+ var timer = try std.time.Timer.start();
try module.update();
+ const update_nanos = timer.read();
var errors = try module.getAllErrorsAlloc();
- defer errors.deinit(module.allocator);
+ defer errors.deinit(module.gpa);
if (errors.list.len != 0) {
for (errors.list) |full_err_msg| {
- std.debug.warn("{}:{}:{}: error: {}\n", .{
+ std.debug.print("{}:{}:{}: error: {}\n", .{
full_err_msg.src_path,
full_err_msg.line + 1,
full_err_msg.column + 1,
full_err_msg.msg,
});
}
+ } else {
+ std.log.info(.compiler, "Update completed in {} ms\n", .{update_nanos / std.time.ns_per_ms});
}
if (zir_out_path) |zop| {
@@ -546,8 +573,9 @@ const Fmt = struct {
any_error: bool,
color: Color,
gpa: *Allocator,
+ out_buffer: std.ArrayList(u8),
- const SeenMap = std.BufSet;
+ const SeenMap = std.AutoHashMap(fs.File.INode, void);
};
pub fn cmdFmt(gpa: *Allocator, args: []const []const u8) !void {
@@ -568,7 +596,7 @@ pub fn cmdFmt(gpa: *Allocator, args: []const []const u8) !void {
process.exit(0);
} else if (mem.eql(u8, arg, "--color")) {
if (i + 1 >= args.len) {
- std.debug.warn("expected [auto|on|off] after --color\n", .{});
+ std.debug.print("expected [auto|on|off] after --color\n", .{});
process.exit(1);
}
i += 1;
@@ -580,7 +608,7 @@ pub fn cmdFmt(gpa: *Allocator, args: []const []const u8) !void {
} else if (mem.eql(u8, next_arg, "off")) {
color = .Off;
} else {
- std.debug.warn("expected [auto|on|off] after --color, found '{}'\n", .{next_arg});
+ std.debug.print("expected [auto|on|off] after --color, found '{}'\n", .{next_arg});
process.exit(1);
}
} else if (mem.eql(u8, arg, "--stdin")) {
@@ -588,7 +616,7 @@ pub fn cmdFmt(gpa: *Allocator, args: []const []const u8) !void {
} else if (mem.eql(u8, arg, "--check")) {
check_flag = true;
} else {
- std.debug.warn("unrecognized parameter: '{}'", .{arg});
+ std.debug.print("unrecognized parameter: '{}'", .{arg});
process.exit(1);
}
} else {
@@ -599,7 +627,7 @@ pub fn cmdFmt(gpa: *Allocator, args: []const []const u8) !void {
if (stdin_flag) {
if (input_files.items.len != 0) {
- std.debug.warn("cannot use --stdin with positional arguments\n", .{});
+ std.debug.print("cannot use --stdin with positional arguments\n", .{});
process.exit(1);
}
@@ -609,7 +637,7 @@ pub fn cmdFmt(gpa: *Allocator, args: []const []const u8) !void {
defer gpa.free(source_code);
const tree = std.zig.parse(gpa, source_code) catch |err| {
- std.debug.warn("error parsing stdin: {}\n", .{err});
+ std.debug.print("error parsing stdin: {}\n", .{err});
process.exit(1);
};
defer tree.deinit();
@@ -632,7 +660,7 @@ pub fn cmdFmt(gpa: *Allocator, args: []const []const u8) !void {
}
if (input_files.items.len == 0) {
- std.debug.warn("expected at least one source file argument\n", .{});
+ std.debug.print("expected at least one source file argument\n", .{});
process.exit(1);
}
@@ -641,10 +669,20 @@ pub fn cmdFmt(gpa: *Allocator, args: []const []const u8) !void {
.seen = Fmt.SeenMap.init(gpa),
.any_error = false,
.color = color,
+ .out_buffer = std.ArrayList(u8).init(gpa),
};
+ defer fmt.seen.deinit();
+ defer fmt.out_buffer.deinit();
for (input_files.span()) |file_path| {
- try fmtPath(&fmt, file_path, check_flag);
+ // Get the real path here to avoid Windows failing on relative file paths with . or .. in them.
+ const real_path = fs.realpathAlloc(gpa, file_path) catch |err| {
+ std.debug.print("unable to open '{}': {}\n", .{ file_path, err });
+ process.exit(1);
+ };
+ defer gpa.free(real_path);
+
+ try fmtPath(&fmt, file_path, check_flag, fs.cwd(), real_path);
}
if (fmt.any_error) {
process.exit(1);
@@ -670,48 +708,82 @@ const FmtError = error{
ReadOnlyFileSystem,
LinkQuotaExceeded,
FileBusy,
+ EndOfStream,
} || fs.File.OpenError;
-fn fmtPath(fmt: *Fmt, file_path: []const u8, check_mode: bool) FmtError!void {
- // get the real path here to avoid Windows failing on relative file paths with . or .. in them
- var real_path = fs.realpathAlloc(fmt.gpa, file_path) catch |err| {
- std.debug.warn("unable to open '{}': {}\n", .{ file_path, err });
- fmt.any_error = true;
- return;
- };
- defer fmt.gpa.free(real_path);
-
- if (fmt.seen.exists(real_path)) return;
- try fmt.seen.put(real_path);
-
- const source_code = fs.cwd().readFileAlloc(fmt.gpa, real_path, max_src_size) catch |err| switch (err) {
- error.IsDir, error.AccessDenied => {
- var dir = try fs.cwd().openDir(file_path, .{ .iterate = true });
- defer dir.close();
-
- var dir_it = dir.iterate();
-
- while (try dir_it.next()) |entry| {
- if (entry.kind == .Directory or mem.endsWith(u8, entry.name, ".zig")) {
- const full_path = try fs.path.join(fmt.gpa, &[_][]const u8{ file_path, entry.name });
- try fmtPath(fmt, full_path, check_mode);
- }
- }
- return;
- },
+fn fmtPath(fmt: *Fmt, file_path: []const u8, check_mode: bool, dir: fs.Dir, sub_path: []const u8) FmtError!void {
+ fmtPathFile(fmt, file_path, check_mode, dir, sub_path) catch |err| switch (err) {
+ error.IsDir, error.AccessDenied => return fmtPathDir(fmt, file_path, check_mode, dir, sub_path),
else => {
- std.debug.warn("unable to open '{}': {}\n", .{ file_path, err });
+ std.debug.print("unable to format '{}': {}\n", .{ file_path, err });
fmt.any_error = true;
return;
},
};
+}
+
+fn fmtPathDir(
+ fmt: *Fmt,
+ file_path: []const u8,
+ check_mode: bool,
+ parent_dir: fs.Dir,
+ parent_sub_path: []const u8,
+) FmtError!void {
+ var dir = try parent_dir.openDir(parent_sub_path, .{ .iterate = true });
+ defer dir.close();
+
+ const stat = try dir.stat();
+ if (try fmt.seen.fetchPut(stat.inode, {})) |_| return;
+
+ var dir_it = dir.iterate();
+ while (try dir_it.next()) |entry| {
+ const is_dir = entry.kind == .Directory;
+ if (is_dir or mem.endsWith(u8, entry.name, ".zig")) {
+ const full_path = try fs.path.join(fmt.gpa, &[_][]const u8{ file_path, entry.name });
+ defer fmt.gpa.free(full_path);
+
+ if (is_dir) {
+ try fmtPathDir(fmt, full_path, check_mode, dir, entry.name);
+ } else {
+ fmtPathFile(fmt, full_path, check_mode, dir, entry.name) catch |err| {
+ std.debug.print("unable to format '{}': {}\n", .{ full_path, err });
+ fmt.any_error = true;
+ return;
+ };
+ }
+ }
+ }
+}
+
+fn fmtPathFile(
+ fmt: *Fmt,
+ file_path: []const u8,
+ check_mode: bool,
+ dir: fs.Dir,
+ sub_path: []const u8,
+) FmtError!void {
+ const source_file = try dir.openFile(sub_path, .{});
+ var file_closed = false;
+ errdefer if (!file_closed) source_file.close();
+
+ const stat = try source_file.stat();
+
+ if (stat.kind == .Directory)
+ return error.IsDir;
+
+ const source_code = source_file.readAllAlloc(fmt.gpa, stat.size, max_src_size) catch |err| switch (err) {
+ error.ConnectionResetByPeer => unreachable,
+ error.ConnectionTimedOut => unreachable,
+ else => |e| return e,
+ };
+ source_file.close();
+ file_closed = true;
defer fmt.gpa.free(source_code);
- const tree = std.zig.parse(fmt.gpa, source_code) catch |err| {
- std.debug.warn("error parsing file '{}': {}\n", .{ file_path, err });
- fmt.any_error = true;
- return;
- };
+ // Add to set after no longer possible to get error.IsDir.
+ if (try fmt.seen.fetchPut(stat.inode, {})) |_| return;
+
+ const tree = try std.zig.parse(fmt.gpa, source_code);
defer tree.deinit();
for (tree.errors) |parse_error| {
@@ -725,18 +797,23 @@ fn fmtPath(fmt: *Fmt, file_path: []const u8, check_mode: bool) FmtError!void {
if (check_mode) {
const anything_changed = try std.zig.render(fmt.gpa, io.null_out_stream, tree);
if (anything_changed) {
- std.debug.warn("{}\n", .{file_path});
+ std.debug.print("{}\n", .{file_path});
fmt.any_error = true;
}
} else {
- const baf = try io.BufferedAtomicFile.create(fmt.gpa, fs.cwd(), real_path, .{});
- defer baf.destroy();
+ // As a heuristic, we make enough capacity for the same as the input source.
+ try fmt.out_buffer.ensureCapacity(source_code.len);
+ fmt.out_buffer.items.len = 0;
+ const anything_changed = try std.zig.render(fmt.gpa, fmt.out_buffer.writer(), tree);
+ if (!anything_changed)
+ return; // Good thing we didn't waste any file system access on this.
- const anything_changed = try std.zig.render(fmt.gpa, baf.stream(), tree);
- if (anything_changed) {
- std.debug.warn("{}\n", .{file_path});
- try baf.finish();
- }
+ var af = try dir.atomicFile(sub_path, .{ .mode = stat.mode });
+ defer af.deinit();
+
+ try af.file.writeAll(fmt.out_buffer.items);
+ try af.finish();
+ std.debug.print("{}\n", .{file_path});
}
}
diff --git a/src-self-hosted/print_targets.zig b/src-self-hosted/print_targets.zig
index f84a4a2cbc..34eda71ccf 100644
--- a/src-self-hosted/print_targets.zig
+++ b/src-self-hosted/print_targets.zig
@@ -62,7 +62,7 @@ pub fn cmdTargets(
allocator: *Allocator,
args: []const []const u8,
/// Output stream
- stdout: var,
+ stdout: anytype,
native_target: Target,
) !void {
const available_glibcs = blk: {
diff --git a/src-self-hosted/stage2.zig b/src-self-hosted/stage2.zig
index bd24ffb399..91524d7396 100644
--- a/src-self-hosted/stage2.zig
+++ b/src-self-hosted/stage2.zig
@@ -653,23 +653,6 @@ export fn stage2_libc_render(stage1_libc: *Stage2LibCInstallation, output_file:
return .None;
}
-fn enumToString(value: var, type_name: []const u8) ![]const u8 {
- switch (@typeInfo(@TypeOf(value))) {
- .Enum => |e| {
- if (e.is_exhaustive) {
- return std.fmt.allocPrint(std.heap.c_allocator, ".{}", .{@tagName(value)});
- } else {
- return std.fmt.allocPrint(
- std.heap.c_allocator,
- "@intToEnum({}, {})",
- .{ type_name, @enumToInt(value) },
- );
- }
- },
- else => unreachable,
- }
-}
-
// ABI warning
const Stage2Target = extern struct {
arch: c_int,
@@ -887,13 +870,13 @@ const Stage2Target = extern struct {
.windows => try os_builtin_str_buffer.outStream().print(
\\ .windows = .{{
- \\ .min = {},
- \\ .max = {},
+ \\ .min = {s},
+ \\ .max = {s},
\\ }}}},
\\
, .{
- try enumToString(target.os.version_range.windows.min, "Target.Os.WindowsVersion"),
- try enumToString(target.os.version_range.windows.max, "Target.Os.WindowsVersion"),
+ target.os.version_range.windows.min,
+ target.os.version_range.windows.max,
}),
}
try os_builtin_str_buffer.appendSlice("};\n");
diff --git a/src-self-hosted/test.zig b/src-self-hosted/test.zig
index 605c973bb9..c64ff3bbcd 100644
--- a/src-self-hosted/test.zig
+++ b/src-self-hosted/test.zig
@@ -5,9 +5,10 @@ const Allocator = std.mem.Allocator;
const zir = @import("zir.zig");
const Package = @import("Package.zig");
+const cheader = @embedFile("cbe.h");
+
test "self-hosted" {
- var ctx: TestContext = undefined;
- try ctx.init();
+ var ctx = TestContext.init();
defer ctx.deinit();
try @import("stage2_tests").addCases(&ctx);
@@ -15,311 +16,592 @@ test "self-hosted" {
try ctx.run();
}
+const ErrorMsg = struct {
+ msg: []const u8,
+ line: u32,
+ column: u32,
+};
+
pub const TestContext = struct {
- zir_cmp_output_cases: std.ArrayList(ZIRCompareOutputCase),
- zir_transform_cases: std.ArrayList(ZIRTransformCase),
+ /// TODO: find a way to treat cases as individual tests (shouldn't show "1 test passed" if there are 200 cases)
+ cases: std.ArrayList(Case),
- pub const ZIRCompareOutputCase = struct {
- name: []const u8,
- src_list: []const []const u8,
- expected_stdout_list: []const []const u8,
- };
-
- pub const ZIRTransformCase = struct {
- name: []const u8,
- cross_target: std.zig.CrossTarget,
- updates: std.ArrayList(Update),
-
- pub const Update = struct {
- expected: Expected,
- src: [:0]const u8,
- };
-
- pub const Expected = union(enum) {
- zir: []const u8,
- errors: []const []const u8,
- };
-
- pub fn addZIR(case: *ZIRTransformCase, src: [:0]const u8, zir_text: []const u8) void {
- case.updates.append(.{
- .src = src,
- .expected = .{ .zir = zir_text },
- }) catch unreachable;
- }
-
- pub fn addError(case: *ZIRTransformCase, src: [:0]const u8, errors: []const []const u8) void {
- case.updates.append(.{
- .src = src,
- .expected = .{ .errors = errors },
- }) catch unreachable;
- }
- };
-
- pub fn addZIRCompareOutput(
- ctx: *TestContext,
- name: []const u8,
- src_list: []const []const u8,
- expected_stdout_list: []const []const u8,
- ) void {
- ctx.zir_cmp_output_cases.append(.{
- .name = name,
- .src_list = src_list,
- .expected_stdout_list = expected_stdout_list,
- }) catch unreachable;
- }
-
- pub fn addZIRTransform(
- ctx: *TestContext,
- name: []const u8,
- cross_target: std.zig.CrossTarget,
+ pub const Update = struct {
+ /// The input to the current update. We simulate an incremental update
+ /// with the file's contents changed to this value each update.
+ ///
+ /// This value can change entirely between updates, which would be akin
+ /// to deleting the source file and creating a new one from scratch; or
+ /// you can keep it mostly consistent, with small changes, testing the
+ /// effects of the incremental compilation.
src: [:0]const u8,
- expected_zir: []const u8,
- ) void {
- const case = ctx.zir_transform_cases.addOne() catch unreachable;
- case.* = .{
- .name = name,
- .cross_target = cross_target,
- .updates = std.ArrayList(ZIRTransformCase.Update).init(std.heap.page_allocator),
- };
- case.updates.append(.{
- .src = src,
- .expected = .{ .zir = expected_zir },
- }) catch unreachable;
- }
+ case: union(enum) {
+ /// A transformation update transforms the input and tests against
+ /// the expected output ZIR.
+ Transformation: [:0]const u8,
+ /// An error update attempts to compile bad code, and ensures that it
+ /// fails to compile, and for the expected reasons.
+ /// A slice containing the expected errors *in sequential order*.
+ Error: []const ErrorMsg,
+ /// An execution update compiles and runs the input, testing the
+ /// stdout against the expected results
+ /// This is a slice containing the expected message.
+ Execution: []const u8,
+ },
+ };
- pub fn addZIRMulti(
+ pub const TestType = enum {
+ Zig,
+ ZIR,
+ };
+
+ /// A Case consists of a set of *updates*. The same Module is used for each
+ /// update, so each update's source is treated as a single file being
+ /// updated by the test harness and incrementally compiled.
+ pub const Case = struct {
+ /// The name of the test case. This is shown if a test fails, and
+ /// otherwise ignored.
+ name: []const u8,
+ /// The platform the test targets. For non-native platforms, an emulator
+ /// such as QEMU is required for tests to complete.
+ target: std.zig.CrossTarget,
+ /// In order to be able to run e.g. Execution updates, this must be set
+ /// to Executable.
+ output_mode: std.builtin.OutputMode,
+ updates: std.ArrayList(Update),
+ extension: TestType,
+ cbe: bool = false,
+
+ /// Adds a subcase in which the module is updated with `src`, and the
+ /// resulting ZIR is validated against `result`.
+ pub fn addTransform(self: *Case, src: [:0]const u8, result: [:0]const u8) void {
+ self.updates.append(.{
+ .src = src,
+ .case = .{ .Transformation = result },
+ }) catch unreachable;
+ }
+
+ /// Adds a subcase in which the module is updated with `src`, compiled,
+ /// run, and the output is tested against `result`.
+ pub fn addCompareOutput(self: *Case, src: [:0]const u8, result: []const u8) void {
+ self.updates.append(.{
+ .src = src,
+ .case = .{ .Execution = result },
+ }) catch unreachable;
+ }
+
+ /// Adds a subcase in which the module is updated with `src`, which
+ /// should contain invalid input, and ensures that compilation fails
+ /// for the expected reasons, given in sequential order in `errors` in
+ /// the form `:line:column: error: message`.
+ pub fn addError(self: *Case, src: [:0]const u8, errors: []const []const u8) void {
+ var array = self.updates.allocator.alloc(ErrorMsg, errors.len) catch unreachable;
+ for (errors) |e, i| {
+ if (e[0] != ':') {
+ @panic("Invalid test: error must be specified as follows:\n:line:column: error: message\n=========\n");
+ }
+ var cur = e[1..];
+ var line_index = std.mem.indexOf(u8, cur, ":");
+ if (line_index == null) {
+ @panic("Invalid test: error must be specified as follows:\n:line:column: error: message\n=========\n");
+ }
+ const line = std.fmt.parseInt(u32, cur[0..line_index.?], 10) catch @panic("Unable to parse line number");
+ cur = cur[line_index.? + 1 ..];
+ const column_index = std.mem.indexOf(u8, cur, ":");
+ if (column_index == null) {
+ @panic("Invalid test: error must be specified as follows:\n:line:column: error: message\n=========\n");
+ }
+ const column = std.fmt.parseInt(u32, cur[0..column_index.?], 10) catch @panic("Unable to parse column number");
+ cur = cur[column_index.? + 2 ..];
+ if (!std.mem.eql(u8, cur[0..7], "error: ")) {
+ @panic("Invalid test: error must be specified as follows:\n:line:column: error: message\n=========\n");
+ }
+ const msg = cur[7..];
+
+ if (line == 0 or column == 0) {
+ @panic("Invalid test: error line and column must be specified starting at one!");
+ }
+
+ array[i] = .{
+ .msg = msg,
+ .line = line - 1,
+ .column = column - 1,
+ };
+ }
+ self.updates.append(.{ .src = src, .case = .{ .Error = array } }) catch unreachable;
+ }
+
+ /// Adds a subcase in which the module is updated with `src`, and
+ /// asserts that it compiles without issue
+ pub fn compiles(self: *Case, src: [:0]const u8) void {
+ self.addError(src, &[_][]const u8{});
+ }
+ };
+
+ pub fn addExe(
ctx: *TestContext,
name: []const u8,
- cross_target: std.zig.CrossTarget,
- ) *ZIRTransformCase {
- const case = ctx.zir_transform_cases.addOne() catch unreachable;
- case.* = .{
+ target: std.zig.CrossTarget,
+ T: TestType,
+ ) *Case {
+ ctx.cases.append(Case{
.name = name,
- .cross_target = cross_target,
- .updates = std.ArrayList(ZIRTransformCase.Update).init(std.heap.page_allocator),
- };
- return case;
+ .target = target,
+ .updates = std.ArrayList(Update).init(ctx.cases.allocator),
+ .output_mode = .Exe,
+ .extension = T,
+ }) catch unreachable;
+ return &ctx.cases.items[ctx.cases.items.len - 1];
}
- fn init(self: *TestContext) !void {
- self.* = .{
- .zir_cmp_output_cases = std.ArrayList(ZIRCompareOutputCase).init(std.heap.page_allocator),
- .zir_transform_cases = std.ArrayList(ZIRTransformCase).init(std.heap.page_allocator),
- };
+ /// Adds a test case for Zig input, producing an executable
+ pub fn exe(ctx: *TestContext, name: []const u8, target: std.zig.CrossTarget) *Case {
+ return ctx.addExe(name, target, .Zig);
+ }
+
+ /// Adds a test case for ZIR input, producing an executable
+ pub fn exeZIR(ctx: *TestContext, name: []const u8, target: std.zig.CrossTarget) *Case {
+ return ctx.addExe(name, target, .ZIR);
+ }
+
+ pub fn addObj(
+ ctx: *TestContext,
+ name: []const u8,
+ target: std.zig.CrossTarget,
+ T: TestType,
+ ) *Case {
+ ctx.cases.append(Case{
+ .name = name,
+ .target = target,
+ .updates = std.ArrayList(Update).init(ctx.cases.allocator),
+ .output_mode = .Obj,
+ .extension = T,
+ }) catch unreachable;
+ return &ctx.cases.items[ctx.cases.items.len - 1];
+ }
+
+ /// Adds a test case for Zig input, producing an object file
+ pub fn obj(ctx: *TestContext, name: []const u8, target: std.zig.CrossTarget) *Case {
+ return ctx.addObj(name, target, .Zig);
+ }
+
+ /// Adds a test case for ZIR input, producing an object file
+ pub fn objZIR(ctx: *TestContext, name: []const u8, target: std.zig.CrossTarget) *Case {
+ return ctx.addObj(name, target, .ZIR);
+ }
+
+ pub fn addC(ctx: *TestContext, name: []const u8, target: std.zig.CrossTarget, T: TestType) *Case {
+ ctx.cases.append(Case{
+ .name = name,
+ .target = target,
+ .updates = std.ArrayList(Update).init(ctx.cases.allocator),
+ .output_mode = .Obj,
+ .extension = T,
+ .cbe = true,
+ }) catch unreachable;
+ return &ctx.cases.items[ctx.cases.items.len - 1];
+ }
+
+ pub fn c(ctx: *TestContext, name: []const u8, target: std.zig.CrossTarget, src: [:0]const u8, comptime out: [:0]const u8) void {
+ ctx.addC(name, target, .Zig).addTransform(src, cheader ++ out);
+ }
+
+ pub fn addCompareOutput(
+ ctx: *TestContext,
+ name: []const u8,
+ T: TestType,
+ src: [:0]const u8,
+ expected_stdout: []const u8,
+ ) void {
+ ctx.addExe(name, .{}, T).addCompareOutput(src, expected_stdout);
+ }
+
+ /// Adds a test case that compiles the Zig source given in `src`, executes
+ /// it, runs it, and tests the output against `expected_stdout`
+ pub fn compareOutput(
+ ctx: *TestContext,
+ name: []const u8,
+ src: [:0]const u8,
+ expected_stdout: []const u8,
+ ) void {
+ return ctx.addCompareOutput(name, .Zig, src, expected_stdout);
+ }
+
+ /// Adds a test case that compiles the ZIR source given in `src`, executes
+ /// it, runs it, and tests the output against `expected_stdout`
+ pub fn compareOutputZIR(
+ ctx: *TestContext,
+ name: []const u8,
+ src: [:0]const u8,
+ expected_stdout: []const u8,
+ ) void {
+ ctx.addCompareOutput(name, .ZIR, src, expected_stdout);
+ }
+
+ pub fn addTransform(
+ ctx: *TestContext,
+ name: []const u8,
+ target: std.zig.CrossTarget,
+ T: TestType,
+ src: [:0]const u8,
+ result: [:0]const u8,
+ ) void {
+ ctx.addObj(name, target, T).addTransform(src, result);
+ }
+
+ /// Adds a test case that compiles the Zig given in `src` to ZIR and tests
+ /// the ZIR against `result`
+ pub fn transform(
+ ctx: *TestContext,
+ name: []const u8,
+ target: std.zig.CrossTarget,
+ src: [:0]const u8,
+ result: [:0]const u8,
+ ) void {
+ ctx.addTransform(name, target, .Zig, src, result);
+ }
+
+ /// Adds a test case that cleans up the ZIR source given in `src`, and
+ /// tests the resulting ZIR against `result`
+ pub fn transformZIR(
+ ctx: *TestContext,
+ name: []const u8,
+ target: std.zig.CrossTarget,
+ src: [:0]const u8,
+ result: [:0]const u8,
+ ) void {
+ ctx.addTransform(name, target, .ZIR, src, result);
+ }
+
+ pub fn addError(
+ ctx: *TestContext,
+ name: []const u8,
+ target: std.zig.CrossTarget,
+ T: TestType,
+ src: [:0]const u8,
+ expected_errors: []const []const u8,
+ ) void {
+ ctx.addObj(name, target, T).addError(src, expected_errors);
+ }
+
+ /// Adds a test case that ensures that the Zig given in `src` fails to
+ /// compile for the expected reasons, given in sequential order in
+ /// `expected_errors` in the form `:line:column: error: message`.
+ pub fn compileError(
+ ctx: *TestContext,
+ name: []const u8,
+ target: std.zig.CrossTarget,
+ src: [:0]const u8,
+ expected_errors: []const []const u8,
+ ) void {
+ ctx.addError(name, target, .Zig, src, expected_errors);
+ }
+
+ /// Adds a test case that ensures that the ZIR given in `src` fails to
+ /// compile for the expected reasons, given in sequential order in
+ /// `expected_errors` in the form `:line:column: error: message`.
+ pub fn compileErrorZIR(
+ ctx: *TestContext,
+ name: []const u8,
+ target: std.zig.CrossTarget,
+ src: [:0]const u8,
+ expected_errors: []const []const u8,
+ ) void {
+ ctx.addError(name, target, .ZIR, src, expected_errors);
+ }
+
+ pub fn addCompiles(
+ ctx: *TestContext,
+ name: []const u8,
+ target: std.zig.CrossTarget,
+ T: TestType,
+ src: [:0]const u8,
+ ) void {
+ ctx.addObj(name, target, T).compiles(src);
+ }
+
+ /// Adds a test case that asserts that the Zig given in `src` compiles
+ /// without any errors.
+ pub fn compiles(
+ ctx: *TestContext,
+ name: []const u8,
+ target: std.zig.CrossTarget,
+ src: [:0]const u8,
+ ) void {
+ ctx.addCompiles(name, target, .Zig, src);
+ }
+
+ /// Adds a test case that asserts that the ZIR given in `src` compiles
+ /// without any errors.
+ pub fn compilesZIR(
+ ctx: *TestContext,
+ name: []const u8,
+ target: std.zig.CrossTarget,
+ src: [:0]const u8,
+ ) void {
+ ctx.addCompiles(name, target, .ZIR, src);
+ }
+
+ /// Adds a test case that first ensures that the Zig given in `src` fails
+ /// to compile for the reasons given in sequential order in
+ /// `expected_errors` in the form `:line:column: error: message`, then
+ /// asserts that fixing the source (updating with `fixed_src`) isn't broken
+ /// by incremental compilation.
+ pub fn incrementalFailure(
+ ctx: *TestContext,
+ name: []const u8,
+ target: std.zig.CrossTarget,
+ src: [:0]const u8,
+ expected_errors: []const []const u8,
+ fixed_src: [:0]const u8,
+ ) void {
+ var case = ctx.addObj(name, target, .Zig);
+ case.addError(src, expected_errors);
+ case.compiles(fixed_src);
+ }
+
+ /// Adds a test case that first ensures that the ZIR given in `src` fails
+ /// to compile for the reasons given in sequential order in
+ /// `expected_errors` in the form `:line:column: error: message`, then
+ /// asserts that fixing the source (updating with `fixed_src`) isn't broken
+ /// by incremental compilation.
+ pub fn incrementalFailureZIR(
+ ctx: *TestContext,
+ name: []const u8,
+ target: std.zig.CrossTarget,
+ src: [:0]const u8,
+ expected_errors: []const []const u8,
+ fixed_src: [:0]const u8,
+ ) void {
+ var case = ctx.addObj(name, target, .ZIR);
+ case.addError(src, expected_errors);
+ case.compiles(fixed_src);
+ }
+
+ fn init() TestContext {
+ const allocator = std.heap.page_allocator;
+ return .{ .cases = std.ArrayList(Case).init(allocator) };
}
fn deinit(self: *TestContext) void {
- self.zir_cmp_output_cases.deinit();
- self.zir_transform_cases.deinit();
+ for (self.cases.items) |case| {
+ for (case.updates.items) |u| {
+ if (u.case == .Error) {
+ case.updates.allocator.free(u.case.Error);
+ }
+ }
+ case.updates.deinit();
+ }
+ self.cases.deinit();
self.* = undefined;
}
fn run(self: *TestContext) !void {
var progress = std.Progress{};
- const root_node = try progress.start("zir", self.zir_cmp_output_cases.items.len +
- self.zir_transform_cases.items.len);
+ const root_node = try progress.start("tests", self.cases.items.len);
defer root_node.end();
const native_info = try std.zig.system.NativeTargetInfo.detect(std.heap.page_allocator, .{});
- for (self.zir_cmp_output_cases.items) |case| {
+ for (self.cases.items) |case| {
std.testing.base_allocator_instance.reset();
- try self.runOneZIRCmpOutputCase(std.testing.allocator, root_node, case, native_info.target);
- try std.testing.allocator_instance.validate();
- }
- for (self.zir_transform_cases.items) |case| {
- std.testing.base_allocator_instance.reset();
- const info = try std.zig.system.NativeTargetInfo.detect(std.testing.allocator, case.cross_target);
- try self.runOneZIRTransformCase(std.testing.allocator, root_node, case, info.target);
- try std.testing.allocator_instance.validate();
- }
- }
- fn runOneZIRCmpOutputCase(
- self: *TestContext,
- allocator: *Allocator,
- root_node: *std.Progress.Node,
- case: ZIRCompareOutputCase,
- target: std.Target,
- ) !void {
- var tmp = std.testing.tmpDir(.{});
- defer tmp.cleanup();
-
- const tmp_src_path = "test-case.zir";
- const root_pkg = try Package.create(allocator, tmp.dir, ".", tmp_src_path);
- defer root_pkg.destroy();
-
- var prg_node = root_node.start(case.name, case.src_list.len);
- prg_node.activate();
- defer prg_node.end();
-
- var module = try Module.init(allocator, .{
- .target = target,
- .output_mode = .Exe,
- .optimize_mode = .Debug,
- .bin_file_dir = tmp.dir,
- .bin_file_path = "a.out",
- .root_pkg = root_pkg,
- });
- defer module.deinit();
-
- for (case.src_list) |source, i| {
- var src_node = prg_node.start("update", 2);
- src_node.activate();
- defer src_node.end();
-
- try tmp.dir.writeFile(tmp_src_path, source);
-
- var update_node = src_node.start("parse,analysis,codegen", null);
- update_node.activate();
- try module.makeBinFileWritable();
- try module.update();
- update_node.end();
-
- var exec_result = x: {
- var exec_node = src_node.start("execute", null);
- exec_node.activate();
- defer exec_node.end();
-
- try module.makeBinFileExecutable();
- break :x try std.ChildProcess.exec(.{
- .allocator = allocator,
- .argv = &[_][]const u8{"./a.out"},
- .cwd_dir = tmp.dir,
- });
- };
- defer allocator.free(exec_result.stdout);
- defer allocator.free(exec_result.stderr);
- switch (exec_result.term) {
- .Exited => |code| {
- if (code != 0) {
- std.debug.warn("elf file exited with code {}\n", .{code});
- return error.BinaryBadExitCode;
- }
- },
- else => return error.BinaryCrashed,
- }
- const expected_stdout = case.expected_stdout_list[i];
- if (!std.mem.eql(u8, expected_stdout, exec_result.stdout)) {
- std.debug.panic(
- "update index {}, mismatched stdout\n====Expected (len={}):====\n{}\n====Actual (len={}):====\n{}\n========\n",
- .{ i, expected_stdout.len, expected_stdout, exec_result.stdout.len, exec_result.stdout },
- );
- }
- }
- }
-
- fn runOneZIRTransformCase(
- self: *TestContext,
- allocator: *Allocator,
- root_node: *std.Progress.Node,
- case: ZIRTransformCase,
- target: std.Target,
- ) !void {
- var tmp = std.testing.tmpDir(.{});
- defer tmp.cleanup();
-
- var update_node = root_node.start(case.name, case.updates.items.len);
- update_node.activate();
- defer update_node.end();
-
- const tmp_src_path = "test-case.zir";
- const root_pkg = try Package.create(allocator, tmp.dir, ".", tmp_src_path);
- defer root_pkg.destroy();
-
- var module = try Module.init(allocator, .{
- .target = target,
- .output_mode = .Obj,
- .optimize_mode = .Debug,
- .bin_file_dir = tmp.dir,
- .bin_file_path = "test-case.o",
- .root_pkg = root_pkg,
- });
- defer module.deinit();
-
- for (case.updates.items) |update| {
- var prg_node = update_node.start("", 3);
+ var prg_node = root_node.start(case.name, case.updates.items.len);
prg_node.activate();
defer prg_node.end();
- try tmp.dir.writeFile(tmp_src_path, update.src);
+ // So that we can see which test case failed when the leak checker goes off,
+ // or there's an internal error
+ progress.initial_delay_ns = 0;
+ progress.refresh_rate_ns = 0;
- var module_node = prg_node.start("parse/analysis/codegen", null);
+ const info = try std.zig.system.NativeTargetInfo.detect(std.testing.allocator, case.target);
+ try self.runOneCase(std.testing.allocator, &prg_node, case, info.target);
+ try std.testing.allocator_instance.validate();
+ }
+ }
+
+ fn runOneCase(self: *TestContext, allocator: *Allocator, root_node: *std.Progress.Node, case: Case, target: std.Target) !void {
+ var tmp = std.testing.tmpDir(.{});
+ defer tmp.cleanup();
+
+ const tmp_src_path = if (case.extension == .Zig) "test_case.zig" else if (case.extension == .ZIR) "test_case.zir" else unreachable;
+ const root_pkg = try Package.create(allocator, tmp.dir, ".", tmp_src_path);
+ defer root_pkg.destroy();
+
+ const bin_name = try std.zig.binNameAlloc(allocator, "test_case", target, case.output_mode, null);
+ defer allocator.free(bin_name);
+
+ var module = try Module.init(allocator, .{
+ .target = target,
+ // TODO: support tests for object file building, and library builds
+ // and linking. This will require a rework to support multi-file
+ // tests.
+ .output_mode = case.output_mode,
+ // TODO: support testing optimizations
+ .optimize_mode = .Debug,
+ .bin_file_dir = tmp.dir,
+ .bin_file_path = bin_name,
+ .root_pkg = root_pkg,
+ .keep_source_files_loaded = true,
+ .object_format = if (case.cbe) .c else null,
+ });
+ defer module.deinit();
+
+ for (case.updates.items) |update, update_index| {
+ var update_node = root_node.start("update", 3);
+ update_node.activate();
+ defer update_node.end();
+
+ var sync_node = update_node.start("write", null);
+ sync_node.activate();
+ try tmp.dir.writeFile(tmp_src_path, update.src);
+ sync_node.end();
+
+ var module_node = update_node.start("parse/analysis/codegen", null);
module_node.activate();
+ try module.makeBinFileWritable();
try module.update();
module_node.end();
- switch (update.expected) {
- .zir => |expected_zir| {
- var emit_node = prg_node.start("emit", null);
- emit_node.activate();
- var new_zir_module = try zir.emit(allocator, module);
- defer new_zir_module.deinit(allocator);
- emit_node.end();
+ if (update.case != .Error) {
+ var all_errors = try module.getAllErrorsAlloc();
+ defer all_errors.deinit(allocator);
+ if (all_errors.list.len != 0) {
+ std.debug.warn("\nErrors occurred updating the module:\n================\n", .{});
+ for (all_errors.list) |err| {
+ std.debug.warn(":{}:{}: error: {}\n================\n", .{ err.line + 1, err.column + 1, err.msg });
+ }
+ std.debug.warn("Test failed.\n", .{});
+ std.process.exit(1);
+ }
+ }
- var write_node = prg_node.start("write", null);
- write_node.activate();
- var out_zir = std.ArrayList(u8).init(allocator);
- defer out_zir.deinit();
- try new_zir_module.writeToStream(allocator, out_zir.outStream());
- write_node.end();
+ switch (update.case) {
+ .Transformation => |expected_output| {
+ if (case.cbe) {
+ // The C file is always closed after an update, because we don't support
+ // incremental updates
+ var file = try tmp.dir.openFile(bin_name, .{ .read = true });
+ defer file.close();
+ var out = file.reader().readAllAlloc(allocator, 1024 * 1024) catch @panic("Unable to read C output!");
+ defer allocator.free(out);
- std.testing.expectEqualSlices(u8, expected_zir, out_zir.items);
+ if (expected_output.len != out.len) {
+ std.debug.warn("\nTransformed C length differs:\n================\nExpected:\n================\n{}\n================\nFound:\n================\n{}\n================\nTest failed.\n", .{ expected_output, out });
+ std.process.exit(1);
+ }
+ for (expected_output) |e, i| {
+ if (out[i] != e) {
+ std.debug.warn("\nTransformed C differs:\n================\nExpected:\n================\n{}\n================\nFound:\n================\n{}\n================\nTest failed.\n", .{ expected_output, out });
+ std.process.exit(1);
+ }
+ }
+ } else {
+ update_node.estimated_total_items = 5;
+ var emit_node = update_node.start("emit", null);
+ emit_node.activate();
+ var new_zir_module = try zir.emit(allocator, module);
+ defer new_zir_module.deinit(allocator);
+ emit_node.end();
+
+ var write_node = update_node.start("write", null);
+ write_node.activate();
+ var out_zir = std.ArrayList(u8).init(allocator);
+ defer out_zir.deinit();
+ try new_zir_module.writeToStream(allocator, out_zir.outStream());
+ write_node.end();
+
+ var test_node = update_node.start("assert", null);
+ test_node.activate();
+ defer test_node.end();
+
+ if (expected_output.len != out_zir.items.len) {
+ std.debug.warn("{}\nTransformed ZIR length differs:\n================\nExpected:\n================\n{}\n================\nFound:\n================\n{}\n================\nTest failed.\n", .{ case.name, expected_output, out_zir.items });
+ std.process.exit(1);
+ }
+ for (expected_output) |e, i| {
+ if (out_zir.items[i] != e) {
+ std.debug.warn("{}\nTransformed ZIR differs:\n================\nExpected:\n================\n{}\n================\nFound:\n================\n{}\n================\nTest failed.\n", .{ case.name, expected_output, out_zir.items });
+ std.process.exit(1);
+ }
+ }
+ }
},
- .errors => |expected_errors| {
+ .Error => |e| {
+ var test_node = update_node.start("assert", null);
+ test_node.activate();
+ defer test_node.end();
+ var handled_errors = try allocator.alloc(bool, e.len);
+ defer allocator.free(handled_errors);
+ for (handled_errors) |*h| {
+ h.* = false;
+ }
var all_errors = try module.getAllErrorsAlloc();
- defer all_errors.deinit(module.allocator);
- for (expected_errors) |expected_error| {
- for (all_errors.list) |full_err_msg| {
- const text = try std.fmt.allocPrint(allocator, ":{}:{}: error: {}", .{
- full_err_msg.line + 1,
- full_err_msg.column + 1,
- full_err_msg.msg,
- });
- defer allocator.free(text);
- if (std.mem.eql(u8, text, expected_error)) {
+ defer all_errors.deinit(allocator);
+ for (all_errors.list) |a| {
+ for (e) |ex, i| {
+ if (a.line == ex.line and a.column == ex.column and std.mem.eql(u8, ex.msg, a.msg)) {
+ handled_errors[i] = true;
break;
}
} else {
- std.debug.warn(
- "{}\nExpected this error:\n================\n{}\n================\nBut found these errors:\n================\n",
- .{ case.name, expected_error },
- );
- for (all_errors.list) |full_err_msg| {
- std.debug.warn(":{}:{}: error: {}\n", .{
- full_err_msg.line + 1,
- full_err_msg.column + 1,
- full_err_msg.msg,
- });
- }
- std.debug.warn("================\nTest failed\n", .{});
+ std.debug.warn("{}\nUnexpected error:\n================\n:{}:{}: error: {}\n================\nTest failed.\n", .{ case.name, a.line + 1, a.column + 1, a.msg });
std.process.exit(1);
}
}
+
+ for (handled_errors) |h, i| {
+ if (!h) {
+ const er = e[i];
+ std.debug.warn("{}\nDid not receive error:\n================\n{}:{}: {}\n================\nTest failed.\n", .{ case.name, er.line, er.column, er.msg });
+ std.process.exit(1);
+ }
+ }
+ },
+ .Execution => |expected_stdout| {
+ std.debug.assert(!case.cbe);
+
+ update_node.estimated_total_items = 4;
+ var exec_result = x: {
+ var exec_node = update_node.start("execute", null);
+ exec_node.activate();
+ defer exec_node.end();
+
+ try module.makeBinFileExecutable();
+
+ const exe_path = try std.fmt.allocPrint(allocator, "." ++ std.fs.path.sep_str ++ "{}", .{bin_name});
+ defer allocator.free(exe_path);
+
+ break :x try std.ChildProcess.exec(.{
+ .allocator = allocator,
+ .argv = &[_][]const u8{exe_path},
+ .cwd_dir = tmp.dir,
+ });
+ };
+ var test_node = update_node.start("test", null);
+ test_node.activate();
+ defer test_node.end();
+
+ defer allocator.free(exec_result.stdout);
+ defer allocator.free(exec_result.stderr);
+ switch (exec_result.term) {
+ .Exited => |code| {
+ if (code != 0) {
+ std.debug.warn("elf file exited with code {}\n", .{code});
+ return error.BinaryBadExitCode;
+ }
+ },
+ else => return error.BinaryCrashed,
+ }
+ if (!std.mem.eql(u8, expected_stdout, exec_result.stdout)) {
+ std.debug.panic(
+ "update index {}, mismatched stdout\n====Expected (len={}):====\n{}\n====Actual (len={}):====\n{}\n========\n",
+ .{ update_index, expected_stdout.len, expected_stdout, exec_result.stdout.len, exec_result.stdout },
+ );
+ }
},
}
}
}
};
-
-fn debugPrintErrors(src: []const u8, errors: var) void {
- std.debug.warn("\n", .{});
- var nl = true;
- var line: usize = 1;
- for (src) |byte| {
- if (nl) {
- std.debug.warn("{: >3}| ", .{line});
- nl = false;
- }
- if (byte == '\n') {
- nl = true;
- line += 1;
- }
- std.debug.warn("{c}", .{byte});
- }
- std.debug.warn("\n", .{});
- for (errors) |err_msg| {
- const loc = std.zig.findLineColumn(src, err_msg.byte_offset);
- std.debug.warn("{}:{}: error: {}\n", .{ loc.line + 1, loc.column + 1, err_msg.msg });
- }
-}
diff --git a/src-self-hosted/tracy.zig b/src-self-hosted/tracy.zig
new file mode 100644
index 0000000000..6f56a87ce6
--- /dev/null
+++ b/src-self-hosted/tracy.zig
@@ -0,0 +1,45 @@
+pub const std = @import("std");
+
+pub const enable = if (std.builtin.is_test) false else @import("build_options").enable_tracy;
+
+extern fn ___tracy_emit_zone_begin_callstack(
+ srcloc: *const ___tracy_source_location_data,
+ depth: c_int,
+ active: c_int,
+) ___tracy_c_zone_context;
+
+extern fn ___tracy_emit_zone_end(ctx: ___tracy_c_zone_context) void;
+
+pub const ___tracy_source_location_data = extern struct {
+ name: ?[*:0]const u8,
+ function: [*:0]const u8,
+ file: [*:0]const u8,
+ line: u32,
+ color: u32,
+};
+
+pub const ___tracy_c_zone_context = extern struct {
+ id: u32,
+ active: c_int,
+
+ pub fn end(self: ___tracy_c_zone_context) void {
+ ___tracy_emit_zone_end(self);
+ }
+};
+
+pub const Ctx = if (enable) ___tracy_c_zone_context else struct {
+ pub fn end(self: Ctx) void {}
+};
+
+pub inline fn trace(comptime src: std.builtin.SourceLocation) Ctx {
+ if (!enable) return .{};
+
+ const loc: ___tracy_source_location_data = .{
+ .name = null,
+ .function = src.fn_name.ptr,
+ .file = src.file.ptr,
+ .line = src.line,
+ .color = 0,
+ };
+ return ___tracy_emit_zone_begin_callstack(&loc, 1, 1);
+}
diff --git a/src-self-hosted/translate_c.zig b/src-self-hosted/translate_c.zig
index 3b1a91b28c..46f33dd0ff 100644
--- a/src-self-hosted/translate_c.zig
+++ b/src-self-hosted/translate_c.zig
@@ -20,7 +20,7 @@ pub const Error = error{OutOfMemory};
const TypeError = Error || error{UnsupportedType};
const TransError = TypeError || error{UnsupportedTranslation};
-const DeclTable = std.HashMap(usize, []const u8, addrHash, addrEql);
+const DeclTable = std.HashMap(usize, []const u8, addrHash, addrEql, false);
fn addrHash(x: usize) u32 {
switch (@typeInfo(usize).Int.bits) {
@@ -586,11 +586,7 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void {
for (proto_node.params()) |*param, i| {
const param_name = if (param.name_token) |name_tok|
tokenSlice(c, name_tok)
- else if (param.param_type == .var_args) {
- assert(i + 1 == proto_node.params_len);
- proto_node.params_len -= 1;
- break;
- } else
+ else
return failDecl(c, fn_decl_loc, fn_name, "function {} parameter has no name", .{fn_name});
const c_param = ZigClangFunctionDecl_getParamDecl(fn_decl, param_id);
@@ -602,10 +598,20 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void {
if (!is_const) {
const bare_arg_name = try std.fmt.allocPrint(c.arena, "arg_{}", .{mangled_param_name});
const arg_name = try block_scope.makeMangledName(c, bare_arg_name);
- const node = try transCreateNodeVarDecl(c, false, false, mangled_param_name);
- node.eq_token = try appendToken(c, .Equal, "=");
- node.init_node = try transCreateNodeIdentifier(c, arg_name);
- node.semicolon_token = try appendToken(c, .Semicolon, ";");
+
+ const mut_tok = try appendToken(c, .Keyword_var, "var");
+ const name_tok = try appendIdentifier(c, mangled_param_name);
+ const eq_token = try appendToken(c, .Equal, "=");
+ const init_node = try transCreateNodeIdentifier(c, arg_name);
+ const semicolon_token = try appendToken(c, .Semicolon, ";");
+ const node = try ast.Node.VarDecl.create(c.arena, .{
+ .mut_token = mut_tok,
+ .name_token = name_tok,
+ .semicolon_token = semicolon_token,
+ }, .{
+ .eq_token = eq_token,
+ .init_node = init_node,
+ });
try block_scope.statements.append(&node.base);
param.name_token = try appendIdentifier(c, arg_name);
_ = try appendToken(c, .Colon, ":");
@@ -622,7 +628,7 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void {
=> return failDecl(c, fn_decl_loc, fn_name, "unable to translate function", .{}),
};
const body_node = try block_scope.complete(rp.c);
- proto_node.body_node = &body_node.base;
+ proto_node.setTrailer("body_node", &body_node.base);
return addTopLevelDecl(c, fn_name, &proto_node.base);
}
@@ -725,23 +731,20 @@ fn visitVarDecl(c: *Context, var_decl: *const ZigClangVarDecl) Error!void {
break :blk null;
};
- const node = try c.arena.create(ast.Node.VarDecl);
- node.* = .{
- .doc_comments = null,
+ const node = try ast.Node.VarDecl.create(c.arena, .{
+ .name_token = name_tok,
+ .mut_token = mut_tok,
+ .semicolon_token = try appendToken(c, .Semicolon, ";"),
+ }, .{
.visib_token = visib_tok,
.thread_local_token = thread_local_token,
- .name_token = name_tok,
.eq_token = eq_tok,
- .mut_token = mut_tok,
- .comptime_token = null,
.extern_export_token = extern_tok,
- .lib_name = null,
.type_node = type_node,
.align_node = align_expr,
.section_node = linksection_expr,
.init_node = init_node,
- .semicolon_token = try appendToken(c, .Semicolon, ";"),
- };
+ });
return addTopLevelDecl(c, checked_name, &node.base);
}
@@ -776,8 +779,8 @@ fn checkForBuiltinTypedef(checked_name: []const u8) ?[]const u8 {
}
fn transTypeDef(c: *Context, typedef_decl: *const ZigClangTypedefNameDecl, top_level_visit: bool) Error!?*ast.Node {
- if (c.decl_table.get(@ptrToInt(ZigClangTypedefNameDecl_getCanonicalDecl(typedef_decl)))) |kv|
- return transCreateNodeIdentifier(c, kv.value); // Avoid processing this decl twice
+ if (c.decl_table.get(@ptrToInt(ZigClangTypedefNameDecl_getCanonicalDecl(typedef_decl)))) |name|
+ return transCreateNodeIdentifier(c, name); // Avoid processing this decl twice
const rp = makeRestorePoint(c);
const typedef_name = try c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, typedef_decl)));
@@ -795,31 +798,46 @@ fn transTypeDef(c: *Context, typedef_decl: *const ZigClangTypedefNameDecl, top_l
_ = try c.decl_table.put(@ptrToInt(ZigClangTypedefNameDecl_getCanonicalDecl(typedef_decl)), checked_name);
const node = (try transCreateNodeTypedef(rp, typedef_decl, true, checked_name)) orelse return null;
- try addTopLevelDecl(c, checked_name, &node.base);
+ try addTopLevelDecl(c, checked_name, node);
return transCreateNodeIdentifier(c, checked_name);
}
-fn transCreateNodeTypedef(rp: RestorePoint, typedef_decl: *const ZigClangTypedefNameDecl, toplevel: bool, checked_name: []const u8) Error!?*ast.Node.VarDecl {
- const node = try transCreateNodeVarDecl(rp.c, toplevel, true, checked_name);
- node.eq_token = try appendToken(rp.c, .Equal, "=");
-
+fn transCreateNodeTypedef(
+ rp: RestorePoint,
+ typedef_decl: *const ZigClangTypedefNameDecl,
+ toplevel: bool,
+ checked_name: []const u8,
+) Error!?*ast.Node {
+ const visib_tok = if (toplevel) try appendToken(rp.c, .Keyword_pub, "pub") else null;
+ const mut_tok = try appendToken(rp.c, .Keyword_const, "const");
+ const name_tok = try appendIdentifier(rp.c, checked_name);
+ const eq_token = try appendToken(rp.c, .Equal, "=");
const child_qt = ZigClangTypedefNameDecl_getUnderlyingType(typedef_decl);
const typedef_loc = ZigClangTypedefNameDecl_getLocation(typedef_decl);
- node.init_node = transQualType(rp, child_qt, typedef_loc) catch |err| switch (err) {
+ const init_node = transQualType(rp, child_qt, typedef_loc) catch |err| switch (err) {
error.UnsupportedType => {
try failDecl(rp.c, typedef_loc, checked_name, "unable to resolve typedef child type", .{});
return null;
},
error.OutOfMemory => |e| return e,
};
+ const semicolon_token = try appendToken(rp.c, .Semicolon, ";");
- node.semicolon_token = try appendToken(rp.c, .Semicolon, ";");
- return node;
+ const node = try ast.Node.VarDecl.create(rp.c.arena, .{
+ .name_token = name_tok,
+ .mut_token = mut_tok,
+ .semicolon_token = semicolon_token,
+ }, .{
+ .visib_token = visib_tok,
+ .eq_token = eq_token,
+ .init_node = init_node,
+ });
+ return &node.base;
}
fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?*ast.Node {
- if (c.decl_table.get(@ptrToInt(ZigClangRecordDecl_getCanonicalDecl(record_decl)))) |kv|
- return try transCreateNodeIdentifier(c, kv.value); // Avoid processing this decl twice
+ if (c.decl_table.get(@ptrToInt(ZigClangRecordDecl_getCanonicalDecl(record_decl)))) |name|
+ return try transCreateNodeIdentifier(c, name); // Avoid processing this decl twice
const record_loc = ZigClangRecordDecl_getLocation(record_decl);
var bare_name = try c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, record_decl)));
@@ -847,12 +865,14 @@ fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?*
const name = try std.fmt.allocPrint(c.arena, "{}_{}", .{ container_kind_name, bare_name });
_ = try c.decl_table.put(@ptrToInt(ZigClangRecordDecl_getCanonicalDecl(record_decl)), name);
- const node = try transCreateNodeVarDecl(c, !is_unnamed, true, name);
+ const visib_tok = if (!is_unnamed) try appendToken(c, .Keyword_pub, "pub") else null;
+ const mut_tok = try appendToken(c, .Keyword_const, "const");
+ const name_tok = try appendIdentifier(c, name);
- node.eq_token = try appendToken(c, .Equal, "=");
+ const eq_token = try appendToken(c, .Equal, "=");
var semicolon: ast.TokenIndex = undefined;
- node.init_node = blk: {
+ const init_node = blk: {
const rp = makeRestorePoint(c);
const record_def = ZigClangRecordDecl_getDefinition(record_decl) orelse {
const opaque = try transCreateNodeOpaqueType(c);
@@ -959,7 +979,16 @@ fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?*
semicolon = try appendToken(c, .Semicolon, ";");
break :blk &container_node.base;
};
- node.semicolon_token = semicolon;
+
+ const node = try ast.Node.VarDecl.create(c.arena, .{
+ .name_token = name_tok,
+ .mut_token = mut_tok,
+ .semicolon_token = semicolon,
+ }, .{
+ .visib_token = visib_tok,
+ .eq_token = eq_token,
+ .init_node = init_node,
+ });
try addTopLevelDecl(c, name, &node.base);
if (!is_unnamed)
@@ -969,7 +998,7 @@ fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?*
fn transEnumDecl(c: *Context, enum_decl: *const ZigClangEnumDecl) Error!?*ast.Node {
if (c.decl_table.get(@ptrToInt(ZigClangEnumDecl_getCanonicalDecl(enum_decl)))) |name|
- return try transCreateNodeIdentifier(c, name.value); // Avoid processing this decl twice
+ return try transCreateNodeIdentifier(c, name); // Avoid processing this decl twice
const rp = makeRestorePoint(c);
const enum_loc = ZigClangEnumDecl_getLocation(enum_decl);
@@ -982,10 +1011,13 @@ fn transEnumDecl(c: *Context, enum_decl: *const ZigClangEnumDecl) Error!?*ast.No
const name = try std.fmt.allocPrint(c.arena, "enum_{}", .{bare_name});
_ = try c.decl_table.put(@ptrToInt(ZigClangEnumDecl_getCanonicalDecl(enum_decl)), name);
- const node = try transCreateNodeVarDecl(c, !is_unnamed, true, name);
- node.eq_token = try appendToken(c, .Equal, "=");
- node.init_node = if (ZigClangEnumDecl_getDefinition(enum_decl)) |enum_def| blk: {
+ const visib_tok = if (!is_unnamed) try appendToken(c, .Keyword_pub, "pub") else null;
+ const mut_tok = try appendToken(c, .Keyword_const, "const");
+ const name_tok = try appendIdentifier(c, name);
+ const eq_token = try appendToken(c, .Equal, "=");
+
+ const init_node = if (ZigClangEnumDecl_getDefinition(enum_decl)) |enum_def| blk: {
var pure_enum = true;
var it = ZigClangEnumDecl_enumerator_begin(enum_def);
var end_it = ZigClangEnumDecl_enumerator_end(enum_def);
@@ -1063,23 +1095,34 @@ fn transEnumDecl(c: *Context, enum_decl: *const ZigClangEnumDecl) Error!?*ast.No
// In C each enum value is in the global namespace. So we put them there too.
// At this point we can rely on the enum emitting successfully.
- const tld_node = try transCreateNodeVarDecl(c, true, true, enum_val_name);
- tld_node.eq_token = try appendToken(c, .Equal, "=");
+ const tld_visib_tok = try appendToken(c, .Keyword_pub, "pub");
+ const tld_mut_tok = try appendToken(c, .Keyword_const, "const");
+ const tld_name_tok = try appendIdentifier(c, enum_val_name);
+ const tld_eq_token = try appendToken(c, .Equal, "=");
const cast_node = try rp.c.createBuiltinCall("@enumToInt", 1);
const enum_ident = try transCreateNodeIdentifier(c, name);
const period_tok = try appendToken(c, .Period, ".");
const field_ident = try transCreateNodeIdentifier(c, field_name);
- const field_access_node = try c.arena.create(ast.Node.InfixOp);
+ const field_access_node = try c.arena.create(ast.Node.SimpleInfixOp);
field_access_node.* = .{
+ .base = .{ .tag = .Period },
.op_token = period_tok,
.lhs = enum_ident,
- .op = .Period,
.rhs = field_ident,
};
cast_node.params()[0] = &field_access_node.base;
cast_node.rparen_token = try appendToken(rp.c, .RParen, ")");
- tld_node.init_node = &cast_node.base;
- tld_node.semicolon_token = try appendToken(c, .Semicolon, ";");
+ const tld_init_node = &cast_node.base;
+ const tld_semicolon_token = try appendToken(c, .Semicolon, ";");
+ const tld_node = try ast.Node.VarDecl.create(c.arena, .{
+ .name_token = tld_name_tok,
+ .mut_token = tld_mut_tok,
+ .semicolon_token = tld_semicolon_token,
+ }, .{
+ .visib_token = tld_visib_tok,
+ .eq_token = tld_eq_token,
+ .init_node = tld_init_node,
+ });
try addTopLevelDecl(c, field_name, &tld_node.base);
}
// make non exhaustive
@@ -1109,7 +1152,16 @@ fn transEnumDecl(c: *Context, enum_decl: *const ZigClangEnumDecl) Error!?*ast.No
} else
try transCreateNodeOpaqueType(c);
- node.semicolon_token = try appendToken(c, .Semicolon, ";");
+ const semicolon_token = try appendToken(c, .Semicolon, ";");
+ const node = try ast.Node.VarDecl.create(c.arena, .{
+ .name_token = name_tok,
+ .mut_token = mut_tok,
+ .semicolon_token = semicolon_token,
+ }, .{
+ .visib_token = visib_tok,
+ .eq_token = eq_token,
+ .init_node = init_node,
+ });
try addTopLevelDecl(c, name, &node.base);
if (!is_unnamed)
@@ -1117,11 +1169,23 @@ fn transEnumDecl(c: *Context, enum_decl: *const ZigClangEnumDecl) Error!?*ast.No
return transCreateNodeIdentifier(c, name);
}
-fn createAlias(c: *Context, alias: var) !void {
- const node = try transCreateNodeVarDecl(c, true, true, alias.alias);
- node.eq_token = try appendToken(c, .Equal, "=");
- node.init_node = try transCreateNodeIdentifier(c, alias.name);
- node.semicolon_token = try appendToken(c, .Semicolon, ";");
+fn createAlias(c: *Context, alias: anytype) !void {
+ const visib_tok = try appendToken(c, .Keyword_pub, "pub");
+ const mut_tok = try appendToken(c, .Keyword_const, "const");
+ const name_tok = try appendIdentifier(c, alias.alias);
+ const eq_token = try appendToken(c, .Equal, "=");
+ const init_node = try transCreateNodeIdentifier(c, alias.name);
+ const semicolon_token = try appendToken(c, .Semicolon, ";");
+
+ const node = try ast.Node.VarDecl.create(c.arena, .{
+ .name_token = name_tok,
+ .mut_token = mut_tok,
+ .semicolon_token = semicolon_token,
+ }, .{
+ .visib_token = visib_tok,
+ .eq_token = eq_token,
+ .init_node = init_node,
+ });
return addTopLevelDecl(c, alias.alias, &node.base);
}
@@ -1155,7 +1219,7 @@ fn transStmt(
.StringLiteralClass => return transStringLiteral(rp, scope, @ptrCast(*const ZigClangStringLiteral, stmt), result_used),
.ParenExprClass => {
const expr = try transExpr(rp, scope, ZigClangParenExpr_getSubExpr(@ptrCast(*const ZigClangParenExpr, stmt)), .used, lrvalue);
- if (expr.id == .GroupedExpression) return maybeSuppressResult(rp, scope, result_used, expr);
+ if (expr.tag == .GroupedExpression) return maybeSuppressResult(rp, scope, result_used, expr);
const node = try rp.c.arena.create(ast.Node.GroupedExpression);
node.* = .{
.lparen = try appendToken(rp.c, .LParen, "("),
@@ -1200,7 +1264,7 @@ fn transStmt(
.OpaqueValueExprClass => {
const source_expr = ZigClangOpaqueValueExpr_getSourceExpr(@ptrCast(*const ZigClangOpaqueValueExpr, stmt)).?;
const expr = try transExpr(rp, scope, source_expr, .used, lrvalue);
- if (expr.id == .GroupedExpression) return maybeSuppressResult(rp, scope, result_used, expr);
+ if (expr.tag == .GroupedExpression) return maybeSuppressResult(rp, scope, result_used, expr);
const node = try rp.c.arena.create(ast.Node.GroupedExpression);
node.* = .{
.lparen = try appendToken(rp.c, .LParen, "("),
@@ -1230,7 +1294,7 @@ fn transBinaryOperator(
const op = ZigClangBinaryOperator_getOpcode(stmt);
const qt = ZigClangBinaryOperator_getType(stmt);
var op_token: ast.TokenIndex = undefined;
- var op_id: ast.Node.InfixOp.Op = undefined;
+ var op_id: ast.Node.Tag = undefined;
switch (op) {
.Assign => return try transCreateNodeAssign(rp, scope, result_used, ZigClangBinaryOperator_getLHS(stmt), ZigClangBinaryOperator_getRHS(stmt)),
.Comma => {
@@ -1461,13 +1525,17 @@ fn transDeclStmtOne(
@ptrCast(*const ZigClangNamedDecl, var_decl),
));
const mangled_name = try block_scope.makeMangledName(c, name);
- const node = try transCreateNodeVarDecl(c, false, ZigClangQualType_isConstQualified(qual_type), mangled_name);
+ const mut_tok = if (ZigClangQualType_isConstQualified(qual_type))
+ try appendToken(c, .Keyword_const, "const")
+ else
+ try appendToken(c, .Keyword_var, "var");
+ const name_tok = try appendIdentifier(c, mangled_name);
_ = try appendToken(c, .Colon, ":");
const loc = ZigClangDecl_getLocation(decl);
- node.type_node = try transQualType(rp, qual_type, loc);
+ const type_node = try transQualType(rp, qual_type, loc);
- node.eq_token = try appendToken(c, .Equal, "=");
+ const eq_token = try appendToken(c, .Equal, "=");
var init_node = if (ZigClangVarDecl_getInit(var_decl)) |expr|
try transExprCoercing(rp, scope, expr, .used, .r_value)
else
@@ -1478,8 +1546,17 @@ fn transDeclStmtOne(
builtin_node.rparen_token = try appendToken(rp.c, .RParen, ")");
init_node = &builtin_node.base;
}
- node.init_node = init_node;
- node.semicolon_token = try appendToken(c, .Semicolon, ";");
+ const semicolon_token = try appendToken(c, .Semicolon, ";");
+ const node = try ast.Node.VarDecl.create(c.arena, .{
+ .name_token = name_tok,
+ .mut_token = mut_tok,
+ .semicolon_token = semicolon_token,
+ }, .{
+ .thread_local_token = thread_local_token,
+ .eq_token = eq_token,
+ .type_node = type_node,
+ .init_node = init_node,
+ });
return &node.base;
},
.Typedef => {
@@ -1494,7 +1571,7 @@ fn transDeclStmtOne(
const mangled_name = try block_scope.makeMangledName(c, name);
const node = (try transCreateNodeTypedef(rp, typedef_decl, false, mangled_name)) orelse
return error.UnsupportedTranslation;
- return &node.base;
+ return node;
},
else => |kind| return revertAndWarn(
rp,
@@ -1561,7 +1638,7 @@ fn transImplicitCastExpr(
return maybeSuppressResult(rp, scope, result_used, sub_expr_node);
}
- const prefix_op = try transCreateNodePrefixOp(rp.c, .AddressOf, .Ampersand, "&");
+ const prefix_op = try transCreateNodeSimplePrefixOp(rp.c, .AddressOf, .Ampersand, "&");
prefix_op.rhs = try transExpr(rp, scope, sub_expr, .used, .r_value);
return maybeSuppressResult(rp, scope, result_used, &prefix_op.base);
@@ -1616,7 +1693,7 @@ fn transBoolExpr(
var res = try transExpr(rp, scope, expr, used, lrvalue);
if (isBoolRes(res)) {
- if (!grouped and res.id == .GroupedExpression) {
+ if (!grouped and res.tag == .GroupedExpression) {
const group = @fieldParentPtr(ast.Node.GroupedExpression, "base", res);
res = group.expr;
// get zig fmt to work properly
@@ -1659,30 +1736,23 @@ fn exprIsStringLiteral(expr: *const ZigClangExpr) bool {
}
fn isBoolRes(res: *ast.Node) bool {
- switch (res.id) {
- .InfixOp => switch (@fieldParentPtr(ast.Node.InfixOp, "base", res).op) {
- .BoolOr,
- .BoolAnd,
- .EqualEqual,
- .BangEqual,
- .LessThan,
- .GreaterThan,
- .LessOrEqual,
- .GreaterOrEqual,
- => return true,
+ switch (res.tag) {
+ .BoolOr,
+ .BoolAnd,
+ .EqualEqual,
+ .BangEqual,
+ .LessThan,
+ .GreaterThan,
+ .LessOrEqual,
+ .GreaterOrEqual,
+ .BoolNot,
+ .BoolLiteral,
+ => return true,
- else => {},
- },
- .PrefixOp => switch (@fieldParentPtr(ast.Node.PrefixOp, "base", res).op) {
- .BoolNot => return true,
-
- else => {},
- },
- .BoolLiteral => return true,
.GroupedExpression => return isBoolRes(@fieldParentPtr(ast.Node.GroupedExpression, "base", res).expr),
- else => {},
+
+ else => return false,
}
- return false;
}
fn finishBoolExpr(
@@ -2130,7 +2200,7 @@ fn transInitListExprRecord(
var raw_name = try rp.c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, field_decl)));
if (ZigClangFieldDecl_isAnonymousStructOrUnion(field_decl)) {
const name = rp.c.decl_table.get(@ptrToInt(ZigClangFieldDecl_getCanonicalDecl(field_decl))).?;
- raw_name = try mem.dupe(rp.c.arena, u8, name.value);
+ raw_name = try mem.dupe(rp.c.arena, u8, name);
}
const field_name_tok = try appendIdentifier(rp.c, raw_name);
@@ -2161,22 +2231,17 @@ fn transCreateNodeArrayType(
rp: RestorePoint,
source_loc: ZigClangSourceLocation,
ty: *const ZigClangType,
- len: var,
-) TransError!*ast.Node {
- var node = try transCreateNodePrefixOp(
- rp.c,
- .{
- .ArrayType = .{
- .len_expr = undefined,
- .sentinel = null,
- },
- },
- .LBracket,
- "[",
- );
- node.op.ArrayType.len_expr = try transCreateNodeInt(rp.c, len);
+ len: anytype,
+) !*ast.Node {
+ const node = try rp.c.arena.create(ast.Node.ArrayType);
+ const op_token = try appendToken(rp.c, .LBracket, "[");
+ const len_expr = try transCreateNodeInt(rp.c, len);
_ = try appendToken(rp.c, .RBracket, "]");
- node.rhs = try transType(rp, ty, source_loc);
+ node.* = .{
+ .op_token = op_token,
+ .rhs = try transType(rp, ty, source_loc),
+ .len_expr = len_expr,
+ };
return &node.base;
}
@@ -2244,11 +2309,11 @@ fn transInitListExprArray(
&filler_init_node.base
else blk: {
const mul_tok = try appendToken(rp.c, .AsteriskAsterisk, "**");
- const mul_node = try rp.c.arena.create(ast.Node.InfixOp);
+ const mul_node = try rp.c.arena.create(ast.Node.SimpleInfixOp);
mul_node.* = .{
+ .base = .{ .tag = .ArrayMult },
.op_token = mul_tok,
.lhs = &filler_init_node.base,
- .op = .ArrayMult,
.rhs = try transCreateNodeInt(rp.c, leftover_count),
};
break :blk &mul_node.base;
@@ -2258,11 +2323,11 @@ fn transInitListExprArray(
return rhs_node;
}
- const cat_node = try rp.c.arena.create(ast.Node.InfixOp);
+ const cat_node = try rp.c.arena.create(ast.Node.SimpleInfixOp);
cat_node.* = .{
+ .base = .{ .tag = .ArrayCat },
.op_token = cat_tok,
.lhs = &init_node.base,
- .op = .ArrayCat,
.rhs = rhs_node,
};
return &cat_node.base;
@@ -2449,7 +2514,7 @@ fn transDoWhileLoop(
},
};
defer cond_scope.deinit();
- const prefix_op = try transCreateNodePrefixOp(rp.c, .BoolNot, .Bang, "!");
+ const prefix_op = try transCreateNodeSimplePrefixOp(rp.c, .BoolNot, .Bang, "!");
prefix_op.rhs = try transBoolExpr(rp, &cond_scope.base, @ptrCast(*const ZigClangExpr, ZigClangDoStmt_getCond(stmt)), .used, .r_value, true);
_ = try appendToken(rp.c, .RParen, ")");
if_node.condition = &prefix_op.base;
@@ -2655,11 +2720,11 @@ fn transCase(
const ellips = try appendToken(rp.c, .Ellipsis3, "...");
const rhs_node = try transExpr(rp, scope, rhs, .used, .r_value);
- const node = try rp.c.arena.create(ast.Node.InfixOp);
+ const node = try rp.c.arena.create(ast.Node.SimpleInfixOp);
node.* = .{
+ .base = .{ .tag = .Range },
.op_token = ellips,
.lhs = lhs_node,
- .op = .Range,
.rhs = rhs_node,
};
break :blk &node.base;
@@ -2855,7 +2920,7 @@ fn transMemberExpr(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangMemberE
const field_decl = @ptrCast(*const struct_ZigClangFieldDecl, member_decl);
if (ZigClangFieldDecl_isAnonymousStructOrUnion(field_decl)) {
const name = rp.c.decl_table.get(@ptrToInt(ZigClangFieldDecl_getCanonicalDecl(field_decl))).?;
- break :blk try mem.dupe(rp.c.arena, u8, name.value);
+ break :blk try mem.dupe(rp.c.arena, u8, name);
}
}
const decl = @ptrCast(*const ZigClangNamedDecl, member_decl);
@@ -3036,7 +3101,7 @@ fn transUnaryOperator(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangUnar
else
return transCreatePreCrement(rp, scope, stmt, .AssignSub, .MinusEqual, "-=", used),
.AddrOf => {
- const op_node = try transCreateNodePrefixOp(rp.c, .AddressOf, .Ampersand, "&");
+ const op_node = try transCreateNodeSimplePrefixOp(rp.c, .AddressOf, .Ampersand, "&");
op_node.rhs = try transExpr(rp, scope, op_expr, used, .r_value);
return &op_node.base;
},
@@ -3052,7 +3117,7 @@ fn transUnaryOperator(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangUnar
.Plus => return transExpr(rp, scope, op_expr, used, .r_value),
.Minus => {
if (!qualTypeHasWrappingOverflow(ZigClangExpr_getType(op_expr))) {
- const op_node = try transCreateNodePrefixOp(rp.c, .Negation, .Minus, "-");
+ const op_node = try transCreateNodeSimplePrefixOp(rp.c, .Negation, .Minus, "-");
op_node.rhs = try transExpr(rp, scope, op_expr, .used, .r_value);
return &op_node.base;
} else if (cIsUnsignedInteger(ZigClangExpr_getType(op_expr))) {
@@ -3065,12 +3130,12 @@ fn transUnaryOperator(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangUnar
return revertAndWarn(rp, error.UnsupportedTranslation, ZigClangUnaryOperator_getBeginLoc(stmt), "C negation with non float non integer", .{});
},
.Not => {
- const op_node = try transCreateNodePrefixOp(rp.c, .BitNot, .Tilde, "~");
+ const op_node = try transCreateNodeSimplePrefixOp(rp.c, .BitNot, .Tilde, "~");
op_node.rhs = try transExpr(rp, scope, op_expr, .used, .r_value);
return &op_node.base;
},
.LNot => {
- const op_node = try transCreateNodePrefixOp(rp.c, .BoolNot, .Bang, "!");
+ const op_node = try transCreateNodeSimplePrefixOp(rp.c, .BoolNot, .Bang, "!");
op_node.rhs = try transBoolExpr(rp, scope, op_expr, .used, .r_value, true);
return &op_node.base;
},
@@ -3085,7 +3150,7 @@ fn transCreatePreCrement(
rp: RestorePoint,
scope: *Scope,
stmt: *const ZigClangUnaryOperator,
- op: ast.Node.InfixOp.Op,
+ op: ast.Node.Tag,
op_tok_id: std.zig.Token.Id,
bytes: []const u8,
used: ResultUsed,
@@ -3114,12 +3179,21 @@ fn transCreatePreCrement(
defer block_scope.deinit();
const ref = try block_scope.makeMangledName(rp.c, "ref");
- const node = try transCreateNodeVarDecl(rp.c, false, true, ref);
- node.eq_token = try appendToken(rp.c, .Equal, "=");
- const rhs_node = try transCreateNodePrefixOp(rp.c, .AddressOf, .Ampersand, "&");
+ const mut_tok = try appendToken(rp.c, .Keyword_const, "const");
+ const name_tok = try appendIdentifier(rp.c, ref);
+ const eq_token = try appendToken(rp.c, .Equal, "=");
+ const rhs_node = try transCreateNodeSimplePrefixOp(rp.c, .AddressOf, .Ampersand, "&");
rhs_node.rhs = try transExpr(rp, scope, op_expr, .used, .r_value);
- node.init_node = &rhs_node.base;
- node.semicolon_token = try appendToken(rp.c, .Semicolon, ";");
+ const init_node = &rhs_node.base;
+ const semicolon_token = try appendToken(rp.c, .Semicolon, ";");
+ const node = try ast.Node.VarDecl.create(rp.c.arena, .{
+ .name_token = name_tok,
+ .mut_token = mut_tok,
+ .semicolon_token = semicolon_token,
+ }, .{
+ .eq_token = eq_token,
+ .init_node = init_node,
+ });
try block_scope.statements.append(&node.base);
const lhs_node = try transCreateNodeIdentifier(rp.c, ref);
@@ -3150,7 +3224,7 @@ fn transCreatePostCrement(
rp: RestorePoint,
scope: *Scope,
stmt: *const ZigClangUnaryOperator,
- op: ast.Node.InfixOp.Op,
+ op: ast.Node.Tag,
op_tok_id: std.zig.Token.Id,
bytes: []const u8,
used: ResultUsed,
@@ -3180,12 +3254,21 @@ fn transCreatePostCrement(
defer block_scope.deinit();
const ref = try block_scope.makeMangledName(rp.c, "ref");
- const node = try transCreateNodeVarDecl(rp.c, false, true, ref);
- node.eq_token = try appendToken(rp.c, .Equal, "=");
- const rhs_node = try transCreateNodePrefixOp(rp.c, .AddressOf, .Ampersand, "&");
+ const mut_tok = try appendToken(rp.c, .Keyword_const, "const");
+ const name_tok = try appendIdentifier(rp.c, ref);
+ const eq_token = try appendToken(rp.c, .Equal, "=");
+ const rhs_node = try transCreateNodeSimplePrefixOp(rp.c, .AddressOf, .Ampersand, "&");
rhs_node.rhs = try transExpr(rp, scope, op_expr, .used, .r_value);
- node.init_node = &rhs_node.base;
- node.semicolon_token = try appendToken(rp.c, .Semicolon, ";");
+ const init_node = &rhs_node.base;
+ const semicolon_token = try appendToken(rp.c, .Semicolon, ";");
+ const node = try ast.Node.VarDecl.create(rp.c.arena, .{
+ .name_token = name_tok,
+ .mut_token = mut_tok,
+ .semicolon_token = semicolon_token,
+ }, .{
+ .eq_token = eq_token,
+ .init_node = init_node,
+ });
try block_scope.statements.append(&node.base);
const lhs_node = try transCreateNodeIdentifier(rp.c, ref);
@@ -3193,10 +3276,19 @@ fn transCreatePostCrement(
_ = try appendToken(rp.c, .Semicolon, ";");
const tmp = try block_scope.makeMangledName(rp.c, "tmp");
- const tmp_node = try transCreateNodeVarDecl(rp.c, false, true, tmp);
- tmp_node.eq_token = try appendToken(rp.c, .Equal, "=");
- tmp_node.init_node = ref_node;
- tmp_node.semicolon_token = try appendToken(rp.c, .Semicolon, ";");
+ const tmp_mut_tok = try appendToken(rp.c, .Keyword_const, "const");
+ const tmp_name_tok = try appendIdentifier(rp.c, tmp);
+ const tmp_eq_token = try appendToken(rp.c, .Equal, "=");
+ const tmp_init_node = ref_node;
+ const tmp_semicolon_token = try appendToken(rp.c, .Semicolon, ";");
+ const tmp_node = try ast.Node.VarDecl.create(rp.c.arena, .{
+ .name_token = tmp_name_tok,
+ .mut_token = tmp_mut_tok,
+ .semicolon_token = semicolon_token,
+ }, .{
+ .eq_token = tmp_eq_token,
+ .init_node = tmp_init_node,
+ });
try block_scope.statements.append(&tmp_node.base);
const token = try appendToken(rp.c, op_tok_id, bytes);
@@ -3254,10 +3346,10 @@ fn transCreateCompoundAssign(
rp: RestorePoint,
scope: *Scope,
stmt: *const ZigClangCompoundAssignOperator,
- assign_op: ast.Node.InfixOp.Op,
+ assign_op: ast.Node.Tag,
assign_tok_id: std.zig.Token.Id,
assign_bytes: []const u8,
- bin_op: ast.Node.InfixOp.Op,
+ bin_op: ast.Node.Tag,
bin_tok_id: std.zig.Token.Id,
bin_bytes: []const u8,
used: ResultUsed,
@@ -3268,14 +3360,21 @@ fn transCreateCompoundAssign(
const lhs = ZigClangCompoundAssignOperator_getLHS(stmt);
const rhs = ZigClangCompoundAssignOperator_getRHS(stmt);
const loc = ZigClangCompoundAssignOperator_getBeginLoc(stmt);
- const is_signed = cIsSignedInteger(getExprQualType(rp.c, lhs));
+ const lhs_qt = getExprQualType(rp.c, lhs);
+ const rhs_qt = getExprQualType(rp.c, rhs);
+ const is_signed = cIsSignedInteger(lhs_qt);
+ const requires_int_cast = blk: {
+ const are_integers = cIsInteger(lhs_qt) and cIsInteger(rhs_qt);
+ const are_same_sign = cIsSignedInteger(lhs_qt) == cIsSignedInteger(rhs_qt);
+ break :blk are_integers and !are_same_sign;
+ };
if (used == .unused) {
// common case
// c: lhs += rhs
// zig: lhs += rhs
if ((is_mod or is_div) and is_signed) {
const op_token = try appendToken(rp.c, .Equal, "=");
- const op_node = try rp.c.arena.create(ast.Node.InfixOp);
+ const op_node = try rp.c.arena.create(ast.Node.SimpleInfixOp);
const builtin = if (is_mod) "@rem" else "@divTrunc";
const builtin_node = try rp.c.createBuiltinCall(builtin, 2);
const lhs_node = try transExpr(rp, scope, lhs, .used, .l_value);
@@ -3284,9 +3383,9 @@ fn transCreateCompoundAssign(
builtin_node.params()[1] = try transExpr(rp, scope, rhs, .used, .r_value);
builtin_node.rparen_token = try appendToken(rp.c, .RParen, ")");
op_node.* = .{
+ .base = .{ .tag = .Assign },
.op_token = op_token,
.lhs = lhs_node,
- .op = .Assign,
.rhs = &builtin_node.base,
};
_ = try appendToken(rp.c, .Semicolon, ";");
@@ -3295,15 +3394,18 @@ fn transCreateCompoundAssign(
const lhs_node = try transExpr(rp, scope, lhs, .used, .l_value);
const eq_token = try appendToken(rp.c, assign_tok_id, assign_bytes);
- var rhs_node = if (is_shift)
+ var rhs_node = if (is_shift or requires_int_cast)
try transExprCoercing(rp, scope, rhs, .used, .r_value)
else
try transExpr(rp, scope, rhs, .used, .r_value);
- if (is_shift) {
+ if (is_shift or requires_int_cast) {
const cast_node = try rp.c.createBuiltinCall("@intCast", 2);
- const rhs_type = try qualTypeToLog2IntRef(rp, getExprQualType(rp.c, rhs), loc);
- cast_node.params()[0] = rhs_type;
+ const cast_to_type = if (is_shift)
+ try qualTypeToLog2IntRef(rp, getExprQualType(rp.c, rhs), loc)
+ else
+ try transQualType(rp, getExprQualType(rp.c, lhs), loc);
+ cast_node.params()[0] = cast_to_type;
_ = try appendToken(rp.c, .Comma, ",");
cast_node.params()[1] = rhs_node;
cast_node.rparen_token = try appendToken(rp.c, .RParen, ")");
@@ -3324,12 +3426,21 @@ fn transCreateCompoundAssign(
defer block_scope.deinit();
const ref = try block_scope.makeMangledName(rp.c, "ref");
- const node = try transCreateNodeVarDecl(rp.c, false, true, ref);
- node.eq_token = try appendToken(rp.c, .Equal, "=");
- const addr_node = try transCreateNodePrefixOp(rp.c, .AddressOf, .Ampersand, "&");
+ const mut_tok = try appendToken(rp.c, .Keyword_const, "const");
+ const name_tok = try appendIdentifier(rp.c, ref);
+ const eq_token = try appendToken(rp.c, .Equal, "=");
+ const addr_node = try transCreateNodeSimplePrefixOp(rp.c, .AddressOf, .Ampersand, "&");
addr_node.rhs = try transExpr(rp, scope, lhs, .used, .l_value);
- node.init_node = &addr_node.base;
- node.semicolon_token = try appendToken(rp.c, .Semicolon, ";");
+ const init_node = &addr_node.base;
+ const semicolon_token = try appendToken(rp.c, .Semicolon, ";");
+ const node = try ast.Node.VarDecl.create(rp.c.arena, .{
+ .name_token = name_tok,
+ .mut_token = mut_tok,
+ .semicolon_token = semicolon_token,
+ }, .{
+ .eq_token = eq_token,
+ .init_node = init_node,
+ });
try block_scope.statements.append(&node.base);
const lhs_node = try transCreateNodeIdentifier(rp.c, ref);
@@ -3338,7 +3449,7 @@ fn transCreateCompoundAssign(
if ((is_mod or is_div) and is_signed) {
const op_token = try appendToken(rp.c, .Equal, "=");
- const op_node = try rp.c.arena.create(ast.Node.InfixOp);
+ const op_node = try rp.c.arena.create(ast.Node.SimpleInfixOp);
const builtin = if (is_mod) "@rem" else "@divTrunc";
const builtin_node = try rp.c.createBuiltinCall(builtin, 2);
builtin_node.params()[0] = try transCreateNodePtrDeref(rp.c, lhs_node);
@@ -3347,9 +3458,9 @@ fn transCreateCompoundAssign(
builtin_node.rparen_token = try appendToken(rp.c, .RParen, ")");
_ = try appendToken(rp.c, .Semicolon, ";");
op_node.* = .{
+ .base = .{ .tag = .Assign },
.op_token = op_token,
.lhs = ref_node,
- .op = .Assign,
.rhs = &builtin_node.base,
};
_ = try appendToken(rp.c, .Semicolon, ";");
@@ -3358,10 +3469,13 @@ fn transCreateCompoundAssign(
const bin_token = try appendToken(rp.c, bin_tok_id, bin_bytes);
var rhs_node = try transExpr(rp, scope, rhs, .used, .r_value);
- if (is_shift) {
+ if (is_shift or requires_int_cast) {
const cast_node = try rp.c.createBuiltinCall("@intCast", 2);
- const rhs_type = try qualTypeToLog2IntRef(rp, getExprQualType(rp.c, rhs), loc);
- cast_node.params()[0] = rhs_type;
+ const cast_to_type = if (is_shift)
+ try qualTypeToLog2IntRef(rp, getExprQualType(rp.c, rhs), loc)
+ else
+ try transQualType(rp, getExprQualType(rp.c, lhs), loc);
+ cast_node.params()[0] = cast_to_type;
_ = try appendToken(rp.c, .Comma, ",");
cast_node.params()[1] = rhs_node;
cast_node.rparen_token = try appendToken(rp.c, .RParen, ")");
@@ -3371,8 +3485,8 @@ fn transCreateCompoundAssign(
const rhs_bin = try transCreateNodeInfixOp(rp, scope, ref_node, bin_op, bin_token, rhs_node, .used, false);
_ = try appendToken(rp.c, .Semicolon, ";");
- const eq_token = try appendToken(rp.c, .Equal, "=");
- const assign = try transCreateNodeInfixOp(rp, scope, ref_node, .Assign, eq_token, rhs_bin, .used, false);
+ const ass_eq_token = try appendToken(rp.c, .Equal, "=");
+ const assign = try transCreateNodeInfixOp(rp, scope, ref_node, .Assign, ass_eq_token, rhs_bin, .used, false);
try block_scope.statements.append(assign);
}
@@ -3490,10 +3604,19 @@ fn transBinaryConditionalOperator(rp: RestorePoint, scope: *Scope, stmt: *const
defer block_scope.deinit();
const mangled_name = try block_scope.makeMangledName(rp.c, "cond_temp");
- const tmp_var = try transCreateNodeVarDecl(rp.c, false, true, mangled_name);
- tmp_var.eq_token = try appendToken(rp.c, .Equal, "=");
- tmp_var.init_node = try transExpr(rp, &block_scope.base, cond_expr, .used, .r_value);
- tmp_var.semicolon_token = try appendToken(rp.c, .Semicolon, ";");
+ const mut_tok = try appendToken(rp.c, .Keyword_const, "const");
+ const name_tok = try appendIdentifier(rp.c, mangled_name);
+ const eq_token = try appendToken(rp.c, .Equal, "=");
+ const init_node = try transExpr(rp, &block_scope.base, cond_expr, .used, .r_value);
+ const semicolon_token = try appendToken(rp.c, .Semicolon, ";");
+ const tmp_var = try ast.Node.VarDecl.create(rp.c.arena, .{
+ .name_token = name_tok,
+ .mut_token = mut_tok,
+ .semicolon_token = semicolon_token,
+ }, .{
+ .eq_token = eq_token,
+ .init_node = init_node,
+ });
try block_scope.statements.append(&tmp_var.base);
const break_node = try transCreateNodeBreakToken(rp.c, block_scope.label);
@@ -3590,11 +3713,11 @@ fn maybeSuppressResult(
}
const lhs = try transCreateNodeIdentifier(rp.c, "_");
const op_token = try appendToken(rp.c, .Equal, "=");
- const op_node = try rp.c.arena.create(ast.Node.InfixOp);
+ const op_node = try rp.c.arena.create(ast.Node.SimpleInfixOp);
op_node.* = .{
+ .base = .{ .tag = .Assign },
.op_token = op_token,
.lhs = lhs,
- .op = .Assign,
.rhs = result,
};
return &op_node.base;
@@ -3928,9 +4051,9 @@ fn transCreateNodeAssign(
defer block_scope.deinit();
const tmp = try block_scope.makeMangledName(rp.c, "tmp");
-
- const node = try transCreateNodeVarDecl(rp.c, false, true, tmp);
- node.eq_token = try appendToken(rp.c, .Equal, "=");
+ const mut_tok = try appendToken(rp.c, .Keyword_const, "const");
+ const name_tok = try appendIdentifier(rp.c, tmp);
+ const eq_token = try appendToken(rp.c, .Equal, "=");
var rhs_node = try transExpr(rp, &block_scope.base, rhs, .used, .r_value);
if (!exprIsBooleanType(lhs) and isBoolRes(rhs_node)) {
const builtin_node = try rp.c.createBuiltinCall("@boolToInt", 1);
@@ -3938,16 +4061,24 @@ fn transCreateNodeAssign(
builtin_node.rparen_token = try appendToken(rp.c, .RParen, ")");
rhs_node = &builtin_node.base;
}
- node.init_node = rhs_node;
- node.semicolon_token = try appendToken(rp.c, .Semicolon, ";");
+ const init_node = rhs_node;
+ const semicolon_token = try appendToken(rp.c, .Semicolon, ";");
+ const node = try ast.Node.VarDecl.create(rp.c.arena, .{
+ .name_token = name_tok,
+ .mut_token = mut_tok,
+ .semicolon_token = semicolon_token,
+ }, .{
+ .eq_token = eq_token,
+ .init_node = init_node,
+ });
try block_scope.statements.append(&node.base);
const lhs_node = try transExpr(rp, &block_scope.base, lhs, .used, .l_value);
- const eq_token = try appendToken(rp.c, .Equal, "=");
+ const lhs_eq_token = try appendToken(rp.c, .Equal, "=");
const ident = try transCreateNodeIdentifier(rp.c, tmp);
_ = try appendToken(rp.c, .Semicolon, ";");
- const assign = try transCreateNodeInfixOp(rp, &block_scope.base, lhs_node, .Assign, eq_token, ident, .used, false);
+ const assign = try transCreateNodeInfixOp(rp, &block_scope.base, lhs_node, .Assign, lhs_eq_token, ident, .used, false);
try block_scope.statements.append(assign);
const break_node = try transCreateNodeBreak(rp.c, label_name);
@@ -3961,26 +4092,26 @@ fn transCreateNodeAssign(
}
fn transCreateNodeFieldAccess(c: *Context, container: *ast.Node, field_name: []const u8) !*ast.Node {
- const field_access_node = try c.arena.create(ast.Node.InfixOp);
+ const field_access_node = try c.arena.create(ast.Node.SimpleInfixOp);
field_access_node.* = .{
+ .base = .{ .tag = .Period },
.op_token = try appendToken(c, .Period, "."),
.lhs = container,
- .op = .Period,
.rhs = try transCreateNodeIdentifier(c, field_name),
};
return &field_access_node.base;
}
-fn transCreateNodePrefixOp(
+fn transCreateNodeSimplePrefixOp(
c: *Context,
- op: ast.Node.PrefixOp.Op,
+ comptime tag: ast.Node.Tag,
op_tok_id: std.zig.Token.Id,
bytes: []const u8,
-) !*ast.Node.PrefixOp {
- const node = try c.arena.create(ast.Node.PrefixOp);
+) !*ast.Node.SimplePrefixOp {
+ const node = try c.arena.create(ast.Node.SimplePrefixOp);
node.* = .{
+ .base = .{ .tag = tag },
.op_token = try appendToken(c, op_tok_id, bytes),
- .op = op,
.rhs = undefined, // translate and set afterward
};
return node;
@@ -3990,7 +4121,7 @@ fn transCreateNodeInfixOp(
rp: RestorePoint,
scope: *Scope,
lhs_node: *ast.Node,
- op: ast.Node.InfixOp.Op,
+ op: ast.Node.Tag,
op_token: ast.TokenIndex,
rhs_node: *ast.Node,
used: ResultUsed,
@@ -4000,11 +4131,11 @@ fn transCreateNodeInfixOp(
try appendToken(rp.c, .LParen, "(")
else
null;
- const node = try rp.c.arena.create(ast.Node.InfixOp);
+ const node = try rp.c.arena.create(ast.Node.SimpleInfixOp);
node.* = .{
+ .base = .{ .tag = op },
.op_token = op_token,
.lhs = lhs_node,
- .op = op,
.rhs = rhs_node,
};
if (!grouped) return maybeSuppressResult(rp, scope, used, &node.base);
@@ -4022,7 +4153,7 @@ fn transCreateNodeBoolInfixOp(
rp: RestorePoint,
scope: *Scope,
stmt: *const ZigClangBinaryOperator,
- op: ast.Node.InfixOp.Op,
+ op: ast.Node.Tag,
used: ResultUsed,
grouped: bool,
) !*ast.Node {
@@ -4052,8 +4183,8 @@ fn transCreateNodePtrType(
is_const: bool,
is_volatile: bool,
op_tok_id: std.zig.Token.Id,
-) !*ast.Node.PrefixOp {
- const node = try c.arena.create(ast.Node.PrefixOp);
+) !*ast.Node.PtrType {
+ const node = try c.arena.create(ast.Node.PtrType);
const op_token = switch (op_tok_id) {
.LBracket => blk: {
const lbracket = try appendToken(c, .LBracket, "[");
@@ -4073,11 +4204,9 @@ fn transCreateNodePtrType(
};
node.* = .{
.op_token = op_token,
- .op = .{
- .PtrType = .{
- .const_token = if (is_const) try appendToken(c, .Keyword_const, "const") else null,
- .volatile_token = if (is_volatile) try appendToken(c, .Keyword_volatile, "volatile") else null,
- },
+ .ptr_info = .{
+ .const_token = if (is_const) try appendToken(c, .Keyword_const, "const") else null,
+ .volatile_token = if (is_volatile) try appendToken(c, .Keyword_volatile, "volatile") else null,
},
.rhs = undefined, // translate and set afterward
};
@@ -4174,7 +4303,7 @@ fn transCreateNodeBoolLiteral(c: *Context, value: bool) !*ast.Node {
return &node.base;
}
-fn transCreateNodeInt(c: *Context, int: var) !*ast.Node {
+fn transCreateNodeInt(c: *Context, int: anytype) !*ast.Node {
const token = try appendTokenFmt(c, .IntegerLiteral, "{}", .{int});
const node = try c.arena.create(ast.Node.IntegerLiteral);
node.* = .{
@@ -4183,7 +4312,7 @@ fn transCreateNodeInt(c: *Context, int: var) !*ast.Node {
return &node.base;
}
-fn transCreateNodeFloat(c: *Context, int: var) !*ast.Node {
+fn transCreateNodeFloat(c: *Context, int: anytype) !*ast.Node {
const token = try appendTokenFmt(c, .FloatLiteral, "{}", .{int});
const node = try c.arena.create(ast.Node.FloatLiteral);
node.* = .{
@@ -4231,28 +4360,10 @@ fn transCreateNodeMacroFn(c: *Context, name: []const u8, ref: *ast.Node, proto_a
_ = try appendToken(c, .RParen, ")");
- const fn_proto = try ast.Node.FnProto.alloc(c.arena, fn_params.items.len);
- fn_proto.* = .{
- .doc_comments = null,
- .visib_token = pub_tok,
- .fn_token = fn_tok,
- .name_token = name_tok,
- .params_len = fn_params.items.len,
- .return_type = proto_alias.return_type,
- .var_args_token = null,
- .extern_export_inline_token = inline_tok,
- .body_node = null,
- .lib_name = null,
- .align_expr = null,
- .section_expr = null,
- .callconv_expr = null,
- };
- mem.copy(ast.Node.FnProto.ParamDecl, fn_proto.params(), fn_params.items);
-
const block_lbrace = try appendToken(c, .LBrace, "{");
const return_expr = try transCreateNodeReturnExpr(c);
- const unwrap_expr = try transCreateNodeUnwrapNull(c, ref.cast(ast.Node.VarDecl).?.init_node.?);
+ const unwrap_expr = try transCreateNodeUnwrapNull(c, ref.cast(ast.Node.VarDecl).?.getTrailer("init_node").?);
const call_expr = try c.createCall(unwrap_expr, fn_params.items.len);
const call_params = call_expr.params();
@@ -4276,7 +4387,18 @@ fn transCreateNodeMacroFn(c: *Context, name: []const u8, ref: *ast.Node, proto_a
.rbrace = try appendToken(c, .RBrace, "}"),
};
block.statements()[0] = &return_expr.base;
- fn_proto.body_node = &block.base;
+
+ const fn_proto = try ast.Node.FnProto.create(c.arena, .{
+ .params_len = fn_params.items.len,
+ .fn_token = fn_tok,
+ .return_type = proto_alias.return_type,
+ }, .{
+ .visib_token = pub_tok,
+ .name_token = name_tok,
+ .extern_export_inline_token = inline_tok,
+ .body_node = &block.base,
+ });
+ mem.copy(ast.Node.FnProto.ParamDecl, fn_proto.params(), fn_params.items);
return &fn_proto.base;
}
@@ -4355,31 +4477,6 @@ fn transCreateNodeBreak(c: *Context, label: ?[]const u8) !*ast.Node.ControlFlowE
return node;
}
-fn transCreateNodeVarDecl(c: *Context, is_pub: bool, is_const: bool, name: []const u8) !*ast.Node.VarDecl {
- const visib_tok = if (is_pub) try appendToken(c, .Keyword_pub, "pub") else null;
- const mut_tok = if (is_const) try appendToken(c, .Keyword_const, "const") else try appendToken(c, .Keyword_var, "var");
- const name_tok = try appendIdentifier(c, name);
-
- const node = try c.arena.create(ast.Node.VarDecl);
- node.* = .{
- .doc_comments = null,
- .visib_token = visib_tok,
- .thread_local_token = null,
- .name_token = name_tok,
- .eq_token = undefined,
- .mut_token = mut_tok,
- .comptime_token = null,
- .extern_export_token = null,
- .lib_name = null,
- .type_node = null,
- .align_node = null,
- .section_node = null,
- .init_node = null,
- .semicolon_token = undefined,
- };
- return node;
-}
-
fn transCreateNodeWhile(c: *Context) !*ast.Node.While {
const while_tok = try appendToken(c, .Keyword_while, "while");
_ = try appendToken(c, .LParen, "(");
@@ -4436,7 +4533,7 @@ fn transCreateNodeShiftOp(
rp: RestorePoint,
scope: *Scope,
stmt: *const ZigClangBinaryOperator,
- op: ast.Node.InfixOp.Op,
+ op: ast.Node.Tag,
op_tok_id: std.zig.Token.Id,
bytes: []const u8,
) !*ast.Node {
@@ -4458,11 +4555,11 @@ fn transCreateNodeShiftOp(
cast_node.params()[1] = rhs;
cast_node.rparen_token = try appendToken(rp.c, .RParen, ")");
- const node = try rp.c.arena.create(ast.Node.InfixOp);
+ const node = try rp.c.arena.create(ast.Node.SimpleInfixOp);
node.* = .{
+ .base = .{ .tag = op },
.op_token = op_token,
.lhs = lhs,
- .op = op,
.rhs = &cast_node.base,
};
@@ -4556,12 +4653,12 @@ fn transType(rp: RestorePoint, ty: *const ZigClangType, source_loc: ZigClangSour
.Pointer => {
const child_qt = ZigClangType_getPointeeType(ty);
if (qualTypeChildIsFnProto(child_qt)) {
- const optional_node = try transCreateNodePrefixOp(rp.c, .OptionalType, .QuestionMark, "?");
+ const optional_node = try transCreateNodeSimplePrefixOp(rp.c, .OptionalType, .QuestionMark, "?");
optional_node.rhs = try transQualType(rp, child_qt, source_loc);
return &optional_node.base;
}
if (typeIsOpaque(rp.c, ZigClangQualType_getTypePtr(child_qt), source_loc)) {
- const optional_node = try transCreateNodePrefixOp(rp.c, .OptionalType, .QuestionMark, "?");
+ const optional_node = try transCreateNodeSimplePrefixOp(rp.c, .OptionalType, .QuestionMark, "?");
const pointer_node = try transCreateNodePtrType(
rp.c,
ZigClangQualType_isConstQualified(child_qt),
@@ -4586,21 +4683,8 @@ fn transType(rp: RestorePoint, ty: *const ZigClangType, source_loc: ZigClangSour
const size_ap_int = ZigClangConstantArrayType_getSize(const_arr_ty);
const size = ZigClangAPInt_getLimitedValue(size_ap_int, math.maxInt(usize));
- var node = try transCreateNodePrefixOp(
- rp.c,
- .{
- .ArrayType = .{
- .len_expr = undefined,
- .sentinel = null,
- },
- },
- .LBracket,
- "[",
- );
- node.op.ArrayType.len_expr = try transCreateNodeInt(rp.c, size);
- _ = try appendToken(rp.c, .RBracket, "]");
- node.rhs = try transQualType(rp, ZigClangConstantArrayType_getElementType(const_arr_ty), source_loc);
- return &node.base;
+ const elem_ty = ZigClangQualType_getTypePtr(ZigClangConstantArrayType_getElementType(const_arr_ty));
+ return try transCreateNodeArrayType(rp, source_loc, elem_ty, size);
},
.IncompleteArray => {
const incomplete_array_ty = @ptrCast(*const ZigClangIncompleteArrayType, ty);
@@ -4794,19 +4878,12 @@ fn finishTransFnProto(
}
}
- if (is_var_args) {
+ const var_args_token: ?ast.TokenIndex = if (is_var_args) blk: {
if (param_count > 0) {
_ = try appendToken(rp.c, .Comma, ",");
}
-
- fn_params.addOneAssumeCapacity().* = .{
- .doc_comments = null,
- .comptime_token = null,
- .noalias_token = null,
- .name_token = null,
- .param_type = .{ .var_args = try appendToken(rp.c, .Ellipsis3, "...") },
- };
- }
+ break :blk try appendToken(rp.c, .Ellipsis3, "...");
+ } else null;
const rparen_tok = try appendToken(rp.c, .RParen, ")");
@@ -4872,44 +4949,53 @@ fn finishTransFnProto(
}
};
- const fn_proto = try ast.Node.FnProto.alloc(rp.c.arena, fn_params.items.len);
- fn_proto.* = .{
- .doc_comments = null,
- .visib_token = pub_tok,
- .fn_token = fn_tok,
- .name_token = name_tok,
+ // We need to reserve an undefined (but non-null) body node to set later.
+ var body_node: ?*ast.Node = null;
+ if (fn_decl_context) |ctx| {
+ if (ctx.has_body) {
+ // TODO: we should be able to use undefined here but
+ // it causes a bug. This is undefined without zig language
+ // being aware of it.
+ body_node = @intToPtr(*ast.Node, 0x08);
+ }
+ }
+
+ const fn_proto = try ast.Node.FnProto.create(rp.c.arena, .{
.params_len = fn_params.items.len,
.return_type = .{ .Explicit = return_type_node },
- .var_args_token = null, // TODO this field is broken in the AST data model
+ .fn_token = fn_tok,
+ }, .{
+ .visib_token = pub_tok,
+ .name_token = name_tok,
.extern_export_inline_token = extern_export_inline_tok,
- .body_node = null,
- .lib_name = null,
.align_expr = align_expr,
.section_expr = linksection_expr,
.callconv_expr = callconv_expr,
- };
+ .body_node = body_node,
+ .var_args_token = var_args_token,
+ });
mem.copy(ast.Node.FnProto.ParamDecl, fn_proto.params(), fn_params.items);
return fn_proto;
}
fn revertAndWarn(
rp: RestorePoint,
- err: var,
+ err: anytype,
source_loc: ZigClangSourceLocation,
comptime format: []const u8,
- args: var,
+ args: anytype,
) (@TypeOf(err) || error{OutOfMemory}) {
rp.activate();
try emitWarning(rp.c, source_loc, format, args);
return err;
}
-fn emitWarning(c: *Context, loc: ZigClangSourceLocation, comptime format: []const u8, args: var) !void {
+fn emitWarning(c: *Context, loc: ZigClangSourceLocation, comptime format: []const u8, args: anytype) !void {
const args_prefix = .{c.locStr(loc)};
_ = try appendTokenFmt(c, .LineComment, "// {}: warning: " ++ format, args_prefix ++ args);
}
-pub fn failDecl(c: *Context, loc: ZigClangSourceLocation, name: []const u8, comptime format: []const u8, args: var) !void {
+pub fn failDecl(c: *Context, loc: ZigClangSourceLocation, name: []const u8, comptime format: []const u8, args: anytype) !void {
// pub const name = @compileError(msg);
const pub_tok = try appendToken(c, .Keyword_pub, "pub");
const const_tok = try appendToken(c, .Keyword_const, "const");
@@ -4935,23 +5021,15 @@ pub fn failDecl(c: *Context, loc: ZigClangSourceLocation, name: []const u8, comp
};
call_node.params()[0] = &msg_node.base;
- const var_decl_node = try c.arena.create(ast.Node.VarDecl);
- var_decl_node.* = .{
- .doc_comments = null,
- .visib_token = pub_tok,
- .thread_local_token = null,
+ const var_decl_node = try ast.Node.VarDecl.create(c.arena, .{
.name_token = name_tok,
- .eq_token = eq_tok,
.mut_token = const_tok,
- .comptime_token = null,
- .extern_export_token = null,
- .lib_name = null,
- .type_node = null,
- .align_node = null,
- .section_node = null,
- .init_node = &call_node.base,
.semicolon_token = semi_tok,
- };
+ }, .{
+ .visib_token = pub_tok,
+ .eq_token = eq_tok,
+ .init_node = &call_node.base,
+ });
try addTopLevelDecl(c, name, &var_decl_node.base);
}
@@ -4960,7 +5038,7 @@ fn appendToken(c: *Context, token_id: Token.Id, bytes: []const u8) !ast.TokenInd
return appendTokenFmt(c, token_id, "{}", .{bytes});
}
-fn appendTokenFmt(c: *Context, token_id: Token.Id, comptime format: []const u8, args: var) !ast.TokenIndex {
+fn appendTokenFmt(c: *Context, token_id: Token.Id, comptime format: []const u8, args: anytype) !ast.TokenIndex {
assert(token_id != .Invalid);
try c.token_ids.ensureCapacity(c.gpa, c.token_ids.items.len + 1);
@@ -5144,10 +5222,12 @@ fn transPreprocessorEntities(c: *Context, unit: *ZigClangASTUnit) Error!void {
fn transMacroDefine(c: *Context, it: *CTokenList.Iterator, source: []const u8, name: []const u8, source_loc: ZigClangSourceLocation) ParseError!void {
const scope = &c.global_scope.base;
- const node = try transCreateNodeVarDecl(c, true, true, name);
- node.eq_token = try appendToken(c, .Equal, "=");
+ const visib_tok = try appendToken(c, .Keyword_pub, "pub");
+ const mut_tok = try appendToken(c, .Keyword_const, "const");
+ const name_tok = try appendIdentifier(c, name);
+ const eq_token = try appendToken(c, .Equal, "=");
- node.init_node = try parseCExpr(c, it, source, source_loc, scope);
+ const init_node = try parseCExpr(c, it, source, source_loc, scope);
const last = it.next().?;
if (last.id != .Eof and last.id != .Nl)
return failDecl(
@@ -5158,7 +5238,16 @@ fn transMacroDefine(c: *Context, it: *CTokenList.Iterator, source: []const u8, n
.{@tagName(last.id)},
);
- node.semicolon_token = try appendToken(c, .Semicolon, ";");
+ const semicolon_token = try appendToken(c, .Semicolon, ";");
+ const node = try ast.Node.VarDecl.create(c.arena, .{
+ .name_token = name_tok,
+ .mut_token = mut_tok,
+ .semicolon_token = semicolon_token,
+ }, .{
+ .visib_token = visib_tok,
+ .eq_token = eq_token,
+ .init_node = init_node,
+ });
_ = try c.global_scope.macro_table.put(name, &node.base);
}
@@ -5202,10 +5291,9 @@ fn transMacroFnDefine(c: *Context, it: *CTokenList.Iterator, source: []const u8,
const param_name_tok = try appendIdentifier(c, mangled_name);
_ = try appendToken(c, .Colon, ":");
- const token_index = try appendToken(c, .Keyword_var, "var");
- const identifier = try c.arena.create(ast.Node.Identifier);
- identifier.* = .{
- .token = token_index,
+ const any_type = try c.arena.create(ast.Node.AnyType);
+ any_type.* = .{
+ .token = try appendToken(c, .Keyword_anytype, "anytype"),
};
(try fn_params.addOne()).* = .{
@@ -5213,7 +5301,7 @@ fn transMacroFnDefine(c: *Context, it: *CTokenList.Iterator, source: []const u8,
.comptime_token = null,
.noalias_token = null,
.name_token = param_name_tok,
- .param_type = .{ .type_expr = &identifier.base },
+ .param_type = .{ .any_type = &any_type.base },
};
if (it.peek().?.id != .Comma)
@@ -5236,24 +5324,6 @@ fn transMacroFnDefine(c: *Context, it: *CTokenList.Iterator, source: []const u8,
const type_of = try c.createBuiltinCall("@TypeOf", 1);
- const fn_proto = try ast.Node.FnProto.alloc(c.arena, fn_params.items.len);
- fn_proto.* = .{
- .visib_token = pub_tok,
- .extern_export_inline_token = inline_tok,
- .fn_token = fn_tok,
- .name_token = name_tok,
- .params_len = fn_params.items.len,
- .return_type = .{ .Explicit = &type_of.base },
- .doc_comments = null,
- .var_args_token = null,
- .body_node = null,
- .lib_name = null,
- .align_expr = null,
- .section_expr = null,
- .callconv_expr = null,
- };
- mem.copy(ast.Node.FnProto.ParamDecl, fn_proto.params(), fn_params.items);
-
const return_expr = try transCreateNodeReturnExpr(c);
const expr = try parseCExpr(c, it, source, source_loc, scope);
const last = it.next().?;
@@ -5266,10 +5336,10 @@ fn transMacroFnDefine(c: *Context, it: *CTokenList.Iterator, source: []const u8,
.{@tagName(last.id)},
);
_ = try appendToken(c, .Semicolon, ";");
- const type_of_arg = if (expr.id != .Block) expr else blk: {
+ const type_of_arg = if (expr.tag != .Block) expr else blk: {
const blk = @fieldParentPtr(ast.Node.Block, "base", expr);
const blk_last = blk.statements()[blk.statements_len - 1];
- std.debug.assert(blk_last.id == .ControlFlowExpression);
+ std.debug.assert(blk_last.tag == .ControlFlowExpression);
const br = @fieldParentPtr(ast.Node.ControlFlowExpression, "base", blk_last);
break :blk br.rhs.?;
};
@@ -5279,7 +5349,18 @@ fn transMacroFnDefine(c: *Context, it: *CTokenList.Iterator, source: []const u8,
try block_scope.statements.append(&return_expr.base);
const block_node = try block_scope.complete(c);
- fn_proto.body_node = &block_node.base;
+ const fn_proto = try ast.Node.FnProto.create(c.arena, .{
+ .fn_token = fn_tok,
+ .params_len = fn_params.items.len,
+ .return_type = .{ .Explicit = &type_of.base },
+ }, .{
+ .visib_token = pub_tok,
+ .extern_export_inline_token = inline_tok,
+ .name_token = name_tok,
+ .body_node = &block_node.base,
+ });
+ mem.copy(ast.Node.FnProto.ParamDecl, fn_proto.params(), fn_params.items);
+
_ = try c.global_scope.macro_table.put(name, &fn_proto.base);
}
@@ -5320,11 +5401,11 @@ fn parseCExpr(c: *Context, it: *CTokenList.Iterator, source: []const u8, source_
// suppress result
const lhs = try transCreateNodeIdentifier(c, "_");
const op_token = try appendToken(c, .Equal, "=");
- const op_node = try c.arena.create(ast.Node.InfixOp);
+ const op_node = try c.arena.create(ast.Node.SimpleInfixOp);
op_node.* = .{
+ .base = .{ .tag = .Assign },
.op_token = op_token,
.lhs = lhs,
- .op = .Assign,
.rhs = last,
};
try block_scope.statements.append(&op_node.base);
@@ -5668,161 +5749,23 @@ fn parseCPrimaryExpr(c: *Context, it: *CTokenList.Iterator, source: []const u8,
const lparen = try appendToken(c, .LParen, "(");
- if (saw_integer_literal) {
- //( if (@typeInfo(dest) == .Pointer))
- // @intToPtr(dest, x)
- //else
- // @as(dest, x) )
- const if_node = try transCreateNodeIf(c);
- const type_info_node = try c.createBuiltinCall("@typeInfo", 1);
- type_info_node.params()[0] = inner_node;
- type_info_node.rparen_token = try appendToken(c, .LParen, ")");
- const cmp_node = try c.arena.create(ast.Node.InfixOp);
- cmp_node.* = .{
- .op_token = try appendToken(c, .EqualEqual, "=="),
- .lhs = &type_info_node.base,
- .op = .EqualEqual,
- .rhs = try transCreateNodeEnumLiteral(c, "Pointer"),
- };
- if_node.condition = &cmp_node.base;
- _ = try appendToken(c, .RParen, ")");
+ //(@import("std").meta.cast(dest, x))
+ const import_fn_call = try c.createBuiltinCall("@import", 1);
+ const std_node = try transCreateNodeStringLiteral(c, "\"std\"");
+ import_fn_call.params()[0] = std_node;
+ import_fn_call.rparen_token = try appendToken(c, .RParen, ")");
+ const inner_field_access = try transCreateNodeFieldAccess(c, &import_fn_call.base, "meta");
+ const outer_field_access = try transCreateNodeFieldAccess(c, inner_field_access, "cast");
- const int_to_ptr = try c.createBuiltinCall("@intToPtr", 2);
- int_to_ptr.params()[0] = inner_node;
- int_to_ptr.params()[1] = node_to_cast;
- int_to_ptr.rparen_token = try appendToken(c, .RParen, ")");
- if_node.body = &int_to_ptr.base;
-
- const else_node = try transCreateNodeElse(c);
- if_node.@"else" = else_node;
-
- const as_node = try c.createBuiltinCall("@as", 2);
- as_node.params()[0] = inner_node;
- as_node.params()[1] = node_to_cast;
- as_node.rparen_token = try appendToken(c, .RParen, ")");
- else_node.body = &as_node.base;
-
- const group_node = try c.arena.create(ast.Node.GroupedExpression);
- group_node.* = .{
- .lparen = lparen,
- .expr = &if_node.base,
- .rparen = try appendToken(c, .RParen, ")"),
- };
- return &group_node.base;
- }
-
- //( if (@typeInfo(@TypeOf(x)) == .Pointer)
- // @ptrCast(dest, @alignCast(@alignOf(dest.Child), x))
- //else if (@typeInfo(@TypeOf(x)) == .Int and @typeInfo(dest) == .Pointer))
- // @intToPtr(dest, x)
- //else
- // @as(dest, x) )
-
- const if_1 = try transCreateNodeIf(c);
- const type_info_1 = try c.createBuiltinCall("@typeInfo", 1);
- const type_of_1 = try c.createBuiltinCall("@TypeOf", 1);
- type_info_1.params()[0] = &type_of_1.base;
- type_of_1.params()[0] = node_to_cast;
- type_of_1.rparen_token = try appendToken(c, .RParen, ")");
- type_info_1.rparen_token = try appendToken(c, .RParen, ")");
-
- const cmp_1 = try c.arena.create(ast.Node.InfixOp);
- cmp_1.* = .{
- .op_token = try appendToken(c, .EqualEqual, "=="),
- .lhs = &type_info_1.base,
- .op = .EqualEqual,
- .rhs = try transCreateNodeEnumLiteral(c, "Pointer"),
- };
- if_1.condition = &cmp_1.base;
- _ = try appendToken(c, .RParen, ")");
-
- const period_tok = try appendToken(c, .Period, ".");
- const child_ident = try transCreateNodeIdentifier(c, "Child");
- const inner_node_child = try c.arena.create(ast.Node.InfixOp);
- inner_node_child.* = .{
- .op_token = period_tok,
- .lhs = inner_node,
- .op = .Period,
- .rhs = child_ident,
- };
-
- const align_of = try c.createBuiltinCall("@alignOf", 1);
- align_of.params()[0] = &inner_node_child.base;
- align_of.rparen_token = try appendToken(c, .RParen, ")");
- // hack to get zig fmt to render a comma in builtin calls
- _ = try appendToken(c, .Comma, ",");
-
- const align_cast = try c.createBuiltinCall("@alignCast", 2);
- align_cast.params()[0] = &align_of.base;
- align_cast.params()[1] = node_to_cast;
- align_cast.rparen_token = try appendToken(c, .RParen, ")");
-
- const ptr_cast = try c.createBuiltinCall("@ptrCast", 2);
- ptr_cast.params()[0] = inner_node;
- ptr_cast.params()[1] = &align_cast.base;
- ptr_cast.rparen_token = try appendToken(c, .RParen, ")");
- if_1.body = &ptr_cast.base;
-
- const else_1 = try transCreateNodeElse(c);
- if_1.@"else" = else_1;
-
- const if_2 = try transCreateNodeIf(c);
- const type_info_2 = try c.createBuiltinCall("@typeInfo", 1);
- const type_of_2 = try c.createBuiltinCall("@TypeOf", 1);
- type_info_2.params()[0] = &type_of_2.base;
- type_of_2.params()[0] = node_to_cast;
- type_of_2.rparen_token = try appendToken(c, .RParen, ")");
- type_info_2.rparen_token = try appendToken(c, .RParen, ")");
-
- const cmp_2 = try c.arena.create(ast.Node.InfixOp);
- cmp_2.* = .{
- .op_token = try appendToken(c, .EqualEqual, "=="),
- .lhs = &type_info_2.base,
- .op = .EqualEqual,
- .rhs = try transCreateNodeEnumLiteral(c, "Int"),
- };
- if_2.condition = &cmp_2.base;
- const cmp_4 = try c.arena.create(ast.Node.InfixOp);
- cmp_4.* = .{
- .op_token = try appendToken(c, .Keyword_and, "and"),
- .lhs = &cmp_2.base,
- .op = .BoolAnd,
- .rhs = undefined,
- };
- const type_info_3 = try c.createBuiltinCall("@typeInfo", 1);
- type_info_3.params()[0] = inner_node;
- type_info_3.rparen_token = try appendToken(c, .LParen, ")");
- const cmp_3 = try c.arena.create(ast.Node.InfixOp);
- cmp_3.* = .{
- .op_token = try appendToken(c, .EqualEqual, "=="),
- .lhs = &type_info_3.base,
- .op = .EqualEqual,
- .rhs = try transCreateNodeEnumLiteral(c, "Pointer"),
- };
- cmp_4.rhs = &cmp_3.base;
- if_2.condition = &cmp_4.base;
- else_1.body = &if_2.base;
- _ = try appendToken(c, .RParen, ")");
-
- const int_to_ptr = try c.createBuiltinCall("@intToPtr", 2);
- int_to_ptr.params()[0] = inner_node;
- int_to_ptr.params()[1] = node_to_cast;
- int_to_ptr.rparen_token = try appendToken(c, .RParen, ")");
- if_2.body = &int_to_ptr.base;
-
- const else_2 = try transCreateNodeElse(c);
- if_2.@"else" = else_2;
-
- const as = try c.createBuiltinCall("@as", 2);
- as.params()[0] = inner_node;
- as.params()[1] = node_to_cast;
- as.rparen_token = try appendToken(c, .RParen, ")");
- else_2.body = &as.base;
+ const cast_fn_call = try c.createCall(outer_field_access, 2);
+ cast_fn_call.params()[0] = inner_node;
+ cast_fn_call.params()[1] = node_to_cast;
+ cast_fn_call.rtoken = try appendToken(c, .RParen, ")");
const group_node = try c.arena.create(ast.Node.GroupedExpression);
group_node.* = .{
.lparen = lparen,
- .expr = &if_1.base,
+ .expr = &cast_fn_call.base,
.rparen = try appendToken(c, .RParen, ")"),
};
return &group_node.base;
@@ -5841,9 +5784,60 @@ fn parseCPrimaryExpr(c: *Context, it: *CTokenList.Iterator, source: []const u8,
}
}
+fn nodeIsInfixOp(tag: ast.Node.Tag) bool {
+ return switch (tag) {
+ .Add,
+ .AddWrap,
+ .ArrayCat,
+ .ArrayMult,
+ .Assign,
+ .AssignBitAnd,
+ .AssignBitOr,
+ .AssignBitShiftLeft,
+ .AssignBitShiftRight,
+ .AssignBitXor,
+ .AssignDiv,
+ .AssignSub,
+ .AssignSubWrap,
+ .AssignMod,
+ .AssignAdd,
+ .AssignAddWrap,
+ .AssignMul,
+ .AssignMulWrap,
+ .BangEqual,
+ .BitAnd,
+ .BitOr,
+ .BitShiftLeft,
+ .BitShiftRight,
+ .BitXor,
+ .BoolAnd,
+ .BoolOr,
+ .Div,
+ .EqualEqual,
+ .ErrorUnion,
+ .GreaterOrEqual,
+ .GreaterThan,
+ .LessOrEqual,
+ .LessThan,
+ .MergeErrorSets,
+ .Mod,
+ .Mul,
+ .MulWrap,
+ .Period,
+ .Range,
+ .Sub,
+ .SubWrap,
+ .UnwrapOptional,
+ .Catch,
+ => true,
+
+ else => false,
+ };
+}
+
fn macroBoolToInt(c: *Context, node: *ast.Node) !*ast.Node {
if (!isBoolRes(node)) {
- if (node.id != .InfixOp) return node;
+ if (!nodeIsInfixOp(node.tag)) return node;
const group_node = try c.arena.create(ast.Node.GroupedExpression);
group_node.* = .{
@@ -5862,7 +5856,7 @@ fn macroBoolToInt(c: *Context, node: *ast.Node) !*ast.Node {
fn macroIntToBool(c: *Context, node: *ast.Node) !*ast.Node {
if (isBoolRes(node)) {
- if (node.id != .InfixOp) return node;
+ if (!nodeIsInfixOp(node.tag)) return node;
const group_node = try c.arena.create(ast.Node.GroupedExpression);
group_node.* = .{
@@ -5875,11 +5869,11 @@ fn macroIntToBool(c: *Context, node: *ast.Node) !*ast.Node {
const op_token = try appendToken(c, .BangEqual, "!=");
const zero = try transCreateNodeInt(c, 0);
- const res = try c.arena.create(ast.Node.InfixOp);
+ const res = try c.arena.create(ast.Node.SimpleInfixOp);
res.* = .{
+ .base = .{ .tag = .BangEqual },
.op_token = op_token,
.lhs = node,
- .op = .BangEqual,
.rhs = zero,
};
const group_node = try c.arena.create(ast.Node.GroupedExpression);
@@ -5896,7 +5890,7 @@ fn parseCSuffixOpExpr(c: *Context, it: *CTokenList.Iterator, source: []const u8,
while (true) {
const tok = it.next().?;
var op_token: ast.TokenIndex = undefined;
- var op_id: ast.Node.InfixOp.Op = undefined;
+ var op_id: ast.Node.Tag = undefined;
var bool_op = false;
switch (tok.id) {
.Period => {
@@ -5950,7 +5944,7 @@ fn parseCSuffixOpExpr(c: *Context, it: *CTokenList.Iterator, source: []const u8,
if (prev_id == .Keyword_void) {
const ptr = try transCreateNodePtrType(c, false, false, .Asterisk);
ptr.rhs = node;
- const optional_node = try transCreateNodePrefixOp(c, .OptionalType, .QuestionMark, "?");
+ const optional_node = try transCreateNodeSimplePrefixOp(c, .OptionalType, .QuestionMark, "?");
optional_node.rhs = &ptr.base;
return &optional_node.base;
} else {
@@ -6067,6 +6061,61 @@ fn parseCSuffixOpExpr(c: *Context, it: *CTokenList.Iterator, source: []const u8,
node = &call_node.base;
continue;
},
+ .LBrace => {
+ // must come immediately after `node`
+ _ = try appendToken(c, .Comma, ",");
+
+ const dot = try appendToken(c, .Period, ".");
+ _ = try appendToken(c, .LBrace, "{");
+
+ var init_vals = std.ArrayList(*ast.Node).init(c.gpa);
+ defer init_vals.deinit();
+
+ while (true) {
+ const val = try parseCPrefixOpExpr(c, it, source, source_loc, scope);
+ try init_vals.append(val);
+ const next = it.next().?;
+ if (next.id == .Comma)
+ _ = try appendToken(c, .Comma, ",")
+ else if (next.id == .RBrace)
+ break
+ else {
+ const first_tok = it.list.at(0);
+ try failDecl(
+ c,
+ source_loc,
+ source[first_tok.start..first_tok.end],
+ "unable to translate C expr: expected ',' or '}}'",
+ .{},
+ );
+ return error.ParseError;
+ }
+ }
+ const tuple_node = try ast.Node.StructInitializerDot.alloc(c.arena, init_vals.items.len);
+ tuple_node.* = .{
+ .dot = dot,
+ .list_len = init_vals.items.len,
+ .rtoken = try appendToken(c, .RBrace, "}"),
+ };
+ mem.copy(*ast.Node, tuple_node.list(), init_vals.items);
+
+
+ //(@import("std").mem.zeroInit(T, .{x}))
+ const import_fn_call = try c.createBuiltinCall("@import", 1);
+ const std_node = try transCreateNodeStringLiteral(c, "\"std\"");
+ import_fn_call.params()[0] = std_node;
+ import_fn_call.rparen_token = try appendToken(c, .RParen, ")");
+ const inner_field_access = try transCreateNodeFieldAccess(c, &import_fn_call.base, "mem");
+ const outer_field_access = try transCreateNodeFieldAccess(c, inner_field_access, "zeroInit");
+
+ const zero_init_call = try c.createCall(outer_field_access, 2);
+ zero_init_call.params()[0] = node;
+ zero_init_call.params()[1] = &tuple_node.base;
+ zero_init_call.rtoken = try appendToken(c, .RParen, ")");
+
+ node = &zero_init_call.base;
+ continue;
+ },
.BangEqual => {
op_token = try appendToken(c, .BangEqual, "!=");
op_id = .BangEqual;
@@ -6103,11 +6152,11 @@ fn parseCSuffixOpExpr(c: *Context, it: *CTokenList.Iterator, source: []const u8,
const cast_fn = if (bool_op) macroIntToBool else macroBoolToInt;
const lhs_node = try cast_fn(c, node);
const rhs_node = try parseCPrefixOpExpr(c, it, source, source_loc, scope);
- const op_node = try c.arena.create(ast.Node.InfixOp);
+ const op_node = try c.arena.create(ast.Node.SimpleInfixOp);
op_node.* = .{
+ .base = .{ .tag = op_id },
.op_token = op_token,
.lhs = lhs_node,
- .op = op_id,
.rhs = try cast_fn(c, rhs_node),
};
node = &op_node.base;
@@ -6119,18 +6168,18 @@ fn parseCPrefixOpExpr(c: *Context, it: *CTokenList.Iterator, source: []const u8,
switch (op_tok.id) {
.Bang => {
- const node = try transCreateNodePrefixOp(c, .BoolNot, .Bang, "!");
+ const node = try transCreateNodeSimplePrefixOp(c, .BoolNot, .Bang, "!");
node.rhs = try parseCPrefixOpExpr(c, it, source, source_loc, scope);
return &node.base;
},
.Minus => {
- const node = try transCreateNodePrefixOp(c, .Negation, .Minus, "-");
+ const node = try transCreateNodeSimplePrefixOp(c, .Negation, .Minus, "-");
node.rhs = try parseCPrefixOpExpr(c, it, source, source_loc, scope);
return &node.base;
},
.Plus => return try parseCPrefixOpExpr(c, it, source, source_loc, scope),
.Tilde => {
- const node = try transCreateNodePrefixOp(c, .BitNot, .Tilde, "~");
+ const node = try transCreateNodeSimplePrefixOp(c, .BitNot, .Tilde, "~");
node.rhs = try parseCPrefixOpExpr(c, it, source, source_loc, scope);
return &node.base;
},
@@ -6139,7 +6188,7 @@ fn parseCPrefixOpExpr(c: *Context, it: *CTokenList.Iterator, source: []const u8,
return try transCreateNodePtrDeref(c, node);
},
.Ampersand => {
- const node = try transCreateNodePrefixOp(c, .AddressOf, .Ampersand, "&");
+ const node = try transCreateNodeSimplePrefixOp(c, .AddressOf, .Ampersand, "&");
node.rhs = try parseCPrefixOpExpr(c, it, source, source_loc, scope);
return &node.base;
},
@@ -6160,44 +6209,61 @@ fn tokenSlice(c: *Context, token: ast.TokenIndex) []u8 {
}
fn getContainer(c: *Context, node: *ast.Node) ?*ast.Node {
- if (node.id == .ContainerDecl) {
- return node;
- } else if (node.id == .PrefixOp) {
- return node;
- } else if (node.cast(ast.Node.Identifier)) |ident| {
- if (c.global_scope.sym_table.get(tokenSlice(c, ident.token))) |kv| {
- if (kv.value.cast(ast.Node.VarDecl)) |var_decl|
- return getContainer(c, var_decl.init_node.?);
- }
- } else if (node.cast(ast.Node.InfixOp)) |infix| {
- if (infix.op != .Period)
- return null;
- if (getContainerTypeOf(c, infix.lhs)) |ty_node| {
- if (ty_node.cast(ast.Node.ContainerDecl)) |container| {
- for (container.fieldsAndDecls()) |field_ref| {
- const field = field_ref.cast(ast.Node.ContainerField).?;
- const ident = infix.rhs.cast(ast.Node.Identifier).?;
- if (mem.eql(u8, tokenSlice(c, field.name_token), tokenSlice(c, ident.token))) {
- return getContainer(c, field.type_expr.?);
+ switch (node.tag) {
+ .ContainerDecl,
+ .AddressOf,
+ .Await,
+ .BitNot,
+ .BoolNot,
+ .OptionalType,
+ .Negation,
+ .NegationWrap,
+ .Resume,
+ .Try,
+ .ArrayType,
+ .ArrayTypeSentinel,
+ .PtrType,
+ .SliceType,
+ => return node,
+
+ .Identifier => {
+ const ident = node.cast(ast.Node.Identifier).?;
+ if (c.global_scope.sym_table.get(tokenSlice(c, ident.token))) |value| {
+ if (value.cast(ast.Node.VarDecl)) |var_decl|
+ return getContainer(c, var_decl.getTrailer("init_node").?);
+ }
+ },
+
+ .Period => {
+ const infix = node.castTag(.Period).?;
+
+ if (getContainerTypeOf(c, infix.lhs)) |ty_node| {
+ if (ty_node.cast(ast.Node.ContainerDecl)) |container| {
+ for (container.fieldsAndDecls()) |field_ref| {
+ const field = field_ref.cast(ast.Node.ContainerField).?;
+ const ident = infix.rhs.cast(ast.Node.Identifier).?;
+ if (mem.eql(u8, tokenSlice(c, field.name_token), tokenSlice(c, ident.token))) {
+ return getContainer(c, field.type_expr.?);
+ }
}
}
}
- }
+ },
+
+ else => {},
}
return null;
}
fn getContainerTypeOf(c: *Context, ref: *ast.Node) ?*ast.Node {
if (ref.cast(ast.Node.Identifier)) |ident| {
- if (c.global_scope.sym_table.get(tokenSlice(c, ident.token))) |kv| {
- if (kv.value.cast(ast.Node.VarDecl)) |var_decl| {
- if (var_decl.type_node) |ty|
+ if (c.global_scope.sym_table.get(tokenSlice(c, ident.token))) |value| {
+ if (value.cast(ast.Node.VarDecl)) |var_decl| {
+ if (var_decl.getTrailer("type_node")) |ty|
return getContainer(c, ty);
}
}
- } else if (ref.cast(ast.Node.InfixOp)) |infix| {
- if (infix.op != .Period)
- return null;
+ } else if (ref.castTag(.Period)) |infix| {
if (getContainerTypeOf(c, infix.lhs)) |ty_node| {
if (ty_node.cast(ast.Node.ContainerDecl)) |container| {
for (container.fieldsAndDecls()) |field_ref| {
@@ -6215,13 +6281,11 @@ fn getContainerTypeOf(c: *Context, ref: *ast.Node) ?*ast.Node {
}
fn getFnProto(c: *Context, ref: *ast.Node) ?*ast.Node.FnProto {
- const init = if (ref.cast(ast.Node.VarDecl)) |v| v.init_node.? else return null;
+ const init = if (ref.cast(ast.Node.VarDecl)) |v| v.getTrailer("init_node").? else return null;
if (getContainerTypeOf(c, init)) |ty_node| {
- if (ty_node.cast(ast.Node.PrefixOp)) |prefix| {
- if (prefix.op == .OptionalType) {
- if (prefix.rhs.cast(ast.Node.FnProto)) |fn_proto| {
- return fn_proto;
- }
+ if (ty_node.castTag(.OptionalType)) |prefix| {
+ if (prefix.rhs.cast(ast.Node.FnProto)) |fn_proto| {
+ return fn_proto;
}
}
}
@@ -6229,8 +6293,7 @@ fn getFnProto(c: *Context, ref: *ast.Node) ?*ast.Node.FnProto {
}
fn addMacros(c: *Context) !void {
- var macro_it = c.global_scope.macro_table.iterator();
- while (macro_it.next()) |kv| {
+ for (c.global_scope.macro_table.items()) |kv| {
if (getFnProto(c, kv.value)) |proto_node| {
// If a macro aliases a global variable which is a function pointer, we conclude that
// the macro is intended to represent a function that assumes the function pointer
diff --git a/src-self-hosted/type.zig b/src-self-hosted/type.zig
index aa8c000095..1cc1b690f3 100644
--- a/src-self-hosted/type.zig
+++ b/src-self-hosted/type.zig
@@ -21,8 +21,14 @@ pub const Type = extern union {
switch (self.tag()) {
.u8,
.i8,
- .isize,
+ .u16,
+ .i16,
+ .u32,
+ .i32,
+ .u64,
+ .i64,
.usize,
+ .isize,
.c_short,
.c_ushort,
.c_int,
@@ -54,8 +60,10 @@ pub const Type = extern union {
.@"undefined" => return .Undefined,
.fn_noreturn_no_args => return .Fn,
+ .fn_void_no_args => return .Fn,
.fn_naked_noreturn_no_args => return .Fn,
.fn_ccc_void_no_args => return .Fn,
+ .function => return .Fn,
.array, .array_u8_sentinel_0 => return .Array,
.single_const_pointer => return .Pointer,
@@ -112,6 +120,12 @@ pub const Type = extern union {
.Undefined => return true,
.Null => return true,
.Pointer => {
+ // Hot path for common case:
+ if (a.cast(Payload.SingleConstPointer)) |a_payload| {
+ if (b.cast(Payload.SingleConstPointer)) |b_payload| {
+ return eql(a_payload.pointee_type, b_payload.pointee_type);
+ }
+ }
const is_slice_a = isSlice(a);
const is_slice_b = isSlice(b);
if (is_slice_a != is_slice_b)
@@ -119,10 +133,14 @@ pub const Type = extern union {
@panic("TODO implement more pointer Type equality comparison");
},
.Int => {
- if (a.tag() != b.tag()) {
- // Detect that e.g. u64 != usize, even if the bits match on a particular target.
+ // Detect that e.g. u64 != usize, even if the bits match on a particular target.
+ const a_is_named_int = a.isNamedInt();
+ const b_is_named_int = b.isNamedInt();
+ if (a_is_named_int != b_is_named_int)
return false;
- }
+ if (a_is_named_int)
+ return a.tag() == b.tag();
+ // Remaining cases are arbitrary sized integers.
// The target will not be branched upon, because we handled target-dependent cases above.
const info_a = a.intInfo(@as(Target, undefined));
const info_b = b.intInfo(@as(Target, undefined));
@@ -145,6 +163,22 @@ pub const Type = extern union {
return sentinel_b == null;
}
},
+ .Fn => {
+ if (!a.fnReturnType().eql(b.fnReturnType()))
+ return false;
+ if (a.fnCallingConvention() != b.fnCallingConvention())
+ return false;
+ const a_param_len = a.fnParamLen();
+ const b_param_len = b.fnParamLen();
+ if (a_param_len != b_param_len)
+ return false;
+ var i: usize = 0;
+ while (i < a_param_len) : (i += 1) {
+ if (!a.fnParamType(i).eql(b.fnParamType(i)))
+ return false;
+ }
+ return true;
+ },
.Float,
.Struct,
.Optional,
@@ -152,23 +186,114 @@ pub const Type = extern union {
.ErrorSet,
.Enum,
.Union,
- .Fn,
.BoundFn,
.Opaque,
.Frame,
.AnyFrame,
.Vector,
.EnumLiteral,
- => @panic("TODO implement more Type equality comparison"),
+ => std.debug.panic("TODO implement Type equality comparison of {} and {}", .{ a, b }),
}
}
+ pub fn copy(self: Type, allocator: *Allocator) error{OutOfMemory}!Type {
+ if (self.tag_if_small_enough < Tag.no_payload_count) {
+ return Type{ .tag_if_small_enough = self.tag_if_small_enough };
+ } else switch (self.ptr_otherwise.tag) {
+ .u8,
+ .i8,
+ .u16,
+ .i16,
+ .u32,
+ .i32,
+ .u64,
+ .i64,
+ .usize,
+ .isize,
+ .c_short,
+ .c_ushort,
+ .c_int,
+ .c_uint,
+ .c_long,
+ .c_ulong,
+ .c_longlong,
+ .c_ulonglong,
+ .c_longdouble,
+ .c_void,
+ .f16,
+ .f32,
+ .f64,
+ .f128,
+ .bool,
+ .void,
+ .type,
+ .anyerror,
+ .comptime_int,
+ .comptime_float,
+ .noreturn,
+ .@"null",
+ .@"undefined",
+ .fn_noreturn_no_args,
+ .fn_void_no_args,
+ .fn_naked_noreturn_no_args,
+ .fn_ccc_void_no_args,
+ .single_const_pointer_to_comptime_int,
+ .const_slice_u8,
+ => unreachable,
+
+ .array_u8_sentinel_0 => return self.copyPayloadShallow(allocator, Payload.Array_u8_Sentinel0),
+ .array => {
+ const payload = @fieldParentPtr(Payload.Array, "base", self.ptr_otherwise);
+ const new_payload = try allocator.create(Payload.Array);
+ new_payload.* = .{
+ .base = payload.base,
+ .len = payload.len,
+ .elem_type = try payload.elem_type.copy(allocator),
+ };
+ return Type{ .ptr_otherwise = &new_payload.base };
+ },
+ .single_const_pointer => {
+ const payload = @fieldParentPtr(Payload.SingleConstPointer, "base", self.ptr_otherwise);
+ const new_payload = try allocator.create(Payload.SingleConstPointer);
+ new_payload.* = .{
+ .base = payload.base,
+ .pointee_type = try payload.pointee_type.copy(allocator),
+ };
+ return Type{ .ptr_otherwise = &new_payload.base };
+ },
+ .int_signed => return self.copyPayloadShallow(allocator, Payload.IntSigned),
+ .int_unsigned => return self.copyPayloadShallow(allocator, Payload.IntUnsigned),
+ .function => {
+ const payload = @fieldParentPtr(Payload.Function, "base", self.ptr_otherwise);
+ const new_payload = try allocator.create(Payload.Function);
+ const param_types = try allocator.alloc(Type, payload.param_types.len);
+ for (payload.param_types) |param_type, i| {
+ param_types[i] = try param_type.copy(allocator);
+ }
+ new_payload.* = .{
+ .base = payload.base,
+ .return_type = try payload.return_type.copy(allocator),
+ .param_types = param_types,
+ .cc = payload.cc,
+ };
+ return Type{ .ptr_otherwise = &new_payload.base };
+ },
+ }
+ }
+
+ fn copyPayloadShallow(self: Type, allocator: *Allocator, comptime T: type) error{OutOfMemory}!Type {
+ const payload = @fieldParentPtr(T, "base", self.ptr_otherwise);
+ const new_payload = try allocator.create(T);
+ new_payload.* = payload.*;
+ return Type{ .ptr_otherwise = &new_payload.base };
+ }
+
pub fn format(
self: Type,
comptime fmt: []const u8,
options: std.fmt.FormatOptions,
- out_stream: var,
- ) !void {
+ out_stream: anytype,
+ ) @TypeOf(out_stream).Error!void {
comptime assert(fmt.len == 0);
var ty = self;
while (true) {
@@ -176,8 +301,14 @@ pub const Type = extern union {
switch (t) {
.u8,
.i8,
- .isize,
+ .u16,
+ .i16,
+ .u32,
+ .i32,
+ .u64,
+ .i64,
.usize,
+ .isize,
.c_short,
.c_ushort,
.c_int,
@@ -206,9 +337,20 @@ pub const Type = extern union {
.const_slice_u8 => return out_stream.writeAll("[]const u8"),
.fn_noreturn_no_args => return out_stream.writeAll("fn() noreturn"),
+ .fn_void_no_args => return out_stream.writeAll("fn() void"),
.fn_naked_noreturn_no_args => return out_stream.writeAll("fn() callconv(.Naked) noreturn"),
.fn_ccc_void_no_args => return out_stream.writeAll("fn() callconv(.C) void"),
.single_const_pointer_to_comptime_int => return out_stream.writeAll("*const comptime_int"),
+ .function => {
+ const payload = @fieldParentPtr(Payload.Function, "base", ty.ptr_otherwise);
+ try out_stream.writeAll("fn(");
+ for (payload.param_types) |param_type, i| {
+ if (i != 0) try out_stream.writeAll(", ");
+ try param_type.format("", .{}, out_stream);
+ }
+ try out_stream.writeAll(") ");
+ try payload.return_type.format("", .{}, out_stream);
+ },
.array_u8_sentinel_0 => {
const payload = @fieldParentPtr(Payload.Array_u8_Sentinel0, "base", ty.ptr_otherwise);
@@ -243,8 +385,14 @@ pub const Type = extern union {
switch (self.tag()) {
.u8 => return Value.initTag(.u8_type),
.i8 => return Value.initTag(.i8_type),
- .isize => return Value.initTag(.isize_type),
+ .u16 => return Value.initTag(.u16_type),
+ .i16 => return Value.initTag(.i16_type),
+ .u32 => return Value.initTag(.u32_type),
+ .i32 => return Value.initTag(.i32_type),
+ .u64 => return Value.initTag(.u64_type),
+ .i64 => return Value.initTag(.i64_type),
.usize => return Value.initTag(.usize_type),
+ .isize => return Value.initTag(.isize_type),
.c_short => return Value.initTag(.c_short_type),
.c_ushort => return Value.initTag(.c_ushort_type),
.c_int => return Value.initTag(.c_int_type),
@@ -269,6 +417,7 @@ pub const Type = extern union {
.@"null" => return Value.initTag(.null_type),
.@"undefined" => return Value.initTag(.undefined_type),
.fn_noreturn_no_args => return Value.initTag(.fn_noreturn_no_args_type),
+ .fn_void_no_args => return Value.initTag(.fn_void_no_args_type),
.fn_naked_noreturn_no_args => return Value.initTag(.fn_naked_noreturn_no_args_type),
.fn_ccc_void_no_args => return Value.initTag(.fn_ccc_void_no_args_type),
.single_const_pointer_to_comptime_int => return Value.initTag(.single_const_pointer_to_comptime_int_type),
@@ -285,8 +434,14 @@ pub const Type = extern union {
return switch (self.tag()) {
.u8,
.i8,
- .isize,
+ .u16,
+ .i16,
+ .u32,
+ .i32,
+ .u64,
+ .i64,
.usize,
+ .isize,
.c_short,
.c_ushort,
.c_int,
@@ -303,8 +458,10 @@ pub const Type = extern union {
.bool,
.anyerror,
.fn_noreturn_no_args,
+ .fn_void_no_args,
.fn_naked_noreturn_no_args,
.fn_ccc_void_no_args,
+ .function,
.single_const_pointer_to_comptime_int,
.const_slice_u8,
.array_u8_sentinel_0,
@@ -326,6 +483,10 @@ pub const Type = extern union {
};
}
+ pub fn isNoReturn(self: Type) bool {
+ return self.zigTypeTag() == .NoReturn;
+ }
+
/// Asserts that hasCodeGenBits() is true.
pub fn abiAlignment(self: Type, target: Target) u32 {
return switch (self.tag()) {
@@ -333,11 +494,17 @@ pub const Type = extern union {
.i8,
.bool,
.fn_noreturn_no_args, // represents machine code; not a pointer
+ .fn_void_no_args, // represents machine code; not a pointer
.fn_naked_noreturn_no_args, // represents machine code; not a pointer
.fn_ccc_void_no_args, // represents machine code; not a pointer
+ .function, // represents machine code; not a pointer
.array_u8_sentinel_0,
=> return 1,
+ .i16, .u16 => return 2,
+ .i32, .u32 => return 4,
+ .i64, .u64 => return 8,
+
.isize,
.usize,
.single_const_pointer_to_comptime_int,
@@ -387,12 +554,87 @@ pub const Type = extern union {
};
}
+ /// Asserts the type has the ABI size already resolved.
+ pub fn abiSize(self: Type, target: Target) u64 {
+ return switch (self.tag()) {
+ .fn_noreturn_no_args => unreachable, // represents machine code; not a pointer
+ .fn_void_no_args => unreachable, // represents machine code; not a pointer
+ .fn_naked_noreturn_no_args => unreachable, // represents machine code; not a pointer
+ .fn_ccc_void_no_args => unreachable, // represents machine code; not a pointer
+ .function => unreachable, // represents machine code; not a pointer
+ .c_void => unreachable,
+ .void => unreachable,
+ .type => unreachable,
+ .comptime_int => unreachable,
+ .comptime_float => unreachable,
+ .noreturn => unreachable,
+ .@"null" => unreachable,
+ .@"undefined" => unreachable,
+
+ .u8,
+ .i8,
+ .bool,
+ => return 1,
+
+ .array_u8_sentinel_0 => @fieldParentPtr(Payload.Array_u8_Sentinel0, "base", self.ptr_otherwise).len,
+ .array => {
+ const payload = @fieldParentPtr(Payload.Array, "base", self.ptr_otherwise);
+ const elem_size = std.math.max(payload.elem_type.abiAlignment(target), payload.elem_type.abiSize(target));
+ return payload.len * elem_size;
+ },
+ .i16, .u16 => return 2,
+ .i32, .u32 => return 4,
+ .i64, .u64 => return 8,
+
+ .isize,
+ .usize,
+ .single_const_pointer_to_comptime_int,
+ .const_slice_u8,
+ .single_const_pointer,
+ => return @divExact(target.cpu.arch.ptrBitWidth(), 8),
+
+ .c_short => return @divExact(CType.short.sizeInBits(target), 8),
+ .c_ushort => return @divExact(CType.ushort.sizeInBits(target), 8),
+ .c_int => return @divExact(CType.int.sizeInBits(target), 8),
+ .c_uint => return @divExact(CType.uint.sizeInBits(target), 8),
+ .c_long => return @divExact(CType.long.sizeInBits(target), 8),
+ .c_ulong => return @divExact(CType.ulong.sizeInBits(target), 8),
+ .c_longlong => return @divExact(CType.longlong.sizeInBits(target), 8),
+ .c_ulonglong => return @divExact(CType.ulonglong.sizeInBits(target), 8),
+
+ .f16 => return 2,
+ .f32 => return 4,
+ .f64 => return 8,
+ .f128 => return 16,
+ .c_longdouble => return 16,
+
+ .anyerror => return 2, // TODO revisit this when we have the concept of the error tag type
+
+ .int_signed, .int_unsigned => {
+ const bits: u16 = if (self.cast(Payload.IntSigned)) |pl|
+ pl.bits
+ else if (self.cast(Payload.IntUnsigned)) |pl|
+ pl.bits
+ else
+ unreachable;
+
+ return std.math.ceilPowerOfTwoPromote(u16, (bits + 7) / 8);
+ },
+ };
+ }
+
pub fn isSinglePointer(self: Type) bool {
return switch (self.tag()) {
.u8,
.i8,
- .isize,
+ .u16,
+ .i16,
+ .u32,
+ .i32,
+ .u64,
+ .i64,
.usize,
+ .isize,
.c_short,
.c_ushort,
.c_int,
@@ -420,8 +662,10 @@ pub const Type = extern union {
.array_u8_sentinel_0,
.const_slice_u8,
.fn_noreturn_no_args,
+ .fn_void_no_args,
.fn_naked_noreturn_no_args,
.fn_ccc_void_no_args,
+ .function,
.int_unsigned,
.int_signed,
=> false,
@@ -436,8 +680,14 @@ pub const Type = extern union {
return switch (self.tag()) {
.u8,
.i8,
- .isize,
+ .u16,
+ .i16,
+ .u32,
+ .i32,
+ .u64,
+ .i64,
.usize,
+ .isize,
.c_short,
.c_ushort,
.c_int,
@@ -466,8 +716,10 @@ pub const Type = extern union {
.single_const_pointer,
.single_const_pointer_to_comptime_int,
.fn_noreturn_no_args,
+ .fn_void_no_args,
.fn_naked_noreturn_no_args,
.fn_ccc_void_no_args,
+ .function,
.int_unsigned,
.int_signed,
=> false,
@@ -481,8 +733,14 @@ pub const Type = extern union {
return switch (self.tag()) {
.u8,
.i8,
- .isize,
+ .u16,
+ .i16,
+ .u32,
+ .i32,
+ .u64,
+ .i64,
.usize,
+ .isize,
.c_short,
.c_ushort,
.c_int,
@@ -509,8 +767,10 @@ pub const Type = extern union {
.array,
.array_u8_sentinel_0,
.fn_noreturn_no_args,
+ .fn_void_no_args,
.fn_naked_noreturn_no_args,
.fn_ccc_void_no_args,
+ .function,
.int_unsigned,
.int_signed,
=> unreachable,
@@ -527,8 +787,14 @@ pub const Type = extern union {
return switch (self.tag()) {
.u8,
.i8,
- .isize,
+ .u16,
+ .i16,
+ .u32,
+ .i32,
+ .u64,
+ .i64,
.usize,
+ .isize,
.c_short,
.c_ushort,
.c_int,
@@ -553,8 +819,10 @@ pub const Type = extern union {
.@"null",
.@"undefined",
.fn_noreturn_no_args,
+ .fn_void_no_args,
.fn_naked_noreturn_no_args,
.fn_ccc_void_no_args,
+ .function,
.int_unsigned,
.int_signed,
=> unreachable,
@@ -571,8 +839,14 @@ pub const Type = extern union {
return switch (self.tag()) {
.u8,
.i8,
- .isize,
+ .u16,
+ .i16,
+ .u32,
+ .i32,
+ .u64,
+ .i64,
.usize,
+ .isize,
.c_short,
.c_ushort,
.c_int,
@@ -597,8 +871,10 @@ pub const Type = extern union {
.@"null",
.@"undefined",
.fn_noreturn_no_args,
+ .fn_void_no_args,
.fn_naked_noreturn_no_args,
.fn_ccc_void_no_args,
+ .function,
.single_const_pointer,
.single_const_pointer_to_comptime_int,
.const_slice_u8,
@@ -616,8 +892,14 @@ pub const Type = extern union {
return switch (self.tag()) {
.u8,
.i8,
- .isize,
+ .u16,
+ .i16,
+ .u32,
+ .i32,
+ .u64,
+ .i64,
.usize,
+ .isize,
.c_short,
.c_ushort,
.c_int,
@@ -642,8 +924,10 @@ pub const Type = extern union {
.@"null",
.@"undefined",
.fn_noreturn_no_args,
+ .fn_void_no_args,
.fn_naked_noreturn_no_args,
.fn_ccc_void_no_args,
+ .function,
.single_const_pointer,
.single_const_pointer_to_comptime_int,
.const_slice_u8,
@@ -656,6 +940,11 @@ pub const Type = extern union {
};
}
+ /// Returns true if and only if the type is a fixed-width integer.
+ pub fn isInt(self: Type) bool {
+ return self.isSignedInt() or self.isUnsignedInt();
+ }
+
/// Returns true if and only if the type is a fixed-width, signed integer.
pub fn isSignedInt(self: Type) bool {
return switch (self.tag()) {
@@ -675,8 +964,10 @@ pub const Type = extern union {
.@"null",
.@"undefined",
.fn_noreturn_no_args,
+ .fn_void_no_args,
.fn_naked_noreturn_no_args,
.fn_ccc_void_no_args,
+ .function,
.array,
.single_const_pointer,
.single_const_pointer_to_comptime_int,
@@ -689,6 +980,9 @@ pub const Type = extern union {
.c_uint,
.c_ulong,
.c_ulonglong,
+ .u16,
+ .u32,
+ .u64,
=> false,
.int_signed,
@@ -698,11 +992,68 @@ pub const Type = extern union {
.c_int,
.c_long,
.c_longlong,
+ .i16,
+ .i32,
+ .i64,
=> true,
};
}
- /// Asserts the type is a fixed-width integer.
+ /// Returns true if and only if the type is a fixed-width, unsigned integer.
+ pub fn isUnsignedInt(self: Type) bool {
+ return switch (self.tag()) {
+ .f16,
+ .f32,
+ .f64,
+ .f128,
+ .c_longdouble,
+ .c_void,
+ .bool,
+ .void,
+ .type,
+ .anyerror,
+ .comptime_int,
+ .comptime_float,
+ .noreturn,
+ .@"null",
+ .@"undefined",
+ .fn_noreturn_no_args,
+ .fn_void_no_args,
+ .fn_naked_noreturn_no_args,
+ .fn_ccc_void_no_args,
+ .function,
+ .array,
+ .single_const_pointer,
+ .single_const_pointer_to_comptime_int,
+ .array_u8_sentinel_0,
+ .const_slice_u8,
+ .int_signed,
+ .i8,
+ .isize,
+ .c_short,
+ .c_int,
+ .c_long,
+ .c_longlong,
+ .i16,
+ .i32,
+ .i64,
+ => false,
+
+ .int_unsigned,
+ .u8,
+ .usize,
+ .c_ushort,
+ .c_uint,
+ .c_ulong,
+ .c_ulonglong,
+ .u16,
+ .u32,
+ .u64,
+ => true,
+ };
+ }
+
+ /// Asserts the type is an integer.
pub fn intInfo(self: Type, target: Target) struct { signed: bool, bits: u16 } {
return switch (self.tag()) {
.f16,
@@ -721,8 +1072,10 @@ pub const Type = extern union {
.@"null",
.@"undefined",
.fn_noreturn_no_args,
+ .fn_void_no_args,
.fn_naked_noreturn_no_args,
.fn_ccc_void_no_args,
+ .function,
.array,
.single_const_pointer,
.single_const_pointer_to_comptime_int,
@@ -734,6 +1087,12 @@ pub const Type = extern union {
.int_signed => .{ .signed = true, .bits = self.cast(Payload.IntSigned).?.bits },
.u8 => .{ .signed = false, .bits = 8 },
.i8 => .{ .signed = true, .bits = 8 },
+ .u16 => .{ .signed = false, .bits = 16 },
+ .i16 => .{ .signed = true, .bits = 16 },
+ .u32 => .{ .signed = false, .bits = 32 },
+ .i32 => .{ .signed = true, .bits = 32 },
+ .u64 => .{ .signed = false, .bits = 64 },
+ .i64 => .{ .signed = true, .bits = 64 },
.usize => .{ .signed = false, .bits = target.cpu.arch.ptrBitWidth() },
.isize => .{ .signed = true, .bits = target.cpu.arch.ptrBitWidth() },
.c_short => .{ .signed = true, .bits = CType.short.sizeInBits(target) },
@@ -747,6 +1106,59 @@ pub const Type = extern union {
};
}
+ pub fn isNamedInt(self: Type) bool {
+ return switch (self.tag()) {
+ .f16,
+ .f32,
+ .f64,
+ .f128,
+ .c_longdouble,
+ .c_void,
+ .bool,
+ .void,
+ .type,
+ .anyerror,
+ .comptime_int,
+ .comptime_float,
+ .noreturn,
+ .@"null",
+ .@"undefined",
+ .fn_noreturn_no_args,
+ .fn_void_no_args,
+ .fn_naked_noreturn_no_args,
+ .fn_ccc_void_no_args,
+ .function,
+ .array,
+ .single_const_pointer,
+ .single_const_pointer_to_comptime_int,
+ .array_u8_sentinel_0,
+ .const_slice_u8,
+ .int_unsigned,
+ .int_signed,
+ .u8,
+ .i8,
+ .u16,
+ .i16,
+ .u32,
+ .i32,
+ .u64,
+ .i64,
+ => false,
+
+ .usize,
+ .isize,
+ .c_short,
+ .c_ushort,
+ .c_int,
+ .c_uint,
+ .c_long,
+ .c_ulong,
+ .c_longlong,
+ .c_ulonglong,
+ => true,
+ };
+ }
+
pub fn isFloat(self: Type) bool {
return switch (self.tag()) {
.f16,
@@ -777,8 +1189,10 @@ pub const Type = extern union {
pub fn fnParamLen(self: Type) usize {
return switch (self.tag()) {
.fn_noreturn_no_args => 0,
+ .fn_void_no_args => 0,
.fn_naked_noreturn_no_args => 0,
.fn_ccc_void_no_args => 0,
+ .function => @fieldParentPtr(Payload.Function, "base", self.ptr_otherwise).param_types.len,
.f16,
.f32,
@@ -802,6 +1216,12 @@ pub const Type = extern union {
.const_slice_u8,
.u8,
.i8,
+ .u16,
+ .i16,
+ .u32,
+ .i32,
+ .u64,
+ .i64,
.usize,
.isize,
.c_short,
@@ -823,8 +1243,13 @@ pub const Type = extern union {
pub fn fnParamTypes(self: Type, types: []Type) void {
switch (self.tag()) {
.fn_noreturn_no_args => return,
+ .fn_void_no_args => return,
.fn_naked_noreturn_no_args => return,
.fn_ccc_void_no_args => return,
+ .function => {
+ const payload = @fieldParentPtr(Payload.Function, "base", self.ptr_otherwise);
+ std.mem.copy(Type, types, payload.param_types);
+ },
.f16,
.f32,
@@ -848,6 +1273,68 @@ pub const Type = extern union {
.const_slice_u8,
.u8,
.i8,
+ .u16,
+ .i16,
+ .u32,
+ .i32,
+ .u64,
+ .i64,
+ .usize,
+ .isize,
+ .c_short,
+ .c_ushort,
+ .c_int,
+ .c_uint,
+ .c_long,
+ .c_ulong,
+ .c_longlong,
+ .c_ulonglong,
+ .int_unsigned,
+ .int_signed,
+ => unreachable,
+ }
+ }
+
+ /// Asserts the type is a function.
+ pub fn fnParamType(self: Type, index: usize) Type {
+ switch (self.tag()) {
+ .function => {
+ const payload = @fieldParentPtr(Payload.Function, "base", self.ptr_otherwise);
+ return payload.param_types[index];
+ },
+
+ .fn_noreturn_no_args,
+ .fn_void_no_args,
+ .fn_naked_noreturn_no_args,
+ .fn_ccc_void_no_args,
+ .f16,
+ .f32,
+ .f64,
+ .f128,
+ .c_longdouble,
+ .c_void,
+ .bool,
+ .void,
+ .type,
+ .anyerror,
+ .comptime_int,
+ .comptime_float,
+ .noreturn,
+ .@"null",
+ .@"undefined",
+ .array,
+ .single_const_pointer,
+ .single_const_pointer_to_comptime_int,
+ .array_u8_sentinel_0,
+ .const_slice_u8,
+ .u8,
+ .i8,
+ .u16,
+ .i16,
+ .u32,
+ .i32,
+ .u64,
+ .i64,
.usize,
.isize,
.c_short,
@@ -869,7 +1356,12 @@ pub const Type = extern union {
return switch (self.tag()) {
.fn_noreturn_no_args => Type.initTag(.noreturn),
.fn_naked_noreturn_no_args => Type.initTag(.noreturn),
- .fn_ccc_void_no_args => Type.initTag(.void),
+
+ .fn_void_no_args,
+ .fn_ccc_void_no_args,
+ => Type.initTag(.void),
+
+ .function => @fieldParentPtr(Payload.Function, "base", self.ptr_otherwise).return_type,
.f16,
.f32,
@@ -893,6 +1385,12 @@ pub const Type = extern union {
.const_slice_u8,
.u8,
.i8,
+ .u16,
+ .i16,
+ .u32,
+ .i32,
+ .u64,
+ .i64,
.usize,
.isize,
.c_short,
@@ -913,8 +1411,10 @@ pub const Type = extern union {
pub fn fnCallingConvention(self: Type) std.builtin.CallingConvention {
return switch (self.tag()) {
.fn_noreturn_no_args => .Unspecified,
+ .fn_void_no_args => .Unspecified,
.fn_naked_noreturn_no_args => .Naked,
.fn_ccc_void_no_args => .C,
+ .function => @fieldParentPtr(Payload.Function, "base", self.ptr_otherwise).cc,
.f16,
.f32,
@@ -938,6 +1438,12 @@ pub const Type = extern union {
.const_slice_u8,
.u8,
.i8,
+ .u16,
+ .i16,
+ .u32,
+ .i32,
+ .u64,
+ .i64,
.usize,
.isize,
.c_short,
@@ -958,8 +1464,10 @@ pub const Type = extern union {
pub fn fnIsVarArgs(self: Type) bool {
return switch (self.tag()) {
.fn_noreturn_no_args => false,
+ .fn_void_no_args => false,
.fn_naked_noreturn_no_args => false,
.fn_ccc_void_no_args => false,
+ .function => false,
.f16,
.f32,
@@ -983,6 +1491,12 @@ pub const Type = extern union {
.const_slice_u8,
.u8,
.i8,
+ .u16,
+ .i16,
+ .u32,
+ .i32,
+ .u64,
+ .i64,
.usize,
.isize,
.c_short,
@@ -1010,6 +1524,12 @@ pub const Type = extern union {
.comptime_float,
.u8,
.i8,
+ .u16,
+ .i16,
+ .u32,
+ .i32,
+ .u64,
+ .i64,
.usize,
.isize,
.c_short,
@@ -1033,8 +1553,10 @@ pub const Type = extern union {
.@"null",
.@"undefined",
.fn_noreturn_no_args,
+ .fn_void_no_args,
.fn_naked_noreturn_no_args,
.fn_ccc_void_no_args,
+ .function,
.array,
.single_const_pointer,
.single_const_pointer_to_comptime_int,
@@ -1056,6 +1578,12 @@ pub const Type = extern union {
.comptime_float,
.u8,
.i8,
+ .u16,
+ .i16,
+ .u32,
+ .i32,
+ .u64,
+ .i64,
.usize,
.isize,
.c_short,
@@ -1070,8 +1598,10 @@ pub const Type = extern union {
.type,
.anyerror,
.fn_noreturn_no_args,
+ .fn_void_no_args,
.fn_naked_noreturn_no_args,
.fn_ccc_void_no_args,
+ .function,
.single_const_pointer_to_comptime_int,
.array_u8_sentinel_0,
.const_slice_u8,
@@ -1112,6 +1642,12 @@ pub const Type = extern union {
.comptime_float,
.u8,
.i8,
+ .u16,
+ .i16,
+ .u32,
+ .i32,
+ .u64,
+ .i64,
.usize,
.isize,
.c_short,
@@ -1126,8 +1662,10 @@ pub const Type = extern union {
.type,
.anyerror,
.fn_noreturn_no_args,
+ .fn_void_no_args,
.fn_naked_noreturn_no_args,
.fn_ccc_void_no_args,
+ .function,
.single_const_pointer_to_comptime_int,
.array_u8_sentinel_0,
.const_slice_u8,
@@ -1154,8 +1692,14 @@ pub const Type = extern union {
// The first section of this enum are tags that require no payload.
u8,
i8,
- isize,
+ u16,
+ i16,
+ u32,
+ i32,
+ u64,
+ i64,
usize,
+ isize,
c_short,
c_ushort,
c_int,
@@ -1180,6 +1724,7 @@ pub const Type = extern union {
@"null",
@"undefined",
fn_noreturn_no_args,
+ fn_void_no_args,
fn_naked_noreturn_no_args,
fn_ccc_void_no_args,
single_const_pointer_to_comptime_int,
@@ -1191,6 +1736,7 @@ pub const Type = extern union {
single_const_pointer,
int_signed,
int_unsigned,
+ function,
pub const last_no_payload_tag = Tag.const_slice_u8;
pub const no_payload_count = @enumToInt(last_no_payload_tag) + 1;
@@ -1229,6 +1775,14 @@ pub const Type = extern union {
bits: u16,
};
+
+ pub const Function = struct {
+ base: Payload = Payload{ .tag = .function },
+
+ param_types: []Type,
+ return_type: Type,
+ cc: std.builtin.CallingConvention,
+ };
};
};
diff --git a/src-self-hosted/value.zig b/src-self-hosted/value.zig
index 5660cd760f..a3e1daa383 100644
--- a/src-self-hosted/value.zig
+++ b/src-self-hosted/value.zig
@@ -23,8 +23,14 @@ pub const Value = extern union {
// The first section of this enum are tags that require no payload.
u8_type,
i8_type,
- isize_type,
+ u16_type,
+ i16_type,
+ u32_type,
+ i32_type,
+ u64_type,
+ i64_type,
usize_type,
+ isize_type,
c_short_type,
c_ushort_type,
c_int_type,
@@ -49,6 +55,7 @@ pub const Value = extern union {
null_type,
undefined_type,
fn_noreturn_no_args_type,
+ fn_void_no_args_type,
fn_naked_noreturn_no_args_type,
fn_ccc_void_no_args_type,
single_const_pointer_to_comptime_int_type,
@@ -78,8 +85,8 @@ pub const Value = extern union {
pub const no_payload_count = @enumToInt(last_no_payload_tag) + 1;
};
- pub fn initTag(comptime small_tag: Tag) Value {
- comptime assert(@enumToInt(small_tag) < Tag.no_payload_count);
+ pub fn initTag(small_tag: Tag) Value {
+ assert(@enumToInt(small_tag) < Tag.no_payload_count);
return .{ .tag_if_small_enough = @enumToInt(small_tag) };
}
@@ -107,17 +114,132 @@ pub const Value = extern union {
return @fieldParentPtr(T, "base", self.ptr_otherwise);
}
+ pub fn copy(self: Value, allocator: *Allocator) error{OutOfMemory}!Value {
+ if (self.tag_if_small_enough < Tag.no_payload_count) {
+ return Value{ .tag_if_small_enough = self.tag_if_small_enough };
+ } else switch (self.ptr_otherwise.tag) {
+ .u8_type,
+ .i8_type,
+ .u16_type,
+ .i16_type,
+ .u32_type,
+ .i32_type,
+ .u64_type,
+ .i64_type,
+ .usize_type,
+ .isize_type,
+ .c_short_type,
+ .c_ushort_type,
+ .c_int_type,
+ .c_uint_type,
+ .c_long_type,
+ .c_ulong_type,
+ .c_longlong_type,
+ .c_ulonglong_type,
+ .c_longdouble_type,
+ .f16_type,
+ .f32_type,
+ .f64_type,
+ .f128_type,
+ .c_void_type,
+ .bool_type,
+ .void_type,
+ .type_type,
+ .anyerror_type,
+ .comptime_int_type,
+ .comptime_float_type,
+ .noreturn_type,
+ .null_type,
+ .undefined_type,
+ .fn_noreturn_no_args_type,
+ .fn_void_no_args_type,
+ .fn_naked_noreturn_no_args_type,
+ .fn_ccc_void_no_args_type,
+ .single_const_pointer_to_comptime_int_type,
+ .const_slice_u8_type,
+ .undef,
+ .zero,
+ .the_one_possible_value,
+ .null_value,
+ .bool_true,
+ .bool_false,
+ => unreachable,
+
+ .ty => {
+ const payload = @fieldParentPtr(Payload.Ty, "base", self.ptr_otherwise);
+ const new_payload = try allocator.create(Payload.Ty);
+ new_payload.* = .{
+ .base = payload.base,
+ .ty = try payload.ty.copy(allocator),
+ };
+ return Value{ .ptr_otherwise = &new_payload.base };
+ },
+ .int_u64 => return self.copyPayloadShallow(allocator, Payload.Int_u64),
+ .int_i64 => return self.copyPayloadShallow(allocator, Payload.Int_i64),
+ .int_big_positive => {
+ @panic("TODO implement copying of big ints");
+ },
+ .int_big_negative => {
+ @panic("TODO implement copying of big ints");
+ },
+ .function => return self.copyPayloadShallow(allocator, Payload.Function),
+ .ref_val => {
+ const payload = @fieldParentPtr(Payload.RefVal, "base", self.ptr_otherwise);
+ const new_payload = try allocator.create(Payload.RefVal);
+ new_payload.* = .{
+ .base = payload.base,
+ .val = try payload.val.copy(allocator),
+ };
+ return Value{ .ptr_otherwise = &new_payload.base };
+ },
+ .decl_ref => return self.copyPayloadShallow(allocator, Payload.DeclRef),
+ .elem_ptr => {
+ const payload = @fieldParentPtr(Payload.ElemPtr, "base", self.ptr_otherwise);
+ const new_payload = try allocator.create(Payload.ElemPtr);
+ new_payload.* = .{
+ .base = payload.base,
+ .array_ptr = try payload.array_ptr.copy(allocator),
+ .index = payload.index,
+ };
+ return Value{ .ptr_otherwise = &new_payload.base };
+ },
+ .bytes => return self.copyPayloadShallow(allocator, Payload.Bytes),
+ .repeated => {
+ const payload = @fieldParentPtr(Payload.Repeated, "base", self.ptr_otherwise);
+ const new_payload = try allocator.create(Payload.Repeated);
+ new_payload.* = .{
+ .base = payload.base,
+ .val = try payload.val.copy(allocator),
+ };
+ return Value{ .ptr_otherwise = &new_payload.base };
+ },
+ }
+ }
+
+ fn copyPayloadShallow(self: Value, allocator: *Allocator, comptime T: type) error{OutOfMemory}!Value {
+ const payload = @fieldParentPtr(T, "base", self.ptr_otherwise);
+ const new_payload = try allocator.create(T);
+ new_payload.* = payload.*;
+ return Value{ .ptr_otherwise = &new_payload.base };
+ }
+
pub fn format(
self: Value,
comptime fmt: []const u8,
options: std.fmt.FormatOptions,
- out_stream: var,
+ out_stream: anytype,
) !void {
comptime assert(fmt.len == 0);
var val = self;
while (true) switch (val.tag()) {
.u8_type => return out_stream.writeAll("u8"),
.i8_type => return out_stream.writeAll("i8"),
+ .u16_type => return out_stream.writeAll("u16"),
+ .i16_type => return out_stream.writeAll("i16"),
+ .u32_type => return out_stream.writeAll("u32"),
+ .i32_type => return out_stream.writeAll("i32"),
+ .u64_type => return out_stream.writeAll("u64"),
+ .i64_type => return out_stream.writeAll("i64"),
.isize_type => return out_stream.writeAll("isize"),
.usize_type => return out_stream.writeAll("usize"),
.c_short_type => return out_stream.writeAll("c_short"),
@@ -144,6 +266,7 @@ pub const Value = extern union {
.null_type => return out_stream.writeAll("@TypeOf(null)"),
.undefined_type => return out_stream.writeAll("@TypeOf(undefined)"),
.fn_noreturn_no_args_type => return out_stream.writeAll("fn() noreturn"),
+ .fn_void_no_args_type => return out_stream.writeAll("fn() void"),
.fn_naked_noreturn_no_args_type => return out_stream.writeAll("fn() callconv(.Naked) noreturn"),
.fn_ccc_void_no_args_type => return out_stream.writeAll("fn() callconv(.C) void"),
.single_const_pointer_to_comptime_int_type => return out_stream.writeAll("*const comptime_int"),
@@ -203,8 +326,14 @@ pub const Value = extern union {
.u8_type => Type.initTag(.u8),
.i8_type => Type.initTag(.i8),
- .isize_type => Type.initTag(.isize),
+ .u16_type => Type.initTag(.u16),
+ .i16_type => Type.initTag(.i16),
+ .u32_type => Type.initTag(.u32),
+ .i32_type => Type.initTag(.i32),
+ .u64_type => Type.initTag(.u64),
+ .i64_type => Type.initTag(.i64),
.usize_type => Type.initTag(.usize),
+ .isize_type => Type.initTag(.isize),
.c_short_type => Type.initTag(.c_short),
.c_ushort_type => Type.initTag(.c_ushort),
.c_int_type => Type.initTag(.c_int),
@@ -229,6 +358,7 @@ pub const Value = extern union {
.null_type => Type.initTag(.@"null"),
.undefined_type => Type.initTag(.@"undefined"),
.fn_noreturn_no_args_type => Type.initTag(.fn_noreturn_no_args),
+ .fn_void_no_args_type => Type.initTag(.fn_void_no_args),
.fn_naked_noreturn_no_args_type => Type.initTag(.fn_naked_noreturn_no_args),
.fn_ccc_void_no_args_type => Type.initTag(.fn_ccc_void_no_args),
.single_const_pointer_to_comptime_int_type => Type.initTag(.single_const_pointer_to_comptime_int),
@@ -260,8 +390,14 @@ pub const Value = extern union {
.ty,
.u8_type,
.i8_type,
- .isize_type,
+ .u16_type,
+ .i16_type,
+ .u32_type,
+ .i32_type,
+ .u64_type,
+ .i64_type,
.usize_type,
+ .isize_type,
.c_short_type,
.c_ushort_type,
.c_int_type,
@@ -286,12 +422,11 @@ pub const Value = extern union {
.null_type,
.undefined_type,
.fn_noreturn_no_args_type,
+ .fn_void_no_args_type,
.fn_naked_noreturn_no_args_type,
.fn_ccc_void_no_args_type,
.single_const_pointer_to_comptime_int_type,
.const_slice_u8_type,
- .bool_true,
- .bool_false,
.null_value,
.function,
.ref_val,
@@ -304,8 +439,11 @@ pub const Value = extern union {
.the_one_possible_value, // An integer with one possible value is always zero.
.zero,
+ .bool_false,
=> return BigIntMutable.init(&space.limbs, 0).toConst(),
+ .bool_true => return BigIntMutable.init(&space.limbs, 1).toConst(),
+
.int_u64 => return BigIntMutable.init(&space.limbs, self.cast(Payload.Int_u64).?.int).toConst(),
.int_i64 => return BigIntMutable.init(&space.limbs, self.cast(Payload.Int_i64).?.int).toConst(),
.int_big_positive => return self.cast(Payload.IntBigPositive).?.asBigInt(),
@@ -319,8 +457,14 @@ pub const Value = extern union {
.ty,
.u8_type,
.i8_type,
- .isize_type,
+ .u16_type,
+ .i16_type,
+ .u32_type,
+ .i32_type,
+ .u64_type,
+ .i64_type,
.usize_type,
+ .isize_type,
.c_short_type,
.c_ushort_type,
.c_int_type,
@@ -345,12 +489,11 @@ pub const Value = extern union {
.null_type,
.undefined_type,
.fn_noreturn_no_args_type,
+ .fn_void_no_args_type,
.fn_naked_noreturn_no_args_type,
.fn_ccc_void_no_args_type,
.single_const_pointer_to_comptime_int_type,
.const_slice_u8_type,
- .bool_true,
- .bool_false,
.null_value,
.function,
.ref_val,
@@ -363,8 +506,11 @@ pub const Value = extern union {
.zero,
.the_one_possible_value, // an integer with one possible value is always zero
+ .bool_false,
=> return 0,
+ .bool_true => return 1,
+
.int_u64 => return self.cast(Payload.Int_u64).?.int,
.int_i64 => return @intCast(u64, self.cast(Payload.Int_u64).?.int),
.int_big_positive => return self.cast(Payload.IntBigPositive).?.asBigInt().to(u64) catch unreachable,
@@ -379,8 +525,14 @@ pub const Value = extern union {
.ty,
.u8_type,
.i8_type,
- .isize_type,
+ .u16_type,
+ .i16_type,
+ .u32_type,
+ .i32_type,
+ .u64_type,
+ .i64_type,
.usize_type,
+ .isize_type,
.c_short_type,
.c_ushort_type,
.c_int_type,
@@ -405,12 +557,11 @@ pub const Value = extern union {
.null_type,
.undefined_type,
.fn_noreturn_no_args_type,
+ .fn_void_no_args_type,
.fn_naked_noreturn_no_args_type,
.fn_ccc_void_no_args_type,
.single_const_pointer_to_comptime_int_type,
.const_slice_u8_type,
- .bool_true,
- .bool_false,
.null_value,
.function,
.ref_val,
@@ -423,8 +574,11 @@ pub const Value = extern union {
.the_one_possible_value, // an integer with one possible value is always zero
.zero,
+ .bool_false,
=> return 0,
+ .bool_true => return 1,
+
.int_u64 => {
const x = self.cast(Payload.Int_u64).?.int;
if (x == 0) return 0;
@@ -444,8 +598,14 @@ pub const Value = extern union {
.ty,
.u8_type,
.i8_type,
- .isize_type,
+ .u16_type,
+ .i16_type,
+ .u32_type,
+ .i32_type,
+ .u64_type,
+ .i64_type,
.usize_type,
+ .isize_type,
.c_short_type,
.c_ushort_type,
.c_int_type,
@@ -470,12 +630,11 @@ pub const Value = extern union {
.null_type,
.undefined_type,
.fn_noreturn_no_args_type,
+ .fn_void_no_args_type,
.fn_naked_noreturn_no_args_type,
.fn_ccc_void_no_args_type,
.single_const_pointer_to_comptime_int_type,
.const_slice_u8_type,
- .bool_true,
- .bool_false,
.null_value,
.function,
.ref_val,
@@ -488,8 +647,18 @@ pub const Value = extern union {
.zero,
.undef,
.the_one_possible_value, // an integer with one possible value is always zero
+ .bool_false,
=> return true,
+ .bool_true => {
+ const info = ty.intInfo(target);
+ if (info.signed) {
+ return info.bits >= 2;
+ } else {
+ return info.bits >= 1;
+ }
+ },
+
.int_u64 => switch (ty.zigTypeTag()) {
.Int => {
const x = self.cast(Payload.Int_u64).?.int;
@@ -538,8 +707,14 @@ pub const Value = extern union {
.ty,
.u8_type,
.i8_type,
- .isize_type,
+ .u16_type,
+ .i16_type,
+ .u32_type,
+ .i32_type,
+ .u64_type,
+ .i64_type,
.usize_type,
+ .isize_type,
.c_short_type,
.c_ushort_type,
.c_int_type,
@@ -564,6 +739,7 @@ pub const Value = extern union {
.null_type,
.undefined_type,
.fn_noreturn_no_args_type,
+ .fn_void_no_args_type,
.fn_naked_noreturn_no_args_type,
.fn_ccc_void_no_args_type,
.single_const_pointer_to_comptime_int_type,
@@ -594,8 +770,14 @@ pub const Value = extern union {
.ty,
.u8_type,
.i8_type,
- .isize_type,
+ .u16_type,
+ .i16_type,
+ .u32_type,
+ .i32_type,
+ .u64_type,
+ .i64_type,
.usize_type,
+ .isize_type,
.c_short_type,
.c_ushort_type,
.c_int_type,
@@ -620,12 +802,11 @@ pub const Value = extern union {
.null_type,
.undefined_type,
.fn_noreturn_no_args_type,
+ .fn_void_no_args_type,
.fn_naked_noreturn_no_args_type,
.fn_ccc_void_no_args_type,
.single_const_pointer_to_comptime_int_type,
.const_slice_u8_type,
- .bool_true,
- .bool_false,
.null_value,
.function,
.ref_val,
@@ -638,8 +819,11 @@ pub const Value = extern union {
.zero,
.the_one_possible_value, // an integer with one possible value is always zero
+ .bool_false,
=> return .eq,
+ .bool_true => return .gt,
+
.int_u64 => return std.math.order(lhs.cast(Payload.Int_u64).?.int, 0),
.int_i64 => return std.math.order(lhs.cast(Payload.Int_i64).?.int, 0),
.int_big_positive => return lhs.cast(Payload.IntBigPositive).?.asBigInt().orderAgainstScalar(0),
@@ -683,7 +867,7 @@ pub const Value = extern union {
pub fn toBool(self: Value) bool {
return switch (self.tag()) {
.bool_true => true,
- .bool_false => false,
+ .bool_false, .zero => false,
else => unreachable,
};
}
@@ -695,8 +879,14 @@ pub const Value = extern union {
.ty,
.u8_type,
.i8_type,
- .isize_type,
+ .u16_type,
+ .i16_type,
+ .u32_type,
+ .i32_type,
+ .u64_type,
+ .i64_type,
.usize_type,
+ .isize_type,
.c_short_type,
.c_ushort_type,
.c_int_type,
@@ -721,6 +911,7 @@ pub const Value = extern union {
.null_type,
.undefined_type,
.fn_noreturn_no_args_type,
+ .fn_void_no_args_type,
.fn_naked_noreturn_no_args_type,
.fn_ccc_void_no_args_type,
.single_const_pointer_to_comptime_int_type,
@@ -757,8 +948,14 @@ pub const Value = extern union {
.ty,
.u8_type,
.i8_type,
- .isize_type,
+ .u16_type,
+ .i16_type,
+ .u32_type,
+ .i32_type,
+ .u64_type,
+ .i64_type,
.usize_type,
+ .isize_type,
.c_short_type,
.c_ushort_type,
.c_int_type,
@@ -783,6 +980,7 @@ pub const Value = extern union {
.null_type,
.undefined_type,
.fn_noreturn_no_args_type,
+ .fn_void_no_args_type,
.fn_naked_noreturn_no_args_type,
.fn_ccc_void_no_args_type,
.single_const_pointer_to_comptime_int_type,
@@ -836,8 +1034,14 @@ pub const Value = extern union {
.ty,
.u8_type,
.i8_type,
- .isize_type,
+ .u16_type,
+ .i16_type,
+ .u32_type,
+ .i32_type,
+ .u64_type,
+ .i64_type,
.usize_type,
+ .isize_type,
.c_short_type,
.c_ushort_type,
.c_int_type,
@@ -862,6 +1066,7 @@ pub const Value = extern union {
.null_type,
.undefined_type,
.fn_noreturn_no_args_type,
+ .fn_void_no_args_type,
.fn_naked_noreturn_no_args_type,
.fn_ccc_void_no_args_type,
.single_const_pointer_to_comptime_int_type,
@@ -929,11 +1134,6 @@ pub const Value = extern union {
len: u64,
};
- pub const SingleConstPtrType = struct {
- base: Payload = Payload{ .tag = .single_const_ptr_type },
- elem_type: *Type,
- };
-
/// Represents a pointer to another immutable value.
pub const RefVal = struct {
base: Payload = Payload{ .tag = .ref_val },
diff --git a/src-self-hosted/zir.zig b/src-self-hosted/zir.zig
index a00782771d..5e8c966b94 100644
--- a/src-self-hosted/zir.zig
+++ b/src-self-hosted/zir.zig
@@ -12,29 +12,56 @@ const TypedValue = @import("TypedValue.zig");
const ir = @import("ir.zig");
const IrModule = @import("Module.zig");
+/// This struct is relevent only for the ZIR Module text format. It is not used for
+/// semantic analysis of Zig source code.
+pub const Decl = struct {
+ name: []const u8,
+
+ /// Hash of slice into the source of the part after the = and before the next instruction.
+ contents_hash: std.zig.SrcHash,
+
+ inst: *Inst,
+};
+
/// These are instructions that correspond to the ZIR text format. See `ir.Inst` for
/// in-memory, analyzed instructions with types and values.
pub const Inst = struct {
tag: Tag,
/// Byte offset into the source.
src: usize,
- name: []const u8,
-
- /// Slice into the source of the part after the = and before the next instruction.
- contents: []const u8 = &[0]u8{},
+ /// Pre-allocated field for mapping ZIR text instructions to post-analysis instructions.
+ analyzed_inst: ?*ir.Inst = null,
/// These names are used directly as the instruction names in the text format.
pub const Tag = enum {
+ /// Function parameter value. These must be first in a function's main block,
+ /// in respective order with the parameters.
+ arg,
+ /// A labeled block of code, which can return a value.
+ block,
+ /// Return a value from a `Block`.
+ @"break",
breakpoint,
+ /// Same as `break` but without an operand; the operand is assumed to be the void value.
+ breakvoid,
call,
compileerror,
+ /// Special case, has no textual representation.
+ @"const",
/// Represents a pointer to a global decl by name.
declref,
+ /// Represents a pointer to a global decl by string name.
+ declref_str,
/// The syntax `@foo` is equivalent to `declval("foo")`.
/// declval is equivalent to declref followed by deref.
declval,
+ /// Same as declval but the parameter is a `*Module.Decl` rather than a name.
+ declval_in_module,
+ boolnot,
+ /// String Literal. Makes an anonymous Decl and then takes a pointer to it.
str,
int,
+ inttype,
ptrtoint,
fieldptr,
deref,
@@ -42,30 +69,87 @@ pub const Inst = struct {
@"asm",
@"unreachable",
@"return",
+ returnvoid,
@"fn",
+ fntype,
@"export",
primitive,
- ref,
- fntype,
intcast,
bitcast,
elemptr,
add,
+ sub,
cmp,
condbr,
isnull,
isnonnull,
+
+ /// Returns whether the instruction is one of the control flow "noreturn" types.
+ /// Function calls do not count.
+ pub fn isNoReturn(tag: Tag) bool {
+ return switch (tag) {
+ .arg,
+ .block,
+ .breakpoint,
+ .call,
+ .@"const",
+ .declref,
+ .declref_str,
+ .declval,
+ .declval_in_module,
+ .str,
+ .int,
+ .inttype,
+ .ptrtoint,
+ .fieldptr,
+ .deref,
+ .as,
+ .@"asm",
+ .@"fn",
+ .fntype,
+ .@"export",
+ .primitive,
+ .intcast,
+ .bitcast,
+ .elemptr,
+ .add,
+ .sub,
+ .cmp,
+ .isnull,
+ .isnonnull,
+ .boolnot,
+ => false,
+
+ .condbr,
+ .@"unreachable",
+ .@"return",
+ .returnvoid,
+ .@"break",
+ .breakvoid,
+ .compileerror,
+ => true,
+ };
+ }
};
pub fn TagToType(tag: Tag) type {
return switch (tag) {
+ .arg => Arg,
+ .block => Block,
+ .@"break" => Break,
.breakpoint => Breakpoint,
+ .breakvoid => BreakVoid,
.call => Call,
.declref => DeclRef,
+ .declref_str => DeclRefStr,
.declval => DeclVal,
+ .declval_in_module => DeclValInModule,
.compileerror => CompileError,
+ .@"const" => Const,
+ .boolnot => BoolNot,
.str => Str,
.int => Int,
+ .inttype => IntType,
.ptrtoint => PtrToInt,
.fieldptr => FieldPtr,
.deref => Deref,
@@ -73,15 +157,16 @@ pub const Inst = struct {
.@"asm" => Asm,
.@"unreachable" => Unreachable,
.@"return" => Return,
+ .returnvoid => ReturnVoid,
.@"fn" => Fn,
.@"export" => Export,
.primitive => Primitive,
- .ref => Ref,
.fntype => FnType,
.intcast => IntCast,
.bitcast => BitCast,
.elemptr => ElemPtr,
.add => Add,
+ .sub => Sub,
.cmp => Cmp,
.condbr => CondBr,
.isnull => IsNull,
@@ -96,6 +181,35 @@ pub const Inst = struct {
return @fieldParentPtr(T, "base", base);
}
+ pub const Arg = struct {
+ pub const base_tag = Tag.arg;
+ base: Inst,
+
+ positionals: struct {},
+ kw_args: struct {},
+ };
+
+ pub const Block = struct {
+ pub const base_tag = Tag.block;
+ base: Inst,
+
+ positionals: struct {
+ body: Module.Body,
+ },
+ kw_args: struct {},
+ };
+
+ pub const Break = struct {
+ pub const base_tag = Tag.@"break";
+ base: Inst,
+
+ positionals: struct {
+ block: *Block,
+ operand: *Inst,
+ },
+ kw_args: struct {},
+ };
+
pub const Breakpoint = struct {
pub const base_tag = Tag.breakpoint;
base: Inst,
@@ -104,6 +218,16 @@ pub const Inst = struct {
kw_args: struct {},
};
+ pub const BreakVoid = struct {
+ pub const base_tag = Tag.breakvoid;
+ base: Inst,
+
+ positionals: struct {
+ block: *Block,
+ },
+ kw_args: struct {},
+ };
+
pub const Call = struct {
pub const base_tag = Tag.call;
base: Inst,
@@ -121,6 +245,16 @@ pub const Inst = struct {
pub const base_tag = Tag.declref;
base: Inst,
+ positionals: struct {
+ name: []const u8,
+ },
+ kw_args: struct {},
+ };
+
+ pub const DeclRefStr = struct {
+ pub const base_tag = Tag.declref_str;
+ base: Inst,
+
positionals: struct {
name: *Inst,
},
@@ -137,6 +271,16 @@ pub const Inst = struct {
kw_args: struct {},
};
+ pub const DeclValInModule = struct {
+ pub const base_tag = Tag.declval_in_module;
+ base: Inst,
+
+ positionals: struct {
+ decl: *IrModule.Decl,
+ },
+ kw_args: struct {},
+ };
+
pub const CompileError = struct {
pub const base_tag = Tag.compileerror;
base: Inst,
@@ -147,6 +291,26 @@ pub const Inst = struct {
kw_args: struct {},
};
+ pub const Const = struct {
+ pub const base_tag = Tag.@"const";
+ base: Inst,
+
+ positionals: struct {
+ typed_value: TypedValue,
+ },
+ kw_args: struct {},
+ };
+
+ pub const BoolNot = struct {
+ pub const base_tag = Tag.boolnot;
+ base: Inst,
+
+ positionals: struct {
+ operand: *Inst,
+ },
+ kw_args: struct {},
+ };
+
pub const Str = struct {
pub const base_tag = Tag.str;
base: Inst,
@@ -168,6 +332,7 @@ pub const Inst = struct {
};
pub const PtrToInt = struct {
+ pub const builtin_name = "@ptrToInt";
pub const base_tag = Tag.ptrtoint;
base: Inst,
@@ -200,6 +365,7 @@ pub const Inst = struct {
pub const As = struct {
pub const base_tag = Tag.as;
+ pub const builtin_name = "@as";
base: Inst,
positionals: struct {
@@ -238,6 +404,16 @@ pub const Inst = struct {
pub const base_tag = Tag.@"return";
base: Inst,
+ positionals: struct {
+ operand: *Inst,
+ },
+ kw_args: struct {},
+ };
+
+ pub const ReturnVoid = struct {
+ pub const base_tag = Tag.returnvoid;
+ base: Inst,
+
positionals: struct {},
kw_args: struct {},
};
@@ -253,23 +429,37 @@ pub const Inst = struct {
kw_args: struct {},
};
+ pub const FnType = struct {
+ pub const base_tag = Tag.fntype;
+ base: Inst,
+
+ positionals: struct {
+ param_types: []*Inst,
+ return_type: *Inst,
+ },
+ kw_args: struct {
+ cc: std.builtin.CallingConvention = .Unspecified,
+ },
+ };
+
+ pub const IntType = struct {
+ pub const base_tag = Tag.inttype;
+ base: Inst,
+
+ positionals: struct {
+ signed: *Inst,
+ bits: *Inst,
+ },
+ kw_args: struct {},
+ };
+
pub const Export = struct {
pub const base_tag = Tag.@"export";
base: Inst,
positionals: struct {
symbol_name: *Inst,
- value: *Inst,
- },
- kw_args: struct {},
- };
-
- pub const Ref = struct {
- pub const base_tag = Tag.ref;
- base: Inst,
-
- positionals: struct {
- operand: *Inst,
+ decl_name: []const u8,
},
kw_args: struct {},
};
@@ -284,6 +474,14 @@ pub const Inst = struct {
kw_args: struct {},
pub const Builtin = enum {
+ i8,
+ u8,
+ i16,
+ u16,
+ i32,
+ u32,
+ i64,
+ u64,
isize,
usize,
c_short,
@@ -315,6 +513,14 @@ pub const Inst = struct {
pub fn toTypedValue(self: Builtin) TypedValue {
return switch (self) {
+ .i8 => .{ .ty = Type.initTag(.type), .val = Value.initTag(.i8_type) },
+ .u8 => .{ .ty = Type.initTag(.type), .val = Value.initTag(.u8_type) },
+ .i16 => .{ .ty = Type.initTag(.type), .val = Value.initTag(.i16_type) },
+ .u16 => .{ .ty = Type.initTag(.type), .val = Value.initTag(.u16_type) },
+ .i32 => .{ .ty = Type.initTag(.type), .val = Value.initTag(.i32_type) },
+ .u32 => .{ .ty = Type.initTag(.type), .val = Value.initTag(.u32_type) },
+ .i64 => .{ .ty = Type.initTag(.type), .val = Value.initTag(.i64_type) },
+ .u64 => .{ .ty = Type.initTag(.type), .val = Value.initTag(.u64_type) },
.isize => .{ .ty = Type.initTag(.type), .val = Value.initTag(.isize_type) },
.usize => .{ .ty = Type.initTag(.type), .val = Value.initTag(.usize_type) },
.c_short => .{ .ty = Type.initTag(.type), .val = Value.initTag(.c_short_type) },
@@ -348,19 +554,6 @@ pub const Inst = struct {
};
};
- pub const FnType = struct {
- pub const base_tag = Tag.fntype;
- base: Inst,
-
- positionals: struct {
- param_types: []*Inst,
- return_type: *Inst,
- },
- kw_args: struct {
- cc: std.builtin.CallingConvention = .Unspecified,
- },
- };
-
pub const IntCast = struct {
pub const base_tag = Tag.intcast;
base: Inst,
@@ -405,6 +598,19 @@ pub const Inst = struct {
kw_args: struct {},
};
+ pub const Sub = struct {
+ pub const base_tag = Tag.sub;
+ base: Inst,
+
+ positionals: struct {
+ lhs: *Inst,
+ rhs: *Inst,
+ },
+ kw_args: struct {},
+ };
+
+ /// TODO get rid of the op positional arg and make that data part of
+ /// the base Inst tag.
pub const Cmp = struct {
pub const base_tag = Tag.cmp;
base: Inst,
@@ -456,7 +662,7 @@ pub const ErrorMsg = struct {
};
pub const Module = struct {
- decls: []*Inst,
+ decls: []*Decl,
arena: std.heap.ArenaAllocator,
error_msg: ?ErrorMsg = null,
@@ -475,13 +681,31 @@ pub const Module = struct {
self.writeToStream(std.heap.page_allocator, std.io.getStdErr().outStream()) catch {};
}
- const InstPtrTable = std.AutoHashMap(*Inst, struct { inst: *Inst, index: ?usize });
+ const DeclAndIndex = struct {
+ decl: *Decl,
+ index: usize,
+ };
/// TODO Look into making a table to speed this up.
- pub fn findDecl(self: Module, name: []const u8) ?*Inst {
- for (self.decls) |decl| {
+ pub fn findDecl(self: Module, name: []const u8) ?DeclAndIndex {
+ for (self.decls) |decl, i| {
if (mem.eql(u8, decl.name, name)) {
- return decl;
+ return DeclAndIndex{
+ .decl = decl,
+ .index = i,
+ };
+ }
+ }
+ return null;
+ }
+
+ pub fn findInstDecl(self: Module, inst: *Inst) ?DeclAndIndex {
+ for (self.decls) |decl, i| {
+ if (decl.inst == inst) {
+ return DeclAndIndex{
+ .decl = decl,
+ .index = i,
+ };
}
}
return null;
@@ -489,75 +713,68 @@ pub const Module = struct {
/// The allocator is used for temporary storage, but this function always returns
/// with no resources allocated.
- pub fn writeToStream(self: Module, allocator: *Allocator, stream: var) !void {
- // First, build a map of *Inst to @ or % indexes
- var inst_table = InstPtrTable.init(allocator);
- defer inst_table.deinit();
+ pub fn writeToStream(self: Module, allocator: *Allocator, stream: anytype) !void {
+ var write = Writer{
+ .module = &self,
+ .inst_table = InstPtrTable.init(allocator),
+ .block_table = std.AutoHashMap(*Inst.Block, []const u8).init(allocator),
+ .arena = std.heap.ArenaAllocator.init(allocator),
+ .indent = 2,
+ };
+ defer write.arena.deinit();
+ defer write.inst_table.deinit();
+ defer write.block_table.deinit();
- try inst_table.ensureCapacity(self.decls.len);
+ // First, build a map of *Inst to @ or % indexes
+ try write.inst_table.ensureCapacity(self.decls.len);
for (self.decls) |decl, decl_i| {
- try inst_table.putNoClobber(decl, .{ .inst = decl, .index = null });
+ try write.inst_table.putNoClobber(decl.inst, .{ .inst = decl.inst, .index = null, .name = decl.name });
- if (decl.cast(Inst.Fn)) |fn_inst| {
+ if (decl.inst.cast(Inst.Fn)) |fn_inst| {
for (fn_inst.positionals.body.instructions) |inst, inst_i| {
- try inst_table.putNoClobber(inst, .{ .inst = inst, .index = inst_i });
+ try write.inst_table.putNoClobber(inst, .{ .inst = inst, .index = inst_i, .name = undefined });
}
}
}
for (self.decls) |decl, i| {
try stream.print("@{} ", .{decl.name});
- try self.writeInstToStream(stream, decl, &inst_table);
+ try write.writeInstToStream(stream, decl.inst);
try stream.writeByte('\n');
}
}
+};
+
+const InstPtrTable = std.AutoHashMap(*Inst, struct { inst: *Inst, index: ?usize, name: []const u8 });
+
+const Writer = struct {
+ module: *const Module,
+ inst_table: InstPtrTable,
+ block_table: std.AutoHashMap(*Inst.Block, []const u8),
+ arena: std.heap.ArenaAllocator,
+ indent: usize,
fn writeInstToStream(
- self: Module,
- stream: var,
- decl: *Inst,
- inst_table: *const InstPtrTable,
- ) @TypeOf(stream).Error!void {
- // TODO I tried implementing this with an inline for loop and hit a compiler bug
- switch (decl.tag) {
- .breakpoint => return self.writeInstToStreamGeneric(stream, .breakpoint, decl, inst_table),
- .call => return self.writeInstToStreamGeneric(stream, .call, decl, inst_table),
- .declref => return self.writeInstToStreamGeneric(stream, .declref, decl, inst_table),
- .declval => return self.writeInstToStreamGeneric(stream, .declval, decl, inst_table),
- .compileerror => return self.writeInstToStreamGeneric(stream, .compileerror, decl, inst_table),
- .str => return self.writeInstToStreamGeneric(stream, .str, decl, inst_table),
- .int => return self.writeInstToStreamGeneric(stream, .int, decl, inst_table),
- .ptrtoint => return self.writeInstToStreamGeneric(stream, .ptrtoint, decl, inst_table),
- .fieldptr => return self.writeInstToStreamGeneric(stream, .fieldptr, decl, inst_table),
- .deref => return self.writeInstToStreamGeneric(stream, .deref, decl, inst_table),
- .as => return self.writeInstToStreamGeneric(stream, .as, decl, inst_table),
- .@"asm" => return self.writeInstToStreamGeneric(stream, .@"asm", decl, inst_table),
- .@"unreachable" => return self.writeInstToStreamGeneric(stream, .@"unreachable", decl, inst_table),
- .@"return" => return self.writeInstToStreamGeneric(stream, .@"return", decl, inst_table),
- .@"fn" => return self.writeInstToStreamGeneric(stream, .@"fn", decl, inst_table),
- .@"export" => return self.writeInstToStreamGeneric(stream, .@"export", decl, inst_table),
- .ref => return self.writeInstToStreamGeneric(stream, .ref, decl, inst_table),
- .primitive => return self.writeInstToStreamGeneric(stream, .primitive, decl, inst_table),
- .fntype => return self.writeInstToStreamGeneric(stream, .fntype, decl, inst_table),
- .intcast => return self.writeInstToStreamGeneric(stream, .intcast, decl, inst_table),
- .bitcast => return self.writeInstToStreamGeneric(stream, .bitcast, decl, inst_table),
- .elemptr => return self.writeInstToStreamGeneric(stream, .elemptr, decl, inst_table),
- .add => return self.writeInstToStreamGeneric(stream, .add, decl, inst_table),
- .cmp => return self.writeInstToStreamGeneric(stream, .cmp, decl, inst_table),
- .condbr => return self.writeInstToStreamGeneric(stream, .condbr, decl, inst_table),
- .isnull => return self.writeInstToStreamGeneric(stream, .isnull, decl, inst_table),
- .isnonnull => return self.writeInstToStreamGeneric(stream, .isnonnull, decl, inst_table),
+ self: *Writer,
+ stream: anytype,
+ inst: *Inst,
+ ) (@TypeOf(stream).Error || error{OutOfMemory})!void {
+ inline for (@typeInfo(Inst.Tag).Enum.fields) |enum_field| {
+ const expected_tag = @field(Inst.Tag, enum_field.name);
+ if (inst.tag == expected_tag) {
+ return self.writeInstToStreamGeneric(stream, expected_tag, inst);
+ }
}
+ unreachable; // all tags handled
}
fn writeInstToStreamGeneric(
- self: Module,
- stream: var,
+ self: *Writer,
+ stream: anytype,
comptime inst_tag: Inst.Tag,
base: *Inst,
- inst_table: *const InstPtrTable,
- ) !void {
+ ) (@TypeOf(stream).Error || error{OutOfMemory})!void {
const SpecificInst = Inst.TagToType(inst_tag);
const inst = @fieldParentPtr(SpecificInst, "base", base);
const Positionals = @TypeOf(inst.positionals);
@@ -567,7 +784,7 @@ pub const Module = struct {
if (i != 0) {
try stream.writeAll(", ");
}
- try self.writeParamToStream(stream, @field(inst.positionals, arg_field.name), inst_table);
+ try self.writeParamToStream(stream, @field(inst.positionals, arg_field.name));
}
comptime var need_comma = pos_fields.len != 0;
@@ -577,13 +794,13 @@ pub const Module = struct {
if (@field(inst.kw_args, arg_field.name)) |non_optional| {
if (need_comma) try stream.writeAll(", ");
try stream.print("{}=", .{arg_field.name});
- try self.writeParamToStream(stream, non_optional, inst_table);
+ try self.writeParamToStream(stream, non_optional);
need_comma = true;
}
} else {
if (need_comma) try stream.writeAll(", ");
try stream.print("{}=", .{arg_field.name});
- try self.writeParamToStream(stream, @field(inst.kw_args, arg_field.name), inst_table);
+ try self.writeParamToStream(stream, @field(inst.kw_args, arg_field.name));
need_comma = true;
}
}
@@ -591,56 +808,73 @@ pub const Module = struct {
try stream.writeByte(')');
}
- fn writeParamToStream(self: Module, stream: var, param: var, inst_table: *const InstPtrTable) !void {
+ fn writeParamToStream(self: *Writer, stream: anytype, param: anytype) !void {
if (@typeInfo(@TypeOf(param)) == .Enum) {
return stream.writeAll(@tagName(param));
}
switch (@TypeOf(param)) {
- *Inst => return self.writeInstParamToStream(stream, param, inst_table),
+ *Inst => return self.writeInstParamToStream(stream, param),
[]*Inst => {
try stream.writeByte('[');
for (param) |inst, i| {
if (i != 0) {
try stream.writeAll(", ");
}
- try self.writeInstParamToStream(stream, inst, inst_table);
+ try self.writeInstParamToStream(stream, inst);
}
try stream.writeByte(']');
},
Module.Body => {
try stream.writeAll("{\n");
for (param.instructions) |inst, i| {
- try stream.print(" %{} ", .{i});
- try self.writeInstToStream(stream, inst, inst_table);
+ try stream.writeByteNTimes(' ', self.indent);
+ try stream.print("%{} ", .{i});
+ if (inst.cast(Inst.Block)) |block| {
+ const name = try std.fmt.allocPrint(&self.arena.allocator, "label_{}", .{i});
+ try self.block_table.put(block, name);
+ }
+ self.indent += 2;
+ try self.writeInstToStream(stream, inst);
+ self.indent -= 2;
try stream.writeByte('\n');
}
+ try stream.writeByteNTimes(' ', self.indent - 2);
try stream.writeByte('}');
},
bool => return stream.writeByte("01"[@boolToInt(param)]),
[]u8, []const u8 => return std.zig.renderStringLiteral(param, stream),
- BigIntConst => return stream.print("{}", .{param}),
+ BigIntConst, usize => return stream.print("{}", .{param}),
+ TypedValue => unreachable, // this is a special case
+ *IrModule.Decl => unreachable, // this is a special case
+ *Inst.Block => {
+ const name = self.block_table.get(param).?;
+ return std.zig.renderStringLiteral(name, stream);
+ },
else => |T| @compileError("unimplemented: rendering parameter of type " ++ @typeName(T)),
}
}
- fn writeInstParamToStream(self: Module, stream: var, inst: *Inst, inst_table: *const InstPtrTable) !void {
- if (inst_table.getValue(inst)) |info| {
+ fn writeInstParamToStream(self: *Writer, stream: anytype, inst: *Inst) !void {
+ if (self.inst_table.get(inst)) |info| {
if (info.index) |i| {
try stream.print("%{}", .{info.index});
} else {
- try stream.print("@{}", .{info.inst.name});
+ try stream.print("@{}", .{info.name});
}
} else if (inst.cast(Inst.DeclVal)) |decl_val| {
try stream.print("@{}", .{decl_val.positionals.name});
+ } else if (inst.cast(Inst.DeclValInModule)) |decl_val| {
+ try stream.print("@{}", .{decl_val.positionals.decl.name});
} else {
- //try stream.print("?", .{});
- unreachable;
+ // This should be unreachable in theory, but since ZIR is used for debugging the compiler
+ // we output some debug text instead.
+ try stream.print("?{}?", .{@tagName(inst.tag)});
}
}
};
pub fn parse(allocator: *Allocator, source: [:0]const u8) Allocator.Error!Module {
- var global_name_map = std.StringHashMap(usize).init(allocator);
+ var global_name_map = std.StringHashMap(*Inst).init(allocator);
defer global_name_map.deinit();
var parser: Parser = .{
@@ -651,7 +885,9 @@ pub fn parse(allocator: *Allocator, source: [:0]const u8) Allocator.Error!Module
.global_name_map = &global_name_map,
.decls = .{},
.unnamed_index = 0,
+ .block_table = std.StringHashMap(*Inst.Block).init(allocator),
};
+ defer parser.block_table.deinit();
errdefer parser.arena.deinit();
parser.parseRoot() catch |err| switch (err) {
@@ -673,23 +909,26 @@ const Parser = struct {
arena: std.heap.ArenaAllocator,
i: usize,
source: [:0]const u8,
- decls: std.ArrayListUnmanaged(*Inst),
- global_name_map: *std.StringHashMap(usize),
+ decls: std.ArrayListUnmanaged(*Decl),
+ global_name_map: *std.StringHashMap(*Inst),
error_msg: ?ErrorMsg = null,
unnamed_index: usize,
+ block_table: std.StringHashMap(*Inst.Block),
const Body = struct {
instructions: std.ArrayList(*Inst),
- name_map: std.StringHashMap(usize),
+ name_map: *std.StringHashMap(*Inst),
};
- fn parseBody(self: *Parser) !Module.Body {
+ fn parseBody(self: *Parser, body_ctx: ?*Body) !Module.Body {
+ var name_map = std.StringHashMap(*Inst).init(self.allocator);
+ defer name_map.deinit();
+
var body_context = Body{
.instructions = std.ArrayList(*Inst).init(self.allocator),
- .name_map = std.StringHashMap(usize).init(self.allocator),
+ .name_map = if (body_ctx) |bctx| bctx.name_map else &name_map,
};
defer body_context.instructions.deinit();
- defer body_context.name_map.deinit();
try requireEatBytes(self, "{");
skipSpace(self);
@@ -702,12 +941,12 @@ const Parser = struct {
skipSpace(self);
try requireEatBytes(self, "=");
skipSpace(self);
- const inst = try parseInstruction(self, &body_context, ident);
+ const decl = try parseInstruction(self, &body_context, ident);
const ident_index = body_context.instructions.items.len;
- if (try body_context.name_map.put(ident, ident_index)) |_| {
+ if (try body_context.name_map.fetchPut(ident, decl.inst)) |_| {
return self.fail("redefinition of identifier '{}'", .{ident});
}
- try body_context.instructions.append(inst);
+ try body_context.instructions.append(decl.inst);
continue;
},
' ', '\n' => continue,
@@ -788,12 +1027,12 @@ const Parser = struct {
skipSpace(self);
try requireEatBytes(self, "=");
skipSpace(self);
- const inst = try parseInstruction(self, null, ident);
+ const decl = try parseInstruction(self, null, ident);
const ident_index = self.decls.items.len;
- if (try self.global_name_map.put(ident, ident_index)) |_| {
+ if (try self.global_name_map.fetchPut(ident, decl.inst)) |_| {
return self.fail("redefinition of identifier '{}'", .{ident});
}
- try self.decls.append(self.allocator, inst);
+ try self.decls.append(self.allocator, decl);
},
' ', '\n' => self.i += 1,
0 => break,
@@ -848,7 +1087,7 @@ const Parser = struct {
}
}
- fn fail(self: *Parser, comptime format: []const u8, args: var) InnerError {
+ fn fail(self: *Parser, comptime format: []const u8, args: anytype) InnerError {
@setCold(true);
self.error_msg = ErrorMsg{
.byte_offset = self.i,
@@ -857,7 +1096,7 @@ const Parser = struct {
return error.ParseFailure;
}
- fn parseInstruction(self: *Parser, body_ctx: ?*Body, name: []const u8) InnerError!*Inst {
+ fn parseInstruction(self: *Parser, body_ctx: ?*Body, name: []const u8) InnerError!*Decl {
const contents_start = self.i;
const fn_name = try skipToAndOver(self, '(');
inline for (@typeInfo(Inst.Tag).Enum.fields) |field| {
@@ -876,14 +1115,17 @@ const Parser = struct {
body_ctx: ?*Body,
inst_name: []const u8,
contents_start: usize,
- ) InnerError!*Inst {
+ ) InnerError!*Decl {
const inst_specific = try self.arena.allocator.create(InstType);
inst_specific.base = .{
- .name = inst_name,
.src = self.i,
.tag = InstType.base_tag,
};
+ if (InstType == Inst.Block) {
+ try self.block_table.put(inst_name, inst_specific);
+ }
+
if (@hasField(InstType, "ty")) {
inst_specific.ty = opt_type orelse {
return self.fail("instruction '" ++ fn_name ++ "' requires type", .{});
@@ -929,10 +1171,15 @@ const Parser = struct {
}
try requireEatBytes(self, ")");
- inst_specific.base.contents = self.source[contents_start..self.i];
+ const decl = try self.arena.allocator.create(Decl);
+ decl.* = .{
+ .name = inst_name,
+ .contents_hash = std.zig.hashSrc(self.source[contents_start..self.i]),
+ .inst = &inst_specific.base,
+ };
//std.debug.warn("parsed {} = '{}'\n", .{ inst_specific.base.name, inst_specific.base.contents });
- return &inst_specific.base;
+ return decl;
}
fn parseParameterGeneric(self: *Parser, comptime T: type, body_ctx: ?*Body) !T {
@@ -950,7 +1197,7 @@ const Parser = struct {
};
}
switch (T) {
- Module.Body => return parseBody(self),
+ Module.Body => return parseBody(self, body_ctx),
bool => {
const bool_value = switch (self.source[self.i]) {
'0' => false,
@@ -978,6 +1225,16 @@ const Parser = struct {
*Inst => return parseParameterInst(self, body_ctx),
[]u8, []const u8 => return self.parseStringLiteral(),
BigIntConst => return self.parseIntegerLiteral(),
+ usize => {
+ const big_int = try self.parseIntegerLiteral();
+ return big_int.to(usize) catch |err| return self.fail("integer literal: {}", .{@errorName(err)});
+ },
+ TypedValue => return self.fail("'const' is a special instruction; not legal in ZIR text", .{}),
+ *IrModule.Decl => return self.fail("'declval_in_module' is a special instruction; not legal in ZIR text", .{}),
+ *Inst.Block => {
+ const name = try self.parseStringLiteral();
+ return self.block_table.get(name).?;
+ },
else => @compileError("Unimplemented: ir parseParameterGeneric for type " ++ @typeName(T)),
}
return self.fail("TODO parse parameter {}", .{@typeName(T)});
@@ -991,7 +1248,7 @@ const Parser = struct {
};
const map = if (local_ref)
if (body_ctx) |bc|
- &bc.name_map
+ bc.name_map
else
return self.fail("referencing a % instruction in global scope", .{})
else
@@ -1004,7 +1261,7 @@ const Parser = struct {
else => continue,
};
const ident = self.source[name_start..self.i];
- const kv = map.get(ident) orelse {
+ return map.get(ident) orelse {
const bad_name = self.source[name_start - 1 .. self.i];
const src = name_start - 1;
if (local_ref) {
@@ -1014,7 +1271,6 @@ const Parser = struct {
const declval = try self.arena.allocator.create(Inst.DeclVal);
declval.* = .{
.base = .{
- .name = try self.generateName(),
.src = src,
.tag = Inst.DeclVal.base_tag,
},
@@ -1024,11 +1280,6 @@ const Parser = struct {
return &declval.base;
}
};
- if (local_ref) {
- return body_ctx.?.instructions.items[kv.value];
- } else {
- return self.decls.items[kv.value];
- }
}
fn generateName(self: *Parser) ![]u8 {
@@ -1046,8 +1297,11 @@ pub fn emit(allocator: *Allocator, old_module: IrModule) !Module {
.old_module = &old_module,
.next_auto_name = 0,
.names = std.StringHashMap(void).init(allocator),
- .primitive_table = std.AutoHashMap(Inst.Primitive.Builtin, *Inst).init(allocator),
+ .primitive_table = std.AutoHashMap(Inst.Primitive.Builtin, *Decl).init(allocator),
+ .indent = 0,
+ .block_table = std.AutoHashMap(*ir.Inst.Block, *Inst.Block).init(allocator),
};
+ defer ctx.block_table.deinit();
defer ctx.decls.deinit(allocator);
defer ctx.names.deinit();
defer ctx.primitive_table.deinit();
@@ -1065,74 +1319,115 @@ const EmitZIR = struct {
allocator: *Allocator,
arena: std.heap.ArenaAllocator,
old_module: *const IrModule,
- decls: std.ArrayListUnmanaged(*Inst),
+ decls: std.ArrayListUnmanaged(*Decl),
names: std.StringHashMap(void),
next_auto_name: usize,
- primitive_table: std.AutoHashMap(Inst.Primitive.Builtin, *Inst),
+ primitive_table: std.AutoHashMap(Inst.Primitive.Builtin, *Decl),
+ indent: usize,
+ block_table: std.AutoHashMap(*ir.Inst.Block, *Inst.Block),
fn emit(self: *EmitZIR) !void {
// Put all the Decls in a list and sort them by name to avoid nondeterminism introduced
// by the hash table.
var src_decls = std.ArrayList(*IrModule.Decl).init(self.allocator);
defer src_decls.deinit();
- try src_decls.ensureCapacity(self.old_module.decl_table.size);
- try self.decls.ensureCapacity(self.allocator, self.old_module.decl_table.size);
- try self.names.ensureCapacity(self.old_module.decl_table.size);
+ try src_decls.ensureCapacity(self.old_module.decl_table.items().len);
+ try self.decls.ensureCapacity(self.allocator, self.old_module.decl_table.items().len);
+ try self.names.ensureCapacity(self.old_module.decl_table.items().len);
- var decl_it = self.old_module.decl_table.iterator();
- while (decl_it.next()) |kv| {
- const decl = kv.value;
+ for (self.old_module.decl_table.items()) |entry| {
+ const decl = entry.value;
src_decls.appendAssumeCapacity(decl);
self.names.putAssumeCapacityNoClobber(mem.spanZ(decl.name), {});
}
std.sort.sort(*IrModule.Decl, src_decls.items, {}, (struct {
fn lessThan(context: void, a: *IrModule.Decl, b: *IrModule.Decl) bool {
- return a.src < b.src;
+ return a.src_index < b.src_index;
}
}).lessThan);
// Emit all the decls.
for (src_decls.items) |ir_decl| {
- if (self.old_module.export_owners.getValue(ir_decl)) |exports| {
+ switch (ir_decl.analysis) {
+ .unreferenced => continue,
+
+ .complete => {},
+ .codegen_failure => {}, // We still can emit the ZIR.
+ .codegen_failure_retryable => {}, // We still can emit the ZIR.
+
+ .in_progress => unreachable,
+ .outdated => unreachable,
+
+ .sema_failure,
+ .sema_failure_retryable,
+ .dependency_failure,
+ => if (self.old_module.failed_decls.get(ir_decl)) |err_msg| {
+ const fail_inst = try self.arena.allocator.create(Inst.CompileError);
+ fail_inst.* = .{
+ .base = .{
+ .src = ir_decl.src(),
+ .tag = Inst.CompileError.base_tag,
+ },
+ .positionals = .{
+ .msg = try self.arena.allocator.dupe(u8, err_msg.msg),
+ },
+ .kw_args = .{},
+ };
+ const decl = try self.arena.allocator.create(Decl);
+ decl.* = .{
+ .name = mem.spanZ(ir_decl.name),
+ .contents_hash = undefined,
+ .inst = &fail_inst.base,
+ };
+ try self.decls.append(self.allocator, decl);
+ continue;
+ },
+ }
+ if (self.old_module.export_owners.get(ir_decl)) |exports| {
for (exports) |module_export| {
- const declval = try self.emitDeclVal(ir_decl.src, mem.spanZ(module_export.exported_decl.name));
const symbol_name = try self.emitStringLiteral(module_export.src, module_export.options.name);
const export_inst = try self.arena.allocator.create(Inst.Export);
export_inst.* = .{
.base = .{
- .name = try self.autoName(),
.src = module_export.src,
.tag = Inst.Export.base_tag,
},
.positionals = .{
- .symbol_name = symbol_name,
- .value = declval,
+ .symbol_name = symbol_name.inst,
+ .decl_name = mem.spanZ(module_export.exported_decl.name),
},
.kw_args = .{},
};
- try self.decls.append(self.allocator, &export_inst.base);
+ _ = try self.emitUnnamedDecl(&export_inst.base);
}
} else {
- const new_decl = try self.emitTypedValue(ir_decl.src, ir_decl.typed_value.most_recent.typed_value);
+ const new_decl = try self.emitTypedValue(ir_decl.src(), ir_decl.typed_value.most_recent.typed_value);
new_decl.name = try self.arena.allocator.dupe(u8, mem.spanZ(ir_decl.name));
}
}
}
- fn resolveInst(self: *EmitZIR, inst_table: *std.AutoHashMap(*ir.Inst, *Inst), inst: *ir.Inst) !*Inst {
+ const ZirBody = struct {
+ inst_table: *std.AutoHashMap(*ir.Inst, *Inst),
+ instructions: *std.ArrayList(*Inst),
+ };
+
+ fn resolveInst(self: *EmitZIR, new_body: ZirBody, inst: *ir.Inst) !*Inst {
if (inst.cast(ir.Inst.Constant)) |const_inst| {
- const new_decl = if (const_inst.val.cast(Value.Payload.Function)) |func_pl| blk: {
+ const new_inst = if (const_inst.val.cast(Value.Payload.Function)) |func_pl| blk: {
const owner_decl = func_pl.func.owner_decl;
break :blk try self.emitDeclVal(inst.src, mem.spanZ(owner_decl.name));
} else if (const_inst.val.cast(Value.Payload.DeclRef)) |declref| blk: {
- break :blk try self.emitDeclRef(inst.src, declref.decl);
+ const decl_ref = try self.emitDeclRef(inst.src, declref.decl);
+ try new_body.instructions.append(decl_ref);
+ break :blk decl_ref;
} else blk: {
- break :blk try self.emitTypedValue(inst.src, .{ .ty = inst.ty, .val = const_inst.val });
+ break :blk (try self.emitTypedValue(inst.src, .{ .ty = inst.ty, .val = const_inst.val })).inst;
};
- try inst_table.putNoClobber(inst, new_decl);
- return new_decl;
+ try new_body.inst_table.putNoClobber(inst, new_inst);
+ return new_inst;
} else {
- return inst_table.getValue(inst).?;
+ return new_body.inst_table.get(inst).?;
}
}
@@ -1140,7 +1435,6 @@ const EmitZIR = struct {
const declval = try self.arena.allocator.create(Inst.DeclVal);
declval.* = .{
.base = .{
- .name = try self.autoName(),
.src = src,
.tag = Inst.DeclVal.base_tag,
},
@@ -1150,12 +1444,11 @@ const EmitZIR = struct {
return &declval.base;
}
- fn emitComptimeIntVal(self: *EmitZIR, src: usize, val: Value) !*Inst {
+ fn emitComptimeIntVal(self: *EmitZIR, src: usize, val: Value) !*Decl {
const big_int_space = try self.arena.allocator.create(Value.BigIntSpace);
const int_inst = try self.arena.allocator.create(Inst.Int);
int_inst.* = .{
.base = .{
- .name = try self.autoName(),
.src = src,
.tag = Inst.Int.base_tag,
},
@@ -1164,34 +1457,29 @@ const EmitZIR = struct {
},
.kw_args = .{},
};
- try self.decls.append(self.allocator, &int_inst.base);
- return &int_inst.base;
+ return self.emitUnnamedDecl(&int_inst.base);
}
- fn emitDeclRef(self: *EmitZIR, src: usize, decl: *IrModule.Decl) !*Inst {
- const declval = try self.emitDeclVal(src, mem.spanZ(decl.name));
- const ref_inst = try self.arena.allocator.create(Inst.Ref);
- ref_inst.* = .{
+ fn emitDeclRef(self: *EmitZIR, src: usize, module_decl: *IrModule.Decl) !*Inst {
+ const declref_inst = try self.arena.allocator.create(Inst.DeclRef);
+ declref_inst.* = .{
.base = .{
- .name = try self.autoName(),
.src = src,
- .tag = Inst.Ref.base_tag,
+ .tag = Inst.DeclRef.base_tag,
},
.positionals = .{
- .operand = declval,
+ .name = mem.spanZ(module_decl.name),
},
.kw_args = .{},
};
- try self.decls.append(self.allocator, &ref_inst.base);
-
- return &ref_inst.base;
+ return &declref_inst.base;
}
- fn emitTypedValue(self: *EmitZIR, src: usize, typed_value: TypedValue) Allocator.Error!*Inst {
+ fn emitTypedValue(self: *EmitZIR, src: usize, typed_value: TypedValue) Allocator.Error!*Decl {
const allocator = &self.arena.allocator;
if (typed_value.val.cast(Value.Payload.DeclRef)) |decl_ref| {
const decl = decl_ref.decl;
- return self.emitDeclRef(src, decl);
+ return try self.emitUnnamedDecl(try self.emitDeclRef(src, decl));
}
switch (typed_value.ty.zigTypeTag()) {
.Pointer => {
@@ -1218,18 +1506,16 @@ const EmitZIR = struct {
const as_inst = try self.arena.allocator.create(Inst.As);
as_inst.* = .{
.base = .{
- .name = try self.autoName(),
.src = src,
.tag = Inst.As.base_tag,
},
.positionals = .{
- .dest_type = try self.emitType(src, typed_value.ty),
- .value = try self.emitComptimeIntVal(src, typed_value.val),
+ .dest_type = (try self.emitType(src, typed_value.ty)).inst,
+ .value = (try self.emitComptimeIntVal(src, typed_value.val)).inst,
},
.kw_args = .{},
};
-
- return &as_inst.base;
+ return self.emitUnnamedDecl(&as_inst.base);
},
.Type => {
const ty = typed_value.val.toType();
@@ -1251,11 +1537,10 @@ const EmitZIR = struct {
try self.emitBody(body, &inst_table, &instructions);
},
.sema_failure => {
- const err_msg = self.old_module.failed_decls.getValue(module_fn.owner_decl).?;
+ const err_msg = self.old_module.failed_decls.get(module_fn.owner_decl).?;
const fail_inst = try self.arena.allocator.create(Inst.CompileError);
fail_inst.* = .{
.base = .{
- .name = try self.autoName(),
.src = src,
.tag = Inst.CompileError.base_tag,
},
@@ -1270,7 +1555,6 @@ const EmitZIR = struct {
const fail_inst = try self.arena.allocator.create(Inst.CompileError);
fail_inst.* = .{
.base = .{
- .name = try self.autoName(),
.src = src,
.tag = Inst.CompileError.base_tag,
},
@@ -1283,7 +1567,7 @@ const EmitZIR = struct {
},
}
- const fn_type = try self.emitType(src, module_fn.fn_type);
+ const fn_type = try self.emitType(src, typed_value.ty);
const arena_instrs = try self.arena.allocator.alloc(*Inst, instructions.items.len);
mem.copy(*Inst, arena_instrs, instructions.items);
@@ -1291,18 +1575,16 @@ const EmitZIR = struct {
const fn_inst = try self.arena.allocator.create(Inst.Fn);
fn_inst.* = .{
.base = .{
- .name = try self.autoName(),
.src = src,
.tag = Inst.Fn.base_tag,
},
.positionals = .{
- .fn_type = fn_type,
+ .fn_type = fn_type.inst,
.body = .{ .instructions = arena_instrs },
},
.kw_args = .{},
};
- try self.decls.append(self.allocator, &fn_inst.base);
- return &fn_inst.base;
+ return self.emitUnnamedDecl(&fn_inst.base);
},
.Array => {
// TODO more checks to make sure this can be emitted as a string literal
@@ -1318,7 +1600,6 @@ const EmitZIR = struct {
const str_inst = try self.arena.allocator.create(Inst.Str);
str_inst.* = .{
.base = .{
- .name = try self.autoName(),
.src = src,
.tag = Inst.Str.base_tag,
},
@@ -1327,8 +1608,7 @@ const EmitZIR = struct {
},
.kw_args = .{},
};
- try self.decls.append(self.allocator, &str_inst.base);
- return &str_inst.base;
+ return self.emitUnnamedDecl(&str_inst.base);
},
.Void => return self.emitPrimitive(src, .void_value),
else => |t| std.debug.panic("TODO implement emitTypedValue for {}", .{@tagName(t)}),
@@ -1339,7 +1619,6 @@ const EmitZIR = struct {
const new_inst = try self.arena.allocator.create(T);
new_inst.* = .{
.base = .{
- .name = try self.autoName(),
.src = src,
.tag = T.base_tag,
},
@@ -1351,29 +1630,150 @@ const EmitZIR = struct {
fn emitBody(
self: *EmitZIR,
- body: IrModule.Body,
+ body: ir.Body,
inst_table: *std.AutoHashMap(*ir.Inst, *Inst),
instructions: *std.ArrayList(*Inst),
) Allocator.Error!void {
+ const new_body = ZirBody{
+ .inst_table = inst_table,
+ .instructions = instructions,
+ };
for (body.instructions) |inst| {
const new_inst = switch (inst.tag) {
+ .not => blk: {
+ const old_inst = inst.cast(ir.Inst.Not).?;
+ assert(inst.ty.zigTypeTag() == .Bool);
+ const new_inst = try self.arena.allocator.create(Inst.BoolNot);
+ new_inst.* = .{
+ .base = .{
+ .src = inst.src,
+ .tag = Inst.BoolNot.base_tag,
+ },
+ .positionals = .{
+ .operand = try self.resolveInst(new_body, old_inst.args.operand),
+ },
+ .kw_args = .{},
+ };
+ break :blk &new_inst.base;
+ },
+ .add => blk: {
+ const old_inst = inst.cast(ir.Inst.Add).?;
+ const new_inst = try self.arena.allocator.create(Inst.Add);
+ new_inst.* = .{
+ .base = .{
+ .src = inst.src,
+ .tag = Inst.Add.base_tag,
+ },
+ .positionals = .{
+ .lhs = try self.resolveInst(new_body, old_inst.args.lhs),
+ .rhs = try self.resolveInst(new_body, old_inst.args.rhs),
+ },
+ .kw_args = .{},
+ };
+ break :blk &new_inst.base;
+ },
+ .sub => blk: {
+ const old_inst = inst.cast(ir.Inst.Sub).?;
+ const new_inst = try self.arena.allocator.create(Inst.Sub);
+ new_inst.* = .{
+ .base = .{
+ .src = inst.src,
+ .tag = Inst.Sub.base_tag,
+ },
+ .positionals = .{
+ .lhs = try self.resolveInst(new_body, old_inst.args.lhs),
+ .rhs = try self.resolveInst(new_body, old_inst.args.rhs),
+ },
+ .kw_args = .{},
+ };
+ break :blk &new_inst.base;
+ },
+ .arg => blk: {
+ const old_inst = inst.cast(ir.Inst.Arg).?;
+ const new_inst = try self.arena.allocator.create(Inst.Arg);
+ new_inst.* = .{
+ .base = .{
+ .src = inst.src,
+ .tag = Inst.Arg.base_tag,
+ },
+ .positionals = .{},
+ .kw_args = .{},
+ };
+ break :blk &new_inst.base;
+ },
+ .block => blk: {
+ const old_inst = inst.cast(ir.Inst.Block).?;
+ const new_inst = try self.arena.allocator.create(Inst.Block);
+
+ try self.block_table.put(old_inst, new_inst);
+
+ var block_body = std.ArrayList(*Inst).init(self.allocator);
+ defer block_body.deinit();
+
+ try self.emitBody(old_inst.args.body, inst_table, &block_body);
+
+ new_inst.* = .{
+ .base = .{
+ .src = inst.src,
+ .tag = Inst.Block.base_tag,
+ },
+ .positionals = .{
+ .body = .{ .instructions = block_body.toOwnedSlice() },
+ },
+ .kw_args = .{},
+ };
+
+ break :blk &new_inst.base;
+ },
+ .br => blk: {
+ const old_inst = inst.cast(ir.Inst.Br).?;
+ const new_block = self.block_table.get(old_inst.args.block).?;
+ const new_inst = try self.arena.allocator.create(Inst.Break);
+ new_inst.* = .{
+ .base = .{
+ .src = inst.src,
+ .tag = Inst.Break.base_tag,
+ },
+ .positionals = .{
+ .block = new_block,
+ .operand = try self.resolveInst(new_body, old_inst.args.operand),
+ },
+ .kw_args = .{},
+ };
+ break :blk &new_inst.base;
+ },
.breakpoint => try self.emitTrivial(inst.src, Inst.Breakpoint),
+ .brvoid => blk: {
+ const old_inst = inst.cast(ir.Inst.BrVoid).?;
+ const new_block = self.block_table.get(old_inst.args.block).?;
+ const new_inst = try self.arena.allocator.create(Inst.BreakVoid);
+ new_inst.* = .{
+ .base = .{
+ .src = inst.src,
+ .tag = Inst.BreakVoid.base_tag,
+ },
+ .positionals = .{
+ .block = new_block,
+ },
+ .kw_args = .{},
+ };
+ break :blk &new_inst.base;
+ },
.call => blk: {
const old_inst = inst.cast(ir.Inst.Call).?;
const new_inst = try self.arena.allocator.create(Inst.Call);
const args = try self.arena.allocator.alloc(*Inst, old_inst.args.args.len);
for (args) |*elem, i| {
- elem.* = try self.resolveInst(inst_table, old_inst.args.args[i]);
+ elem.* = try self.resolveInst(new_body, old_inst.args.args[i]);
}
new_inst.* = .{
.base = .{
- .name = try self.autoName(),
.src = inst.src,
.tag = Inst.Call.base_tag,
},
.positionals = .{
- .func = try self.resolveInst(inst_table, old_inst.args.func),
+ .func = try self.resolveInst(new_body, old_inst.args.func),
.args = args,
},
.kw_args = .{},
@@ -1381,7 +1781,22 @@ const EmitZIR = struct {
break :blk &new_inst.base;
},
.unreach => try self.emitTrivial(inst.src, Inst.Unreachable),
- .ret => try self.emitTrivial(inst.src, Inst.Return),
+ .ret => blk: {
+ const old_inst = inst.cast(ir.Inst.Ret).?;
+ const new_inst = try self.arena.allocator.create(Inst.Return);
+ new_inst.* = .{
+ .base = .{
+ .src = inst.src,
+ .tag = Inst.Return.base_tag,
+ },
+ .positionals = .{
+ .operand = try self.resolveInst(new_body, old_inst.args.operand),
+ },
+ .kw_args = .{},
+ };
+ break :blk &new_inst.base;
+ },
+ .retvoid => try self.emitTrivial(inst.src, Inst.ReturnVoid),
.constant => unreachable, // excluded from function bodies
.assembly => blk: {
const old_inst = inst.cast(ir.Inst.Assembly).?;
@@ -1389,33 +1804,32 @@ const EmitZIR = struct {
const inputs = try self.arena.allocator.alloc(*Inst, old_inst.args.inputs.len);
for (inputs) |*elem, i| {
- elem.* = try self.emitStringLiteral(inst.src, old_inst.args.inputs[i]);
+ elem.* = (try self.emitStringLiteral(inst.src, old_inst.args.inputs[i])).inst;
}
const clobbers = try self.arena.allocator.alloc(*Inst, old_inst.args.clobbers.len);
for (clobbers) |*elem, i| {
- elem.* = try self.emitStringLiteral(inst.src, old_inst.args.clobbers[i]);
+ elem.* = (try self.emitStringLiteral(inst.src, old_inst.args.clobbers[i])).inst;
}
const args = try self.arena.allocator.alloc(*Inst, old_inst.args.args.len);
for (args) |*elem, i| {
- elem.* = try self.resolveInst(inst_table, old_inst.args.args[i]);
+ elem.* = try self.resolveInst(new_body, old_inst.args.args[i]);
}
new_inst.* = .{
.base = .{
- .name = try self.autoName(),
.src = inst.src,
.tag = Inst.Asm.base_tag,
},
.positionals = .{
- .asm_source = try self.emitStringLiteral(inst.src, old_inst.args.asm_source),
- .return_type = try self.emitType(inst.src, inst.ty),
+ .asm_source = (try self.emitStringLiteral(inst.src, old_inst.args.asm_source)).inst,
+ .return_type = (try self.emitType(inst.src, inst.ty)).inst,
},
.kw_args = .{
.@"volatile" = old_inst.args.is_volatile,
.output = if (old_inst.args.output) |o|
- try self.emitStringLiteral(inst.src, o)
+ (try self.emitStringLiteral(inst.src, o)).inst
else
null,
.inputs = inputs,
@@ -1430,12 +1844,11 @@ const EmitZIR = struct {
const new_inst = try self.arena.allocator.create(Inst.PtrToInt);
new_inst.* = .{
.base = .{
- .name = try self.autoName(),
.src = inst.src,
.tag = Inst.PtrToInt.base_tag,
},
.positionals = .{
- .ptr = try self.resolveInst(inst_table, old_inst.args.ptr),
+ .ptr = try self.resolveInst(new_body, old_inst.args.ptr),
},
.kw_args = .{},
};
@@ -1446,13 +1859,12 @@ const EmitZIR = struct {
const new_inst = try self.arena.allocator.create(Inst.BitCast);
new_inst.* = .{
.base = .{
- .name = try self.autoName(),
.src = inst.src,
.tag = Inst.BitCast.base_tag,
},
.positionals = .{
- .dest_type = try self.emitType(inst.src, inst.ty),
- .operand = try self.resolveInst(inst_table, old_inst.args.operand),
+ .dest_type = (try self.emitType(inst.src, inst.ty)).inst,
+ .operand = try self.resolveInst(new_body, old_inst.args.operand),
},
.kw_args = .{},
};
@@ -1463,13 +1875,12 @@ const EmitZIR = struct {
const new_inst = try self.arena.allocator.create(Inst.Cmp);
new_inst.* = .{
.base = .{
- .name = try self.autoName(),
.src = inst.src,
.tag = Inst.Cmp.base_tag,
},
.positionals = .{
- .lhs = try self.resolveInst(inst_table, old_inst.args.lhs),
- .rhs = try self.resolveInst(inst_table, old_inst.args.rhs),
+ .lhs = try self.resolveInst(new_body, old_inst.args.lhs),
+ .rhs = try self.resolveInst(new_body, old_inst.args.rhs),
.op = old_inst.args.op,
},
.kw_args = .{},
@@ -1491,12 +1902,11 @@ const EmitZIR = struct {
const new_inst = try self.arena.allocator.create(Inst.CondBr);
new_inst.* = .{
.base = .{
- .name = try self.autoName(),
.src = inst.src,
.tag = Inst.CondBr.base_tag,
},
.positionals = .{
- .condition = try self.resolveInst(inst_table, old_inst.args.condition),
+ .condition = try self.resolveInst(new_body, old_inst.args.condition),
.true_body = .{ .instructions = true_body.toOwnedSlice() },
.false_body = .{ .instructions = false_body.toOwnedSlice() },
},
@@ -1509,12 +1919,11 @@ const EmitZIR = struct {
const new_inst = try self.arena.allocator.create(Inst.IsNull);
new_inst.* = .{
.base = .{
- .name = try self.autoName(),
.src = inst.src,
.tag = Inst.IsNull.base_tag,
},
.positionals = .{
- .operand = try self.resolveInst(inst_table, old_inst.args.operand),
+ .operand = try self.resolveInst(new_body, old_inst.args.operand),
},
.kw_args = .{},
};
@@ -1525,12 +1934,11 @@ const EmitZIR = struct {
const new_inst = try self.arena.allocator.create(Inst.IsNonNull);
new_inst.* = .{
.base = .{
- .name = try self.autoName(),
.src = inst.src,
.tag = Inst.IsNonNull.base_tag,
},
.positionals = .{
- .operand = try self.resolveInst(inst_table, old_inst.args.operand),
+ .operand = try self.resolveInst(new_body, old_inst.args.operand),
},
.kw_args = .{},
};
@@ -1538,12 +1946,20 @@ const EmitZIR = struct {
},
};
try instructions.append(new_inst);
- try inst_table.putNoClobber(inst, new_inst);
+ try inst_table.put(inst, new_inst);
}
}
- fn emitType(self: *EmitZIR, src: usize, ty: Type) Allocator.Error!*Inst {
+ fn emitType(self: *EmitZIR, src: usize, ty: Type) Allocator.Error!*Decl {
switch (ty.tag()) {
+ .i8 => return self.emitPrimitive(src, .i8),
+ .u8 => return self.emitPrimitive(src, .u8),
+ .i16 => return self.emitPrimitive(src, .i16),
+ .u16 => return self.emitPrimitive(src, .u16),
+ .i32 => return self.emitPrimitive(src, .i32),
+ .u32 => return self.emitPrimitive(src, .u32),
+ .i64 => return self.emitPrimitive(src, .i64),
+ .u64 => return self.emitPrimitive(src, .u64),
.isize => return self.emitPrimitive(src, .isize),
.usize => return self.emitPrimitive(src, .usize),
.c_short => return self.emitPrimitive(src, .c_short),
@@ -1575,26 +1991,44 @@ const EmitZIR = struct {
ty.fnParamTypes(param_types);
const emitted_params = try self.arena.allocator.alloc(*Inst, param_types.len);
for (param_types) |param_type, i| {
- emitted_params[i] = try self.emitType(src, param_type);
+ emitted_params[i] = (try self.emitType(src, param_type)).inst;
}
const fntype_inst = try self.arena.allocator.create(Inst.FnType);
fntype_inst.* = .{
.base = .{
- .name = try self.autoName(),
.src = src,
.tag = Inst.FnType.base_tag,
},
.positionals = .{
.param_types = emitted_params,
- .return_type = try self.emitType(src, ty.fnReturnType()),
+ .return_type = (try self.emitType(src, ty.fnReturnType())).inst,
},
.kw_args = .{
.cc = ty.fnCallingConvention(),
},
};
- try self.decls.append(self.allocator, &fntype_inst.base);
- return &fntype_inst.base;
+ return self.emitUnnamedDecl(&fntype_inst.base);
+ },
+ .Int => {
+ const info = ty.intInfo(self.old_module.target());
+ const signed = try self.emitPrimitive(src, if (info.signed) .@"true" else .@"false");
+ const bits_payload = try self.arena.allocator.create(Value.Payload.Int_u64);
+ bits_payload.* = .{ .int = info.bits };
+ const bits = try self.emitComptimeIntVal(src, Value.initPayload(&bits_payload.base));
+ const inttype_inst = try self.arena.allocator.create(Inst.IntType);
+ inttype_inst.* = .{
+ .base = .{
+ .src = src,
+ .tag = Inst.IntType.base_tag,
+ },
+ .positionals = .{
+ .signed = signed.inst,
+ .bits = bits.inst,
+ },
+ .kw_args = .{},
+ };
+ return self.emitUnnamedDecl(&inttype_inst.base);
},
else => std.debug.panic("TODO implement emitType for {}", .{ty}),
},
@@ -1607,19 +2041,18 @@ const EmitZIR = struct {
self.next_auto_name += 1;
const gop = try self.names.getOrPut(proposed_name);
if (!gop.found_existing) {
- gop.kv.value = {};
+ gop.entry.value = {};
return proposed_name;
}
}
}
- fn emitPrimitive(self: *EmitZIR, src: usize, tag: Inst.Primitive.Builtin) !*Inst {
+ fn emitPrimitive(self: *EmitZIR, src: usize, tag: Inst.Primitive.Builtin) !*Decl {
const gop = try self.primitive_table.getOrPut(tag);
if (!gop.found_existing) {
const primitive_inst = try self.arena.allocator.create(Inst.Primitive);
primitive_inst.* = .{
.base = .{
- .name = try self.autoName(),
.src = src,
.tag = Inst.Primitive.base_tag,
},
@@ -1628,17 +2061,15 @@ const EmitZIR = struct {
},
.kw_args = .{},
};
- try self.decls.append(self.allocator, &primitive_inst.base);
- gop.kv.value = &primitive_inst.base;
+ gop.entry.value = try self.emitUnnamedDecl(&primitive_inst.base);
}
- return gop.kv.value;
+ return gop.entry.value;
}
- fn emitStringLiteral(self: *EmitZIR, src: usize, str: []const u8) !*Inst {
+ fn emitStringLiteral(self: *EmitZIR, src: usize, str: []const u8) !*Decl {
const str_inst = try self.arena.allocator.create(Inst.Str);
str_inst.* = .{
.base = .{
- .name = try self.autoName(),
.src = src,
.tag = Inst.Str.base_tag,
},
@@ -1647,22 +2078,17 @@ const EmitZIR = struct {
},
.kw_args = .{},
};
- try self.decls.append(self.allocator, &str_inst.base);
+ return self.emitUnnamedDecl(&str_inst.base);
+ }
- const ref_inst = try self.arena.allocator.create(Inst.Ref);
- ref_inst.* = .{
- .base = .{
- .name = try self.autoName(),
- .src = src,
- .tag = Inst.Ref.base_tag,
- },
- .positionals = .{
- .operand = &str_inst.base,
- },
- .kw_args = .{},
+ fn emitUnnamedDecl(self: *EmitZIR, inst: *Inst) !*Decl {
+ const decl = try self.arena.allocator.create(Decl);
+ decl.* = .{
+ .name = try self.autoName(),
+ .contents_hash = undefined,
+ .inst = inst,
};
- try self.decls.append(self.allocator, &ref_inst.base);
-
- return &ref_inst.base;
+ try self.decls.append(self.allocator, decl);
+ return decl;
}
};
diff --git a/src/all_types.hpp b/src/all_types.hpp
index 9413ea73a4..a73efe2c82 100644
--- a/src/all_types.hpp
+++ b/src/all_types.hpp
@@ -692,7 +692,7 @@ enum NodeType {
NodeTypeSuspend,
NodeTypeAnyFrameType,
NodeTypeEnumLiteral,
- NodeTypeVarFieldType,
+ NodeTypeAnyTypeField,
};
enum FnInline {
@@ -705,7 +705,7 @@ struct AstNodeFnProto {
Buf *name;
ZigList params;
AstNode *return_type;
- Token *return_var_token;
+ Token *return_anytype_token;
AstNode *fn_def_node;
// populated if this is an extern declaration
Buf *lib_name;
@@ -734,7 +734,7 @@ struct AstNodeFnDef {
struct AstNodeParamDecl {
Buf *name;
AstNode *type;
- Token *var_token;
+ Token *anytype_token;
Buf doc_comments;
bool is_noalias;
bool is_comptime;
@@ -1827,6 +1827,7 @@ enum BuiltinFnId {
BuiltinFnIdBitSizeof,
BuiltinFnIdWasmMemorySize,
BuiltinFnIdWasmMemoryGrow,
+ BuiltinFnIdSrc,
};
struct BuiltinFnEntry {
@@ -2144,7 +2145,7 @@ struct CodeGen {
ZigType *entry_num_lit_float;
ZigType *entry_undef;
ZigType *entry_null;
- ZigType *entry_var;
+ ZigType *entry_anytype;
ZigType *entry_global_error_set;
ZigType *entry_enum_literal;
ZigType *entry_any_frame;
@@ -2640,6 +2641,7 @@ enum IrInstSrcId {
IrInstSrcIdCall,
IrInstSrcIdCallArgs,
IrInstSrcIdCallExtra,
+ IrInstSrcIdAsyncCallExtra,
IrInstSrcIdConst,
IrInstSrcIdReturn,
IrInstSrcIdContainerInitList,
@@ -2754,6 +2756,7 @@ enum IrInstSrcId {
IrInstSrcIdSpillEnd,
IrInstSrcIdWasmMemorySize,
IrInstSrcIdWasmMemoryGrow,
+ IrInstSrcIdSrc,
};
// ir_render_* functions in codegen.cpp consume Gen instructions and produce LLVM IR.
@@ -3253,6 +3256,20 @@ struct IrInstSrcCallExtra {
ResultLoc *result_loc;
};
+// This is a pass1 instruction, used by @asyncCall, when the args node
+// is not a literal.
+// `args` is expected to be either a struct or a tuple.
+struct IrInstSrcAsyncCallExtra {
+ IrInstSrc base;
+
+ CallModifier modifier;
+ IrInstSrc *fn_ref;
+ IrInstSrc *ret_ptr;
+ IrInstSrc *new_stack;
+ IrInstSrc *args;
+ ResultLoc *result_loc;
+};
+
struct IrInstGenCall {
IrInstGen base;
@@ -3761,6 +3778,10 @@ struct IrInstGenWasmMemoryGrow {
IrInstGen *delta;
};
+struct IrInstSrcSrc {
+ IrInstSrc base;
+};
+
struct IrInstSrcSlice {
IrInstSrc base;
diff --git a/src/analyze.cpp b/src/analyze.cpp
index 9062c1fb13..66f3f28b50 100644
--- a/src/analyze.cpp
+++ b/src/analyze.cpp
@@ -1129,7 +1129,7 @@ ZigValue *analyze_const_value(CodeGen *g, Scope *scope, AstNode *node, ZigType *
ZigValue *result = g->pass1_arena->create();
ZigValue *result_ptr = g->pass1_arena->create();
result->special = ConstValSpecialUndef;
- result->type = (type_entry == nullptr) ? g->builtin_types.entry_var : type_entry;
+ result->type = (type_entry == nullptr) ? g->builtin_types.entry_anytype : type_entry;
result_ptr->special = ConstValSpecialStatic;
result_ptr->type = get_pointer_to_type(g, result->type, false);
result_ptr->data.x_ptr.mut = ConstPtrMutComptimeVar;
@@ -1230,7 +1230,7 @@ Error type_val_resolve_zero_bits(CodeGen *g, ZigValue *type_val, ZigType *parent
Error type_val_resolve_is_opaque_type(CodeGen *g, ZigValue *type_val, bool *is_opaque_type) {
if (type_val->special != ConstValSpecialLazy) {
assert(type_val->special == ConstValSpecialStatic);
- if (type_val->data.x_type == g->builtin_types.entry_var) {
+ if (type_val->data.x_type == g->builtin_types.entry_anytype) {
*is_opaque_type = false;
return ErrorNone;
}
@@ -1511,13 +1511,13 @@ ZigType *get_generic_fn_type(CodeGen *g, FnTypeId *fn_type_id) {
}
for (; i < fn_type_id->param_count; i += 1) {
const char *comma_str = (i == 0) ? "" : ",";
- buf_appendf(&fn_type->name, "%svar", comma_str);
+ buf_appendf(&fn_type->name, "%sanytype", comma_str);
}
buf_append_str(&fn_type->name, ")");
if (fn_type_id->cc != CallingConventionUnspecified) {
buf_appendf(&fn_type->name, " callconv(.%s)", calling_convention_name(fn_type_id->cc));
}
- buf_append_str(&fn_type->name, " var");
+ buf_append_str(&fn_type->name, " anytype");
fn_type->data.fn.fn_type_id = *fn_type_id;
fn_type->data.fn.is_generic = true;
@@ -1853,10 +1853,10 @@ static ZigType *analyze_fn_type(CodeGen *g, AstNode *proto_node, Scope *child_sc
buf_sprintf("var args only allowed in functions with C calling convention"));
return g->builtin_types.entry_invalid;
}
- } else if (param_node->data.param_decl.var_token != nullptr) {
+ } else if (param_node->data.param_decl.anytype_token != nullptr) {
if (!calling_convention_allows_zig_types(fn_type_id.cc)) {
add_node_error(g, param_node,
- buf_sprintf("parameter of type 'var' not allowed in function with calling convention '%s'",
+ buf_sprintf("parameter of type 'anytype' not allowed in function with calling convention '%s'",
calling_convention_name(fn_type_id.cc)));
return g->builtin_types.entry_invalid;
}
@@ -1942,10 +1942,10 @@ static ZigType *analyze_fn_type(CodeGen *g, AstNode *proto_node, Scope *child_sc
fn_entry->align_bytes = fn_type_id.alignment;
}
- if (fn_proto->return_var_token != nullptr) {
+ if (fn_proto->return_anytype_token != nullptr) {
if (!calling_convention_allows_zig_types(fn_type_id.cc)) {
add_node_error(g, fn_proto->return_type,
- buf_sprintf("return type 'var' not allowed in function with calling convention '%s'",
+ buf_sprintf("return type 'anytype' not allowed in function with calling convention '%s'",
calling_convention_name(fn_type_id.cc)));
return g->builtin_types.entry_invalid;
}
@@ -3802,7 +3802,7 @@ void scan_decls(CodeGen *g, ScopeDecls *decls_scope, AstNode *node) {
case NodeTypeEnumLiteral:
case NodeTypeAnyFrameType:
case NodeTypeErrorSetField:
- case NodeTypeVarFieldType:
+ case NodeTypeAnyTypeField:
zig_unreachable();
}
}
@@ -3823,15 +3823,18 @@ static Error resolve_decl_container(CodeGen *g, TldContainer *tld_container) {
}
}
-ZigType *validate_var_type(CodeGen *g, AstNode *source_node, ZigType *type_entry) {
+ZigType *validate_var_type(CodeGen *g, AstNodeVariableDeclaration *source_node, ZigType *type_entry) {
switch (type_entry->id) {
case ZigTypeIdInvalid:
return g->builtin_types.entry_invalid;
+ case ZigTypeIdOpaque:
+ if (source_node->is_extern)
+ return type_entry;
+ ZIG_FALLTHROUGH;
case ZigTypeIdUnreachable:
case ZigTypeIdUndefined:
case ZigTypeIdNull:
- case ZigTypeIdOpaque:
- add_node_error(g, source_node, buf_sprintf("variable of type '%s' not allowed",
+ add_node_error(g, source_node->type, buf_sprintf("variable of type '%s' not allowed",
buf_ptr(&type_entry->name)));
return g->builtin_types.entry_invalid;
case ZigTypeIdComptimeFloat:
@@ -3973,7 +3976,7 @@ static void resolve_decl_var(CodeGen *g, TldVar *tld_var, bool allow_lazy) {
} else {
tld_var->analyzing_type = true;
ZigType *proposed_type = analyze_type_expr(g, tld_var->base.parent_scope, var_decl->type);
- explicit_type = validate_var_type(g, var_decl->type, proposed_type);
+ explicit_type = validate_var_type(g, var_decl, proposed_type);
}
}
@@ -4012,6 +4015,10 @@ static void resolve_decl_var(CodeGen *g, TldVar *tld_var, bool allow_lazy) {
} else if (!is_extern) {
add_node_error(g, source_node, buf_sprintf("variables must be initialized"));
implicit_type = g->builtin_types.entry_invalid;
+ } else if (explicit_type == nullptr) {
+ // extern variable without explicit type
+ add_node_error(g, source_node, buf_sprintf("unable to infer variable type"));
+ implicit_type = g->builtin_types.entry_invalid;
}
ZigType *type = explicit_type ? explicit_type : implicit_type;
@@ -5864,7 +5871,7 @@ ZigValue *get_the_one_possible_value(CodeGen *g, ZigType *type_entry) {
ReqCompTime type_requires_comptime(CodeGen *g, ZigType *ty) {
Error err;
- if (ty == g->builtin_types.entry_var) {
+ if (ty == g->builtin_types.entry_anytype) {
return ReqCompTimeYes;
}
switch (ty->id) {
@@ -6012,6 +6019,19 @@ ZigValue *create_const_null(CodeGen *g, ZigType *type) {
return const_val;
}
+void init_const_fn(ZigValue *const_val, ZigFn *fn) {
+ const_val->special = ConstValSpecialStatic;
+ const_val->type = fn->type_entry;
+ const_val->data.x_ptr.special = ConstPtrSpecialFunction;
+ const_val->data.x_ptr.data.fn.fn_entry = fn;
+}
+
+ZigValue *create_const_fn(CodeGen *g, ZigFn *fn) {
+ ZigValue *const_val = g->pass1_arena->create();
+ init_const_fn(const_val, fn);
+ return const_val;
+}
+
void init_const_float(ZigValue *const_val, ZigType *type, double value) {
const_val->special = ConstValSpecialStatic;
const_val->type = type;
@@ -9584,6 +9604,12 @@ void copy_const_val(CodeGen *g, ZigValue *dest, ZigValue *src) {
break;
}
}
+ } else if (dest->type->id == ZigTypeIdUnion) {
+ bigint_init_bigint(&dest->data.x_union.tag, &src->data.x_union.tag);
+ dest->data.x_union.payload = g->pass1_arena->create();
+ copy_const_val(g, dest->data.x_union.payload, src->data.x_union.payload);
+ dest->data.x_union.payload->parent.id = ConstParentIdUnion;
+ dest->data.x_union.payload->parent.data.p_union.union_val = dest;
} else if (type_has_optional_repr(dest->type) && dest->data.x_optional != nullptr) {
dest->data.x_optional = g->pass1_arena->create();
copy_const_val(g, dest->data.x_optional, src->data.x_optional);
diff --git a/src/analyze.hpp b/src/analyze.hpp
index 5899db8a64..cb58aa6b74 100644
--- a/src/analyze.hpp
+++ b/src/analyze.hpp
@@ -77,7 +77,7 @@ void resolve_top_level_decl(CodeGen *g, Tld *tld, AstNode *source_node, bool all
ZigType *get_src_ptr_type(ZigType *type);
uint32_t get_ptr_align(CodeGen *g, ZigType *type);
bool get_ptr_const(CodeGen *g, ZigType *type);
-ZigType *validate_var_type(CodeGen *g, AstNode *source_node, ZigType *type_entry);
+ZigType *validate_var_type(CodeGen *g, AstNodeVariableDeclaration *source_node, ZigType *type_entry);
ZigType *container_ref_type(ZigType *type_entry);
bool type_is_complete(ZigType *type_entry);
bool type_is_resolved(ZigType *type_entry, ResolveStatus status);
@@ -180,6 +180,9 @@ ZigValue *create_const_slice(CodeGen *g, ZigValue *array_val, size_t start, size
void init_const_null(ZigValue *const_val, ZigType *type);
ZigValue *create_const_null(CodeGen *g, ZigType *type);
+void init_const_fn(ZigValue *const_val, ZigFn *fn);
+ZigValue *create_const_fn(CodeGen *g, ZigFn *fn);
+
ZigValue **alloc_const_vals_ptrs(CodeGen *g, size_t count);
ZigValue **realloc_const_vals_ptrs(CodeGen *g, ZigValue **ptr, size_t old_count, size_t new_count);
diff --git a/src/ast_render.cpp b/src/ast_render.cpp
index 49fad80a40..ad308bf416 100644
--- a/src/ast_render.cpp
+++ b/src/ast_render.cpp
@@ -270,8 +270,8 @@ static const char *node_type_str(NodeType node_type) {
return "EnumLiteral";
case NodeTypeErrorSetField:
return "ErrorSetField";
- case NodeTypeVarFieldType:
- return "VarFieldType";
+ case NodeTypeAnyTypeField:
+ return "AnyTypeField";
}
zig_unreachable();
}
@@ -466,8 +466,8 @@ static void render_node_extra(AstRender *ar, AstNode *node, bool grouped) {
}
if (param_decl->data.param_decl.is_var_args) {
fprintf(ar->f, "...");
- } else if (param_decl->data.param_decl.var_token != nullptr) {
- fprintf(ar->f, "var");
+ } else if (param_decl->data.param_decl.anytype_token != nullptr) {
+ fprintf(ar->f, "anytype");
} else {
render_node_grouped(ar, param_decl->data.param_decl.type);
}
@@ -496,8 +496,8 @@ static void render_node_extra(AstRender *ar, AstNode *node, bool grouped) {
fprintf(ar->f, ")");
}
- if (node->data.fn_proto.return_var_token != nullptr) {
- fprintf(ar->f, "var");
+ if (node->data.fn_proto.return_anytype_token != nullptr) {
+ fprintf(ar->f, "anytype");
} else {
AstNode *return_type_node = node->data.fn_proto.return_type;
assert(return_type_node != nullptr);
@@ -1216,8 +1216,8 @@ static void render_node_extra(AstRender *ar, AstNode *node, bool grouped) {
fprintf(ar->f, ".%s", buf_ptr(&node->data.enum_literal.identifier->data.str_lit.str));
break;
}
- case NodeTypeVarFieldType: {
- fprintf(ar->f, "var");
+ case NodeTypeAnyTypeField: {
+ fprintf(ar->f, "anytype");
break;
}
case NodeTypeParamDecl:
diff --git a/src/codegen.cpp b/src/codegen.cpp
index f945dd6545..3473a2b0ac 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -1535,9 +1535,11 @@ static LLVMValueRef gen_widen_or_shorten(CodeGen *g, bool want_runtime_safety, Z
zig_unreachable();
}
- if (actual_type->id == ZigTypeIdInt &&
- !wanted_type->data.integral.is_signed && actual_type->data.integral.is_signed &&
- want_runtime_safety)
+ if (actual_type->id == ZigTypeIdInt && want_runtime_safety && (
+ // negative to unsigned
+ (!wanted_type->data.integral.is_signed && actual_type->data.integral.is_signed) ||
+ // unsigned would become negative
+ (wanted_type->data.integral.is_signed && !actual_type->data.integral.is_signed && actual_bits == wanted_bits)))
{
LLVMValueRef zero = LLVMConstNull(get_llvm_type(g, actual_type));
LLVMValueRef ok_bit = LLVMBuildICmp(g->builder, LLVMIntSGE, expr_val, zero, "");
@@ -1547,7 +1549,7 @@ static LLVMValueRef gen_widen_or_shorten(CodeGen *g, bool want_runtime_safety, Z
LLVMBuildCondBr(g->builder, ok_bit, ok_block, fail_block);
LLVMPositionBuilderAtEnd(g->builder, fail_block);
- gen_safety_crash(g, PanicMsgIdCastNegativeToUnsigned);
+ gen_safety_crash(g, actual_type->data.integral.is_signed ? PanicMsgIdCastNegativeToUnsigned : PanicMsgIdCastTruncatedData);
LLVMPositionBuilderAtEnd(g->builder, ok_block);
}
@@ -3540,7 +3542,7 @@ static LLVMValueRef ir_render_int_to_enum(CodeGen *g, IrExecutableGen *executabl
for (size_t field_i = 0; field_i < field_count; field_i += 1) {
TypeEnumField *type_enum_field = &wanted_type->data.enumeration.fields[field_i];
-
+
Buf *name = type_enum_field->name;
auto entry = occupied_tag_values.put_unique(type_enum_field->value, name);
if (entry != nullptr) {
@@ -3654,7 +3656,7 @@ static LLVMValueRef ir_gen_negation(CodeGen *g, IrInstGen *inst, IrInstGen *oper
} else if (scalar_type->data.integral.is_signed) {
return LLVMBuildNSWNeg(g->builder, llvm_operand, "");
} else {
- return LLVMBuildNUWNeg(g->builder, llvm_operand, "");
+ zig_unreachable();
}
} else {
zig_unreachable();
@@ -3984,7 +3986,7 @@ static LLVMValueRef ir_render_elem_ptr(CodeGen *g, IrExecutableGen *executable,
assert(array_type->data.pointer.child_type->id == ZigTypeIdArray);
array_type = array_type->data.pointer.child_type;
}
-
+
assert(array_type->data.array.len != 0 || array_type->data.array.sentinel != nullptr);
if (safety_check_on) {
@@ -5258,7 +5260,7 @@ static LLVMValueRef get_enum_tag_name_function(CodeGen *g, ZigType *enum_type) {
for (size_t field_i = 0; field_i < field_count; field_i += 1) {
TypeEnumField *type_enum_field = &enum_type->data.enumeration.fields[field_i];
-
+
Buf *name = type_enum_field->name;
auto entry = occupied_tag_values.put_unique(type_enum_field->value, name);
if (entry != nullptr) {
@@ -5471,7 +5473,7 @@ static LLVMTypeRef get_atomic_abi_type(CodeGen *g, IrInstGen *instruction) {
}
auto bit_count = operand_type->data.integral.bit_count;
bool is_signed = operand_type->data.integral.is_signed;
-
+
ir_assert(bit_count != 0, instruction);
if (bit_count == 1 || !is_power_of_2(bit_count)) {
return get_llvm_type(g, get_int_type(g, is_signed, operand_type->abi_size * 8));
@@ -5583,8 +5585,12 @@ static LLVMValueRef ir_render_memset(CodeGen *g, IrExecutableGen *executable, Ir
bool val_is_undef = value_is_all_undef(g, instruction->byte->value);
LLVMValueRef fill_char;
- if (val_is_undef && ir_want_runtime_safety_scope(g, instruction->base.base.scope)) {
- fill_char = LLVMConstInt(LLVMInt8Type(), 0xaa, false);
+ if (val_is_undef) {
+ if (ir_want_runtime_safety_scope(g, instruction->base.base.scope)) {
+ fill_char = LLVMConstInt(LLVMInt8Type(), 0xaa, false);
+ } else {
+ return nullptr;
+ }
} else {
fill_char = ir_llvm_value(g, instruction->byte);
}
@@ -7473,6 +7479,12 @@ static LLVMValueRef gen_const_val(CodeGen *g, ZigValue *const_val, const char *n
continue;
}
ZigValue *field_val = const_val->data.x_struct.fields[i];
+ if (field_val == nullptr) {
+ add_node_error(g, type_struct_field->decl_node,
+ buf_sprintf("compiler bug: generating const value for struct field '%s'",
+ buf_ptr(type_struct_field->name)));
+ codegen_report_errors_and_exit(g);
+ }
ZigType *field_type = field_val->type;
assert(field_type != nullptr);
if ((err = ensure_const_val_repr(nullptr, g, nullptr, field_val, field_type))) {
@@ -8436,8 +8448,8 @@ static void define_builtin_types(CodeGen *g) {
}
{
ZigType *entry = new_type_table_entry(ZigTypeIdOpaque);
- buf_init_from_str(&entry->name, "(var)");
- g->builtin_types.entry_var = entry;
+ buf_init_from_str(&entry->name, "(anytype)");
+ g->builtin_types.entry_anytype = entry;
}
for (size_t i = 0; i < array_length(c_int_type_infos); i += 1) {
@@ -8714,6 +8726,7 @@ static void define_builtin_fns(CodeGen *g) {
create_builtin_fn(g, BuiltinFnIdBitSizeof, "bitSizeOf", 1);
create_builtin_fn(g, BuiltinFnIdWasmMemorySize, "wasmMemorySize", 1);
create_builtin_fn(g, BuiltinFnIdWasmMemoryGrow, "wasmMemoryGrow", 2);
+ create_builtin_fn(g, BuiltinFnIdSrc, "src", 0);
}
static const char *bool_to_str(bool b) {
@@ -9264,7 +9277,7 @@ static void init(CodeGen *g) {
abi_name = (g->zig_target->arch == ZigLLVM_riscv32) ? "ilp32" : "lp64";
}
}
-
+
g->target_machine = ZigLLVMCreateTargetMachine(target_ref, buf_ptr(&g->llvm_triple_str),
target_specific_cpu_args, target_specific_features, opt_level, reloc_mode,
to_llvm_code_model(g), g->function_sections, float_abi, abi_name);
@@ -9464,9 +9477,15 @@ void add_cc_args(CodeGen *g, ZigList &args, const char *out_dep_pa
const char *libcxx_include_path = buf_ptr(buf_sprintf("%s" OS_SEP "libcxx" OS_SEP "include",
buf_ptr(g->zig_lib_dir)));
+ const char *libcxxabi_include_path = buf_ptr(buf_sprintf("%s" OS_SEP "libcxxabi" OS_SEP "include",
+ buf_ptr(g->zig_lib_dir)));
+
args.append("-isystem");
args.append(libcxx_include_path);
+ args.append("-isystem");
+ args.append(libcxxabi_include_path);
+
if (target_abi_is_musl(g->zig_target->abi)) {
args.append("-D_LIBCPP_HAS_MUSL_LIBC");
}
diff --git a/src/compiler.cpp b/src/compiler.cpp
index 8294fc7871..6c477a1506 100644
--- a/src/compiler.cpp
+++ b/src/compiler.cpp
@@ -38,11 +38,19 @@ Error get_compiler_id(Buf **result) {
ZigList lib_paths = {};
if ((err = os_self_exe_shared_libs(lib_paths)))
return err;
+ #if defined(ZIG_OS_DARWIN)
+ // only add the self exe path on mac os
+ Buf *lib_path = lib_paths.at(0);
+ if ((err = cache_add_file(ch, lib_path)))
+ return err;
+ #else
for (size_t i = 0; i < lib_paths.length; i += 1) {
Buf *lib_path = lib_paths.at(i);
if ((err = cache_add_file(ch, lib_path)))
return err;
}
+ #endif
+
if ((err = cache_final(ch, &saved_compiler_id)))
return err;
diff --git a/src/hash_map.hpp b/src/hash_map.hpp
index 69e5568093..8681e5b761 100644
--- a/src/hash_map.hpp
+++ b/src/hash_map.hpp
@@ -19,45 +19,85 @@ public:
init_capacity(capacity);
}
void deinit(void) {
- heap::c_allocator.deallocate(_entries, _capacity);
+ _entries.deinit();
+ heap::c_allocator.deallocate(_index_bytes,
+ _indexes_len * capacity_index_size(_indexes_len));
}
struct Entry {
+ uint32_t hash;
+ uint32_t distance_from_start_index;
K key;
V value;
- bool used;
- int distance_from_start_index;
};
void clear() {
- for (int i = 0; i < _capacity; i += 1) {
- _entries[i].used = false;
- }
- _size = 0;
+ _entries.clear();
+ memset(_index_bytes, 0, _indexes_len * capacity_index_size(_indexes_len));
_max_distance_from_start_index = 0;
_modification_count += 1;
}
- int size() const {
- return _size;
+ size_t size() const {
+ return _entries.length;
}
void put(const K &key, const V &value) {
_modification_count += 1;
- internal_put(key, value);
- // if we get too full (60%), double the capacity
- if (_size * 5 >= _capacity * 3) {
- Entry *old_entries = _entries;
- int old_capacity = _capacity;
- init_capacity(_capacity * 2);
- // dump all of the old elements into the new table
- for (int i = 0; i < old_capacity; i += 1) {
- Entry *old_entry = &old_entries[i];
- if (old_entry->used)
- internal_put(old_entry->key, old_entry->value);
+ // This allows us to take a pointer to an entry in `internal_put` which
+ // will not become a dead pointer when the array list is appended.
+ _entries.ensure_capacity(_entries.length + 1);
+
+ if (_index_bytes == nullptr) {
+ if (_entries.length < 16) {
+ _entries.append({HashFunction(key), 0, key, value});
+ return;
+ } else {
+ _indexes_len = 32;
+ _index_bytes = heap::c_allocator.allocate(_indexes_len);
+ _max_distance_from_start_index = 0;
+ for (size_t i = 0; i < _entries.length; i += 1) {
+ Entry *entry = &_entries.items[i];
+ put_index(entry, i, _index_bytes);
+ }
+ return internal_put(key, value, _index_bytes);
}
- heap::c_allocator.deallocate(old_entries, old_capacity);
+ }
+
+ // if we would get too full (60%), double the indexes size
+ if ((_entries.length + 1) * 5 >= _indexes_len * 3) {
+ heap::c_allocator.deallocate(_index_bytes,
+ _indexes_len * capacity_index_size(_indexes_len));
+ _indexes_len *= 2;
+ size_t sz = capacity_index_size(_indexes_len);
+ // This zero initializes the bytes, setting them all empty.
+ _index_bytes = heap::c_allocator.allocate(_indexes_len * sz);
+ _max_distance_from_start_index = 0;
+ for (size_t i = 0; i < _entries.length; i += 1) {
+ Entry *entry = &_entries.items[i];
+ switch (sz) {
+ case 1:
+ put_index(entry, i, (uint8_t*)_index_bytes);
+ continue;
+ case 2:
+ put_index(entry, i, (uint16_t*)_index_bytes);
+ continue;
+ case 4:
+ put_index(entry, i, (uint32_t*)_index_bytes);
+ continue;
+ default:
+ put_index(entry, i, (size_t*)_index_bytes);
+ continue;
+ }
+ }
+ }
+
+ switch (capacity_index_size(_indexes_len)) {
+ case 1: return internal_put(key, value, (uint8_t*)_index_bytes);
+ case 2: return internal_put(key, value, (uint16_t*)_index_bytes);
+ case 4: return internal_put(key, value, (uint32_t*)_index_bytes);
+ default: return internal_put(key, value, (size_t*)_index_bytes);
}
}
@@ -81,40 +121,31 @@ public:
return internal_get(key);
}
- void maybe_remove(const K &key) {
- if (maybe_get(key)) {
- remove(key);
- }
+ bool remove(const K &key) {
+ bool deleted_something = maybe_remove(key);
+ if (!deleted_something)
+ zig_panic("key not found");
+ return deleted_something;
}
- void remove(const K &key) {
+ bool maybe_remove(const K &key) {
_modification_count += 1;
- int start_index = key_to_index(key);
- for (int roll_over = 0; roll_over <= _max_distance_from_start_index; roll_over += 1) {
- int index = (start_index + roll_over) % _capacity;
- Entry *entry = &_entries[index];
-
- if (!entry->used)
- zig_panic("key not found");
-
- if (!EqualFn(entry->key, key))
- continue;
-
- for (; roll_over < _capacity; roll_over += 1) {
- int next_index = (start_index + roll_over + 1) % _capacity;
- Entry *next_entry = &_entries[next_index];
- if (!next_entry->used || next_entry->distance_from_start_index == 0) {
- entry->used = false;
- _size -= 1;
- return;
+ if (_index_bytes == nullptr) {
+ uint32_t hash = HashFunction(key);
+ for (size_t i = 0; i < _entries.length; i += 1) {
+ if (_entries.items[i].hash == hash && EqualFn(_entries.items[i].key, key)) {
+ _entries.swap_remove(i);
+ return true;
}
- *entry = *next_entry;
- entry->distance_from_start_index -= 1;
- entry = next_entry;
}
- zig_panic("shifting everything in the table");
+ return false;
+ }
+ switch (capacity_index_size(_indexes_len)) {
+ case 1: return internal_remove(key, (uint8_t*)_index_bytes);
+ case 2: return internal_remove(key, (uint16_t*)_index_bytes);
+ case 4: return internal_remove(key, (uint32_t*)_index_bytes);
+ default: return internal_remove(key, (size_t*)_index_bytes);
}
- zig_panic("key not found");
}
class Iterator {
@@ -122,24 +153,16 @@ public:
Entry *next() {
if (_inital_modification_count != _table->_modification_count)
zig_panic("concurrent modification");
- if (_count >= _table->size())
- return NULL;
- for (; _index < _table->_capacity; _index += 1) {
- Entry *entry = &_table->_entries[_index];
- if (entry->used) {
- _index += 1;
- _count += 1;
- return entry;
- }
- }
- zig_panic("no next item");
+ if (_index >= _table->_entries.length)
+ return nullptr;
+ Entry *entry = &_table->_entries.items[_index];
+ _index += 1;
+ return entry;
}
private:
const HashMap * _table;
- // how many items have we returned
- int _count = 0;
// iterator through the entry array
- int _index = 0;
+ size_t _index = 0;
// used to detect concurrent modification
uint32_t _inital_modification_count;
Iterator(const HashMap * table) :
@@ -154,89 +177,244 @@ public:
}
private:
+ // Maintains insertion order.
+ ZigList _entries;
+ // If _indexes_len is less than 2**8, this is an array of uint8_t.
+ // If _indexes_len is less than 2**16, it is an array of uint16_t.
+ // If _indexes_len is less than 2**32, it is an array of uint32_t.
+ // Otherwise it is size_t.
+ // It's off by 1. 0 means empty slot, 1 means index 0, etc.
+ uint8_t *_index_bytes;
+ // This is the number of indexes. When indexes are bytes, it equals number of bytes.
+ // When indexes are uint16_t, _indexes_len is half the number of bytes.
+ size_t _indexes_len;
- Entry *_entries;
- int _capacity;
- int _size;
- int _max_distance_from_start_index;
- // this is used to detect bugs where a hashtable is edited while an iterator is running.
+ size_t _max_distance_from_start_index;
+ // This is used to detect bugs where a hashtable is edited while an iterator is running.
uint32_t _modification_count;
- void init_capacity(int capacity) {
- _capacity = capacity;
- _entries = heap::c_allocator.allocate(_capacity);
- _size = 0;
+ void init_capacity(size_t capacity) {
+ _entries = {};
+ _entries.ensure_capacity(capacity);
+ _indexes_len = 0;
+ if (capacity >= 16) {
+ // So that at capacity it will only be 60% full.
+ _indexes_len = capacity * 5 / 3;
+ size_t sz = capacity_index_size(_indexes_len);
+ // This zero initializes _index_bytes which sets them all to empty.
+ _index_bytes = heap::c_allocator.allocate(_indexes_len * sz);
+ } else {
+ _index_bytes = nullptr;
+ }
+
_max_distance_from_start_index = 0;
- for (int i = 0; i < _capacity; i += 1) {
- _entries[i].used = false;
- }
+ _modification_count = 0;
}
- void internal_put(K key, V value) {
- int start_index = key_to_index(key);
- for (int roll_over = 0, distance_from_start_index = 0;
- roll_over < _capacity; roll_over += 1, distance_from_start_index += 1)
+ static size_t capacity_index_size(size_t len) {
+ if (len < UINT8_MAX)
+ return 1;
+ if (len < UINT16_MAX)
+ return 2;
+ if (len < UINT32_MAX)
+ return 4;
+ return sizeof(size_t);
+ }
+
+ template
+ void internal_put(const K &key, const V &value, I *indexes) {
+ uint32_t hash = HashFunction(key);
+ uint32_t distance_from_start_index = 0;
+ size_t start_index = hash_to_index(hash);
+ for (size_t roll_over = 0; roll_over < _indexes_len;
+ roll_over += 1, distance_from_start_index += 1)
{
- int index = (start_index + roll_over) % _capacity;
- Entry *entry = &_entries[index];
+ size_t index_index = (start_index + roll_over) % _indexes_len;
+ I index_data = indexes[index_index];
+ if (index_data == 0) {
+ _entries.append_assuming_capacity({ hash, distance_from_start_index, key, value });
+ indexes[index_index] = _entries.length;
+ if (distance_from_start_index > _max_distance_from_start_index)
+ _max_distance_from_start_index = distance_from_start_index;
+ return;
+ }
+ // This pointer survives the following append because we call
+ // _entries.ensure_capacity before internal_put.
+ Entry *entry = &_entries.items[index_data - 1];
+ if (entry->hash == hash && EqualFn(entry->key, key)) {
+ *entry = {hash, distance_from_start_index, key, value};
+ if (distance_from_start_index > _max_distance_from_start_index)
+ _max_distance_from_start_index = distance_from_start_index;
+ return;
+ }
+ if (entry->distance_from_start_index < distance_from_start_index) {
+ // In this case, we did not find the item. We will put a new entry.
+ // However, we will use this index for the new entry, and move
+ // the previous index down the line, to keep the _max_distance_from_start_index
+ // as small as possible.
+ _entries.append_assuming_capacity({ hash, distance_from_start_index, key, value });
+ indexes[index_index] = _entries.length;
+ if (distance_from_start_index > _max_distance_from_start_index)
+ _max_distance_from_start_index = distance_from_start_index;
- if (entry->used && !EqualFn(entry->key, key)) {
- if (entry->distance_from_start_index < distance_from_start_index) {
- // robin hood to the rescue
- Entry tmp = *entry;
- if (distance_from_start_index > _max_distance_from_start_index)
- _max_distance_from_start_index = distance_from_start_index;
- *entry = {
- key,
- value,
- true,
- distance_from_start_index,
- };
- key = tmp.key;
- value = tmp.value;
- distance_from_start_index = tmp.distance_from_start_index;
+ distance_from_start_index = entry->distance_from_start_index;
+
+ // Find somewhere to put the index we replaced by shifting
+ // following indexes backwards.
+ roll_over += 1;
+ distance_from_start_index += 1;
+ for (; roll_over < _indexes_len; roll_over += 1, distance_from_start_index += 1) {
+ size_t index_index = (start_index + roll_over) % _indexes_len;
+ I next_index_data = indexes[index_index];
+ if (next_index_data == 0) {
+ if (distance_from_start_index > _max_distance_from_start_index)
+ _max_distance_from_start_index = distance_from_start_index;
+ entry->distance_from_start_index = distance_from_start_index;
+ indexes[index_index] = index_data;
+ return;
+ }
+ Entry *next_entry = &_entries.items[next_index_data - 1];
+ if (next_entry->distance_from_start_index < distance_from_start_index) {
+ if (distance_from_start_index > _max_distance_from_start_index)
+ _max_distance_from_start_index = distance_from_start_index;
+ entry->distance_from_start_index = distance_from_start_index;
+ indexes[index_index] = index_data;
+ distance_from_start_index = next_entry->distance_from_start_index;
+ entry = next_entry;
+ index_data = next_index_data;
+ }
}
- continue;
+ zig_unreachable();
}
-
- if (!entry->used) {
- // adding an entry. otherwise overwriting old value with
- // same key
- _size += 1;
- }
-
- if (distance_from_start_index > _max_distance_from_start_index)
- _max_distance_from_start_index = distance_from_start_index;
- *entry = {
- key,
- value,
- true,
- distance_from_start_index,
- };
- return;
}
- zig_panic("put into a full HashMap");
+ zig_unreachable();
}
+ template
+ void put_index(Entry *entry, size_t entry_index, I *indexes) {
+ size_t start_index = hash_to_index(entry->hash);
+ size_t index_data = entry_index + 1;
+ for (size_t roll_over = 0, distance_from_start_index = 0;
+ roll_over < _indexes_len; roll_over += 1, distance_from_start_index += 1)
+ {
+ size_t index_index = (start_index + roll_over) % _indexes_len;
+ size_t next_index_data = indexes[index_index];
+ if (next_index_data == 0) {
+ if (distance_from_start_index > _max_distance_from_start_index)
+ _max_distance_from_start_index = distance_from_start_index;
+ entry->distance_from_start_index = distance_from_start_index;
+ indexes[index_index] = index_data;
+ return;
+ }
+ Entry *next_entry = &_entries.items[next_index_data - 1];
+ if (next_entry->distance_from_start_index < distance_from_start_index) {
+ if (distance_from_start_index > _max_distance_from_start_index)
+ _max_distance_from_start_index = distance_from_start_index;
+ entry->distance_from_start_index = distance_from_start_index;
+ indexes[index_index] = index_data;
+ distance_from_start_index = next_entry->distance_from_start_index;
+ entry = next_entry;
+ index_data = next_index_data;
+ }
+ }
+ zig_unreachable();
+ }
Entry *internal_get(const K &key) const {
- int start_index = key_to_index(key);
- for (int roll_over = 0; roll_over <= _max_distance_from_start_index; roll_over += 1) {
- int index = (start_index + roll_over) % _capacity;
- Entry *entry = &_entries[index];
+ if (_index_bytes == nullptr) {
+ uint32_t hash = HashFunction(key);
+ for (size_t i = 0; i < _entries.length; i += 1) {
+ if (_entries.items[i].hash == hash && EqualFn(_entries.items[i].key, key)) {
+ return &_entries.items[i];
+ }
+ }
+ return nullptr;
+ }
+ switch (capacity_index_size(_indexes_len)) {
+ case 1: return internal_get2(key, (uint8_t*)_index_bytes);
+ case 2: return internal_get2(key, (uint16_t*)_index_bytes);
+ case 4: return internal_get2(key, (uint32_t*)_index_bytes);
+ default: return internal_get2(key, (size_t*)_index_bytes);
+ }
+ }
- if (!entry->used)
- return NULL;
+ template
+ Entry *internal_get2(const K &key, I *indexes) const {
+ uint32_t hash = HashFunction(key);
+ size_t start_index = hash_to_index(hash);
+ for (size_t roll_over = 0; roll_over <= _max_distance_from_start_index; roll_over += 1) {
+ size_t index_index = (start_index + roll_over) % _indexes_len;
+ size_t index_data = indexes[index_index];
+ if (index_data == 0)
+ return nullptr;
- if (EqualFn(entry->key, key))
+ Entry *entry = &_entries.items[index_data - 1];
+ if (entry->hash == hash && EqualFn(entry->key, key))
return entry;
}
- return NULL;
+ return nullptr;
}
- int key_to_index(const K &key) const {
- return (int)(HashFunction(key) % ((uint32_t)_capacity));
+ size_t hash_to_index(uint32_t hash) const {
+ return ((size_t)hash) % _indexes_len;
+ }
+
+ template
+ bool internal_remove(const K &key, I *indexes) {
+ uint32_t hash = HashFunction(key);
+ size_t start_index = hash_to_index(hash);
+ for (size_t roll_over = 0; roll_over <= _max_distance_from_start_index; roll_over += 1) {
+ size_t index_index = (start_index + roll_over) % _indexes_len;
+ size_t index_data = indexes[index_index];
+ if (index_data == 0)
+ return false;
+
+ size_t index = index_data - 1;
+ Entry *entry = &_entries.items[index];
+ if (entry->hash != hash || !EqualFn(entry->key, key))
+ continue;
+
+ size_t prev_index = index_index;
+ _entries.swap_remove(index);
+ if (_entries.length > 0 && _entries.length != index) {
+ // Because of the swap remove, now we need to update the index that was
+ // pointing to the last entry and is now pointing to this removed item slot.
+ update_entry_index(_entries.length, index, indexes);
+ }
+
+ // Now we have to shift over the following indexes.
+ roll_over += 1;
+ for (; roll_over < _indexes_len; roll_over += 1) {
+ size_t next_index = (start_index + roll_over) % _indexes_len;
+ if (indexes[next_index] == 0) {
+ indexes[prev_index] = 0;
+ return true;
+ }
+ Entry *next_entry = &_entries.items[indexes[next_index] - 1];
+ if (next_entry->distance_from_start_index == 0) {
+ indexes[prev_index] = 0;
+ return true;
+ }
+ indexes[prev_index] = indexes[next_index];
+ prev_index = next_index;
+ next_entry->distance_from_start_index -= 1;
+ }
+ zig_unreachable();
+ }
+ return false;
+ }
+
+ template
+ void update_entry_index(size_t old_entry_index, size_t new_entry_index, I *indexes) {
+ size_t start_index = hash_to_index(_entries.items[new_entry_index].hash);
+ for (size_t roll_over = 0; roll_over <= _max_distance_from_start_index; roll_over += 1) {
+ size_t index_index = (start_index + roll_over) % _indexes_len;
+ if (indexes[index_index] == old_entry_index + 1) {
+ indexes[index_index] = new_entry_index + 1;
+ return;
+ }
+ }
+ zig_unreachable();
}
};
-
#endif
diff --git a/src/ir.cpp b/src/ir.cpp
index 887f0a2f9b..11ff7746e7 100644
--- a/src/ir.cpp
+++ b/src/ir.cpp
@@ -13,6 +13,7 @@
#include "os.hpp"
#include "range_set.hpp"
#include "softfloat.hpp"
+#include "softfloat_ext.hpp"
#include "util.hpp"
#include "mem_list.hpp"
#include "all_types.hpp"
@@ -286,6 +287,7 @@ static IrInstGen *ir_analyze_struct_value_field_value(IrAnalyze *ira, IrInst* so
IrInstGen *struct_operand, TypeStructField *field);
static bool value_cmp_numeric_val_any(ZigValue *left, Cmp predicate, ZigValue *right);
static bool value_cmp_numeric_val_all(ZigValue *left, Cmp predicate, ZigValue *right);
+static void memoize_field_init_val(CodeGen *codegen, ZigType *container_type, TypeStructField *field);
#define ir_assert(OK, SOURCE_INSTRUCTION) ir_assert_impl((OK), (SOURCE_INSTRUCTION), __FILE__, __LINE__)
#define ir_assert_gen(OK, SOURCE_INSTRUCTION) ir_assert_gen_impl((OK), (SOURCE_INSTRUCTION), __FILE__, __LINE__)
@@ -308,6 +310,8 @@ static void destroy_instruction_src(IrInstSrc *inst) {
return heap::c_allocator.destroy(reinterpret_cast(inst));
case IrInstSrcIdCallExtra:
return heap::c_allocator.destroy(reinterpret_cast(inst));
+ case IrInstSrcIdAsyncCallExtra:
+ return heap::c_allocator.destroy(reinterpret_cast(inst));
case IrInstSrcIdUnOp:
return heap::c_allocator.destroy(reinterpret_cast(inst));
case IrInstSrcIdCondBr:
@@ -560,6 +564,8 @@ static void destroy_instruction_src(IrInstSrc *inst) {
return heap::c_allocator.destroy(reinterpret_cast(inst));
case IrInstSrcIdWasmMemoryGrow:
return heap::c_allocator.destroy(reinterpret_cast(inst));
+ case IrInstSrcIdSrc:
+ return heap::c_allocator.destroy(reinterpret_cast(inst));
}
zig_unreachable();
}
@@ -822,12 +828,11 @@ static ZigValue *const_ptr_pointee_unchecked_no_isf(CodeGen *g, ZigValue *const_
ZigValue *array_val = const_val->data.x_ptr.data.base_array.array_val;
size_t elem_index = const_val->data.x_ptr.data.base_array.elem_index;
- // TODO handle sentinel terminated arrays
expand_undef_array(g, array_val);
result = g->pass1_arena->create();
result->special = array_val->special;
result->type = get_array_type(g, array_val->type->data.array.child_type,
- array_val->type->data.array.len - elem_index, nullptr);
+ array_val->type->data.array.len - elem_index, array_val->type->data.array.sentinel);
result->data.x_array.special = ConstArraySpecialNone;
result->data.x_array.data.s_none.elements = &array_val->data.x_array.data.s_none.elements[elem_index];
result->parent.id = ConstParentIdArray;
@@ -1170,6 +1175,10 @@ static constexpr IrInstSrcId ir_inst_id(IrInstSrcCallExtra *) {
return IrInstSrcIdCallExtra;
}
+static constexpr IrInstSrcId ir_inst_id(IrInstSrcAsyncCallExtra *) {
+ return IrInstSrcIdAsyncCallExtra;
+}
+
static constexpr IrInstSrcId ir_inst_id(IrInstSrcConst *) {
return IrInstSrcIdConst;
}
@@ -1626,6 +1635,9 @@ static constexpr IrInstSrcId ir_inst_id(IrInstSrcWasmMemoryGrow *) {
return IrInstSrcIdWasmMemoryGrow;
}
+static constexpr IrInstSrcId ir_inst_id(IrInstSrcSrc *) {
+ return IrInstSrcIdSrc;
+}
static constexpr IrInstGenId ir_inst_id(IrInstGenDeclVar *) {
return IrInstGenIdDeclVar;
@@ -2436,6 +2448,25 @@ static IrInstSrc *ir_build_call_extra(IrBuilderSrc *irb, Scope *scope, AstNode *
return &call_instruction->base;
}
+static IrInstSrc *ir_build_async_call_extra(IrBuilderSrc *irb, Scope *scope, AstNode *source_node,
+ CallModifier modifier, IrInstSrc *fn_ref, IrInstSrc *ret_ptr, IrInstSrc *new_stack, IrInstSrc *args, ResultLoc *result_loc)
+{
+ IrInstSrcAsyncCallExtra *call_instruction = ir_build_instruction(irb, scope, source_node);
+ call_instruction->modifier = modifier;
+ call_instruction->fn_ref = fn_ref;
+ call_instruction->ret_ptr = ret_ptr;
+ call_instruction->new_stack = new_stack;
+ call_instruction->args = args;
+ call_instruction->result_loc = result_loc;
+
+ ir_ref_instruction(fn_ref, irb->current_basic_block);
+ if (ret_ptr != nullptr) ir_ref_instruction(ret_ptr, irb->current_basic_block);
+ ir_ref_instruction(new_stack, irb->current_basic_block);
+ ir_ref_instruction(args, irb->current_basic_block);
+
+ return &call_instruction->base;
+}
+
static IrInstSrc *ir_build_call_args(IrBuilderSrc *irb, Scope *scope, AstNode *source_node,
IrInstSrc *options, IrInstSrc *fn_ref, IrInstSrc **args_ptr, size_t args_len,
ResultLoc *result_loc)
@@ -5029,6 +5060,11 @@ static IrInstGen *ir_build_wasm_memory_grow_gen(IrAnalyze *ira, IrInst *source_i
return &instruction->base;
}
+static IrInstSrc *ir_build_src(IrBuilderSrc *irb, Scope *scope, AstNode *source_node) {
+ IrInstSrcSrc *instruction = ir_build_instruction(irb, scope, source_node);
+
+ return &instruction->base;
+}
static void ir_count_defers(IrBuilderSrc *irb, Scope *inner_scope, Scope *outer_scope, size_t *results) {
results[ReturnKindUnconditional] = 0;
@@ -6172,11 +6208,10 @@ static IrInstSrc *ir_gen_this(IrBuilderSrc *irb, Scope *orig_scope, AstNode *nod
static IrInstSrc *ir_gen_async_call(IrBuilderSrc *irb, Scope *scope, AstNode *await_node, AstNode *call_node,
LVal lval, ResultLoc *result_loc)
{
- size_t arg_offset = 3;
- if (call_node->data.fn_call_expr.params.length < arg_offset) {
+ if (call_node->data.fn_call_expr.params.length != 4) {
add_node_error(irb->codegen, call_node,
- buf_sprintf("expected at least %" ZIG_PRI_usize " arguments, found %" ZIG_PRI_usize,
- arg_offset, call_node->data.fn_call_expr.params.length));
+ buf_sprintf("expected 4 arguments, found %" ZIG_PRI_usize,
+ call_node->data.fn_call_expr.params.length));
return irb->codegen->invalid_inst_src;
}
@@ -6195,20 +6230,37 @@ static IrInstSrc *ir_gen_async_call(IrBuilderSrc *irb, Scope *scope, AstNode *aw
if (fn_ref == irb->codegen->invalid_inst_src)
return fn_ref;
- size_t arg_count = call_node->data.fn_call_expr.params.length - arg_offset;
- IrInstSrc **args = heap::c_allocator.allocate(arg_count);
- for (size_t i = 0; i < arg_count; i += 1) {
- AstNode *arg_node = call_node->data.fn_call_expr.params.at(i + arg_offset);
- IrInstSrc *arg = ir_gen_node(irb, arg_node, scope);
- if (arg == irb->codegen->invalid_inst_src)
- return arg;
- args[i] = arg;
- }
-
CallModifier modifier = (await_node == nullptr) ? CallModifierAsync : CallModifierNone;
bool is_async_call_builtin = true;
- IrInstSrc *call = ir_build_call_src(irb, scope, call_node, nullptr, fn_ref, arg_count, args,
- ret_ptr, modifier, is_async_call_builtin, bytes, result_loc);
+ AstNode *args_node = call_node->data.fn_call_expr.params.at(3);
+ if (args_node->type == NodeTypeContainerInitExpr) {
+ if (args_node->data.container_init_expr.kind == ContainerInitKindArray ||
+ args_node->data.container_init_expr.entries.length == 0)
+ {
+ size_t arg_count = args_node->data.container_init_expr.entries.length;
+ IrInstSrc **args = heap::c_allocator.allocate(arg_count);
+ for (size_t i = 0; i < arg_count; i += 1) {
+ AstNode *arg_node = args_node->data.container_init_expr.entries.at(i);
+ IrInstSrc *arg = ir_gen_node(irb, arg_node, scope);
+ if (arg == irb->codegen->invalid_inst_src)
+ return arg;
+ args[i] = arg;
+ }
+
+ IrInstSrc *call = ir_build_call_src(irb, scope, call_node, nullptr, fn_ref, arg_count, args,
+ ret_ptr, modifier, is_async_call_builtin, bytes, result_loc);
+ return ir_lval_wrap(irb, scope, call, lval, result_loc);
+ } else {
+ exec_add_error_node(irb->codegen, irb->exec, args_node,
+ buf_sprintf("TODO: @asyncCall with anon struct literal"));
+ return irb->codegen->invalid_inst_src;
+ }
+ }
+ IrInstSrc *args = ir_gen_node(irb, args_node, scope);
+ if (args == irb->codegen->invalid_inst_src)
+ return args;
+
+ IrInstSrc *call = ir_build_async_call_extra(irb, scope, call_node, modifier, fn_ref, ret_ptr, bytes, args, result_loc);
return ir_lval_wrap(irb, scope, call, lval, result_loc);
}
@@ -7449,6 +7501,11 @@ static IrInstSrc *ir_gen_builtin_fn_call(IrBuilderSrc *irb, Scope *scope, AstNod
return ir_gen_union_init_expr(irb, scope, node, union_type_inst, name_inst, init_node,
lval, result_loc);
}
+ case BuiltinFnIdSrc:
+ {
+ IrInstSrc *src_inst = ir_build_src(irb, scope, node);
+ return ir_lval_wrap(irb, scope, src_inst, lval, result_loc);
+ }
}
zig_unreachable();
}
@@ -9885,7 +9942,7 @@ static IrInstSrc *ir_gen_fn_proto(IrBuilderSrc *irb, Scope *parent_scope, AstNod
is_var_args = true;
break;
}
- if (param_node->data.param_decl.var_token == nullptr) {
+ if (param_node->data.param_decl.anytype_token == nullptr) {
AstNode *type_node = param_node->data.param_decl.type;
IrInstSrc *type_value = ir_gen_node(irb, type_node, parent_scope);
if (type_value == irb->codegen->invalid_inst_src)
@@ -9911,7 +9968,7 @@ static IrInstSrc *ir_gen_fn_proto(IrBuilderSrc *irb, Scope *parent_scope, AstNod
}
IrInstSrc *return_type;
- if (node->data.fn_proto.return_var_token == nullptr) {
+ if (node->data.fn_proto.return_anytype_token == nullptr) {
if (node->data.fn_proto.return_type == nullptr) {
return_type = ir_build_const_type(irb, parent_scope, node, irb->codegen->builtin_types.entry_void);
} else {
@@ -10169,9 +10226,9 @@ static IrInstSrc *ir_gen_node_raw(IrBuilderSrc *irb, AstNode *node, Scope *scope
add_node_error(irb->codegen, node,
buf_sprintf("inferred array size invalid here"));
return irb->codegen->invalid_inst_src;
- case NodeTypeVarFieldType:
+ case NodeTypeAnyTypeField:
return ir_lval_wrap(irb, scope,
- ir_build_const_type(irb, scope, node, irb->codegen->builtin_types.entry_var), lval, result_loc);
+ ir_build_const_type(irb, scope, node, irb->codegen->builtin_types.entry_anytype), lval, result_loc);
}
zig_unreachable();
}
@@ -10239,7 +10296,7 @@ static IrInstSrc *ir_gen_node_extra(IrBuilderSrc *irb, AstNode *node, Scope *sco
case NodeTypeSuspend:
case NodeTypeEnumLiteral:
case NodeTypeInferredArrayType:
- case NodeTypeVarFieldType:
+ case NodeTypeAnyTypeField:
case NodeTypePrefixOpExpr:
add_node_error(irb->codegen, node,
buf_sprintf("invalid left-hand side to assignment"));
@@ -10461,7 +10518,7 @@ ZigValue *const_ptr_pointee(IrAnalyze *ira, CodeGen *codegen, ZigValue *const_va
if (val == nullptr) return nullptr;
assert(const_val->type->id == ZigTypeIdPointer);
ZigType *expected_type = const_val->type->data.pointer.child_type;
- if (expected_type == codegen->builtin_types.entry_var) {
+ if (expected_type == codegen->builtin_types.entry_anytype) {
return val;
}
switch (type_has_one_possible_value(codegen, expected_type)) {
@@ -12585,28 +12642,29 @@ static ZigType *ir_resolve_peer_types(IrAnalyze *ira, AstNode *source_node, ZigT
if (prev_type->id == ZigTypeIdPointer &&
prev_type->data.pointer.ptr_len == PtrLenSingle &&
prev_type->data.pointer.child_type->id == ZigTypeIdArray &&
- ((cur_type->id == ZigTypeIdPointer && cur_type->data.pointer.ptr_len == PtrLenUnknown)))
+ ((cur_type->id == ZigTypeIdPointer && cur_type->data.pointer.ptr_len == PtrLenUnknown)))
{
- prev_inst = cur_inst;
+ convert_to_const_slice = false;
+ prev_inst = cur_inst;
if (prev_type->data.pointer.is_const && !cur_type->data.pointer.is_const) {
// const array pointer and non-const unknown pointer
make_the_pointer_const = true;
}
- continue;
+ continue;
}
// *[N]T to [*]T
if (cur_type->id == ZigTypeIdPointer &&
cur_type->data.pointer.ptr_len == PtrLenSingle &&
cur_type->data.pointer.child_type->id == ZigTypeIdArray &&
- ((prev_type->id == ZigTypeIdPointer && prev_type->data.pointer.ptr_len == PtrLenUnknown)))
+ ((prev_type->id == ZigTypeIdPointer && prev_type->data.pointer.ptr_len == PtrLenUnknown)))
{
if (cur_type->data.pointer.is_const && !prev_type->data.pointer.is_const) {
// const array pointer and non-const unknown pointer
make_the_pointer_const = true;
}
- continue;
+ continue;
}
// *[N]T to []T
@@ -12962,7 +13020,11 @@ static IrInstGen *ir_resolve_cast(IrAnalyze *ira, IrInst *source_instr, IrInstGe
{
if (instr_is_comptime(value) || !type_has_bits(ira->codegen, wanted_type)) {
IrInstGen *result = ir_const(ira, source_instr, wanted_type);
- if (!eval_const_expr_implicit_cast(ira, source_instr, cast_op, value->value, value->value->type,
+ ZigValue *val = ir_resolve_const(ira, value, UndefBad);
+ if (val == nullptr)
+ return ira->codegen->invalid_inst_gen;
+
+ if (!eval_const_expr_implicit_cast(ira, source_instr, cast_op, val, val->type,
result->value, wanted_type))
{
return ira->codegen->invalid_inst_gen;
@@ -14703,10 +14765,139 @@ static IrInstGen *ir_analyze_struct_literal_to_array(IrAnalyze *ira, IrInst* sou
}
static IrInstGen *ir_analyze_struct_literal_to_struct(IrAnalyze *ira, IrInst* source_instr,
- IrInstGen *value, ZigType *wanted_type)
+ IrInstGen *struct_operand, ZigType *wanted_type)
{
- ir_add_error(ira, source_instr, buf_sprintf("TODO: type coercion of anon struct literal to struct"));
- return ira->codegen->invalid_inst_gen;
+ Error err;
+
+ IrInstGen *struct_ptr = ir_get_ref(ira, source_instr, struct_operand, true, false);
+ if (type_is_invalid(struct_ptr->value->type))
+ return ira->codegen->invalid_inst_gen;
+
+ if (wanted_type->data.structure.resolve_status == ResolveStatusBeingInferred) {
+ ir_add_error(ira, source_instr, buf_sprintf("type coercion of anon struct literal to inferred struct"));
+ return ira->codegen->invalid_inst_gen;
+ }
+
+ if ((err = type_resolve(ira->codegen, wanted_type, ResolveStatusSizeKnown)))
+ return ira->codegen->invalid_inst_gen;
+
+ size_t actual_field_count = wanted_type->data.structure.src_field_count;
+ size_t instr_field_count = struct_operand->value->type->data.structure.src_field_count;
+
+ bool need_comptime = ir_should_inline(ira->old_irb.exec, source_instr->scope)
+ || type_requires_comptime(ira->codegen, wanted_type) == ReqCompTimeYes;
+ bool is_comptime = true;
+
+ // Determine if the struct_operand will be comptime.
+ // Also emit compile errors for missing fields and duplicate fields.
+ AstNode **field_assign_nodes = heap::c_allocator.allocate(actual_field_count);
+ ZigValue **field_values = heap::c_allocator.allocate(actual_field_count);
+ IrInstGen **casted_fields = heap::c_allocator.allocate(actual_field_count);
+ IrInstGen *const_result = ir_const(ira, source_instr, wanted_type);
+
+ for (size_t i = 0; i < instr_field_count; i += 1) {
+ TypeStructField *src_field = struct_operand->value->type->data.structure.fields[i];
+ TypeStructField *dst_field = find_struct_type_field(wanted_type, src_field->name);
+ if (dst_field == nullptr) {
+ ErrorMsg *msg = ir_add_error(ira, source_instr, buf_sprintf("no field named '%s' in struct '%s'",
+ buf_ptr(src_field->name), buf_ptr(&wanted_type->name)));
+ if (wanted_type->data.structure.decl_node) {
+ add_error_note(ira->codegen, msg, wanted_type->data.structure.decl_node,
+ buf_sprintf("struct '%s' declared here", buf_ptr(&wanted_type->name)));
+ }
+ add_error_note(ira->codegen, msg, src_field->decl_node,
+ buf_sprintf("field '%s' declared here", buf_ptr(src_field->name)));
+ return ira->codegen->invalid_inst_gen;
+ }
+
+ ir_assert(src_field->decl_node != nullptr, source_instr);
+ AstNode *existing_assign_node = field_assign_nodes[dst_field->src_index];
+ if (existing_assign_node != nullptr) {
+ ErrorMsg *msg = ir_add_error(ira, source_instr, buf_sprintf("duplicate field"));
+ add_error_note(ira->codegen, msg, existing_assign_node, buf_sprintf("other field here"));
+ return ira->codegen->invalid_inst_gen;
+ }
+ field_assign_nodes[dst_field->src_index] = src_field->decl_node;
+
+ IrInstGen *field_ptr = ir_analyze_struct_field_ptr(ira, source_instr, src_field, struct_ptr,
+ struct_operand->value->type, false);
+ if (type_is_invalid(field_ptr->value->type))
+ return ira->codegen->invalid_inst_gen;
+ IrInstGen *field_value = ir_get_deref(ira, source_instr, field_ptr, nullptr);
+ if (type_is_invalid(field_value->value->type))
+ return ira->codegen->invalid_inst_gen;
+ IrInstGen *casted_value = ir_implicit_cast(ira, field_value, dst_field->type_entry);
+ if (type_is_invalid(casted_value->value->type))
+ return ira->codegen->invalid_inst_gen;
+
+ casted_fields[dst_field->src_index] = casted_value;
+ if (need_comptime || instr_is_comptime(casted_value)) {
+ ZigValue *field_val = ir_resolve_const(ira, casted_value, UndefOk);
+ if (field_val == nullptr)
+ return ira->codegen->invalid_inst_gen;
+ field_val->parent.id = ConstParentIdStruct;
+ field_val->parent.data.p_struct.struct_val = const_result->value;
+ field_val->parent.data.p_struct.field_index = dst_field->src_index;
+ field_values[dst_field->src_index] = field_val;
+ } else {
+ is_comptime = false;
+ }
+ }
+
+ bool any_missing = false;
+ for (size_t i = 0; i < actual_field_count; i += 1) {
+ if (field_assign_nodes[i] != nullptr) continue;
+
+ // look for a default field value
+ TypeStructField *field = wanted_type->data.structure.fields[i];
+ memoize_field_init_val(ira->codegen, wanted_type, field);
+ if (field->init_val == nullptr) {
+ ir_add_error(ira, source_instr,
+ buf_sprintf("missing field: '%s'", buf_ptr(field->name)));
+ any_missing = true;
+ continue;
+ }
+ if (type_is_invalid(field->init_val->type))
+ return ira->codegen->invalid_inst_gen;
+ ZigValue *init_val_copy = ira->codegen->pass1_arena->create();
+ copy_const_val(ira->codegen, init_val_copy, field->init_val);
+ init_val_copy->parent.id = ConstParentIdStruct;
+ init_val_copy->parent.data.p_struct.struct_val = const_result->value;
+ init_val_copy->parent.data.p_struct.field_index = i;
+ field_values[i] = init_val_copy;
+ casted_fields[i] = ir_const_move(ira, source_instr, init_val_copy);
+ }
+ if (any_missing)
+ return ira->codegen->invalid_inst_gen;
+
+ if (is_comptime) {
+ heap::c_allocator.deallocate(field_assign_nodes, actual_field_count);
+ IrInstGen *const_result = ir_const(ira, source_instr, wanted_type);
+ const_result->value->data.x_struct.fields = field_values;
+ return const_result;
+ }
+
+ IrInstGen *result_loc_inst = ir_resolve_result(ira, source_instr, no_result_loc(),
+ wanted_type, nullptr, true, true);
+ if (type_is_invalid(result_loc_inst->value->type) || result_loc_inst->value->type->id == ZigTypeIdUnreachable) {
+ return ira->codegen->invalid_inst_gen;
+ }
+
+ for (size_t i = 0; i < actual_field_count; i += 1) {
+ TypeStructField *field = wanted_type->data.structure.fields[i];
+ IrInstGen *field_ptr = ir_analyze_struct_field_ptr(ira, source_instr, field, result_loc_inst, wanted_type, true);
+ if (type_is_invalid(field_ptr->value->type))
+ return ira->codegen->invalid_inst_gen;
+ IrInstGen *store_ptr_inst = ir_analyze_store_ptr(ira, source_instr, field_ptr, casted_fields[i], true);
+ if (type_is_invalid(store_ptr_inst->value->type))
+ return ira->codegen->invalid_inst_gen;
+ }
+
+ heap::c_allocator.deallocate(field_assign_nodes, actual_field_count);
+ heap::c_allocator.deallocate(field_values, actual_field_count);
+ heap::c_allocator.deallocate(casted_fields, actual_field_count);
+
+ return ir_get_deref(ira, source_instr, result_loc_inst, nullptr);
}
static IrInstGen *ir_analyze_struct_literal_to_union(IrAnalyze *ira, IrInst* source_instr,
@@ -14727,7 +14918,7 @@ static IrInstGen *ir_analyze_struct_literal_to_union(IrAnalyze *ira, IrInst* sou
TypeUnionField *union_field = find_union_type_field(union_type, only_field->name);
if (union_field == nullptr) {
ir_add_error_node(ira, only_field->decl_node,
- buf_sprintf("no member named '%s' in union '%s'",
+ buf_sprintf("no field named '%s' in union '%s'",
buf_ptr(only_field->name), buf_ptr(&union_type->name)));
return ira->codegen->invalid_inst_gen;
}
@@ -14849,7 +15040,7 @@ static IrInstGen *ir_analyze_cast(IrAnalyze *ira, IrInst *source_instr,
}
// This means the wanted type is anything.
- if (wanted_type == ira->codegen->builtin_types.entry_var) {
+ if (wanted_type == ira->codegen->builtin_types.entry_anytype) {
return value;
}
@@ -15127,46 +15318,6 @@ static IrInstGen *ir_analyze_cast(IrAnalyze *ira, IrInst *source_instr,
}
}
- // *[N]T to E![]T
- if (wanted_type->id == ZigTypeIdErrorUnion &&
- is_slice(wanted_type->data.error_union.payload_type) &&
- actual_type->id == ZigTypeIdPointer &&
- actual_type->data.pointer.ptr_len == PtrLenSingle &&
- actual_type->data.pointer.child_type->id == ZigTypeIdArray)
- {
- ZigType *slice_type = wanted_type->data.error_union.payload_type;
- ZigType *slice_ptr_type = slice_type->data.structure.fields[slice_ptr_index]->type_entry;
- assert(slice_ptr_type->id == ZigTypeIdPointer);
- ZigType *array_type = actual_type->data.pointer.child_type;
- bool const_ok = (slice_ptr_type->data.pointer.is_const || array_type->data.array.len == 0
- || !actual_type->data.pointer.is_const);
- if (const_ok && types_match_const_cast_only(ira, slice_ptr_type->data.pointer.child_type,
- array_type->data.array.child_type, source_node,
- !slice_ptr_type->data.pointer.is_const).id == ConstCastResultIdOk)
- {
- // If the pointers both have ABI align, it works.
- bool ok_align = slice_ptr_type->data.pointer.explicit_alignment == 0 &&
- actual_type->data.pointer.explicit_alignment == 0;
- if (!ok_align) {
- // If either one has non ABI align, we have to resolve them both
- if ((err = type_resolve(ira->codegen, actual_type->data.pointer.child_type,
- ResolveStatusAlignmentKnown)))
- {
- return ira->codegen->invalid_inst_gen;
- }
- if ((err = type_resolve(ira->codegen, slice_ptr_type->data.pointer.child_type,
- ResolveStatusAlignmentKnown)))
- {
- return ira->codegen->invalid_inst_gen;
- }
- ok_align = get_ptr_align(ira->codegen, actual_type) >= get_ptr_align(ira->codegen, slice_ptr_type);
- }
- if (ok_align) {
- return ir_resolve_ptr_of_array_to_slice(ira, source_instr, value, slice_type, nullptr);
- }
- }
- }
-
// @Vector(N,T1) to @Vector(N,T2)
if (actual_type->id == ZigTypeIdVector && wanted_type->id == ZigTypeIdVector) {
if (actual_type->data.vector.len == wanted_type->data.vector.len &&
@@ -15346,6 +15497,7 @@ static IrInstGen *ir_analyze_cast(IrAnalyze *ira, IrInst *source_instr,
if (is_pointery_and_elem_is_not_pointery(actual_type)) {
ZigType *dest_ptr_type = nullptr;
if (wanted_type->id == ZigTypeIdPointer &&
+ actual_type->id != ZigTypeIdOptional &&
wanted_type->data.pointer.child_type == ira->codegen->builtin_types.entry_c_void)
{
dest_ptr_type = wanted_type;
@@ -15483,7 +15635,7 @@ static IrInstGen *ir_implicit_cast(IrAnalyze *ira, IrInstGen *value, ZigType *ex
static ZigType *get_ptr_elem_type(CodeGen *g, IrInstGen *ptr) {
ir_assert_gen(ptr->value->type->id == ZigTypeIdPointer, ptr);
ZigType *elem_type = ptr->value->type->data.pointer.child_type;
- if (elem_type != g->builtin_types.entry_var)
+ if (elem_type != g->builtin_types.entry_anytype)
return elem_type;
if (ir_resolve_lazy(g, ptr->base.source_node, ptr->value))
@@ -15535,7 +15687,7 @@ static IrInstGen *ir_get_deref(IrAnalyze *ira, IrInst* source_instruction, IrIns
}
if (ptr->value->data.x_ptr.mut != ConstPtrMutRuntimeVar) {
ZigValue *pointee = const_ptr_pointee_unchecked(ira->codegen, ptr->value);
- if (child_type == ira->codegen->builtin_types.entry_var) {
+ if (child_type == ira->codegen->builtin_types.entry_anytype) {
child_type = pointee->type;
}
if (pointee->special != ConstValSpecialRuntime) {
@@ -18353,7 +18505,7 @@ static IrInstGen *ir_analyze_instruction_decl_var(IrAnalyze *ira, IrInstSrcDeclV
if (decl_var_instruction->var_type != nullptr) {
var_type = decl_var_instruction->var_type->child;
ZigType *proposed_type = ir_resolve_type(ira, var_type);
- explicit_type = validate_var_type(ira->codegen, var_type->base.source_node, proposed_type);
+ explicit_type = validate_var_type(ira->codegen, &var->decl_node->data.variable_declaration, proposed_type);
if (type_is_invalid(explicit_type)) {
var->var_type = ira->codegen->builtin_types.entry_invalid;
return ira->codegen->invalid_inst_gen;
@@ -18935,7 +19087,7 @@ static Error ir_result_has_type(IrAnalyze *ira, ResultLoc *result_loc, bool *out
ZigType *dest_type = ir_resolve_type(ira, result_cast->base.source_instruction->child);
if (type_is_invalid(dest_type))
return ErrorSemanticAnalyzeFail;
- *out = (dest_type != ira->codegen->builtin_types.entry_var);
+ *out = (dest_type != ira->codegen->builtin_types.entry_anytype);
return ErrorNone;
}
case ResultLocIdVar:
@@ -19141,7 +19293,7 @@ static IrInstGen *ir_resolve_result_raw(IrAnalyze *ira, IrInst *suspend_source_i
if (type_is_invalid(dest_type))
return ira->codegen->invalid_inst_gen;
- if (dest_type == ira->codegen->builtin_types.entry_var) {
+ if (dest_type == ira->codegen->builtin_types.entry_anytype) {
return ir_resolve_no_result_loc(ira, suspend_source_instr, result_loc, value_type);
}
@@ -19287,7 +19439,7 @@ static IrInstGen *ir_resolve_result_raw(IrAnalyze *ira, IrInst *suspend_source_i
return ira->codegen->invalid_inst_gen;
}
- if (child_type != ira->codegen->builtin_types.entry_var) {
+ if (child_type != ira->codegen->builtin_types.entry_anytype) {
if (type_size(ira->codegen, child_type) != type_size(ira->codegen, value_type)) {
// pointer cast won't work; we need a temporary location.
result_bit_cast->parent->written = parent_was_written;
@@ -19448,9 +19600,9 @@ static IrInstGen *ir_analyze_instruction_resolve_result(IrAnalyze *ira, IrInstSr
if (type_is_invalid(implicit_elem_type))
return ira->codegen->invalid_inst_gen;
} else {
- implicit_elem_type = ira->codegen->builtin_types.entry_var;
+ implicit_elem_type = ira->codegen->builtin_types.entry_anytype;
}
- if (implicit_elem_type == ira->codegen->builtin_types.entry_var) {
+ if (implicit_elem_type == ira->codegen->builtin_types.entry_anytype) {
Buf *bare_name = buf_alloc();
Buf *name = get_anon_type_name(ira->codegen, nullptr, container_string(ContainerKindStruct),
instruction->base.base.scope, instruction->base.base.source_node, bare_name);
@@ -19607,7 +19759,7 @@ static bool ir_analyze_fn_call_inline_arg(IrAnalyze *ira, AstNode *fn_proto_node
assert(param_decl_node->type == NodeTypeParamDecl);
IrInstGen *casted_arg;
- if (param_decl_node->data.param_decl.var_token == nullptr) {
+ if (param_decl_node->data.param_decl.anytype_token == nullptr) {
AstNode *param_type_node = param_decl_node->data.param_decl.type;
ZigType *param_type = ir_analyze_type_expr(ira, *exec_scope, param_type_node);
if (type_is_invalid(param_type))
@@ -19647,7 +19799,7 @@ static bool ir_analyze_fn_call_generic_arg(IrAnalyze *ira, AstNode *fn_proto_nod
arg_part_of_generic_id = true;
casted_arg = arg;
} else {
- if (param_decl_node->data.param_decl.var_token == nullptr) {
+ if (param_decl_node->data.param_decl.anytype_token == nullptr) {
AstNode *param_type_node = param_decl_node->data.param_decl.type;
ZigType *param_type = ir_analyze_type_expr(ira, *child_scope, param_type_node);
if (type_is_invalid(param_type))
@@ -19859,7 +20011,7 @@ static IrInstGen *ir_analyze_store_ptr(IrAnalyze *ira, IrInst* source_instr,
}
if (ptr->value->type->data.pointer.inferred_struct_field != nullptr &&
- child_type == ira->codegen->builtin_types.entry_var)
+ child_type == ira->codegen->builtin_types.entry_anytype)
{
child_type = ptr->value->type->data.pointer.inferred_struct_field->inferred_struct_type;
}
@@ -20030,7 +20182,7 @@ static IrInstGen *ir_analyze_fn_call(IrAnalyze *ira, IrInst* source_instr,
}
IrInstGen *first_arg;
- if (!first_arg_known_bare && handle_is_ptr(ira->codegen, first_arg_ptr->value->type->data.pointer.child_type)) {
+ if (!first_arg_known_bare) {
first_arg = first_arg_ptr;
} else {
first_arg = ir_get_deref(ira, &first_arg_ptr->base, first_arg_ptr, nullptr);
@@ -20050,6 +20202,11 @@ static IrInstGen *ir_analyze_fn_call(IrAnalyze *ira, IrInst* source_instr,
}
AstNode *return_type_node = fn_proto_node->data.fn_proto.return_type;
+ if (return_type_node == nullptr) {
+ ir_add_error(ira, &fn_ref->base,
+ buf_sprintf("TODO implement inferred return types https://github.com/ziglang/zig/issues/447"));
+ return ira->codegen->invalid_inst_gen;
+ }
ZigType *specified_return_type = ir_analyze_type_expr(ira, exec_scope, return_type_node);
if (type_is_invalid(specified_return_type))
return ira->codegen->invalid_inst_gen;
@@ -20160,7 +20317,7 @@ static IrInstGen *ir_analyze_fn_call(IrAnalyze *ira, IrInst* source_instr,
}
IrInstGen *first_arg;
- if (!first_arg_known_bare && handle_is_ptr(ira->codegen, first_arg_ptr->value->type->data.pointer.child_type)) {
+ if (!first_arg_known_bare) {
first_arg = first_arg_ptr;
} else {
first_arg = ir_get_deref(ira, &first_arg_ptr->base, first_arg_ptr, nullptr);
@@ -20212,7 +20369,7 @@ static IrInstGen *ir_analyze_fn_call(IrAnalyze *ira, IrInst* source_instr,
inst_fn_type_id.alignment = align_bytes;
}
- if (fn_proto_node->data.fn_proto.return_var_token == nullptr) {
+ if (fn_proto_node->data.fn_proto.return_anytype_token == nullptr) {
AstNode *return_type_node = fn_proto_node->data.fn_proto.return_type;
ZigType *specified_return_type = ir_analyze_type_expr(ira, impl_fn->child_scope, return_type_node);
if (type_is_invalid(specified_return_type))
@@ -20311,7 +20468,7 @@ static IrInstGen *ir_analyze_fn_call(IrAnalyze *ira, IrInst* source_instr,
if (type_is_invalid(dummy_result->value->type))
return ira->codegen->invalid_inst_gen;
ZigType *res_child_type = result_loc->value->type->data.pointer.child_type;
- if (res_child_type == ira->codegen->builtin_types.entry_var) {
+ if (res_child_type == ira->codegen->builtin_types.entry_anytype) {
res_child_type = impl_fn_type_id->return_type;
}
if (!handle_is_ptr(ira->codegen, res_child_type)) {
@@ -20365,9 +20522,7 @@ static IrInstGen *ir_analyze_fn_call(IrAnalyze *ira, IrInst* source_instr,
return ira->codegen->invalid_inst_gen;
IrInstGen *first_arg;
- if (param_type->id == ZigTypeIdPointer &&
- handle_is_ptr(ira->codegen, first_arg_ptr->value->type->data.pointer.child_type))
- {
+ if (param_type->id == ZigTypeIdPointer) {
first_arg = first_arg_ptr;
} else {
first_arg = ir_get_deref(ira, &first_arg_ptr->base, first_arg_ptr, nullptr);
@@ -20454,7 +20609,7 @@ static IrInstGen *ir_analyze_fn_call(IrAnalyze *ira, IrInst* source_instr,
if (type_is_invalid(dummy_result->value->type))
return ira->codegen->invalid_inst_gen;
ZigType *res_child_type = result_loc->value->type->data.pointer.child_type;
- if (res_child_type == ira->codegen->builtin_types.entry_var) {
+ if (res_child_type == ira->codegen->builtin_types.entry_anytype) {
res_child_type = return_type;
}
if (!handle_is_ptr(ira->codegen, res_child_type)) {
@@ -20614,40 +20769,106 @@ static IrInstGen *ir_analyze_call_extra(IrAnalyze *ira, IrInst* source_instr,
modifier, stack, stack_src, false, args_ptr, args_len, nullptr, result_loc);
}
-static IrInstGen *ir_analyze_instruction_call_extra(IrAnalyze *ira, IrInstSrcCallExtra *instruction) {
- IrInstGen *args = instruction->args->child;
+static IrInstGen *ir_analyze_async_call_extra(IrAnalyze *ira, IrInst* source_instr, CallModifier modifier,
+ IrInstSrc *pass1_fn_ref, IrInstSrc *ret_ptr, IrInstSrc *new_stack, IrInstGen **args_ptr, size_t args_len, ResultLoc *result_loc)
+{
+ IrInstGen *fn_ref = pass1_fn_ref->child;
+ if (type_is_invalid(fn_ref->value->type))
+ return ira->codegen->invalid_inst_gen;
+
+ if (ir_should_inline(ira->old_irb.exec, source_instr->scope)) {
+ ir_add_error(ira, source_instr, buf_sprintf("TODO: comptime @asyncCall"));
+ return ira->codegen->invalid_inst_gen;
+ }
+
+ IrInstGen *first_arg_ptr = nullptr;
+ IrInst *first_arg_ptr_src = nullptr;
+ ZigFn *fn = nullptr;
+ if (instr_is_comptime(fn_ref)) {
+ if (fn_ref->value->type->id == ZigTypeIdBoundFn) {
+ assert(fn_ref->value->special == ConstValSpecialStatic);
+ fn = fn_ref->value->data.x_bound_fn.fn;
+ first_arg_ptr = fn_ref->value->data.x_bound_fn.first_arg;
+ first_arg_ptr_src = fn_ref->value->data.x_bound_fn.first_arg_src;
+ if (type_is_invalid(first_arg_ptr->value->type))
+ return ira->codegen->invalid_inst_gen;
+ } else {
+ fn = ir_resolve_fn(ira, fn_ref);
+ }
+ }
+
+ IrInstGen *ret_ptr_uncasted = nullptr;
+ if (ret_ptr != nullptr) {
+ ret_ptr_uncasted = ret_ptr->child;
+ if (type_is_invalid(ret_ptr_uncasted->value->type))
+ return ira->codegen->invalid_inst_gen;
+ }
+
+ ZigType *fn_type = (fn != nullptr) ? fn->type_entry : fn_ref->value->type;
+ IrInstGen *casted_new_stack = analyze_casted_new_stack(ira, source_instr, new_stack->child,
+ &new_stack->base, true, fn);
+ if (casted_new_stack != nullptr && type_is_invalid(casted_new_stack->value->type))
+ return ira->codegen->invalid_inst_gen;
+
+ return ir_analyze_fn_call(ira, source_instr, fn, fn_type, fn_ref, first_arg_ptr, first_arg_ptr_src,
+ modifier, casted_new_stack, &new_stack->base, true, args_ptr, args_len, ret_ptr_uncasted, result_loc);
+}
+
+static bool ir_extract_tuple_call_args(IrAnalyze *ira, IrInst *source_instr, IrInstGen *args, IrInstGen ***args_ptr, size_t *args_len) {
ZigType *args_type = args->value->type;
if (type_is_invalid(args_type))
- return ira->codegen->invalid_inst_gen;
+ return false;
if (args_type->id != ZigTypeIdStruct) {
ir_add_error(ira, &args->base,
buf_sprintf("expected tuple or struct, found '%s'", buf_ptr(&args_type->name)));
- return ira->codegen->invalid_inst_gen;
+ return false;
}
- IrInstGen **args_ptr = nullptr;
- size_t args_len = 0;
-
if (is_tuple(args_type)) {
- args_len = args_type->data.structure.src_field_count;
- args_ptr = heap::c_allocator.allocate(args_len);
- for (size_t i = 0; i < args_len; i += 1) {
+ *args_len = args_type->data.structure.src_field_count;
+ *args_ptr = heap::c_allocator.allocate(*args_len);
+ for (size_t i = 0; i < *args_len; i += 1) {
TypeStructField *arg_field = args_type->data.structure.fields[i];
- args_ptr[i] = ir_analyze_struct_value_field_value(ira, &instruction->base.base, args, arg_field);
- if (type_is_invalid(args_ptr[i]->value->type))
- return ira->codegen->invalid_inst_gen;
+ (*args_ptr)[i] = ir_analyze_struct_value_field_value(ira, source_instr, args, arg_field);
+ if (type_is_invalid((*args_ptr)[i]->value->type))
+ return false;
}
} else {
ir_add_error(ira, &args->base, buf_sprintf("TODO: struct args"));
+ return false;
+ }
+ return true;
+}
+
+static IrInstGen *ir_analyze_instruction_call_extra(IrAnalyze *ira, IrInstSrcCallExtra *instruction) {
+ IrInstGen *args = instruction->args->child;
+ IrInstGen **args_ptr = nullptr;
+ size_t args_len = 0;
+ if (!ir_extract_tuple_call_args(ira, &instruction->base.base, args, &args_ptr, &args_len)) {
return ira->codegen->invalid_inst_gen;
}
+
IrInstGen *result = ir_analyze_call_extra(ira, &instruction->base.base, instruction->options,
instruction->fn_ref, args_ptr, args_len, instruction->result_loc);
heap::c_allocator.deallocate(args_ptr, args_len);
return result;
}
+static IrInstGen *ir_analyze_instruction_async_call_extra(IrAnalyze *ira, IrInstSrcAsyncCallExtra *instruction) {
+ IrInstGen *args = instruction->args->child;
+ IrInstGen **args_ptr = nullptr;
+ size_t args_len = 0;
+ if (!ir_extract_tuple_call_args(ira, &instruction->base.base, args, &args_ptr, &args_len)) {
+ return ira->codegen->invalid_inst_gen;
+ }
+
+ IrInstGen *result = ir_analyze_async_call_extra(ira, &instruction->base.base, instruction->modifier,
+ instruction->fn_ref, instruction->ret_ptr, instruction->new_stack, args_ptr, args_len, instruction->result_loc);
+ heap::c_allocator.deallocate(args_ptr, args_len);
+ return result;
+}
+
static IrInstGen *ir_analyze_instruction_call_args(IrAnalyze *ira, IrInstSrcCallArgs *instruction) {
IrInstGen **args_ptr = heap::c_allocator.allocate(instruction->args_len);
for (size_t i = 0; i < instruction->args_len; i += 1) {
@@ -20881,17 +21102,24 @@ static IrInstGen *ir_analyze_negation(IrAnalyze *ira, IrInstSrcUnOp *instruction
if (type_is_invalid(expr_type))
return ira->codegen->invalid_inst_gen;
- if (!(expr_type->id == ZigTypeIdInt || expr_type->id == ZigTypeIdComptimeInt ||
- expr_type->id == ZigTypeIdFloat || expr_type->id == ZigTypeIdComptimeFloat ||
- expr_type->id == ZigTypeIdVector))
- {
- ir_add_error(ira, &instruction->base.base,
- buf_sprintf("negation of type '%s'", buf_ptr(&expr_type->name)));
- return ira->codegen->invalid_inst_gen;
- }
-
bool is_wrap_op = (instruction->op_id == IrUnOpNegationWrap);
+ switch (expr_type->id) {
+ case ZigTypeIdComptimeInt:
+ case ZigTypeIdFloat:
+ case ZigTypeIdComptimeFloat:
+ case ZigTypeIdVector:
+ break;
+ case ZigTypeIdInt:
+ if (is_wrap_op || expr_type->data.integral.is_signed)
+ break;
+ ZIG_FALLTHROUGH;
+ default:
+ ir_add_error(ira, &instruction->base.base,
+ buf_sprintf("negation of type '%s'", buf_ptr(&expr_type->name)));
+ return ira->codegen->invalid_inst_gen;
+ }
+
ZigType *scalar_type = (expr_type->id == ZigTypeIdVector) ? expr_type->data.vector.elem_type : expr_type;
if (instr_is_comptime(value)) {
@@ -22112,7 +22340,7 @@ static IrInstGen *ir_analyze_inferred_field_ptr(IrAnalyze *ira, Buf *field_name,
inferred_struct_field->inferred_struct_type = container_type;
inferred_struct_field->field_name = field_name;
- ZigType *elem_type = ira->codegen->builtin_types.entry_var;
+ ZigType *elem_type = ira->codegen->builtin_types.entry_anytype;
ZigType *field_ptr_type = get_pointer_to_type_extra2(ira->codegen, elem_type,
container_ptr_type->data.pointer.is_const, container_ptr_type->data.pointer.is_volatile,
PtrLenSingle, 0, 0, 0, false, VECTOR_INDEX_NONE, inferred_struct_field, nullptr);
@@ -22407,7 +22635,7 @@ static IrInstGen *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstSrcFiel
usize, ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
} else {
ir_add_error_node(ira, source_node,
- buf_sprintf("no member named '%s' in '%s'", buf_ptr(field_name),
+ buf_sprintf("no field named '%s' in '%s'", buf_ptr(field_name),
buf_ptr(&container_type->name)));
return ira->codegen->invalid_inst_gen;
}
@@ -23834,7 +24062,7 @@ static IrInstGen *ir_analyze_union_init(IrAnalyze *ira, IrInst* source_instructi
TypeUnionField *type_field = find_union_type_field(union_type, field_name);
if (type_field == nullptr) {
ir_add_error_node(ira, field_source_node,
- buf_sprintf("no member named '%s' in union '%s'",
+ buf_sprintf("no field named '%s' in union '%s'",
buf_ptr(field_name), buf_ptr(&union_type->name)));
return ira->codegen->invalid_inst_gen;
}
@@ -23930,7 +24158,7 @@ static IrInstGen *ir_analyze_container_init_fields(IrAnalyze *ira, IrInst *sourc
TypeStructField *type_field = find_struct_type_field(container_type, field->name);
if (!type_field) {
ir_add_error_node(ira, field->source_node,
- buf_sprintf("no member named '%s' in struct '%s'",
+ buf_sprintf("no field named '%s' in struct '%s'",
buf_ptr(field->name), buf_ptr(&container_type->name)));
return ira->codegen->invalid_inst_gen;
}
@@ -23965,7 +24193,7 @@ static IrInstGen *ir_analyze_container_init_fields(IrAnalyze *ira, IrInst *sourc
memoize_field_init_val(ira->codegen, container_type, field);
if (field->init_val == nullptr) {
ir_add_error(ira, source_instr,
- buf_sprintf("missing field: '%s'", buf_ptr(container_type->data.structure.fields[i]->name)));
+ buf_sprintf("missing field: '%s'", buf_ptr(field->name)));
any_missing = true;
continue;
}
@@ -24890,7 +25118,7 @@ static ZigValue *create_ptr_like_type_info(IrAnalyze *ira, ZigType *ptr_type_ent
fields[5]->special = ConstValSpecialStatic;
fields[5]->type = ira->codegen->builtin_types.entry_bool;
fields[5]->data.x_bool = attrs_type->data.pointer.allow_zero;
- // sentinel: var
+ // sentinel: anytype
ensure_field_index(result->type, "sentinel", 6);
fields[6]->special = ConstValSpecialStatic;
if (attrs_type->data.pointer.child_type->id != ZigTypeIdOpaque) {
@@ -25018,7 +25246,7 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInst* source_instr, ZigTy
fields[1]->special = ConstValSpecialStatic;
fields[1]->type = ira->codegen->builtin_types.entry_type;
fields[1]->data.x_type = type_entry->data.array.child_type;
- // sentinel: var
+ // sentinel: anytype
fields[2]->special = ConstValSpecialStatic;
fields[2]->type = get_optional_type(ira->codegen, type_entry->data.array.child_type);
fields[2]->data.x_optional = type_entry->data.array.sentinel;
@@ -25318,7 +25546,7 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInst* source_instr, ZigTy
result->special = ConstValSpecialStatic;
result->type = ir_type_info_get_type(ira, "Struct", nullptr);
- ZigValue **fields = alloc_const_vals_ptrs(ira->codegen, 3);
+ ZigValue **fields = alloc_const_vals_ptrs(ira->codegen, 4);
result->data.x_struct.fields = fields;
// layout: ContainerLayout
@@ -25373,7 +25601,7 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInst* source_instr, ZigTy
inner_fields[2]->type = ira->codegen->builtin_types.entry_type;
inner_fields[2]->data.x_type = struct_field->type_entry;
- // default_value: var
+ // default_value: anytype
inner_fields[3]->special = ConstValSpecialStatic;
inner_fields[3]->type = get_optional_type2(ira->codegen, struct_field->type_entry);
if (inner_fields[3]->type == nullptr) return ErrorSemanticAnalyzeFail;
@@ -25399,6 +25627,12 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInst* source_instr, ZigTy
return err;
}
+ // is_tuple: bool
+ ensure_field_index(result->type, "is_tuple", 3);
+ fields[3]->special = ConstValSpecialStatic;
+ fields[3]->type = ira->codegen->builtin_types.entry_bool;
+ fields[3]->data.x_bool = is_tuple(type_entry);
+
break;
}
case ZigTypeIdFn:
@@ -25504,9 +25738,18 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInst* source_instr, ZigTy
break;
}
case ZigTypeIdFnFrame:
- ir_add_error(ira, source_instr,
- buf_sprintf("compiler bug: TODO @typeInfo for async function frames. https://github.com/ziglang/zig/issues/3066"));
- return ErrorSemanticAnalyzeFail;
+ {
+ result = ira->codegen->pass1_arena->create();
+ result->special = ConstValSpecialStatic;
+ result->type = ir_type_info_get_type(ira, "Frame", nullptr);
+ ZigValue **fields = alloc_const_vals_ptrs(ira->codegen, 1);
+ result->data.x_struct.fields = fields;
+ ZigFn *fn = type_entry->data.frame.fn;
+ // function: anytype
+ ensure_field_index(result->type, "function", 0);
+ fields[0] = create_const_fn(ira->codegen, fn);
+ break;
+ }
}
assert(result != nullptr);
@@ -25676,6 +25919,11 @@ static ZigType *type_info_to_type(IrAnalyze *ira, IrInst *source_instr, ZigTypeI
{
return ira->codegen->invalid_inst_gen->value->type;
}
+ if (sentinel != nullptr && (size_enum_index == BuiltinPtrSizeOne || size_enum_index == BuiltinPtrSizeC)) {
+ ir_add_error(ira, source_instr,
+ buf_sprintf("sentinels are only allowed on slices and unknown-length pointers"));
+ return ira->codegen->invalid_inst_gen->value->type;
+ }
BigInt *bi = get_const_field_lit_int(ira, source_instr->source_node, payload, "alignment", 3);
if (bi == nullptr)
return ira->codegen->invalid_inst_gen->value->type;
@@ -25709,7 +25957,7 @@ static ZigType *type_info_to_type(IrAnalyze *ira, IrInst *source_instr, ZigTypeI
0, // host_int_bytes
is_allowzero,
VECTOR_INDEX_NONE, nullptr, sentinel);
- if (size_enum_index != 2)
+ if (size_enum_index != BuiltinPtrSizeSlice)
return ptr_type;
return get_slice_type(ira->codegen, ptr_type);
}
@@ -25775,10 +26023,90 @@ static ZigType *type_info_to_type(IrAnalyze *ira, IrInst *source_instr, ZigTypeI
ZigType *child_type = get_const_field_meta_type_optional(ira, source_instr->source_node, payload, "child", 0);
return get_any_frame_type(ira->codegen, child_type);
}
- case ZigTypeIdErrorSet:
- case ZigTypeIdEnum:
- case ZigTypeIdFnFrame:
case ZigTypeIdEnumLiteral:
+ return ira->codegen->builtin_types.entry_enum_literal;
+ case ZigTypeIdFnFrame: {
+ assert(payload->special == ConstValSpecialStatic);
+ assert(payload->type == ir_type_info_get_type(ira, "Frame", nullptr));
+ ZigValue *function = get_const_field(ira, source_instr->source_node, payload, "function", 0);
+ assert(function->type->id == ZigTypeIdFn);
+ ZigFn *fn = function->data.x_ptr.data.fn.fn_entry;
+ return get_fn_frame_type(ira->codegen, fn);
+ }
+ case ZigTypeIdErrorSet: {
+ assert(payload->special == ConstValSpecialStatic);
+ assert(payload->type->id == ZigTypeIdOptional);
+ ZigValue *slice = payload->data.x_optional;
+ if (slice == nullptr)
+ return ira->codegen->builtin_types.entry_global_error_set;
+ assert(slice->special == ConstValSpecialStatic);
+ assert(is_slice(slice->type));
+ ZigType *err_set_type = new_type_table_entry(ZigTypeIdErrorSet);
+ Buf bare_name = BUF_INIT;
+ buf_init_from_buf(&err_set_type->name, get_anon_type_name(ira->codegen, ira->old_irb.exec, "error", source_instr->scope, source_instr->source_node, &bare_name));
+ err_set_type->size_in_bits = ira->codegen->builtin_types.entry_global_error_set->size_in_bits;
+ err_set_type->abi_align = ira->codegen->builtin_types.entry_global_error_set->abi_align;
+ err_set_type->abi_size = ira->codegen->builtin_types.entry_global_error_set->abi_size;
+ ZigValue *ptr = slice->data.x_struct.fields[slice_ptr_index];
+ assert(ptr->data.x_ptr.special == ConstPtrSpecialBaseArray);;
+ assert(ptr->data.x_ptr.data.base_array.elem_index == 0);
+ ZigValue *arr = ptr->data.x_ptr.data.base_array.array_val;
+ assert(arr->special == ConstValSpecialStatic);
+ assert(arr->data.x_array.special == ConstArraySpecialNone);
+ ZigValue *len = slice->data.x_struct.fields[slice_len_index];
+ size_t count = bigint_as_usize(&len->data.x_bigint);
+ err_set_type->data.error_set.err_count = count;
+ err_set_type->data.error_set.errors = heap::c_allocator.allocate(count);
+ bool *already_set = heap::c_allocator.allocate(ira->codegen->errors_by_index.length + count);
+ for (size_t i = 0; i < count; i++) {
+ ZigValue *error = &arr->data.x_array.data.s_none.elements[i];
+ assert(error->type == ir_type_info_get_type(ira, "Error", nullptr));
+ ErrorTableEntry *err_entry = heap::c_allocator.create();
+ err_entry->decl_node = source_instr->source_node;
+ ZigValue *name_slice = get_const_field(ira, source_instr->source_node, error, "name", 0);
+ ZigValue *name_ptr = name_slice->data.x_struct.fields[slice_ptr_index];
+ ZigValue *name_len = name_slice->data.x_struct.fields[slice_len_index];
+ assert(name_ptr->data.x_ptr.special == ConstPtrSpecialBaseArray);
+ assert(name_ptr->data.x_ptr.data.base_array.elem_index == 0);
+ ZigValue *name_arr = name_ptr->data.x_ptr.data.base_array.array_val;
+ assert(name_arr->special == ConstValSpecialStatic);
+ switch (name_arr->data.x_array.special) {
+ case ConstArraySpecialUndef:
+ return ira->codegen->invalid_inst_gen->value->type;
+ case ConstArraySpecialNone: {
+ buf_resize(&err_entry->name, 0);
+ size_t name_count = bigint_as_usize(&name_len->data.x_bigint);
+ for (size_t j = 0; j < name_count; j++) {
+ ZigValue *ch_val = &name_arr->data.x_array.data.s_none.elements[j];
+ unsigned ch = bigint_as_u32(&ch_val->data.x_bigint);
+ buf_append_char(&err_entry->name, ch);
+ }
+ break;
+ }
+ case ConstArraySpecialBuf:
+ buf_init_from_buf(&err_entry->name, name_arr->data.x_array.data.s_buf);
+ break;
+ }
+ auto existing_entry = ira->codegen->error_table.put_unique(&err_entry->name, err_entry);
+ if (existing_entry) {
+ err_entry->value = existing_entry->value->value;
+ } else {
+ size_t error_value_count = ira->codegen->errors_by_index.length;
+ assert((uint32_t)error_value_count < (((uint32_t)1) << (uint32_t)ira->codegen->err_tag_type->data.integral.bit_count));
+ err_entry->value = error_value_count;
+ ira->codegen->errors_by_index.append(err_entry);
+ }
+ if (already_set[err_entry->value]) {
+ ir_add_error(ira, source_instr, buf_sprintf("duplicate error: %s", buf_ptr(&err_entry->name)));
+ return ira->codegen->invalid_inst_gen->value->type;
+ } else {
+ already_set[err_entry->value] = true;
+ }
+ err_set_type->data.error_set.errors[i] = err_entry;
+ }
+ return err_set_type;
+ }
+ case ZigTypeIdEnum:
ir_add_error(ira, source_instr, buf_sprintf(
"TODO implement @Type for 'TypeInfo.%s': see https://github.com/ziglang/zig/issues/2907", type_id_name(tagTypeId)));
return ira->codegen->invalid_inst_gen->value->type;
@@ -26370,6 +26698,10 @@ static IrInstGen *ir_analyze_instruction_int_cast(IrAnalyze *ira, IrInstSrcIntCa
}
if (instr_is_comptime(target) || dest_type->id == ZigTypeIdComptimeInt) {
+ ZigValue *val = ir_resolve_const(ira, target, UndefBad);
+ if (val == nullptr)
+ return ira->codegen->invalid_inst_gen;
+
return ir_implicit_cast2(ira, &instruction->target->base, target, dest_type);
}
@@ -26407,16 +26739,20 @@ static IrInstGen *ir_analyze_instruction_float_cast(IrAnalyze *ira, IrInstSrcFlo
}
}
- if (instr_is_comptime(target) || dest_type->id == ZigTypeIdComptimeFloat) {
- return ir_implicit_cast2(ira, &instruction->target->base, target, dest_type);
- }
-
if (target->value->type->id != ZigTypeIdFloat) {
ir_add_error(ira, &instruction->target->base, buf_sprintf("expected float type, found '%s'",
buf_ptr(&target->value->type->name)));
return ira->codegen->invalid_inst_gen;
}
+ if (instr_is_comptime(target) || dest_type->id == ZigTypeIdComptimeFloat) {
+ ZigValue *val = ir_resolve_const(ira, target, UndefBad);
+ if (val == nullptr)
+ return ira->codegen->invalid_inst_gen;
+
+ return ir_analyze_widen_or_shorten(ira, &instruction->target->base, target, dest_type);
+ }
+
return ir_analyze_widen_or_shorten(ira, &instruction->base.base, target, dest_type);
}
@@ -28660,7 +28996,37 @@ static IrInstGen *ir_analyze_instruction_check_switch_prongs(IrAnalyze *ira,
ir_add_error(ira, &instruction->base.base,
buf_sprintf("else prong required when switching on type '%s'", buf_ptr(&switch_type->name)));
return ira->codegen->invalid_inst_gen;
- }
+ } else if(switch_type->id == ZigTypeIdMetaType) {
+ HashMap prevs;
+ // HashMap doubles capacity when reaching 60% capacity,
+ // because we know the size at init we can avoid reallocation by doubling it here
+ prevs.init(instruction->range_count * 2);
+ for (size_t range_i = 0; range_i < instruction->range_count; range_i += 1) {
+ IrInstSrcCheckSwitchProngsRange *range = &instruction->ranges[range_i];
+
+ IrInstGen *value = range->start->child;
+ IrInstGen *casted_value = ir_implicit_cast(ira, value, switch_type);
+ if (type_is_invalid(casted_value->value->type)) {
+ prevs.deinit();
+ return ira->codegen->invalid_inst_gen;
+ }
+
+ ZigValue *const_expr_val = ir_resolve_const(ira, casted_value, UndefBad);
+ if (!const_expr_val) {
+ prevs.deinit();
+ return ira->codegen->invalid_inst_gen;
+ }
+
+ auto entry = prevs.put_unique(const_expr_val->data.x_type, value);
+ if(entry != nullptr) {
+ ErrorMsg *msg = ir_add_error(ira, &value->base, buf_sprintf("duplicate switch value"));
+ add_error_note(ira->codegen, msg, entry->value->base.source_node, buf_sprintf("previous value is here"));
+ prevs.deinit();
+ return ira->codegen->invalid_inst_gen;
+ }
+ }
+ prevs.deinit();
+ }
return ir_const_void(ira, &instruction->base.base);
}
@@ -29650,7 +30016,7 @@ static IrInstGen *ir_analyze_instruction_arg_type(IrAnalyze *ira, IrInstSrcArgTy
if (arg_index >= fn_type_id->param_count) {
if (instruction->allow_var) {
// TODO remove this with var args
- return ir_const_type(ira, &instruction->base.base, ira->codegen->builtin_types.entry_var);
+ return ir_const_type(ira, &instruction->base.base, ira->codegen->builtin_types.entry_anytype);
}
ir_add_error(ira, &arg_index_inst->base,
buf_sprintf("arg index %" ZIG_PRI_u64 " out of bounds; '%s' has %" ZIG_PRI_usize " arguments",
@@ -29664,7 +30030,7 @@ static IrInstGen *ir_analyze_instruction_arg_type(IrAnalyze *ira, IrInstSrcArgTy
ir_assert(fn_type->data.fn.is_generic, &instruction->base.base);
if (instruction->allow_var) {
- return ir_const_type(ira, &instruction->base.base, ira->codegen->builtin_types.entry_var);
+ return ir_const_type(ira, &instruction->base.base, ira->codegen->builtin_types.entry_anytype);
} else {
ir_add_error(ira, &arg_index_inst->base,
buf_sprintf("@ArgType could not resolve the type of arg %" ZIG_PRI_u64 " because '%s' is generic",
@@ -30173,6 +30539,21 @@ static ErrorMsg *ir_eval_float_op(IrAnalyze *ira, IrInst* source_instr, BuiltinF
case BuiltinFnIdSqrt:
f128M_sqrt(in, out);
break;
+ case BuiltinFnIdFabs:
+ f128M_abs(in, out);
+ break;
+ case BuiltinFnIdFloor:
+ f128M_roundToInt(in, softfloat_round_min, false, out);
+ break;
+ case BuiltinFnIdCeil:
+ f128M_roundToInt(in, softfloat_round_max, false, out);
+ break;
+ case BuiltinFnIdTrunc:
+ f128M_trunc(in, out);
+ break;
+ case BuiltinFnIdRound:
+ f128M_roundToInt(in, softfloat_round_near_maxMag, false, out);
+ break;
case BuiltinFnIdNearbyInt:
case BuiltinFnIdSin:
case BuiltinFnIdCos:
@@ -30181,11 +30562,6 @@ static ErrorMsg *ir_eval_float_op(IrAnalyze *ira, IrInst* source_instr, BuiltinF
case BuiltinFnIdLog:
case BuiltinFnIdLog10:
case BuiltinFnIdLog2:
- case BuiltinFnIdFabs:
- case BuiltinFnIdFloor:
- case BuiltinFnIdCeil:
- case BuiltinFnIdTrunc:
- case BuiltinFnIdRound:
return ir_add_error(ira, source_instr,
buf_sprintf("compiler bug: TODO: implement '%s' for type '%s'. See https://github.com/ziglang/zig/issues/4026",
float_op_to_name(fop), buf_ptr(&float_type->name)));
@@ -30769,6 +31145,64 @@ static IrInstGen *ir_analyze_instruction_spill_end(IrAnalyze *ira, IrInstSrcSpil
return ir_build_spill_end_gen(ira, &instruction->base.base, begin, operand->value->type);
}
+static IrInstGen *ir_analyze_instruction_src(IrAnalyze *ira, IrInstSrcSrc *instruction) {
+ ZigFn *fn_entry = scope_fn_entry(instruction->base.base.scope);
+ if (fn_entry == nullptr) {
+ ir_add_error(ira, &instruction->base.base, buf_sprintf("@src outside function"));
+ return ira->codegen->invalid_inst_gen;
+ }
+
+ ZigType *u8_ptr = get_pointer_to_type_extra2(
+ ira->codegen, ira->codegen->builtin_types.entry_u8,
+ true, false, PtrLenUnknown,
+ 0, 0, 0, false, VECTOR_INDEX_NONE, nullptr, ira->codegen->intern.for_zero_byte());
+ ZigType *u8_slice = get_slice_type(ira->codegen, u8_ptr);
+
+ ZigType *source_location_type = get_builtin_type(ira->codegen, "SourceLocation");
+ if (type_resolve(ira->codegen, source_location_type, ResolveStatusSizeKnown)) {
+ zig_unreachable();
+ }
+
+ ZigValue *result = ira->codegen->pass1_arena->create();
+ result->special = ConstValSpecialStatic;
+ result->type = source_location_type;
+
+ ZigValue **fields = alloc_const_vals_ptrs(ira->codegen, 4);
+ result->data.x_struct.fields = fields;
+
+ // file: [:0]const u8
+ ensure_field_index(source_location_type, "file", 0);
+ fields[0]->special = ConstValSpecialStatic;
+
+ ZigType *import = instruction->base.base.source_node->owner;
+ Buf *path = import->data.structure.root_struct->path;
+ ZigValue *file_name = create_const_str_lit(ira->codegen, path)->data.x_ptr.data.ref.pointee;
+ init_const_slice(ira->codegen, fields[0], file_name, 0, buf_len(path), true);
+ fields[0]->type = u8_slice;
+
+ // fn_name: [:0]const u8
+ ensure_field_index(source_location_type, "fn_name", 1);
+ fields[1]->special = ConstValSpecialStatic;
+
+ ZigValue *fn_name = create_const_str_lit(ira->codegen, &fn_entry->symbol_name)->data.x_ptr.data.ref.pointee;
+ init_const_slice(ira->codegen, fields[1], fn_name, 0, buf_len(&fn_entry->symbol_name), true);
+ fields[1]->type = u8_slice;
+
+ // line: u32
+ ensure_field_index(source_location_type, "line", 2);
+ fields[2]->special = ConstValSpecialStatic;
+ fields[2]->type = ira->codegen->builtin_types.entry_u32;
+ bigint_init_unsigned(&fields[2]->data.x_bigint, instruction->base.base.source_node->line + 1);
+
+ // column: u32
+ ensure_field_index(source_location_type, "column", 3);
+ fields[3]->special = ConstValSpecialStatic;
+ fields[3]->type = ira->codegen->builtin_types.entry_u32;
+ bigint_init_unsigned(&fields[3]->data.x_bigint, instruction->base.base.source_node->column + 1);
+
+ return ir_const_move(ira, &instruction->base.base, result);
+}
+
static IrInstGen *ir_analyze_instruction_base(IrAnalyze *ira, IrInstSrc *instruction) {
switch (instruction->id) {
case IrInstSrcIdInvalid:
@@ -30802,6 +31236,8 @@ static IrInstGen *ir_analyze_instruction_base(IrAnalyze *ira, IrInstSrc *instruc
return ir_analyze_instruction_call_args(ira, (IrInstSrcCallArgs *)instruction);
case IrInstSrcIdCallExtra:
return ir_analyze_instruction_call_extra(ira, (IrInstSrcCallExtra *)instruction);
+ case IrInstSrcIdAsyncCallExtra:
+ return ir_analyze_instruction_async_call_extra(ira, (IrInstSrcAsyncCallExtra *)instruction);
case IrInstSrcIdBr:
return ir_analyze_instruction_br(ira, (IrInstSrcBr *)instruction);
case IrInstSrcIdCondBr:
@@ -31040,6 +31476,8 @@ static IrInstGen *ir_analyze_instruction_base(IrAnalyze *ira, IrInstSrc *instruc
return ir_analyze_instruction_wasm_memory_size(ira, (IrInstSrcWasmMemorySize *)instruction);
case IrInstSrcIdWasmMemoryGrow:
return ir_analyze_instruction_wasm_memory_grow(ira, (IrInstSrcWasmMemoryGrow *)instruction);
+ case IrInstSrcIdSrc:
+ return ir_analyze_instruction_src(ira, (IrInstSrcSrc *)instruction);
}
zig_unreachable();
}
@@ -31309,6 +31747,7 @@ bool ir_inst_src_has_side_effects(IrInstSrc *instruction) {
case IrInstSrcIdDeclVar:
case IrInstSrcIdStorePtr:
case IrInstSrcIdCallExtra:
+ case IrInstSrcIdAsyncCallExtra:
case IrInstSrcIdCall:
case IrInstSrcIdCallArgs:
case IrInstSrcIdReturn:
@@ -31435,6 +31874,7 @@ bool ir_inst_src_has_side_effects(IrInstSrc *instruction) {
case IrInstSrcIdAlloca:
case IrInstSrcIdSpillEnd:
case IrInstSrcIdWasmMemorySize:
+ case IrInstSrcIdSrc:
return false;
case IrInstSrcIdAsm:
diff --git a/src/ir_print.cpp b/src/ir_print.cpp
index c826d76e03..0acde512f6 100644
--- a/src/ir_print.cpp
+++ b/src/ir_print.cpp
@@ -5,6 +5,7 @@
* See http://opensource.org/licenses/MIT
*/
+#include "all_types.hpp"
#include "analyze.hpp"
#include "ir.hpp"
#include "ir_print.hpp"
@@ -55,6 +56,36 @@ struct IrPrintGen {
static void ir_print_other_inst_src(IrPrintSrc *irp, IrInstSrc *inst);
static void ir_print_other_inst_gen(IrPrintGen *irp, IrInstGen *inst);
+static void ir_print_call_modifier(FILE *f, CallModifier modifier) {
+ switch (modifier) {
+ case CallModifierNone:
+ break;
+ case CallModifierNoSuspend:
+ fprintf(f, "nosuspend ");
+ break;
+ case CallModifierAsync:
+ fprintf(f, "async ");
+ break;
+ case CallModifierNeverTail:
+ fprintf(f, "notail ");
+ break;
+ case CallModifierNeverInline:
+ fprintf(f, "noinline ");
+ break;
+ case CallModifierAlwaysTail:
+ fprintf(f, "tail ");
+ break;
+ case CallModifierAlwaysInline:
+ fprintf(f, "inline ");
+ break;
+ case CallModifierCompileTime:
+ fprintf(f, "comptime ");
+ break;
+ case CallModifierBuiltin:
+ zig_unreachable();
+ }
+}
+
const char* ir_inst_src_type_str(IrInstSrcId id) {
switch (id) {
case IrInstSrcIdInvalid:
@@ -97,6 +128,8 @@ const char* ir_inst_src_type_str(IrInstSrcId id) {
return "SrcVarPtr";
case IrInstSrcIdCallExtra:
return "SrcCallExtra";
+ case IrInstSrcIdAsyncCallExtra:
+ return "SrcAsyncCallExtra";
case IrInstSrcIdCall:
return "SrcCall";
case IrInstSrcIdCallArgs:
@@ -325,6 +358,8 @@ const char* ir_inst_src_type_str(IrInstSrcId id) {
return "SrcWasmMemorySize";
case IrInstSrcIdWasmMemoryGrow:
return "SrcWasmMemoryGrow";
+ case IrInstSrcIdSrc:
+ return "SrcSrc";
}
zig_unreachable();
}
@@ -849,6 +884,23 @@ static void ir_print_call_extra(IrPrintSrc *irp, IrInstSrcCallExtra *instruction
ir_print_result_loc(irp, instruction->result_loc);
}
+static void ir_print_async_call_extra(IrPrintSrc *irp, IrInstSrcAsyncCallExtra *instruction) {
+ fprintf(irp->f, "modifier=");
+ ir_print_call_modifier(irp->f, instruction->modifier);
+ fprintf(irp->f, ", fn=");
+ ir_print_other_inst_src(irp, instruction->fn_ref);
+ if (instruction->ret_ptr != nullptr) {
+ fprintf(irp->f, ", ret_ptr=");
+ ir_print_other_inst_src(irp, instruction->ret_ptr);
+ }
+ fprintf(irp->f, ", new_stack=");
+ ir_print_other_inst_src(irp, instruction->new_stack);
+ fprintf(irp->f, ", args=");
+ ir_print_other_inst_src(irp, instruction->args);
+ fprintf(irp->f, ", result=");
+ ir_print_result_loc(irp, instruction->result_loc);
+}
+
static void ir_print_call_args(IrPrintSrc *irp, IrInstSrcCallArgs *instruction) {
fprintf(irp->f, "opts=");
ir_print_other_inst_src(irp, instruction->options);
@@ -866,33 +918,7 @@ static void ir_print_call_args(IrPrintSrc *irp, IrInstSrcCallArgs *instruction)
}
static void ir_print_call_src(IrPrintSrc *irp, IrInstSrcCall *call_instruction) {
- switch (call_instruction->modifier) {
- case CallModifierNone:
- break;
- case CallModifierNoSuspend:
- fprintf(irp->f, "nosuspend ");
- break;
- case CallModifierAsync:
- fprintf(irp->f, "async ");
- break;
- case CallModifierNeverTail:
- fprintf(irp->f, "notail ");
- break;
- case CallModifierNeverInline:
- fprintf(irp->f, "noinline ");
- break;
- case CallModifierAlwaysTail:
- fprintf(irp->f, "tail ");
- break;
- case CallModifierAlwaysInline:
- fprintf(irp->f, "inline ");
- break;
- case CallModifierCompileTime:
- fprintf(irp->f, "comptime ");
- break;
- case CallModifierBuiltin:
- zig_unreachable();
- }
+ ir_print_call_modifier(irp->f, call_instruction->modifier);
if (call_instruction->fn_entry) {
fprintf(irp->f, "%s", buf_ptr(&call_instruction->fn_entry->symbol_name));
} else {
@@ -911,33 +937,7 @@ static void ir_print_call_src(IrPrintSrc *irp, IrInstSrcCall *call_instruction)
}
static void ir_print_call_gen(IrPrintGen *irp, IrInstGenCall *call_instruction) {
- switch (call_instruction->modifier) {
- case CallModifierNone:
- break;
- case CallModifierNoSuspend:
- fprintf(irp->f, "nosuspend ");
- break;
- case CallModifierAsync:
- fprintf(irp->f, "async ");
- break;
- case CallModifierNeverTail:
- fprintf(irp->f, "notail ");
- break;
- case CallModifierNeverInline:
- fprintf(irp->f, "noinline ");
- break;
- case CallModifierAlwaysTail:
- fprintf(irp->f, "tail ");
- break;
- case CallModifierAlwaysInline:
- fprintf(irp->f, "inline ");
- break;
- case CallModifierCompileTime:
- fprintf(irp->f, "comptime ");
- break;
- case CallModifierBuiltin:
- zig_unreachable();
- }
+ ir_print_call_modifier(irp->f, call_instruction->modifier);
if (call_instruction->fn_entry) {
fprintf(irp->f, "%s", buf_ptr(&call_instruction->fn_entry->symbol_name));
} else {
@@ -1744,6 +1744,10 @@ static void ir_print_wasm_memory_grow(IrPrintGen *irp, IrInstGenWasmMemoryGrow *
fprintf(irp->f, ")");
}
+static void ir_print_builtin_src(IrPrintSrc *irp, IrInstSrcSrc *instruction) {
+ fprintf(irp->f, "@src()");
+}
+
static void ir_print_memset(IrPrintSrc *irp, IrInstSrcMemset *instruction) {
fprintf(irp->f, "@memset(");
ir_print_other_inst_src(irp, instruction->dest_ptr);
@@ -2613,6 +2617,9 @@ static void ir_print_inst_src(IrPrintSrc *irp, IrInstSrc *instruction, bool trai
case IrInstSrcIdCallExtra:
ir_print_call_extra(irp, (IrInstSrcCallExtra *)instruction);
break;
+ case IrInstSrcIdAsyncCallExtra:
+ ir_print_async_call_extra(irp, (IrInstSrcAsyncCallExtra *)instruction);
+ break;
case IrInstSrcIdCall:
ir_print_call_src(irp, (IrInstSrcCall *)instruction);
break;
@@ -2994,6 +3001,9 @@ static void ir_print_inst_src(IrPrintSrc *irp, IrInstSrc *instruction, bool trai
case IrInstSrcIdWasmMemoryGrow:
ir_print_wasm_memory_grow(irp, (IrInstSrcWasmMemoryGrow *)instruction);
break;
+ case IrInstSrcIdSrc:
+ ir_print_builtin_src(irp, (IrInstSrcSrc *)instruction);
+ break;
}
fprintf(irp->f, "\n");
}
diff --git a/src/list.hpp b/src/list.hpp
index 2c6d90c855..803a251437 100644
--- a/src/list.hpp
+++ b/src/list.hpp
@@ -19,6 +19,9 @@ struct ZigList {
ensure_capacity(length + 1);
items[length++] = item;
}
+ void append_assuming_capacity(const T& item) {
+ items[length++] = item;
+ }
// remember that the pointer to this item is invalid after you
// modify the length of the list
const T & at(size_t index) const {
diff --git a/src/os.cpp b/src/os.cpp
index 26ed0dc4e1..33d98fd416 100644
--- a/src/os.cpp
+++ b/src/os.cpp
@@ -6,8 +6,13 @@
*/
#include "os.hpp"
+#include "buffer.hpp"
+#include "heap.hpp"
#include "util.hpp"
#include "error.hpp"
+#include "util_base.hpp"
+#include
+#include
#if defined(_WIN32)
@@ -73,6 +78,8 @@ typedef SSIZE_T ssize_t;
#endif
#if defined(ZIG_OS_WINDOWS)
+static void utf16le_ptr_to_utf8(Buf *out, WCHAR *utf16le);
+static size_t utf8_to_utf16le(WCHAR *utf16_le, Slice utf8);
static uint64_t windows_perf_freq;
#elif defined(__MACH__)
static clock_serv_t macos_calendar_clock;
@@ -148,15 +155,21 @@ static void os_spawn_process_windows(ZigList &args, Termination *t
os_windows_create_command_line(&command_line, args);
PROCESS_INFORMATION piProcInfo = {0};
- STARTUPINFO siStartInfo = {0};
- siStartInfo.cb = sizeof(STARTUPINFO);
+ STARTUPINFOW siStartInfo = {0};
+ siStartInfo.cb = sizeof(STARTUPINFOW);
- const char *exe = args.at(0);
- BOOL success = CreateProcessA(exe, buf_ptr(&command_line), nullptr, nullptr, TRUE, 0, nullptr, nullptr,
+ Slice exe_slice = str(args.at(0));
+ auto exe_utf16_slice = Slice::alloc(exe_slice.len + 1);
+ exe_utf16_slice.ptr[utf8_to_utf16le(exe_utf16_slice.ptr, exe_slice)] = 0;
+
+ auto command_line_utf16 = Slice::alloc(buf_len(&command_line) + 1);
+ command_line_utf16.ptr[utf8_to_utf16le(command_line_utf16.ptr, buf_to_slice(&command_line))] = 0;
+
+ BOOL success = CreateProcessW(exe_utf16_slice.ptr, command_line_utf16.ptr, nullptr, nullptr, TRUE, CREATE_UNICODE_ENVIRONMENT, nullptr, nullptr,
&siStartInfo, &piProcInfo);
if (!success) {
- zig_panic("CreateProcess failed. exe: %s command_line: %s", exe, buf_ptr(&command_line));
+ zig_panic("CreateProcess failed. exe: %s command_line: %s", args.at(0), buf_ptr(&command_line));
}
WaitForSingleObject(piProcInfo.hProcess, INFINITE);
@@ -269,11 +282,13 @@ void os_path_join(Buf *dirname, Buf *basename, Buf *out_full_path) {
Error os_path_real(Buf *rel_path, Buf *out_abs_path) {
#if defined(ZIG_OS_WINDOWS)
- buf_resize(out_abs_path, 4096);
- if (_fullpath(buf_ptr(out_abs_path), buf_ptr(rel_path), buf_len(out_abs_path)) == nullptr) {
- zig_panic("_fullpath failed");
+ PathSpace rel_path_space = slice_to_prefixed_file_w(buf_to_slice(rel_path));
+ PathSpace out_abs_path_space;
+
+ if (_wfullpath(&out_abs_path_space.data.items[0], &rel_path_space.data.items[0], PATH_MAX_WIDE) == nullptr) {
+ zig_panic("_wfullpath failed");
}
- buf_resize(out_abs_path, strlen(buf_ptr(out_abs_path)));
+ utf16le_ptr_to_utf8(out_abs_path, &out_abs_path_space.data.items[0]);
return ErrorNone;
#elif defined(ZIG_OS_POSIX)
buf_resize(out_abs_path, PATH_MAX + 1);
@@ -773,7 +788,8 @@ Error os_fetch_file(FILE *f, Buf *out_buf) {
Error os_file_exists(Buf *full_path, bool *result) {
#if defined(ZIG_OS_WINDOWS)
- *result = GetFileAttributes(buf_ptr(full_path)) != INVALID_FILE_ATTRIBUTES;
+ PathSpace path_space = slice_to_prefixed_file_w(buf_to_slice(full_path));
+ *result = GetFileAttributesW(&path_space.data.items[0]) != INVALID_FILE_ATTRIBUTES;
return ErrorNone;
#else
*result = access(buf_ptr(full_path), F_OK) != -1;
@@ -1021,7 +1037,12 @@ Error os_exec_process(ZigList &args,
}
Error os_write_file(Buf *full_path, Buf *contents) {
+#if defined(ZIG_OS_WINDOWS)
+ PathSpace path_space = slice_to_prefixed_file_w(buf_to_slice(full_path));
+ FILE *f = _wfopen(&path_space.data.items[0], L"wb");
+#else
FILE *f = fopen(buf_ptr(full_path), "wb");
+#endif
if (!f) {
zig_panic("os_write_file failed for %s", buf_ptr(full_path));
}
@@ -1056,7 +1077,12 @@ static Error copy_open_files(FILE *src_f, FILE *dest_f) {
Error os_dump_file(Buf *src_path, FILE *dest_file) {
Error err;
+#if defined(ZIG_OS_WINDOWS)
+ PathSpace path_space = slice_to_prefixed_file_w(buf_to_slice(src_path));
+ FILE *src_f = _wfopen(&path_space.data.items[0], L"rb");
+#else
FILE *src_f = fopen(buf_ptr(src_path), "rb");
+#endif
if (!src_f) {
int err = errno;
if (err == ENOENT) {
@@ -1173,7 +1199,12 @@ Error os_update_file(Buf *src_path, Buf *dst_path) {
}
Error os_copy_file(Buf *src_path, Buf *dest_path) {
+#if defined(ZIG_OS_WINDOWS)
+ PathSpace src_path_space = slice_to_prefixed_file_w(buf_to_slice(src_path));
+ FILE *src_f = _wfopen(&src_path_space.data.items[0], L"rb");
+#else
FILE *src_f = fopen(buf_ptr(src_path), "rb");
+#endif
if (!src_f) {
int err = errno;
if (err == ENOENT) {
@@ -1184,7 +1215,12 @@ Error os_copy_file(Buf *src_path, Buf *dest_path) {
return ErrorFileSystem;
}
}
+#if defined(ZIG_OS_WINDOWS)
+ PathSpace dest_path_space = slice_to_prefixed_file_w(buf_to_slice(dest_path));
+ FILE *dest_f = _wfopen(&dest_path_space.data.items[0], L"wb");
+#else
FILE *dest_f = fopen(buf_ptr(dest_path), "wb");
+#endif
if (!dest_f) {
int err = errno;
if (err == ENOENT) {
@@ -1205,7 +1241,12 @@ Error os_copy_file(Buf *src_path, Buf *dest_path) {
}
Error os_fetch_file_path(Buf *full_path, Buf *out_contents) {
+#if defined(ZIG_OS_WINDOWS)
+ PathSpace path_space = slice_to_prefixed_file_w(buf_to_slice(full_path));
+ FILE *f = _wfopen(&path_space.data.items[0], L"rb");
+#else
FILE *f = fopen(buf_ptr(full_path), "rb");
+#endif
if (!f) {
switch (errno) {
case EACCES:
@@ -1230,11 +1271,11 @@ Error os_fetch_file_path(Buf *full_path, Buf *out_contents) {
Error os_get_cwd(Buf *out_cwd) {
#if defined(ZIG_OS_WINDOWS)
- char buf[4096];
- if (GetCurrentDirectory(4096, buf) == 0) {
+ PathSpace path_space;
+ if (GetCurrentDirectoryW(PATH_MAX_WIDE, &path_space.data.items[0]) == 0) {
zig_panic("GetCurrentDirectory failed");
}
- buf_init_from_str(out_cwd, buf);
+ utf16le_ptr_to_utf8(out_cwd, &path_space.data.items[0]);
return ErrorNone;
#elif defined(ZIG_OS_POSIX)
char buf[PATH_MAX];
@@ -1330,7 +1371,9 @@ Error os_rename(Buf *src_path, Buf *dest_path) {
return ErrorNone;
}
#if defined(ZIG_OS_WINDOWS)
- if (!MoveFileExA(buf_ptr(src_path), buf_ptr(dest_path), MOVEFILE_REPLACE_EXISTING)) {
+ PathSpace src_path_space = slice_to_prefixed_file_w(buf_to_slice(src_path));
+ PathSpace dest_path_space = slice_to_prefixed_file_w(buf_to_slice(dest_path));
+ if (!MoveFileExW(&src_path_space.data.items[0], &dest_path_space.data.items[0], MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH)) {
return ErrorFileSystem;
}
#else
@@ -1426,7 +1469,15 @@ Error os_make_path(Buf *path) {
Error os_make_dir(Buf *path) {
#if defined(ZIG_OS_WINDOWS)
- if (!CreateDirectory(buf_ptr(path), NULL)) {
+ PathSpace path_space = slice_to_prefixed_file_w(buf_to_slice(path));
+ if (memEql(buf_to_slice(path), str("C:\\dev\\tést"))) {
+ for (size_t i = 0; i < path_space.len; i++) {
+ fprintf(stderr, "%d ", path_space.data.items[i]);
+ }
+ fprintf(stderr, "\n");
+ }
+
+ if (!CreateDirectoryW(&path_space.data.items[0], NULL)) {
if (GetLastError() == ERROR_ALREADY_EXISTS)
return ErrorPathAlreadyExists;
if (GetLastError() == ERROR_PATH_NOT_FOUND)
@@ -1531,18 +1582,13 @@ int os_init(void) {
Error os_self_exe_path(Buf *out_path) {
#if defined(ZIG_OS_WINDOWS)
- buf_resize(out_path, 256);
- for (;;) {
- DWORD copied_amt = GetModuleFileName(nullptr, buf_ptr(out_path), buf_len(out_path));
- if (copied_amt <= 0) {
- return ErrorFileNotFound;
- }
- if (copied_amt < buf_len(out_path)) {
- buf_resize(out_path, copied_amt);
- return ErrorNone;
- }
- buf_resize(out_path, buf_len(out_path) * 2);
+ PathSpace path_space;
+ DWORD copied_amt = GetModuleFileNameW(nullptr, &path_space.data.items[0], PATH_MAX_WIDE);
+ if (copied_amt <= 0) {
+ return ErrorFileNotFound;
}
+ utf16le_ptr_to_utf8(out_path, &path_space.data.items[0]);
+ return ErrorNone;
#elif defined(ZIG_OS_DARWIN)
// How long is the executable's path?
@@ -1719,6 +1765,15 @@ static uint8_t utf8CodepointSequenceLength(uint32_t c) {
zig_unreachable();
}
+// Ported from std.unicode.utf8ByteSequenceLength
+static uint8_t utf8ByteSequenceLength(uint8_t first_byte) {
+ if (first_byte < 0b10000000) return 1;
+ if ((first_byte & 0b11100000) == 0b11000000) return 2;
+ if ((first_byte & 0b11110000) == 0b11100000) return 3;
+ if ((first_byte & 0b11111000) == 0b11110000) return 4;
+ zig_unreachable();
+}
+
// Ported from std/unicode.zig
static size_t utf8Encode(uint32_t c, Slice out) {
size_t length = utf8CodepointSequenceLength(c);
@@ -1753,6 +1808,80 @@ static size_t utf8Encode(uint32_t c, Slice out) {
return length;
}
+// Ported from std.unicode.utf8Decode2
+static uint32_t utf8Decode2(Slice bytes) {
+ assert(bytes.len == 2);
+ assert((bytes.at(0) & 0b11100000) == 0b11000000);
+
+ uint32_t value = bytes.at(0) & 0b00011111;
+ assert((bytes.at(1) & 0b11000000) == 0b10000000);
+ value <<= 6;
+ value |= bytes.at(1) & 0b00111111;
+
+ assert(value >= 0x80);
+ return value;
+}
+
+// Ported from std.unicode.utf8Decode3
+static uint32_t utf8Decode3(Slice bytes) {
+ assert(bytes.len == 3);
+ assert((bytes.at(0) & 0b11110000) == 0b11100000);
+
+ uint32_t value = bytes.at(0) & 0b00001111;
+ assert((bytes.at(1) & 0b11000000) == 0b10000000);
+ value <<= 6;
+ value |= bytes.at(1) & 0b00111111;
+
+ assert((bytes.at(2) & 0b11000000) == 0b10000000);
+ value <<= 6;
+ value |= bytes.at(2) & 0b00111111;
+
+ assert(value >= 0x80);
+ assert(value < 0xd800 || value > 0xdfff);
+ return value;
+}
+
+// Ported from std.unicode.utf8Decode4
+static uint32_t utf8Decode4(Slice bytes) {
+ assert(bytes.len == 4);
+ assert((bytes.at(0) & 0b11111000) == 0b11110000);
+
+ uint32_t value = bytes.at(0) & 0b00000111;
+ assert((bytes.at(1) & 0b11000000) == 0b10000000);
+ value <<= 6;
+ value |= bytes.at(1) & 0b00111111;
+
+ assert((bytes.at(2) & 0b11000000) == 0b10000000);
+ value <<= 6;
+ value |= bytes.at(2) & 0b00111111;
+
+ assert((bytes.at(3) & 0b11000000) == 0b10000000);
+ value <<= 6;
+ value |= bytes.at(3) & 0b00111111;
+
+ assert(value >= 0x10000 && value <= 0x10FFFF);
+ return value;
+}
+
+// Ported from std.unicode.utf8Decode
+static uint32_t utf8Decode(Slice bytes) {
+ switch (bytes.len) {
+ case 1:
+ return bytes.at(0);
+ break;
+ case 2:
+ return utf8Decode2(bytes);
+ break;
+ case 3:
+ return utf8Decode3(bytes);
+ break;
+ case 4:
+ return utf8Decode4(bytes);
+ break;
+ default:
+ zig_unreachable();
+ }
+}
// Ported from std.unicode.utf16leToUtf8Alloc
static void utf16le_ptr_to_utf8(Buf *out, WCHAR *utf16le) {
// optimistically guess that it will all be ascii.
@@ -1770,6 +1899,60 @@ static void utf16le_ptr_to_utf8(Buf *out, WCHAR *utf16le) {
out_index += utf8_len;
}
}
+
+// Ported from std.unicode.utf8ToUtf16Le
+static size_t utf8_to_utf16le(WCHAR *utf16_le, Slice utf8) {
+ size_t dest_i = 0;
+ size_t src_i = 0;
+ while (src_i < utf8.len) {
+ uint8_t n = utf8ByteSequenceLength(utf8.at(src_i));
+ size_t next_src_i = src_i + n;
+ uint32_t codepoint = utf8Decode(utf8.slice(src_i, next_src_i));
+ if (codepoint < 0x10000) {
+ utf16_le[dest_i] = codepoint;
+ dest_i += 1;
+ } else {
+ WCHAR high = ((codepoint - 0x10000) >> 10) + 0xD800;
+ WCHAR low = (codepoint & 0x3FF) + 0xDC00;
+ utf16_le[dest_i] = high;
+ utf16_le[dest_i + 1] = low;
+ dest_i += 2;
+ }
+ src_i = next_src_i;
+ }
+ return dest_i;
+}
+
+// Ported from std.os.windows.sliceToPrefixedFileW
+PathSpace slice_to_prefixed_file_w(Slice path) {
+ PathSpace path_space;
+ for (size_t idx = 0; idx < path.len; idx++) {
+ assert(path.ptr[idx] != '*' && path.ptr[idx] != '?' && path.ptr[idx] != '"' &&
+ path.ptr[idx] != '<' && path.ptr[idx] != '>' && path.ptr[idx] != '|');
+ }
+
+ size_t start_index;
+ if (memStartsWith(path, str("\\?")) || !isAbsoluteWindows(path)) {
+ start_index = 0;
+ } else {
+ static WCHAR prefix[4] = { u'\\', u'?', u'?', u'\\' };
+ memCopy(path_space.data.slice(), Slice { prefix, 4 });
+ start_index = 4;
+ }
+
+ path_space.len = start_index + utf8_to_utf16le(path_space.data.slice().sliceFrom(start_index).ptr, path);
+ assert(path_space.len <= path_space.data.len);
+
+ Slice path_slice = path_space.data.slice().slice(0, path_space.len);
+ for (size_t elem_idx = 0; elem_idx < path_slice.len; elem_idx += 1) {
+ if (path_slice.at(elem_idx) == '/') {
+ path_slice.at(elem_idx) = '\\';
+ }
+ }
+
+ path_space.data.items[path_space.len] = 0;
+ return path_space;
+}
#endif
// Ported from std.os.getAppDataDir
@@ -1862,8 +2045,8 @@ Error os_self_exe_shared_libs(ZigList &paths) {
Error os_file_open_rw(Buf *full_path, OsFile *out_file, OsFileAttr *attr, bool need_write, uint32_t mode) {
#if defined(ZIG_OS_WINDOWS)
- // TODO use CreateFileW
- HANDLE result = CreateFileA(buf_ptr(full_path),
+ PathSpace path_space = slice_to_prefixed_file_w(buf_to_slice(full_path));
+ HANDLE result = CreateFileW(&path_space.data.items[0],
need_write ? (GENERIC_READ|GENERIC_WRITE) : GENERIC_READ,
need_write ? 0 : FILE_SHARE_READ,
nullptr,
@@ -1967,8 +2150,9 @@ Error os_file_open_w(Buf *full_path, OsFile *out_file, OsFileAttr *attr, uint32_
Error os_file_open_lock_rw(Buf *full_path, OsFile *out_file) {
#if defined(ZIG_OS_WINDOWS)
+ PathSpace path_space = slice_to_prefixed_file_w(buf_to_slice(full_path));
for (;;) {
- HANDLE result = CreateFileA(buf_ptr(full_path), GENERIC_READ | GENERIC_WRITE,
+ HANDLE result = CreateFileW(&path_space.data.items[0], GENERIC_READ | GENERIC_WRITE,
0, nullptr, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
if (result == INVALID_HANDLE_VALUE) {
diff --git a/src/os.hpp b/src/os.hpp
index e73e5e3aaa..9792a42c45 100644
--- a/src/os.hpp
+++ b/src/os.hpp
@@ -155,4 +155,12 @@ Error ATTRIBUTE_MUST_USE os_get_app_data_dir(Buf *out_path, const char *appname)
Error ATTRIBUTE_MUST_USE os_self_exe_shared_libs(ZigList &paths);
+const size_t PATH_MAX_WIDE = 32767;
+
+struct PathSpace {
+ Array data;
+ size_t len;
+};
+
+PathSpace slice_to_prefixed_file_w(Slice path);
#endif
diff --git a/src/parser.cpp b/src/parser.cpp
index c6c5823672..26233ec6a4 100644
--- a/src/parser.cpp
+++ b/src/parser.cpp
@@ -786,7 +786,7 @@ static AstNode *ast_parse_top_level_decl(ParseContext *pc, VisibMod visib_mod, B
return nullptr;
}
-// FnProto <- KEYWORD_fn IDENTIFIER? LPAREN ParamDeclList RPAREN ByteAlign? LinkSection? EXCLAMATIONMARK? (KEYWORD_var / TypeExpr)
+// FnProto <- KEYWORD_fn IDENTIFIER? LPAREN ParamDeclList RPAREN ByteAlign? LinkSection? EXCLAMATIONMARK? (KEYWORD_anytype / TypeExpr)
static AstNode *ast_parse_fn_proto(ParseContext *pc) {
Token *first = eat_token_if(pc, TokenIdKeywordFn);
if (first == nullptr) {
@@ -801,10 +801,10 @@ static AstNode *ast_parse_fn_proto(ParseContext *pc) {
AstNode *align_expr = ast_parse_byte_align(pc);
AstNode *section_expr = ast_parse_link_section(pc);
AstNode *callconv_expr = ast_parse_callconv(pc);
- Token *var = eat_token_if(pc, TokenIdKeywordVar);
+ Token *anytype = eat_token_if(pc, TokenIdKeywordAnyType);
Token *exmark = nullptr;
AstNode *return_type = nullptr;
- if (var == nullptr) {
+ if (anytype == nullptr) {
exmark = eat_token_if(pc, TokenIdBang);
return_type = ast_expect(pc, ast_parse_type_expr);
}
@@ -816,7 +816,7 @@ static AstNode *ast_parse_fn_proto(ParseContext *pc) {
res->data.fn_proto.align_expr = align_expr;
res->data.fn_proto.section_expr = section_expr;
res->data.fn_proto.callconv_expr = callconv_expr;
- res->data.fn_proto.return_var_token = var;
+ res->data.fn_proto.return_anytype_token = anytype;
res->data.fn_proto.auto_err_set = exmark != nullptr;
res->data.fn_proto.return_type = return_type;
@@ -870,9 +870,9 @@ static AstNode *ast_parse_container_field(ParseContext *pc) {
AstNode *type_expr = nullptr;
if (eat_token_if(pc, TokenIdColon) != nullptr) {
- Token *var_tok = eat_token_if(pc, TokenIdKeywordVar);
- if (var_tok != nullptr) {
- type_expr = ast_create_node(pc, NodeTypeVarFieldType, var_tok);
+ Token *anytype_tok = eat_token_if(pc, TokenIdKeywordAnyType);
+ if (anytype_tok != nullptr) {
+ type_expr = ast_create_node(pc, NodeTypeAnyTypeField, anytype_tok);
} else {
type_expr = ast_expect(pc, ast_parse_type_expr);
}
@@ -2191,14 +2191,14 @@ static AstNode *ast_parse_param_decl(ParseContext *pc) {
}
// ParamType
-// <- KEYWORD_var
+// <- KEYWORD_anytype
// / DOT3
// / TypeExpr
static AstNode *ast_parse_param_type(ParseContext *pc) {
- Token *var_token = eat_token_if(pc, TokenIdKeywordVar);
- if (var_token != nullptr) {
- AstNode *res = ast_create_node(pc, NodeTypeParamDecl, var_token);
- res->data.param_decl.var_token = var_token;
+ Token *anytype_token = eat_token_if(pc, TokenIdKeywordAnyType);
+ if (anytype_token != nullptr) {
+ AstNode *res = ast_create_node(pc, NodeTypeParamDecl, anytype_token);
+ res->data.param_decl.anytype_token = anytype_token;
return res;
}
@@ -2679,7 +2679,7 @@ static AstNode *ast_parse_prefix_type_op(ParseContext *pc) {
if (eat_token_if(pc, TokenIdKeywordAlign) != nullptr) {
expect_token(pc, TokenIdLParen);
- AstNode *align_expr = ast_parse_expr(pc);
+ AstNode *align_expr = ast_expect(pc, ast_parse_expr);
child->data.pointer_type.align_expr = align_expr;
if (eat_token_if(pc, TokenIdColon) != nullptr) {
Token *bit_offset_start = expect_token(pc, TokenIdIntLiteral);
@@ -3207,7 +3207,7 @@ void ast_visit_node_children(AstNode *node, void (*visit)(AstNode **, void *cont
visit_field(&node->data.suspend.block, visit, context);
break;
case NodeTypeEnumLiteral:
- case NodeTypeVarFieldType:
+ case NodeTypeAnyTypeField:
break;
}
}
diff --git a/src/softfloat_ext.cpp b/src/softfloat_ext.cpp
new file mode 100644
index 0000000000..8408a15116
--- /dev/null
+++ b/src/softfloat_ext.cpp
@@ -0,0 +1,25 @@
+#include "softfloat_ext.hpp"
+
+extern "C" {
+ #include "softfloat.h"
+}
+
+void f128M_abs(const float128_t *aPtr, float128_t *zPtr) {
+ float128_t zero_float;
+ ui32_to_f128M(0, &zero_float);
+ if (f128M_lt(aPtr, &zero_float)) {
+ f128M_sub(&zero_float, aPtr, zPtr);
+ } else {
+ *zPtr = *aPtr;
+ }
+}
+
+void f128M_trunc(const float128_t *aPtr, float128_t *zPtr) {
+ float128_t zero_float;
+ ui32_to_f128M(0, &zero_float);
+ if (f128M_lt(aPtr, &zero_float)) {
+ f128M_roundToInt(aPtr, softfloat_round_max, false, zPtr);
+ } else {
+ f128M_roundToInt(aPtr, softfloat_round_min, false, zPtr);
+ }
+}
\ No newline at end of file
diff --git a/src/softfloat_ext.hpp b/src/softfloat_ext.hpp
new file mode 100644
index 0000000000..0a1f958933
--- /dev/null
+++ b/src/softfloat_ext.hpp
@@ -0,0 +1,9 @@
+#ifndef ZIG_SOFTFLOAT_EXT_HPP
+#define ZIG_SOFTFLOAT_EXT_HPP
+
+#include "softfloat_types.h"
+
+void f128M_abs(const float128_t *aPtr, float128_t *zPtr);
+void f128M_trunc(const float128_t *aPtr, float128_t *zPtr);
+
+#endif
\ No newline at end of file
diff --git a/src/tokenizer.cpp b/src/tokenizer.cpp
index f09a146f2b..487a125d62 100644
--- a/src/tokenizer.cpp
+++ b/src/tokenizer.cpp
@@ -106,6 +106,7 @@ static const struct ZigKeyword zig_keywords[] = {
{"allowzero", TokenIdKeywordAllowZero},
{"and", TokenIdKeywordAnd},
{"anyframe", TokenIdKeywordAnyFrame},
+ {"anytype", TokenIdKeywordAnyType},
{"asm", TokenIdKeywordAsm},
{"async", TokenIdKeywordAsync},
{"await", TokenIdKeywordAwait},
@@ -1569,6 +1570,7 @@ const char * token_name(TokenId id) {
case TokenIdKeywordAlign: return "align";
case TokenIdKeywordAnd: return "and";
case TokenIdKeywordAnyFrame: return "anyframe";
+ case TokenIdKeywordAnyType: return "anytype";
case TokenIdKeywordAsm: return "asm";
case TokenIdKeywordBreak: return "break";
case TokenIdKeywordCatch: return "catch";
diff --git a/src/tokenizer.hpp b/src/tokenizer.hpp
index 552ded4ef8..d8af21ee00 100644
--- a/src/tokenizer.hpp
+++ b/src/tokenizer.hpp
@@ -54,6 +54,7 @@ enum TokenId {
TokenIdKeywordAllowZero,
TokenIdKeywordAnd,
TokenIdKeywordAnyFrame,
+ TokenIdKeywordAnyType,
TokenIdKeywordAsm,
TokenIdKeywordAsync,
TokenIdKeywordAwait,
diff --git a/src/util.hpp b/src/util.hpp
index bd1a5b1e4c..ab8f4c8e70 100644
--- a/src/util.hpp
+++ b/src/util.hpp
@@ -159,7 +159,7 @@ struct Slice {
inline T &at(size_t i) {
assert(i < len);
- return &ptr[i];
+ return ptr[i];
}
inline Slice slice(size_t start, size_t end) {
diff --git a/test/cli.zig b/test/cli.zig
index 3af78e1857..77d79ed98e 100644
--- a/test/cli.zig
+++ b/test/cli.zig
@@ -34,6 +34,7 @@ pub fn main() !void {
testZigInitExe,
testGodboltApi,
testMissingOutputPath,
+ testZigFmt,
};
for (test_fns) |testFn| {
try fs.cwd().deleteTree(dir_path);
@@ -143,3 +144,29 @@ fn testMissingOutputPath(zig_exe: []const u8, dir_path: []const u8) !void {
zig_exe, "build-exe", source_path, "--output-dir", output_path,
});
}
+
+fn testZigFmt(zig_exe: []const u8, dir_path: []const u8) !void {
+ _ = try exec(dir_path, &[_][]const u8{ zig_exe, "init-exe" });
+
+ const unformatted_code = " // no reason for indent";
+
+ const fmt1_zig_path = try fs.path.join(a, &[_][]const u8{ dir_path, "fmt1.zig" });
+ try fs.cwd().writeFile(fmt1_zig_path, unformatted_code);
+
+ const run_result1 = try exec(dir_path, &[_][]const u8{ zig_exe, "fmt", fmt1_zig_path });
+ // stderr should be file path + \n
+ testing.expect(std.mem.startsWith(u8, run_result1.stderr, fmt1_zig_path));
+ testing.expect(run_result1.stderr.len == fmt1_zig_path.len + 1 and run_result1.stderr[run_result1.stderr.len - 1] == '\n');
+
+ const fmt2_zig_path = try fs.path.join(a, &[_][]const u8{ dir_path, "fmt2.zig" });
+ try fs.cwd().writeFile(fmt2_zig_path, unformatted_code);
+
+ const run_result2 = try exec(dir_path, &[_][]const u8{ zig_exe, "fmt", dir_path });
+ // running it on the dir, only the new file should be changed
+ testing.expect(std.mem.startsWith(u8, run_result2.stderr, fmt2_zig_path));
+ testing.expect(run_result2.stderr.len == fmt2_zig_path.len + 1 and run_result2.stderr[run_result2.stderr.len - 1] == '\n');
+
+ const run_result3 = try exec(dir_path, &[_][]const u8{ zig_exe, "fmt", dir_path });
+ // both files have been formatted, nothing should change now
+ testing.expect(run_result3.stderr.len == 0);
+}
diff --git a/test/compile_errors.zig b/test/compile_errors.zig
index 278d66ab9f..a1a261f887 100644
--- a/test/compile_errors.zig
+++ b/test/compile_errors.zig
@@ -2,6 +2,55 @@ const tests = @import("tests.zig");
const std = @import("std");
pub fn addCases(cases: *tests.CompileErrorContext) void {
+ cases.addTest("invalid pointer with @Type",
+ \\export fn entry() void {
+ \\ _ = @Type(.{ .Pointer = .{
+ \\ .size = .One,
+ \\ .is_const = false,
+ \\ .is_volatile = false,
+ \\ .alignment = 1,
+ \\ .child = u8,
+ \\ .is_allowzero = false,
+ \\ .sentinel = 0,
+ \\ }});
+ \\}
+ , &[_][]const u8{
+ "tmp.zig:2:16: error: sentinels are only allowed on slices and unknown-length pointers",
+ });
+
+ cases.addTest("int/float conversion to comptime_int/float",
+ \\export fn foo() void {
+ \\ var a: f32 = 2;
+ \\ _ = @floatToInt(comptime_int, a);
+ \\}
+ \\export fn bar() void {
+ \\ var a: u32 = 2;
+ \\ _ = @intToFloat(comptime_float, a);
+ \\}
+ , &[_][]const u8{
+ "tmp.zig:3:35: error: unable to evaluate constant expression",
+ "tmp.zig:3:9: note: referenced here",
+ "tmp.zig:7:37: error: unable to evaluate constant expression",
+ "tmp.zig:7:9: note: referenced here",
+ });
+
+ cases.add("extern variable has no type",
+ \\extern var foo;
+ \\pub export fn entry() void {
+ \\ foo;
+ \\}
+ , &[_][]const u8{
+ "tmp.zig:1:1: error: unable to infer variable type",
+ });
+
+ cases.add("@src outside function",
+ \\comptime {
+ \\ @src();
+ \\}
+ , &[_][]const u8{
+ "tmp.zig:2:5: error: @src outside function",
+ });
+
cases.add("call assigned to constant",
\\const Foo = struct {
\\ x: i32,
@@ -9,7 +58,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
\\fn foo() Foo {
\\ return .{ .x = 42 };
\\}
- \\fn bar(val: var) Foo {
+ \\fn bar(val: anytype) Foo {
\\ return .{ .x = val };
\\}
\\export fn entry() void {
@@ -74,17 +123,17 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
\\ _ = @floatToInt(u32, a);
\\}
\\export fn qux() void {
- \\ var a: u32 = 2;
- \\ _ = @intCast(comptime_int, a);
+ \\ var a: f32 = 2;
+ \\ _ = @intCast(u32, a);
\\}
, &[_][]const u8{
- "tmp.zig:3:32: error: expected type 'comptime_int', found 'u32'",
+ "tmp.zig:3:32: error: unable to evaluate constant expression",
"tmp.zig:3:9: note: referenced here",
"tmp.zig:7:21: error: expected float type, found 'u32'",
"tmp.zig:7:9: note: referenced here",
"tmp.zig:11:26: error: expected float type, found 'u32'",
"tmp.zig:11:9: note: referenced here",
- "tmp.zig:15:32: error: expected type 'comptime_int', found 'u32'",
+ "tmp.zig:15:23: error: expected integer type, found 'f32'",
"tmp.zig:15:9: note: referenced here",
});
@@ -102,17 +151,17 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
\\ _ = @intToFloat(f32, a);
\\}
\\export fn qux() void {
- \\ var a: f32 = 2;
- \\ _ = @floatCast(comptime_float, a);
+ \\ var a: u32 = 2;
+ \\ _ = @floatCast(f32, a);
\\}
, &[_][]const u8{
- "tmp.zig:3:36: error: expected type 'comptime_float', found 'f32'",
+ "tmp.zig:3:36: error: unable to evaluate constant expression",
"tmp.zig:3:9: note: referenced here",
"tmp.zig:7:21: error: expected integer type, found 'f32'",
"tmp.zig:7:9: note: referenced here",
"tmp.zig:11:26: error: expected int type, found 'f32'",
"tmp.zig:11:9: note: referenced here",
- "tmp.zig:15:36: error: expected type 'comptime_float', found 'f32'",
+ "tmp.zig:15:25: error: expected float type, found 'u32'",
"tmp.zig:15:9: note: referenced here",
});
@@ -1013,7 +1062,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
\\ storev(&v[i], 42);
\\}
\\
- \\fn storev(ptr: var, val: i32) void {
+ \\fn storev(ptr: anytype, val: i32) void {
\\ ptr.* = val;
\\}
, &[_][]const u8{
@@ -1028,7 +1077,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
\\ var x = loadv(&v[i]);
\\}
\\
- \\fn loadv(ptr: var) i32 {
+ \\fn loadv(ptr: anytype) i32 {
\\ return ptr.*;
\\}
, &[_][]const u8{
@@ -1136,13 +1185,26 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
"tmp.zig:2:15: error: @Type not available for 'TypeInfo.Struct'",
});
+ cases.add("wrong type for argument tuple to @asyncCall",
+ \\export fn entry1() void {
+ \\ var frame: @Frame(foo) = undefined;
+ \\ @asyncCall(&frame, {}, foo, {});
+ \\}
+ \\
+ \\fn foo() i32 {
+ \\ return 0;
+ \\}
+ , &[_][]const u8{
+ "tmp.zig:3:33: error: expected tuple or struct, found 'void'",
+ });
+
cases.add("wrong type for result ptr to @asyncCall",
\\export fn entry() void {
\\ _ = async amain();
\\}
\\fn amain() i32 {
\\ var frame: @Frame(foo) = undefined;
- \\ return await @asyncCall(&frame, false, foo);
+ \\ return await @asyncCall(&frame, false, foo, .{});
\\}
\\fn foo() i32 {
\\ return 1234;
@@ -1283,7 +1345,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
\\export fn entry() void {
\\ var ptr: fn () callconv(.Async) void = func;
\\ var bytes: [64]u8 = undefined;
- \\ _ = @asyncCall(&bytes, {}, ptr);
+ \\ _ = @asyncCall(&bytes, {}, ptr, .{});
\\}
\\fn func() callconv(.Async) void {}
, &[_][]const u8{
@@ -1459,7 +1521,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
\\export fn entry() void {
\\ var ptr = afunc;
\\ var bytes: [100]u8 align(16) = undefined;
- \\ _ = @asyncCall(&bytes, {}, ptr);
+ \\ _ = @asyncCall(&bytes, {}, ptr, .{});
\\}
\\fn afunc() void { }
, &[_][]const u8{
@@ -1798,7 +1860,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
\\ while (true) {}
\\}
, &[_][]const u8{
- "error: expected type 'fn([]const u8, ?*std.builtin.StackTrace) noreturn', found 'fn([]const u8,var) var'",
+ "error: expected type 'fn([]const u8, ?*std.builtin.StackTrace) noreturn', found 'fn([]const u8,anytype) anytype'",
"note: only one of the functions is generic",
});
@@ -1998,11 +2060,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
});
cases.add("export generic function",
- \\export fn foo(num: var) i32 {
+ \\export fn foo(num: anytype) i32 {
\\ return 0;
\\}
, &[_][]const u8{
- "tmp.zig:1:15: error: parameter of type 'var' not allowed in function with calling convention 'C'",
+ "tmp.zig:1:15: error: parameter of type 'anytype' not allowed in function with calling convention 'C'",
});
cases.add("C pointer to c_void",
@@ -2802,7 +2864,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
});
cases.add("missing parameter name of generic function",
- \\fn dump(var) void {}
+ \\fn dump(anytype) void {}
\\export fn entry() void {
\\ var a: u8 = 9;
\\ dump(a);
@@ -2825,13 +2887,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
});
cases.add("generic fn as parameter without comptime keyword",
- \\fn f(_: fn (var) void) void {}
- \\fn g(_: var) void {}
+ \\fn f(_: fn (anytype) void) void {}
+ \\fn g(_: anytype) void {}
\\export fn entry() void {
\\ f(g);
\\}
, &[_][]const u8{
- "tmp.zig:1:9: error: parameter of type 'fn(var) var' must be declared comptime",
+ "tmp.zig:1:9: error: parameter of type 'fn(anytype) anytype' must be declared comptime",
});
cases.add("optional pointer to void in extern struct",
@@ -3131,7 +3193,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
cases.add("var makes structs required to be comptime known",
\\export fn entry() void {
- \\ const S = struct{v: var};
+ \\ const S = struct{v: anytype};
\\ var s = S{.v=@as(i32, 10)};
\\}
, &[_][]const u8{
@@ -4354,6 +4416,40 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
"tmp.zig:5:14: note: previous value is here",
});
+ cases.add("switch expression - duplicate type",
+ \\fn foo(comptime T: type, x: T) u8 {
+ \\ return switch (T) {
+ \\ u32 => 0,
+ \\ u64 => 1,
+ \\ u32 => 2,
+ \\ else => 3,
+ \\ };
+ \\}
+ \\export fn entry() usize { return @sizeOf(@TypeOf(foo(u32, 0))); }
+ , &[_][]const u8{
+ "tmp.zig:5:9: error: duplicate switch value",
+ "tmp.zig:3:9: note: previous value is here",
+ });
+
+ cases.add("switch expression - duplicate type (struct alias)",
+ \\const Test = struct {
+ \\ bar: i32,
+ \\};
+ \\const Test2 = Test;
+ \\fn foo(comptime T: type, x: T) u8 {
+ \\ return switch (T) {
+ \\ Test => 0,
+ \\ u64 => 1,
+ \\ Test2 => 2,
+ \\ else => 3,
+ \\ };
+ \\}
+ \\export fn entry() usize { return @sizeOf(@TypeOf(foo(u32, 0))); }
+ , &[_][]const u8{
+ "tmp.zig:9:9: error: duplicate switch value",
+ "tmp.zig:7:9: note: previous value is here",
+ });
+
cases.add("switch expression - switch on pointer type with no else",
\\fn foo(x: *u8) void {
\\ switch (x) {
@@ -6004,10 +6100,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
});
cases.add("calling a generic function only known at runtime",
- \\var foos = [_]fn(var) void { foo1, foo2 };
+ \\var foos = [_]fn(anytype) void { foo1, foo2 };
\\
- \\fn foo1(arg: var) void {}
- \\fn foo2(arg: var) void {}
+ \\fn foo1(arg: anytype) void {}
+ \\fn foo2(arg: anytype) void {}
\\
\\pub fn main() !void {
\\ foos[0](true);
@@ -6852,12 +6948,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
});
cases.add("getting return type of generic function",
- \\fn generic(a: var) void {}
+ \\fn generic(a: anytype) void {}
\\comptime {
\\ _ = @TypeOf(generic).ReturnType;
\\}
, &[_][]const u8{
- "tmp.zig:3:25: error: ReturnType has not been resolved because 'fn(var) var' is generic",
+ "tmp.zig:3:25: error: ReturnType has not been resolved because 'fn(anytype) anytype' is generic",
});
cases.add("unsupported modifier at start of asm output constraint",
@@ -7425,7 +7521,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
});
cases.add("issue #5221: invalid struct init type referenced by @typeInfo and passed into function",
- \\fn ignore(comptime param: var) void {}
+ \\fn ignore(comptime param: anytype) void {}
\\
\\export fn foo() void {
\\ const MyStruct = struct {
@@ -7522,4 +7618,23 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
, &[_][]const u8{
"tmp.zig:2:9: error: @wasmMemoryGrow is a wasm32 feature only",
});
+
+ cases.add("Issue #5586: Make unary minus for unsigned types a compile error",
+ \\export fn f(x: u32) u32 {
+ \\ const y = -%x;
+ \\ return -y;
+ \\}
+ , &[_][]const u8{
+ "tmp.zig:3:12: error: negation of type 'u32'",
+ });
+
+ cases.add("Issue #5618: coercion of ?*c_void to *c_void must fail.",
+ \\export fn foo() void {
+ \\ var u: ?*c_void = null;
+ \\ var v: *c_void = undefined;
+ \\ v = u;
+ \\}
+ , &[_][]const u8{
+ "tmp.zig:4:9: error: expected type '*c_void', found '?*c_void'",
+ });
}
diff --git a/test/run_translated_c.zig b/test/run_translated_c.zig
index c7f7c2c5c6..efdc9702a4 100644
--- a/test/run_translated_c.zig
+++ b/test/run_translated_c.zig
@@ -268,5 +268,77 @@ pub fn addCases(cases: *tests.RunTranslatedCContext) void {
\\ if (count != 4) abort();
\\ return 0;
\\}
- ,"");
+ , "");
+
+ cases.add("array value type casts properly",
+ \\#include
+ \\unsigned int choose[53][10];
+ \\static int hash_binary(int k)
+ \\{
+ \\ choose[0][k] = 3;
+ \\ int sum = 0;
+ \\ sum += choose[0][k];
+ \\ return sum;
+ \\}
+ \\
+ \\int main() {
+ \\ int s = hash_binary(4);
+ \\ if (s != 3) abort();
+ \\ return 0;
+ \\}
+ , "");
+
+ cases.add("array value type casts properly use +=",
+ \\#include
+ \\static int hash_binary(int k)
+ \\{
+ \\ unsigned int choose[1][1] = {{3}};
+ \\ int sum = -1;
+ \\ int prev = 0;
+ \\ prev = sum += choose[0][0];
+ \\ if (sum != 2) abort();
+ \\ return sum + prev;
+ \\}
+ \\
+ \\int main() {
+ \\ int x = hash_binary(4);
+ \\ if (x != 4) abort();
+ \\ return 0;
+ \\}
+ , "");
+
+ cases.add("ensure array casts outisde +=",
+ \\#include
+ \\static int hash_binary(int k)
+ \\{
+ \\ unsigned int choose[3] = {1, 2, 3};
+ \\ int sum = -2;
+ \\ int prev = sum + choose[k];
+ \\ if (prev != 0) abort();
+ \\ return sum + prev;
+ \\}
+ \\
+ \\int main() {
+ \\ int x = hash_binary(1);
+ \\ if (x != -2) abort();
+ \\ return 0;
+ \\}
+ , "");
+
+ cases.add("array cast int to uint",
+ \\#include
+ \\static unsigned int hash_binary(int k)
+ \\{
+ \\ int choose[3] = {-1, -2, 3};
+ \\ unsigned int sum = 2;
+ \\ sum += choose[k];
+ \\ return sum;
+ \\}
+ \\
+ \\int main() {
+ \\ unsigned int x = hash_binary(1);
+ \\ if (x != 0) abort();
+ \\ return 0;
+ \\}
+ , "");
}
diff --git a/test/runtime_safety.zig b/test/runtime_safety.zig
index 2e50c3a84c..e27ae7e16e 100644
--- a/test/runtime_safety.zig
+++ b/test/runtime_safety.zig
@@ -280,7 +280,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
\\pub fn main() void {
\\ var bytes: [1]u8 align(16) = undefined;
\\ var ptr = other;
- \\ var frame = @asyncCall(&bytes, {}, ptr);
+ \\ var frame = @asyncCall(&bytes, {}, ptr, .{});
\\}
\\fn other() callconv(.Async) void {
\\ suspend;
@@ -757,6 +757,16 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
\\}
);
+ cases.addRuntimeSafety("unsigned integer not fitting in cast to signed integer - same bit count",
+ \\pub fn panic(message: []const u8, stack_trace: ?*@import("builtin").StackTrace) noreturn {
+ \\ @import("std").os.exit(126);
+ \\}
+ \\pub fn main() void {
+ \\ var value: u8 = 245;
+ \\ var casted = @intCast(i8, value);
+ \\}
+ );
+
cases.addRuntimeSafety("unwrap error",
\\pub fn panic(message: []const u8, stack_trace: ?*@import("builtin").StackTrace) noreturn {
\\ if (@import("std").mem.eql(u8, message, "attempt to unwrap error: Whatever")) {
diff --git a/test/stage1/behavior.zig b/test/stage1/behavior.zig
index 1620aa52df..eb5bd9907f 100644
--- a/test/stage1/behavior.zig
+++ b/test/stage1/behavior.zig
@@ -50,6 +50,7 @@ comptime {
_ = @import("behavior/bugs/4769_b.zig");
_ = @import("behavior/bugs/4769_c.zig");
_ = @import("behavior/bugs/4954.zig");
+ _ = @import("behavior/bugs/5413.zig");
_ = @import("behavior/bugs/5474.zig");
_ = @import("behavior/bugs/5487.zig");
_ = @import("behavior/bugs/394.zig");
@@ -131,4 +132,6 @@ comptime {
}
_ = @import("behavior/while.zig");
_ = @import("behavior/widening.zig");
+ _ = @import("behavior/src.zig");
+ _ = @import("behavior/translate_c_macros.zig");
}
diff --git a/test/stage1/behavior/async_fn.zig b/test/stage1/behavior/async_fn.zig
index 30df7f64aa..807e4c6275 100644
--- a/test/stage1/behavior/async_fn.zig
+++ b/test/stage1/behavior/async_fn.zig
@@ -282,7 +282,7 @@ test "async fn pointer in a struct field" {
};
var foo = Foo{ .bar = simpleAsyncFn2 };
var bytes: [64]u8 align(16) = undefined;
- const f = @asyncCall(&bytes, {}, foo.bar, &data);
+ const f = @asyncCall(&bytes, {}, foo.bar, .{&data});
comptime expect(@TypeOf(f) == anyframe->void);
expect(data == 2);
resume f;
@@ -318,7 +318,7 @@ test "@asyncCall with return type" {
var foo = Foo{ .bar = Foo.middle };
var bytes: [150]u8 align(16) = undefined;
var aresult: i32 = 0;
- _ = @asyncCall(&bytes, &aresult, foo.bar);
+ _ = @asyncCall(&bytes, &aresult, foo.bar, .{});
expect(aresult == 0);
resume Foo.global_frame;
expect(aresult == 1234);
@@ -332,7 +332,7 @@ test "async fn with inferred error set" {
var frame: [1]@Frame(middle) = undefined;
var fn_ptr = middle;
var result: @TypeOf(fn_ptr).ReturnType.ErrorSet!void = undefined;
- _ = @asyncCall(std.mem.sliceAsBytes(frame[0..]), &result, fn_ptr);
+ _ = @asyncCall(std.mem.sliceAsBytes(frame[0..]), &result, fn_ptr, .{});
resume global_frame;
std.testing.expectError(error.Fail, result);
}
@@ -827,7 +827,7 @@ test "cast fn to async fn when it is inferred to be async" {
ptr = func;
var buf: [100]u8 align(16) = undefined;
var result: i32 = undefined;
- const f = @asyncCall(&buf, &result, ptr);
+ const f = @asyncCall(&buf, &result, ptr, .{});
_ = await f;
expect(result == 1234);
ok = true;
@@ -855,7 +855,7 @@ test "cast fn to async fn when it is inferred to be async, awaited directly" {
ptr = func;
var buf: [100]u8 align(16) = undefined;
var result: i32 = undefined;
- _ = await @asyncCall(&buf, &result, ptr);
+ _ = await @asyncCall(&buf, &result, ptr, .{});
expect(result == 1234);
ok = true;
}
@@ -951,7 +951,7 @@ test "@asyncCall with comptime-known function, but not awaited directly" {
fn doTheTest() void {
var frame: [1]@Frame(middle) = undefined;
var result: @TypeOf(middle).ReturnType.ErrorSet!void = undefined;
- _ = @asyncCall(std.mem.sliceAsBytes(frame[0..]), &result, middle);
+ _ = @asyncCall(std.mem.sliceAsBytes(frame[0..]), &result, middle, .{});
resume global_frame;
std.testing.expectError(error.Fail, result);
}
@@ -982,7 +982,7 @@ test "@asyncCall with actual frame instead of byte buffer" {
};
var frame: @Frame(S.func) = undefined;
var result: i32 = undefined;
- const ptr = @asyncCall(&frame, &result, S.func);
+ const ptr = @asyncCall(&frame, &result, S.func, .{});
resume ptr;
expect(result == 1234);
}
@@ -1005,7 +1005,7 @@ test "@asyncCall using the result location inside the frame" {
};
var foo = Foo{ .bar = S.simple2 };
var bytes: [64]u8 align(16) = undefined;
- const f = @asyncCall(&bytes, {}, foo.bar, &data);
+ const f = @asyncCall(&bytes, {}, foo.bar, .{&data});
comptime expect(@TypeOf(f) == anyframe->i32);
expect(data == 2);
resume f;
@@ -1016,7 +1016,7 @@ test "@asyncCall using the result location inside the frame" {
test "@TypeOf an async function call of generic fn with error union type" {
const S = struct {
- fn func(comptime x: var) anyerror!i32 {
+ fn func(comptime x: anytype) anyerror!i32 {
const T = @TypeOf(async func(x));
comptime expect(T == @TypeOf(@frame()).Child);
return undefined;
@@ -1032,7 +1032,7 @@ test "using @TypeOf on a generic function call" {
var buf: [100]u8 align(16) = undefined;
- fn amain(x: var) void {
+ fn amain(x: anytype) void {
if (x == 0) {
global_ok = true;
return;
@@ -1042,7 +1042,7 @@ test "using @TypeOf on a generic function call" {
}
const F = @TypeOf(async amain(x - 1));
const frame = @intToPtr(*F, @ptrToInt(&buf));
- return await @asyncCall(frame, {}, amain, x - 1);
+ return await @asyncCall(frame, {}, amain, .{x - 1});
}
};
_ = async S.amain(@as(u32, 1));
@@ -1057,7 +1057,7 @@ test "recursive call of await @asyncCall with struct return type" {
var buf: [100]u8 align(16) = undefined;
- fn amain(x: var) Foo {
+ fn amain(x: anytype) Foo {
if (x == 0) {
global_ok = true;
return Foo{ .x = 1, .y = 2, .z = 3 };
@@ -1067,7 +1067,7 @@ test "recursive call of await @asyncCall with struct return type" {
}
const F = @TypeOf(async amain(x - 1));
const frame = @intToPtr(*F, @ptrToInt(&buf));
- return await @asyncCall(frame, {}, amain, x - 1);
+ return await @asyncCall(frame, {}, amain, .{x - 1});
}
const Foo = struct {
@@ -1078,7 +1078,7 @@ test "recursive call of await @asyncCall with struct return type" {
};
var res: S.Foo = undefined;
var frame: @TypeOf(async S.amain(@as(u32, 1))) = undefined;
- _ = @asyncCall(&frame, &res, S.amain, @as(u32, 1));
+ _ = @asyncCall(&frame, &res, S.amain, .{@as(u32, 1)});
resume S.global_frame;
expect(S.global_ok);
expect(res.x == 1);
@@ -1336,7 +1336,7 @@ test "async function passed 0-bit arg after non-0-bit arg" {
bar(1, .{}) catch unreachable;
}
- fn bar(x: i32, args: var) anyerror!void {
+ fn bar(x: i32, args: anytype) anyerror!void {
global_frame = @frame();
suspend;
global_int = x;
@@ -1357,7 +1357,7 @@ test "async function passed align(16) arg after align(8) arg" {
bar(10, .{a}) catch unreachable;
}
- fn bar(x: u64, args: var) anyerror!void {
+ fn bar(x: u64, args: anytype) anyerror!void {
expect(x == 10);
global_frame = @frame();
suspend;
@@ -1377,7 +1377,7 @@ test "async function call resolves target fn frame, comptime func" {
fn foo() anyerror!void {
const stack_size = 1000;
var stack_frame: [stack_size]u8 align(std.Target.stack_align) = undefined;
- return await @asyncCall(&stack_frame, {}, bar);
+ return await @asyncCall(&stack_frame, {}, bar, .{});
}
fn bar() anyerror!void {
@@ -1400,7 +1400,7 @@ test "async function call resolves target fn frame, runtime func" {
const stack_size = 1000;
var stack_frame: [stack_size]u8 align(std.Target.stack_align) = undefined;
var func: fn () callconv(.Async) anyerror!void = bar;
- return await @asyncCall(&stack_frame, {}, func);
+ return await @asyncCall(&stack_frame, {}, func, .{});
}
fn bar() anyerror!void {
diff --git a/test/stage1/behavior/bitcast.zig b/test/stage1/behavior/bitcast.zig
index 009f4544ba..2a86044dc1 100644
--- a/test/stage1/behavior/bitcast.zig
+++ b/test/stage1/behavior/bitcast.zig
@@ -171,7 +171,7 @@ test "nested bitcast" {
test "bitcast passed as tuple element" {
const S = struct {
- fn foo(args: var) void {
+ fn foo(args: anytype) void {
comptime expect(@TypeOf(args[0]) == f32);
expect(args[0] == 12.34);
}
@@ -181,7 +181,7 @@ test "bitcast passed as tuple element" {
test "triple level result location with bitcast sandwich passed as tuple element" {
const S = struct {
- fn foo(args: var) void {
+ fn foo(args: anytype) void {
comptime expect(@TypeOf(args[0]) == f64);
expect(args[0] > 12.33 and args[0] < 12.35);
}
diff --git a/test/stage1/behavior/bugs/2114.zig b/test/stage1/behavior/bugs/2114.zig
index ab32a22cf3..1034a256d3 100644
--- a/test/stage1/behavior/bugs/2114.zig
+++ b/test/stage1/behavior/bugs/2114.zig
@@ -2,7 +2,7 @@ const std = @import("std");
const expect = std.testing.expect;
const math = std.math;
-fn ctz(x: var) usize {
+fn ctz(x: anytype) usize {
return @ctz(@TypeOf(x), x);
}
diff --git a/test/stage1/behavior/bugs/3742.zig b/test/stage1/behavior/bugs/3742.zig
index f09127a66f..bf6e1f5207 100644
--- a/test/stage1/behavior/bugs/3742.zig
+++ b/test/stage1/behavior/bugs/3742.zig
@@ -23,7 +23,7 @@ pub fn isCommand(comptime T: type) bool {
}
pub const ArgSerializer = struct {
- pub fn serializeCommand(command: var) void {
+ pub fn serializeCommand(command: anytype) void {
const CmdT = @TypeOf(command);
if (comptime isCommand(CmdT)) {
diff --git a/test/stage1/behavior/bugs/4328.zig b/test/stage1/behavior/bugs/4328.zig
index 0196af1748..98ab7bd155 100644
--- a/test/stage1/behavior/bugs/4328.zig
+++ b/test/stage1/behavior/bugs/4328.zig
@@ -17,11 +17,11 @@ const S = extern struct {
test "Extern function calls in @TypeOf" {
const Test = struct {
- fn test_fn_1(a: var, b: var) @TypeOf(printf("%d %s\n", a, b)) {
+ fn test_fn_1(a: anytype, b: anytype) @TypeOf(printf("%d %s\n", a, b)) {
return 0;
}
- fn test_fn_2(a: var) @TypeOf((S{ .state = 0 }).s_do_thing(a)) {
+ fn test_fn_2(a: anytype) @TypeOf((S{ .state = 0 }).s_do_thing(a)) {
return 1;
}
@@ -56,7 +56,7 @@ test "Extern function calls, dereferences and field access in @TypeOf" {
return .{ .dummy_field = 0 };
}
- fn test_fn_2(a: var) @TypeOf(fopen("test", "r").*.dummy_field) {
+ fn test_fn_2(a: anytype) @TypeOf(fopen("test", "r").*.dummy_field) {
return 255;
}
@@ -68,4 +68,4 @@ test "Extern function calls, dereferences and field access in @TypeOf" {
Test.doTheTest();
comptime Test.doTheTest();
-}
\ No newline at end of file
+}
diff --git a/test/stage1/behavior/bugs/5413.zig b/test/stage1/behavior/bugs/5413.zig
new file mode 100644
index 0000000000..5ef533a761
--- /dev/null
+++ b/test/stage1/behavior/bugs/5413.zig
@@ -0,0 +1,6 @@
+const expect = @import("std").testing.expect;
+
+test "Peer type resolution with string literals and unknown length u8 pointers" {
+ expect(@TypeOf("", "a", @as([*:0]const u8, "")) == [*:0]const u8);
+ expect(@TypeOf(@as([*:0]const u8, "baz"), "foo", "bar") == [*:0]const u8);
+}
diff --git a/test/stage1/behavior/byval_arg_var.zig b/test/stage1/behavior/byval_arg_var.zig
index 3794a965c6..ec3d18a532 100644
--- a/test/stage1/behavior/byval_arg_var.zig
+++ b/test/stage1/behavior/byval_arg_var.zig
@@ -13,11 +13,11 @@ fn start() void {
foo("string literal");
}
-fn foo(x: var) void {
+fn foo(x: anytype) void {
bar(x);
}
-fn bar(x: var) void {
+fn bar(x: anytype) void {
result = x;
}
diff --git a/test/stage1/behavior/call.zig b/test/stage1/behavior/call.zig
index 40b5be4cd3..4d05a83a39 100644
--- a/test/stage1/behavior/call.zig
+++ b/test/stage1/behavior/call.zig
@@ -57,7 +57,7 @@ test "tuple parameters" {
test "comptime call with bound function as parameter" {
const S = struct {
- fn ReturnType(func: var) type {
+ fn ReturnType(func: anytype) type {
return switch (@typeInfo(@TypeOf(func))) {
.BoundFn => |info| info,
else => unreachable,
diff --git a/test/stage1/behavior/cast.zig b/test/stage1/behavior/cast.zig
index 77cdacc307..4b678cd2db 100644
--- a/test/stage1/behavior/cast.zig
+++ b/test/stage1/behavior/cast.zig
@@ -384,6 +384,19 @@ test "@intCast i32 to u7" {
expect(z == 0xff);
}
+test "@floatCast cast down" {
+ {
+ var double: f64 = 0.001534;
+ var single = @floatCast(f32, double);
+ expect(single == 0.001534);
+ }
+ {
+ const double: f64 = 0.001534;
+ const single = @floatCast(f32, double);
+ expect(single == 0.001534);
+ }
+}
+
test "implicit cast undefined to optional" {
expect(MakeType(void).getNull() == null);
expect(MakeType(void).getNonNull() != null);
diff --git a/test/stage1/behavior/enum.zig b/test/stage1/behavior/enum.zig
index b6cb86a363..f569264520 100644
--- a/test/stage1/behavior/enum.zig
+++ b/test/stage1/behavior/enum.zig
@@ -208,7 +208,7 @@ test "@tagName non-exhaustive enum" {
comptime expect(mem.eql(u8, testEnumTagNameBare(NonExhaustive.B), "B"));
}
-fn testEnumTagNameBare(n: var) []const u8 {
+fn testEnumTagNameBare(n: anytype) []const u8 {
return @tagName(n);
}
@@ -1140,3 +1140,27 @@ test "tagName on enum literals" {
expect(mem.eql(u8, @tagName(.FooBar), "FooBar"));
comptime expect(mem.eql(u8, @tagName(.FooBar), "FooBar"));
}
+
+test "method call on an enum" {
+ const S = struct {
+ const E = enum {
+ one,
+ two,
+
+ fn method(self: *E) bool {
+ return self.* == .two;
+ }
+
+ fn generic_method(self: *E, foo: anytype) bool {
+ return self.* == .two and foo == bool;
+ }
+ };
+ fn doTheTest() void {
+ var e = E.two;
+ expect(e.method());
+ expect(e.generic_method(bool));
+ }
+ };
+ S.doTheTest();
+ comptime S.doTheTest();
+}
diff --git a/test/stage1/behavior/error.zig b/test/stage1/behavior/error.zig
index def7fd679d..975e08b04f 100644
--- a/test/stage1/behavior/error.zig
+++ b/test/stage1/behavior/error.zig
@@ -227,7 +227,7 @@ test "error: Infer error set from literals" {
_ = comptime intLiteral("n") catch |err| handleErrors(err);
}
-fn handleErrors(err: var) noreturn {
+fn handleErrors(err: anytype) noreturn {
switch (err) {
error.T => {},
}
diff --git a/test/stage1/behavior/eval.zig b/test/stage1/behavior/eval.zig
index 2af34eaf7e..38dd12c59d 100644
--- a/test/stage1/behavior/eval.zig
+++ b/test/stage1/behavior/eval.zig
@@ -670,10 +670,10 @@ fn loopNTimes(comptime n: usize) void {
}
test "variable inside inline loop that has different types on different iterations" {
- testVarInsideInlineLoop(.{true, @as(u32, 42)});
+ testVarInsideInlineLoop(.{ true, @as(u32, 42) });
}
-fn testVarInsideInlineLoop(args: var) void {
+fn testVarInsideInlineLoop(args: anytype) void {
comptime var i = 0;
inline while (i < args.len) : (i += 1) {
const x = args[i];
@@ -758,7 +758,7 @@ test "comptime bitwise operators" {
test "*align(1) u16 is the same as *align(1:0:2) u16" {
comptime {
expect(*align(1:0:2) u16 == *align(1) u16);
- expect(*align(:0:2) u16 == *u16);
+ expect(*align(2:0:2) u16 == *u16);
}
}
@@ -814,17 +814,16 @@ test "two comptime calls with array default initialized to undefined" {
dynamic_linker: DynamicLinker = DynamicLinker{},
pub fn parse() void {
- var result: CrossTarget = .{ };
+ var result: CrossTarget = .{};
result.getCpuArch();
}
- pub fn getCpuArch(self: CrossTarget) void { }
+ pub fn getCpuArch(self: CrossTarget) void {}
};
const DynamicLinker = struct {
buffer: [255]u8 = undefined,
};
-
};
comptime {
diff --git a/test/stage1/behavior/fn.zig b/test/stage1/behavior/fn.zig
index c1e5459378..c9f7477ecf 100644
--- a/test/stage1/behavior/fn.zig
+++ b/test/stage1/behavior/fn.zig
@@ -104,7 +104,7 @@ test "number literal as an argument" {
comptime numberLiteralArg(3);
}
-fn numberLiteralArg(a: var) void {
+fn numberLiteralArg(a: anytype) void {
expect(a == 3);
}
@@ -132,7 +132,7 @@ test "pass by non-copying value through var arg" {
expect(addPointCoordsVar(Point{ .x = 1, .y = 2 }) == 3);
}
-fn addPointCoordsVar(pt: var) i32 {
+fn addPointCoordsVar(pt: anytype) i32 {
comptime expect(@TypeOf(pt) == Point);
return pt.x + pt.y;
}
@@ -267,7 +267,7 @@ test "ability to give comptime types and non comptime types to same parameter" {
expect(foo(i32) == 20);
}
- fn foo(arg: var) i32 {
+ fn foo(arg: anytype) i32 {
if (@typeInfo(@TypeOf(arg)) == .Type and arg == i32) return 20;
return 9 + arg;
}
diff --git a/test/stage1/behavior/generics.zig b/test/stage1/behavior/generics.zig
index a5d2f9dabe..6b584e381d 100644
--- a/test/stage1/behavior/generics.zig
+++ b/test/stage1/behavior/generics.zig
@@ -47,7 +47,7 @@ comptime {
expect(max_f64(1.2, 3.4) == 3.4);
}
-fn max_var(a: var, b: var) @TypeOf(a + b) {
+fn max_var(a: anytype, b: anytype) @TypeOf(a + b) {
return if (a > b) a else b;
}
@@ -133,15 +133,15 @@ fn getFirstByte(comptime T: type, mem: []const T) u8 {
return getByte(@ptrCast(*const u8, &mem[0]));
}
-const foos = [_]fn (var) bool{
+const foos = [_]fn (anytype) bool{
foo1,
foo2,
};
-fn foo1(arg: var) bool {
+fn foo1(arg: anytype) bool {
return arg;
}
-fn foo2(arg: var) bool {
+fn foo2(arg: anytype) bool {
return !arg;
}
diff --git a/test/stage1/behavior/math.zig b/test/stage1/behavior/math.zig
index 1d361494eb..b13b1ce1e0 100644
--- a/test/stage1/behavior/math.zig
+++ b/test/stage1/behavior/math.zig
@@ -634,6 +634,128 @@ fn testSqrt(comptime T: type, x: T) void {
expect(@sqrt(x * x) == x);
}
+test "@fabs" {
+ testFabs(f128, 12.0);
+ comptime testFabs(f128, 12.0);
+ testFabs(f64, 12.0);
+ comptime testFabs(f64, 12.0);
+ testFabs(f32, 12.0);
+ comptime testFabs(f32, 12.0);
+ testFabs(f16, 12.0);
+ comptime testFabs(f16, 12.0);
+
+ const x = 14.0;
+ const y = -x;
+ const z = @fabs(y);
+ comptime expectEqual(x, z);
+}
+
+fn testFabs(comptime T: type, x: T) void {
+ const y = -x;
+ const z = @fabs(y);
+ expectEqual(x, z);
+}
+
+test "@floor" {
+ // FIXME: Generates a floorl function call
+ // testFloor(f128, 12.0);
+ comptime testFloor(f128, 12.0);
+ testFloor(f64, 12.0);
+ comptime testFloor(f64, 12.0);
+ testFloor(f32, 12.0);
+ comptime testFloor(f32, 12.0);
+ testFloor(f16, 12.0);
+ comptime testFloor(f16, 12.0);
+
+ const x = 14.0;
+ const y = x + 0.7;
+ const z = @floor(y);
+ comptime expectEqual(x, z);
+}
+
+fn testFloor(comptime T: type, x: T) void {
+ const y = x + 0.6;
+ const z = @floor(y);
+ expectEqual(x, z);
+}
+
+test "@ceil" {
+ // FIXME: Generates a ceill function call
+ //testCeil(f128, 12.0);
+ comptime testCeil(f128, 12.0);
+ testCeil(f64, 12.0);
+ comptime testCeil(f64, 12.0);
+ testCeil(f32, 12.0);
+ comptime testCeil(f32, 12.0);
+ testCeil(f16, 12.0);
+ comptime testCeil(f16, 12.0);
+
+ const x = 14.0;
+ const y = x - 0.7;
+ const z = @ceil(y);
+ comptime expectEqual(x, z);
+}
+
+fn testCeil(comptime T: type, x: T) void {
+ const y = x - 0.8;
+ const z = @ceil(y);
+ expectEqual(x, z);
+}
+
+test "@trunc" {
+ // FIXME: Generates a truncl function call
+ //testTrunc(f128, 12.0);
+ comptime testTrunc(f128, 12.0);
+ testTrunc(f64, 12.0);
+ comptime testTrunc(f64, 12.0);
+ testTrunc(f32, 12.0);
+ comptime testTrunc(f32, 12.0);
+ testTrunc(f16, 12.0);
+ comptime testTrunc(f16, 12.0);
+
+ const x = 14.0;
+ const y = x + 0.7;
+ const z = @trunc(y);
+ comptime expectEqual(x, z);
+}
+
+fn testTrunc(comptime T: type, x: T) void {
+ {
+ const y = x + 0.8;
+ const z = @trunc(y);
+ expectEqual(x, z);
+ }
+
+ {
+ const y = -x - 0.8;
+ const z = @trunc(y);
+ expectEqual(-x, z);
+ }
+}
+
+test "@round" {
+ // FIXME: Generates a roundl function call
+ //testRound(f128, 12.0);
+ comptime testRound(f128, 12.0);
+ testRound(f64, 12.0);
+ comptime testRound(f64, 12.0);
+ testRound(f32, 12.0);
+ comptime testRound(f32, 12.0);
+ testRound(f16, 12.0);
+ comptime testRound(f16, 12.0);
+
+ const x = 14.0;
+ const y = x + 0.4;
+ const z = @round(y);
+ comptime expectEqual(x, z);
+}
+
+fn testRound(comptime T: type, x: T) void {
+ const y = x - 0.5;
+ const z = @round(y);
+ expectEqual(x, z);
+}
+
test "comptime_int param and return" {
const a = comptimeAdd(35361831660712422535336160538497375248, 101752735581729509668353361206450473702);
expect(a == 137114567242441932203689521744947848950);
diff --git a/test/stage1/behavior/misc.zig b/test/stage1/behavior/misc.zig
index 021dbe5602..57a9ba2576 100644
--- a/test/stage1/behavior/misc.zig
+++ b/test/stage1/behavior/misc.zig
@@ -713,3 +713,10 @@ test "auto created variables have correct alignment" {
expect(S.foo("\x7a\x7a\x7a\x7a") == 0x7a7a7a7a);
comptime expect(S.foo("\x7a\x7a\x7a\x7a") == 0x7a7a7a7a);
}
+
+extern var opaque_extern_var: @Type(.Opaque);
+var var_to_export: u32 = 42;
+test "extern variable with non-pointer opaque type" {
+ @export(var_to_export, .{ .name = "opaque_extern_var" });
+ expect(@ptrCast(*align(1) u32, &opaque_extern_var).* == 42);
+}
diff --git a/test/stage1/behavior/optional.zig b/test/stage1/behavior/optional.zig
index 0003bb86e1..1dc33eb8ea 100644
--- a/test/stage1/behavior/optional.zig
+++ b/test/stage1/behavior/optional.zig
@@ -67,8 +67,20 @@ fn test_cmp_optional_non_optional() void {
// test evaluation is always lexical
// ensure that the optional isn't always computed before the non-optional
var mutable_state: i32 = 0;
- _ = blk1: { mutable_state += 1; break :blk1 @as(?f64, 10.0); } != blk2: { expect(mutable_state == 1); break :blk2 @as(f64, 5.0); };
- _ = blk1: { mutable_state += 1; break :blk1 @as(f64, 10.0); } != blk2: { expect(mutable_state == 2); break :blk2 @as(?f64, 5.0); };
+ _ = blk1: {
+ mutable_state += 1;
+ break :blk1 @as(?f64, 10.0);
+ } != blk2: {
+ expect(mutable_state == 1);
+ break :blk2 @as(f64, 5.0);
+ };
+ _ = blk1: {
+ mutable_state += 1;
+ break :blk1 @as(f64, 10.0);
+ } != blk2: {
+ expect(mutable_state == 2);
+ break :blk2 @as(?f64, 5.0);
+ };
}
test "passing an optional integer as a parameter" {
diff --git a/test/stage1/behavior/slice.zig b/test/stage1/behavior/slice.zig
index 1faefe6800..8aa3bdb7c1 100644
--- a/test/stage1/behavior/slice.zig
+++ b/test/stage1/behavior/slice.zig
@@ -280,6 +280,11 @@ test "slice syntax resulting in pointer-to-array" {
expect(slice[0] == 5);
comptime expect(@TypeOf(src_slice[0..2]) == *align(4) [2]u8);
}
+
+ fn testConcatStrLiterals() void {
+ expectEqualSlices("a"[0..] ++ "b"[0..], "ab");
+ expectEqualSlices("a"[0..:0] ++ "b"[0..:0], "ab");
+ }
};
S.doTheTest();
diff --git a/test/stage1/behavior/src.zig b/test/stage1/behavior/src.zig
new file mode 100644
index 0000000000..27fa144e54
--- /dev/null
+++ b/test/stage1/behavior/src.zig
@@ -0,0 +1,17 @@
+const std = @import("std");
+const expect = std.testing.expect;
+
+test "@src" {
+ doTheTest();
+}
+
+fn doTheTest() void {
+ const src = @src();
+
+ expect(src.line == 9);
+ expect(src.column == 17);
+ expect(std.mem.endsWith(u8, src.fn_name, "doTheTest"));
+ expect(std.mem.endsWith(u8, src.file, "src.zig"));
+ expect(src.fn_name[src.fn_name.len] == 0);
+ expect(src.file[src.file.len] == 0);
+}
diff --git a/test/stage1/behavior/struct.zig b/test/stage1/behavior/struct.zig
index 3a4e0a4d93..2d83bd23bb 100644
--- a/test/stage1/behavior/struct.zig
+++ b/test/stage1/behavior/struct.zig
@@ -713,7 +713,7 @@ test "packed struct field passed to generic function" {
a: u1,
};
- fn genericReadPackedField(ptr: var) u5 {
+ fn genericReadPackedField(ptr: anytype) u5 {
return ptr.*;
}
};
@@ -754,7 +754,7 @@ test "fully anonymous struct" {
.s = "hi",
});
}
- fn dump(args: var) void {
+ fn dump(args: anytype) void {
expect(args.int == 1234);
expect(args.float == 12.34);
expect(args.b);
@@ -771,7 +771,7 @@ test "fully anonymous list literal" {
fn doTheTest() void {
dump(.{ @as(u32, 1234), @as(f64, 12.34), true, "hi" });
}
- fn dump(args: var) void {
+ fn dump(args: anytype) void {
expect(args.@"0" == 1234);
expect(args.@"1" == 12.34);
expect(args.@"2");
@@ -792,8 +792,8 @@ test "anonymous struct literal assigned to variable" {
test "struct with var field" {
const Point = struct {
- x: var,
- y: var,
+ x: anytype,
+ y: anytype,
};
const pt = Point{
.x = 1,
@@ -851,3 +851,36 @@ test "struct with union field" {
expectEqual(@as(u32, 2), True.ref);
expectEqual(true, True.kind.Bool);
}
+
+test "type coercion of anon struct literal to struct" {
+ const S = struct {
+ const S2 = struct {
+ A: u32,
+ B: []const u8,
+ C: void,
+ D: Foo = .{},
+ };
+
+ const Foo = struct {
+ field: i32 = 1234,
+ };
+
+ fn doTheTest() void {
+ var y: u32 = 42;
+ const t0 = .{ .A = 123, .B = "foo", .C = {} };
+ const t1 = .{ .A = y, .B = "foo", .C = {} };
+ const y0: S2 = t0;
+ var y1: S2 = t1;
+ expect(y0.A == 123);
+ expect(std.mem.eql(u8, y0.B, "foo"));
+ expect(y0.C == {});
+ expect(y0.D.field == 1234);
+ expect(y1.A == y);
+ expect(std.mem.eql(u8, y1.B, "foo"));
+ expect(y1.C == {});
+ expect(y1.D.field == 1234);
+ }
+ };
+ S.doTheTest();
+ comptime S.doTheTest();
+}
diff --git a/test/stage1/behavior/translate_c_macros.h b/test/stage1/behavior/translate_c_macros.h
new file mode 100644
index 0000000000..abc6c1e3cf
--- /dev/null
+++ b/test/stage1/behavior/translate_c_macros.h
@@ -0,0 +1,9 @@
+// initializer list expression
+typedef struct Color {
+ unsigned char r;
+ unsigned char g;
+ unsigned char b;
+ unsigned char a;
+} Color;
+#define CLITERAL(type) (type)
+#define LIGHTGRAY CLITERAL(Color){ 200, 200, 200, 255 } // Light Gray
\ No newline at end of file
diff --git a/test/stage1/behavior/translate_c_macros.zig b/test/stage1/behavior/translate_c_macros.zig
new file mode 100644
index 0000000000..ea42016e9b
--- /dev/null
+++ b/test/stage1/behavior/translate_c_macros.zig
@@ -0,0 +1,12 @@
+const expect = @import("std").testing.expect;
+
+const h = @cImport(@cInclude("stage1/behavior/translate_c_macros.h"));
+
+test "initializer list expression" {
+ @import("std").testing.expectEqual(h.Color{
+ .r = 200,
+ .g = 200,
+ .b = 200,
+ .a = 255,
+ }, h.LIGHTGRAY);
+}
diff --git a/test/stage1/behavior/tuple.zig b/test/stage1/behavior/tuple.zig
index 0b2fdfe4e0..299abec3c9 100644
--- a/test/stage1/behavior/tuple.zig
+++ b/test/stage1/behavior/tuple.zig
@@ -42,7 +42,7 @@ test "tuple multiplication" {
comptime S.doTheTest();
const T = struct {
- fn consume_tuple(tuple: var, len: usize) void {
+ fn consume_tuple(tuple: anytype, len: usize) void {
expect(tuple.len == len);
}
@@ -82,7 +82,7 @@ test "tuple multiplication" {
test "pass tuple to comptime var parameter" {
const S = struct {
- fn Foo(comptime args: var) void {
+ fn Foo(comptime args: anytype) void {
expect(args[0] == 1);
}
diff --git a/test/stage1/behavior/type.zig b/test/stage1/behavior/type.zig
index 2860229cb8..f21e9f1ce9 100644
--- a/test/stage1/behavior/type.zig
+++ b/test/stage1/behavior/type.zig
@@ -213,3 +213,26 @@ test "Type.AnyFrame" {
anyframe->anyframe->u8,
});
}
+
+test "Type.EnumLiteral" {
+ testTypes(&[_]type{
+ @TypeOf(.Dummy),
+ });
+}
+
+fn add(a: i32, b: i32) i32 {
+ return a + b;
+}
+
+test "Type.Frame" {
+ testTypes(&[_]type{
+ @Frame(add),
+ });
+}
+
+test "Type.ErrorSet" {
+ // error sets don't compare equal so just check if they compile
+ _ = @Type(@typeInfo(error{}));
+ _ = @Type(@typeInfo(error{A}));
+ _ = @Type(@typeInfo(error{ A, B, C }));
+}
diff --git a/test/stage1/behavior/type_info.zig b/test/stage1/behavior/type_info.zig
index c897276f83..a79b3a1554 100644
--- a/test/stage1/behavior/type_info.zig
+++ b/test/stage1/behavior/type_info.zig
@@ -202,7 +202,7 @@ fn testUnion() void {
expect(typeinfo_info.Union.fields[4].enum_field != null);
expect(typeinfo_info.Union.fields[4].enum_field.?.value == 4);
expect(typeinfo_info.Union.fields[4].field_type == @TypeOf(@typeInfo(u8).Int));
- expect(typeinfo_info.Union.decls.len == 20);
+ expect(typeinfo_info.Union.decls.len == 21);
const TestNoTagUnion = union {
Foo: void,
@@ -251,14 +251,13 @@ fn testStruct() void {
}
const TestStruct = packed struct {
- const Self = @This();
-
fieldA: usize,
fieldB: void,
fieldC: *Self,
fieldD: u32 = 4,
pub fn foo(self: *const Self) void {}
+ const Self = @This();
};
test "type info: function type info" {
@@ -281,7 +280,7 @@ fn testFunction() void {
expect(bound_fn_info.BoundFn.args[0].arg_type.? == *const TestStruct);
}
-extern fn foo(a: usize, b: bool, args: ...) usize;
+extern fn foo(a: usize, b: bool, ...) usize;
test "typeInfo with comptime parameter in struct fn def" {
const S = struct {
@@ -386,6 +385,48 @@ test "@typeInfo does not force declarations into existence" {
}
test "defaut value for a var-typed field" {
- const S = struct { x: var };
+ const S = struct { x: anytype };
expect(@typeInfo(S).Struct.fields[0].default_value == null);
}
+
+fn add(a: i32, b: i32) i32 {
+ return a + b;
+}
+
+test "type info for async frames" {
+ switch (@typeInfo(@Frame(add))) {
+ .Frame => |frame| {
+ expect(frame.function == add);
+ },
+ else => unreachable,
+ }
+}
+
+test "type info: value is correctly copied" {
+ comptime {
+ var ptrInfo = @typeInfo([]u32);
+ ptrInfo.Pointer.size = .One;
+ expect(@typeInfo([]u32).Pointer.size == .Slice);
+ }
+}
+
+test "Declarations are returned in declaration order" {
+ const S = struct {
+ const a = 1;
+ const b = 2;
+ const c = 3;
+ const d = 4;
+ const e = 5;
+ };
+ const d = @typeInfo(S).Struct.decls;
+ expect(std.mem.eql(u8, d[0].name, "a"));
+ expect(std.mem.eql(u8, d[1].name, "b"));
+ expect(std.mem.eql(u8, d[2].name, "c"));
+ expect(std.mem.eql(u8, d[3].name, "d"));
+ expect(std.mem.eql(u8, d[4].name, "e"));
+}
+
+test "Struct.is_tuple" {
+ expect(@typeInfo(@TypeOf(.{0})).Struct.is_tuple);
+ expect(!@typeInfo(@TypeOf(.{ .a = 0 })).Struct.is_tuple);
+}
diff --git a/test/stage1/behavior/union.zig b/test/stage1/behavior/union.zig
index 8555e712dd..cf3412eb5b 100644
--- a/test/stage1/behavior/union.zig
+++ b/test/stage1/behavior/union.zig
@@ -296,7 +296,7 @@ const TaggedUnionWithAVoid = union(enum) {
B: i32,
};
-fn testTaggedUnionInit(x: var) bool {
+fn testTaggedUnionInit(x: anytype) bool {
const y = TaggedUnionWithAVoid{ .A = x };
return @as(@TagType(TaggedUnionWithAVoid), y) == TaggedUnionWithAVoid.A;
}
@@ -669,3 +669,24 @@ test "cast from anonymous struct to union" {
S.doTheTest();
comptime S.doTheTest();
}
+
+test "method call on an empty union" {
+ const S = struct {
+ const MyUnion = union(Tag) {
+ pub const Tag = enum { X1, X2 };
+ X1: [0]u8,
+ X2: [0]u8,
+
+ pub fn useIt(self: *@This()) bool {
+ return true;
+ }
+ };
+
+ fn doTheTest() void {
+ var u = MyUnion{ .X1 = [0]u8{} };
+ expect(u.useIt());
+ }
+ };
+ S.doTheTest();
+ comptime S.doTheTest();
+}
diff --git a/test/stage1/behavior/var_args.zig b/test/stage1/behavior/var_args.zig
index 0c8674a7fb..eae8f8f888 100644
--- a/test/stage1/behavior/var_args.zig
+++ b/test/stage1/behavior/var_args.zig
@@ -1,6 +1,6 @@
const expect = @import("std").testing.expect;
-fn add(args: var) i32 {
+fn add(args: anytype) i32 {
var sum = @as(i32, 0);
{
comptime var i: usize = 0;
@@ -17,7 +17,7 @@ test "add arbitrary args" {
expect(add(.{}) == 0);
}
-fn readFirstVarArg(args: var) void {
+fn readFirstVarArg(args: anytype) void {
const value = args[0];
}
@@ -31,7 +31,7 @@ test "pass args directly" {
expect(addSomeStuff(.{}) == 0);
}
-fn addSomeStuff(args: var) i32 {
+fn addSomeStuff(args: anytype) i32 {
return add(args);
}
@@ -47,7 +47,7 @@ test "runtime parameter before var args" {
}
}
-fn extraFn(extra: u32, args: var) usize {
+fn extraFn(extra: u32, args: anytype) usize {
if (args.len >= 1) {
expect(args[0] == false);
}
@@ -57,15 +57,15 @@ fn extraFn(extra: u32, args: var) usize {
return args.len;
}
-const foos = [_]fn (var) bool{
+const foos = [_]fn (anytype) bool{
foo1,
foo2,
};
-fn foo1(args: var) bool {
+fn foo1(args: anytype) bool {
return true;
}
-fn foo2(args: var) bool {
+fn foo2(args: anytype) bool {
return false;
}
@@ -78,6 +78,6 @@ test "pass zero length array to var args param" {
doNothingWithFirstArg(.{""});
}
-fn doNothingWithFirstArg(args: var) void {
+fn doNothingWithFirstArg(args: anytype) void {
const a = args[0];
}
diff --git a/test/stage1/behavior/vector.zig b/test/stage1/behavior/vector.zig
index 851074e0d1..8bdffcd500 100644
--- a/test/stage1/behavior/vector.zig
+++ b/test/stage1/behavior/vector.zig
@@ -171,7 +171,7 @@ test "load vector elements via comptime index" {
expect(v[1] == 2);
expect(loadv(&v[2]) == 3);
}
- fn loadv(ptr: var) i32 {
+ fn loadv(ptr: anytype) i32 {
return ptr.*;
}
};
@@ -194,7 +194,7 @@ test "store vector elements via comptime index" {
storev(&v[0], 100);
expect(v[0] == 100);
}
- fn storev(ptr: var, x: i32) void {
+ fn storev(ptr: anytype, x: i32) void {
ptr.* = x;
}
};
@@ -392,7 +392,7 @@ test "vector shift operators" {
if (builtin.os.tag == .wasi) return error.SkipZigTest;
const S = struct {
- fn doTheTestShift(x: var, y: var) void {
+ fn doTheTestShift(x: anytype, y: anytype) void {
const N = @typeInfo(@TypeOf(x)).Array.len;
const TX = @typeInfo(@TypeOf(x)).Array.child;
const TY = @typeInfo(@TypeOf(y)).Array.child;
@@ -409,7 +409,7 @@ test "vector shift operators" {
expectEqual(x[i] << y[i], v);
}
}
- fn doTheTestShiftExact(x: var, y: var, dir: enum { Left, Right }) void {
+ fn doTheTestShiftExact(x: anytype, y: anytype, dir: enum { Left, Right }) void {
const N = @typeInfo(@TypeOf(x)).Array.len;
const TX = @typeInfo(@TypeOf(x)).Array.child;
const TY = @typeInfo(@TypeOf(y)).Array.child;
diff --git a/test/stage2/cbe.zig b/test/stage2/cbe.zig
new file mode 100644
index 0000000000..e817029b83
--- /dev/null
+++ b/test/stage2/cbe.zig
@@ -0,0 +1,91 @@
+const std = @import("std");
+const TestContext = @import("../../src-self-hosted/test.zig").TestContext;
+
+// These tests should work with all platforms, but we're using linux_x64 for
+// now for consistency. Will be expanded eventually.
+const linux_x64 = std.zig.CrossTarget{
+ .cpu_arch = .x86_64,
+ .os_tag = .linux,
+};
+
+pub fn addCases(ctx: *TestContext) !void {
+ ctx.c("empty start function", linux_x64,
+ \\export fn _start() noreturn {}
+ ,
+ \\noreturn void _start(void) {}
+ \\
+ );
+ ctx.c("less empty start function", linux_x64,
+ \\fn main() noreturn {}
+ \\
+ \\export fn _start() noreturn {
+ \\ main();
+ \\}
+ ,
+ \\noreturn void main(void);
+ \\
+ \\noreturn void _start(void) {
+ \\ main();
+ \\}
+ \\
+ \\noreturn void main(void) {}
+ \\
+ );
+ // TODO: implement return values
+ // TODO: figure out a way to prevent asm constants from being generated
+ ctx.c("inline asm", linux_x64,
+ \\fn exitGood() void {
+ \\ asm volatile ("syscall"
+ \\ :
+ \\ : [number] "{rax}" (231),
+ \\ [arg1] "{rdi}" (0)
+ \\ );
+ \\}
+ \\
+ \\export fn _start() noreturn {
+ \\ exitGood();
+ \\}
+ ,
+ \\#include
+ \\
+ \\void exitGood(void);
+ \\
+ \\const char *const exitGood__anon_0 = "{rax}";
+ \\const char *const exitGood__anon_1 = "{rdi}";
+ \\const char *const exitGood__anon_2 = "syscall";
+ \\
+ \\noreturn void _start(void) {
+ \\ exitGood();
+ \\}
+ \\
+ \\void exitGood(void) {
+ \\ register size_t rax_constant __asm__("rax") = 231;
+ \\ register size_t rdi_constant __asm__("rdi") = 0;
+ \\ __asm volatile ("syscall" :: ""(rax_constant), ""(rdi_constant));
+ \\ return;
+ \\}
+ \\
+ );
+ ctx.c("basic return", linux_x64,
+ \\fn main() u8 {
+ \\ return 103;
+ \\}
+ \\
+ \\export fn _start() noreturn {
+ \\ _ = main();
+ \\}
+ ,
+ \\#include
+ \\
+ \\uint8_t main(void);
+ \\
+ \\noreturn void _start(void) {
+ \\ (void)main();
+ \\}
+ \\
+ \\uint8_t main(void) {
+ \\ return 103;
+ \\}
+ \\
+ );
+}
diff --git a/test/stage2/compare_output.zig b/test/stage2/compare_output.zig
index 1f289c2762..c4f85bfba4 100644
--- a/test/stage2/compare_output.zig
+++ b/test/stage2/compare_output.zig
@@ -1,28 +1,230 @@
const std = @import("std");
const TestContext = @import("../../src-self-hosted/test.zig").TestContext;
+// self-hosted does not yet support PE executable files / COFF object files
+// or mach-o files. So we do these test cases cross compiling for x86_64-linux.
+const linux_x64 = std.zig.CrossTarget{
+ .cpu_arch = .x86_64,
+ .os_tag = .linux,
+};
pub fn addCases(ctx: *TestContext) !void {
- // TODO: re-enable these tests.
- // https://github.com/ziglang/zig/issues/1364
+ if (std.Target.current.os.tag != .linux or
+ std.Target.current.cpu.arch != .x86_64)
+ {
+ // TODO implement self-hosted PE (.exe file) linking
+ // TODO implement more ZIR so we don't depend on x86_64-linux
+ return;
+ }
- //// hello world
- //try ctx.testCompareOutputLibC(
- // \\extern fn puts([*]const u8) void;
- // \\pub export fn main() c_int {
- // \\ puts("Hello, world!");
- // \\ return 0;
- // \\}
- //, "Hello, world!" ++ std.cstr.line_sep);
+ {
+ var case = ctx.exe("hello world with updates", linux_x64);
+ // Regular old hello world
+ case.addCompareOutput(
+ \\export fn _start() noreturn {
+ \\ print();
+ \\
+ \\ exit();
+ \\}
+ \\
+ \\fn print() void {
+ \\ asm volatile ("syscall"
+ \\ :
+ \\ : [number] "{rax}" (1),
+ \\ [arg1] "{rdi}" (1),
+ \\ [arg2] "{rsi}" (@ptrToInt("Hello, World!\n")),
+ \\ [arg3] "{rdx}" (14)
+ \\ : "rcx", "r11", "memory"
+ \\ );
+ \\ return;
+ \\}
+ \\
+ \\fn exit() noreturn {
+ \\ asm volatile ("syscall"
+ \\ :
+ \\ : [number] "{rax}" (231),
+ \\ [arg1] "{rdi}" (0)
+ \\ : "rcx", "r11", "memory"
+ \\ );
+ \\ unreachable;
+ \\}
+ ,
+ "Hello, World!\n",
+ );
+ // Now change the message only
+ case.addCompareOutput(
+ \\export fn _start() noreturn {
+ \\ print();
+ \\
+ \\ exit();
+ \\}
+ \\
+ \\fn print() void {
+ \\ asm volatile ("syscall"
+ \\ :
+ \\ : [number] "{rax}" (1),
+ \\ [arg1] "{rdi}" (1),
+ \\ [arg2] "{rsi}" (@ptrToInt("What is up? This is a longer message that will force the data to be relocated in virtual address space.\n")),
+ \\ [arg3] "{rdx}" (104)
+ \\ : "rcx", "r11", "memory"
+ \\ );
+ \\ return;
+ \\}
+ \\
+ \\fn exit() noreturn {
+ \\ asm volatile ("syscall"
+ \\ :
+ \\ : [number] "{rax}" (231),
+ \\ [arg1] "{rdi}" (0)
+ \\ : "rcx", "r11", "memory"
+ \\ );
+ \\ unreachable;
+ \\}
+ ,
+ "What is up? This is a longer message that will force the data to be relocated in virtual address space.\n",
+ );
+ // Now we print it twice.
+ case.addCompareOutput(
+ \\export fn _start() noreturn {
+ \\ print();
+ \\ print();
+ \\
+ \\ exit();
+ \\}
+ \\
+ \\fn print() void {
+ \\ asm volatile ("syscall"
+ \\ :
+ \\ : [number] "{rax}" (1),
+ \\ [arg1] "{rdi}" (1),
+ \\ [arg2] "{rsi}" (@ptrToInt("What is up? This is a longer message that will force the data to be relocated in virtual address space.\n")),
+ \\ [arg3] "{rdx}" (104)
+ \\ : "rcx", "r11", "memory"
+ \\ );
+ \\ return;
+ \\}
+ \\
+ \\fn exit() noreturn {
+ \\ asm volatile ("syscall"
+ \\ :
+ \\ : [number] "{rax}" (231),
+ \\ [arg1] "{rdi}" (0)
+ \\ : "rcx", "r11", "memory"
+ \\ );
+ \\ unreachable;
+ \\}
+ ,
+ \\What is up? This is a longer message that will force the data to be relocated in virtual address space.
+ \\What is up? This is a longer message that will force the data to be relocated in virtual address space.
+ \\
+ );
+ }
- //// function calling another function
- //try ctx.testCompareOutputLibC(
- // \\extern fn puts(s: [*]const u8) void;
- // \\pub export fn main() c_int {
- // \\ return foo("OK");
- // \\}
- // \\fn foo(s: [*]const u8) c_int {
- // \\ puts(s);
- // \\ return 0;
- // \\}
- //, "OK" ++ std.cstr.line_sep);
+ {
+ var case = ctx.exe("adding numbers at comptime", linux_x64);
+ case.addCompareOutput(
+ \\export fn _start() noreturn {
+ \\ asm volatile ("syscall"
+ \\ :
+ \\ : [number] "{rax}" (1),
+ \\ [arg1] "{rdi}" (1),
+ \\ [arg2] "{rsi}" (@ptrToInt("Hello, World!\n")),
+ \\ [arg3] "{rdx}" (10 + 4)
+ \\ : "rcx", "r11", "memory"
+ \\ );
+ \\ asm volatile ("syscall"
+ \\ :
+ \\ : [number] "{rax}" (@as(usize, 230) + @as(usize, 1)),
+ \\ [arg1] "{rdi}" (0)
+ \\ : "rcx", "r11", "memory"
+ \\ );
+ \\ unreachable;
+ \\}
+ ,
+ "Hello, World!\n",
+ );
+ }
+
+ {
+ var case = ctx.exe("adding numbers at runtime", linux_x64);
+ case.addCompareOutput(
+ \\export fn _start() noreturn {
+ \\ add(3, 4);
+ \\
+ \\ exit();
+ \\}
+ \\
+ \\fn add(a: u32, b: u32) void {
+ \\ if (a + b != 7) unreachable;
+ \\}
+ \\
+ \\fn exit() noreturn {
+ \\ asm volatile ("syscall"
+ \\ :
+ \\ : [number] "{rax}" (231),
+ \\ [arg1] "{rdi}" (0)
+ \\ : "rcx", "r11", "memory"
+ \\ );
+ \\ unreachable;
+ \\}
+ ,
+ "",
+ );
+ }
+ {
+ var case = ctx.exe("assert function", linux_x64);
+ case.addCompareOutput(
+ \\export fn _start() noreturn {
+ \\ add(3, 4);
+ \\
+ \\ exit();
+ \\}
+ \\
+ \\fn add(a: u32, b: u32) void {
+ \\ assert(a + b == 7);
+ \\}
+ \\
+ \\pub fn assert(ok: bool) void {
+ \\ if (!ok) unreachable; // assertion failure
+ \\}
+ \\
+ \\fn exit() noreturn {
+ \\ asm volatile ("syscall"
+ \\ :
+ \\ : [number] "{rax}" (231),
+ \\ [arg1] "{rdi}" (0)
+ \\ : "rcx", "r11", "memory"
+ \\ );
+ \\ unreachable;
+ \\}
+ ,
+ "",
+ );
+ case.addCompareOutput(
+ \\export fn _start() noreturn {
+ \\ add(100, 200);
+ \\
+ \\ exit();
+ \\}
+ \\
+ \\fn add(a: u32, b: u32) void {
+ \\ assert(a + b == 300);
+ \\}
+ \\
+ \\pub fn assert(ok: bool) void {
+ \\ if (!ok) unreachable; // assertion failure
+ \\}
+ \\
+ \\fn exit() noreturn {
+ \\ asm volatile ("syscall"
+ \\ :
+ \\ : [number] "{rax}" (231),
+ \\ [arg1] "{rdi}" (0)
+ \\ : "rcx", "r11", "memory"
+ \\ );
+ \\ unreachable;
+ \\}
+ ,
+ "",
+ );
+ }
}
diff --git a/test/stage2/compile_errors.zig b/test/stage2/compile_errors.zig
index 9b8dcd91c4..45e60c0741 100644
--- a/test/stage2/compile_errors.zig
+++ b/test/stage2/compile_errors.zig
@@ -1,55 +1,133 @@
const TestContext = @import("../../src-self-hosted/test.zig").TestContext;
+const std = @import("std");
+
+const ErrorMsg = @import("../../src-self-hosted/Module.zig").ErrorMsg;
+
+const linux_x64 = std.zig.CrossTarget{
+ .cpu_arch = .x86_64,
+ .os_tag = .linux,
+};
pub fn addCases(ctx: *TestContext) !void {
+ ctx.compileErrorZIR("call undefined local", linux_x64,
+ \\@noreturn = primitive(noreturn)
+ \\
+ \\@start_fnty = fntype([], @noreturn, cc=Naked)
+ \\@start = fn(@start_fnty, {
+ \\ %0 = call(%test, [])
+ \\})
+ // TODO: address inconsistency in this message and the one in the next test
+ , &[_][]const u8{":5:13: error: unrecognized identifier: %test"});
+
+ ctx.compileErrorZIR("call with non-existent target", linux_x64,
+ \\@noreturn = primitive(noreturn)
+ \\
+ \\@start_fnty = fntype([], @noreturn, cc=Naked)
+ \\@start = fn(@start_fnty, {
+ \\ %0 = call(@notafunc, [])
+ \\})
+ \\@0 = str("_start")
+ \\@1 = export(@0, "start")
+ , &[_][]const u8{":5:13: error: decl 'notafunc' not found"});
+
+ // TODO: this error should occur at the call site, not the fntype decl
+ ctx.compileErrorZIR("call naked function", linux_x64,
+ \\@noreturn = primitive(noreturn)
+ \\
+ \\@start_fnty = fntype([], @noreturn, cc=Naked)
+ \\@s = fn(@start_fnty, {})
+ \\@start = fn(@start_fnty, {
+ \\ %0 = call(@s, [])
+ \\})
+ \\@0 = str("_start")
+ \\@1 = export(@0, "start")
+ , &[_][]const u8{":4:9: error: unable to call function with naked calling convention"});
+
+ ctx.incrementalFailureZIR("exported symbol collision", linux_x64,
+ \\@noreturn = primitive(noreturn)
+ \\
+ \\@start_fnty = fntype([], @noreturn)
+ \\@start = fn(@start_fnty, {})
+ \\
+ \\@0 = str("_start")
+ \\@1 = export(@0, "start")
+ \\@2 = export(@0, "start")
+ , &[_][]const u8{":8:13: error: exported symbol collision: _start"},
+ \\@noreturn = primitive(noreturn)
+ \\
+ \\@start_fnty = fntype([], @noreturn)
+ \\@start = fn(@start_fnty, {})
+ \\
+ \\@0 = str("_start")
+ \\@1 = export(@0, "start")
+ );
+
+ ctx.compileError("function redefinition", linux_x64,
+ \\fn entry() void {}
+ \\fn entry() void {}
+ , &[_][]const u8{":2:4: error: redefinition of 'entry'"});
+
+ //ctx.incrementalFailure("function redefinition", linux_x64,
+ // \\fn entry() void {}
+ // \\fn entry() void {}
+ //, &[_][]const u8{":2:4: error: redefinition of 'entry'"},
+ // \\fn entry() void {}
+ //);
+
+ //// TODO: need to make sure this works with other variants of export.
+ //ctx.incrementalFailure("exported symbol collision", linux_x64,
+ // \\export fn entry() void {}
+ // \\export fn entry() void {}
+ //, &[_][]const u8{":2:11: error: redefinition of 'entry'"},
+ // \\export fn entry() void {}
+ //);
+
+ // ctx.incrementalFailure("missing function name", linux_x64,
+ // \\fn() void {}
+ // , &[_][]const u8{":1:3: error: missing function name"},
+ // \\fn a() void {}
+ // );
+
// TODO: re-enable these tests.
// https://github.com/ziglang/zig/issues/1364
- //try ctx.testCompileError(
- // \\export fn entry() void {}
- // \\export fn entry() void {}
- //, "1.zig", 2, 8, "exported symbol collision: 'entry'");
-
- //try ctx.testCompileError(
- // \\fn() void {}
- //, "1.zig", 1, 1, "missing function name");
-
- //try ctx.testCompileError(
+ //ctx.testCompileError(
// \\comptime {
// \\ return;
// \\}
//, "1.zig", 2, 5, "return expression outside function definition");
- //try ctx.testCompileError(
+ //ctx.testCompileError(
// \\export fn entry() void {
// \\ defer return;
// \\}
//, "1.zig", 2, 11, "cannot return from defer expression");
- //try ctx.testCompileError(
+ //ctx.testCompileError(
// \\export fn entry() c_int {
// \\ return 36893488147419103232;
// \\}
//, "1.zig", 2, 12, "integer value '36893488147419103232' cannot be stored in type 'c_int'");
- //try ctx.testCompileError(
+ //ctx.testCompileError(
// \\comptime {
// \\ var a: *align(4) align(4) i32 = 0;
// \\}
//, "1.zig", 2, 22, "Extra align qualifier");
- //try ctx.testCompileError(
+ //ctx.testCompileError(
// \\comptime {
// \\ var b: *const const i32 = 0;
// \\}
//, "1.zig", 2, 19, "Extra align qualifier");
- //try ctx.testCompileError(
+ //ctx.testCompileError(
// \\comptime {
// \\ var c: *volatile volatile i32 = 0;
// \\}
//, "1.zig", 2, 22, "Extra align qualifier");
- //try ctx.testCompileError(
+ //ctx.testCompileError(
// \\comptime {
// \\ var d: *allowzero allowzero i32 = 0;
// \\}
diff --git a/test/stage2/test.zig b/test/stage2/test.zig
index dc92f99506..f5acc72f93 100644
--- a/test/stage2/test.zig
+++ b/test/stage2/test.zig
@@ -3,5 +3,6 @@ const TestContext = @import("../../src-self-hosted/test.zig").TestContext;
pub fn addCases(ctx: *TestContext) !void {
try @import("compile_errors.zig").addCases(ctx);
try @import("compare_output.zig").addCases(ctx);
- @import("zir.zig").addCases(ctx);
+ try @import("zir.zig").addCases(ctx);
+ try @import("cbe.zig").addCases(ctx);
}
diff --git a/test/stage2/zir.zig b/test/stage2/zir.zig
index bf5d4b8eae..1a0aed85cf 100644
--- a/test/stage2/zir.zig
+++ b/test/stage2/zir.zig
@@ -8,33 +8,31 @@ const linux_x64 = std.zig.CrossTarget{
.os_tag = .linux,
};
-pub fn addCases(ctx: *TestContext) void {
- ctx.addZIRTransform("referencing decls which appear later in the file", linux_x64,
+pub fn addCases(ctx: *TestContext) !void {
+ ctx.transformZIR("referencing decls which appear later in the file", linux_x64,
\\@void = primitive(void)
\\@fnty = fntype([], @void, cc=C)
\\
\\@9 = str("entry")
- \\@10 = ref(@9)
- \\@11 = export(@10, @entry)
+ \\@11 = export(@9, "entry")
\\
\\@entry = fn(@fnty, {
- \\ %11 = return()
+ \\ %11 = returnvoid()
\\})
,
\\@void = primitive(void)
\\@fnty = fntype([], @void, cc=C)
- \\@9 = str("entry")
- \\@10 = ref(@9)
- \\@unnamed$6 = str("entry")
- \\@unnamed$7 = ref(@unnamed$6)
- \\@unnamed$8 = export(@unnamed$7, @entry)
- \\@unnamed$10 = fntype([], @void, cc=C)
- \\@entry = fn(@unnamed$10, {
- \\ %0 = return()
+ \\@9 = declref("9__anon_0")
+ \\@9__anon_0 = str("entry")
+ \\@unnamed$4 = str("entry")
+ \\@unnamed$5 = export(@unnamed$4, "entry")
+ \\@unnamed$6 = fntype([], @void, cc=C)
+ \\@entry = fn(@unnamed$6, {
+ \\ %0 = returnvoid()
\\})
\\
);
- ctx.addZIRTransform("elemptr, add, cmp, condbr, return, breakpoint", linux_x64,
+ ctx.transformZIR("elemptr, add, cmp, condbr, return, breakpoint", linux_x64,
\\@void = primitive(void)
\\@usize = primitive(usize)
\\@fnty = fntype([], @void, cc=C)
@@ -45,11 +43,10 @@ pub fn addCases(ctx: *TestContext) void {
\\
\\@entry = fn(@fnty, {
\\ %a = str("\x32\x08\x01\x0a")
- \\ %aref = ref(%a)
- \\ %eptr0 = elemptr(%aref, @0)
- \\ %eptr1 = elemptr(%aref, @1)
- \\ %eptr2 = elemptr(%aref, @2)
- \\ %eptr3 = elemptr(%aref, @3)
+ \\ %eptr0 = elemptr(%a, @0)
+ \\ %eptr1 = elemptr(%a, @1)
+ \\ %eptr2 = elemptr(%a, @2)
+ \\ %eptr3 = elemptr(%a, @3)
\\ %v0 = deref(%eptr0)
\\ %v1 = deref(%eptr1)
\\ %v2 = deref(%eptr2)
@@ -61,15 +58,14 @@ pub fn addCases(ctx: *TestContext) void {
\\ %expected = int(69)
\\ %ok = cmp(%result, eq, %expected)
\\ %10 = condbr(%ok, {
- \\ %11 = return()
+ \\ %11 = returnvoid()
\\ }, {
\\ %12 = breakpoint()
\\ })
\\})
\\
\\@9 = str("entry")
- \\@10 = ref(@9)
- \\@11 = export(@10, @entry)
+ \\@11 = export(@9, "entry")
,
\\@void = primitive(void)
\\@fnty = fntype([], @void, cc=C)
@@ -77,65 +73,62 @@ pub fn addCases(ctx: *TestContext) void {
\\@1 = int(1)
\\@2 = int(2)
\\@3 = int(3)
- \\@unnamed$7 = fntype([], @void, cc=C)
- \\@entry = fn(@unnamed$7, {
- \\ %0 = return()
+ \\@unnamed$6 = fntype([], @void, cc=C)
+ \\@entry = fn(@unnamed$6, {
+ \\ %0 = returnvoid()
\\})
- \\@a = str("2\x08\x01\n")
- \\@9 = str("entry")
- \\@10 = ref(@9)
- \\@unnamed$14 = str("entry")
- \\@unnamed$15 = ref(@unnamed$14)
- \\@unnamed$16 = export(@unnamed$15, @entry)
+ \\@entry__anon_1 = str("2\x08\x01\n")
+ \\@9 = declref("9__anon_0")
+ \\@9__anon_0 = str("entry")
+ \\@unnamed$11 = str("entry")
+ \\@unnamed$12 = export(@unnamed$11, "entry")
\\
);
{
- var case = ctx.addZIRMulti("reference cycle with compile error in the cycle", linux_x64);
- case.addZIR(
+ var case = ctx.objZIR("reference cycle with compile error in the cycle", linux_x64);
+ case.addTransform(
\\@void = primitive(void)
\\@fnty = fntype([], @void, cc=C)
\\
\\@9 = str("entry")
- \\@10 = ref(@9)
- \\@11 = export(@10, @entry)
+ \\@11 = export(@9, "entry")
\\
\\@entry = fn(@fnty, {
\\ %0 = call(@a, [])
- \\ %1 = return()
+ \\ %1 = returnvoid()
\\})
\\
\\@a = fn(@fnty, {
\\ %0 = call(@b, [])
- \\ %1 = return()
+ \\ %1 = returnvoid()
\\})
\\
\\@b = fn(@fnty, {
\\ %0 = call(@a, [])
- \\ %1 = return()
+ \\ %1 = returnvoid()
\\})
,
\\@void = primitive(void)
\\@fnty = fntype([], @void, cc=C)
- \\@9 = str("entry")
- \\@10 = ref(@9)
- \\@unnamed$6 = str("entry")
- \\@unnamed$7 = ref(@unnamed$6)
- \\@unnamed$8 = export(@unnamed$7, @entry)
- \\@unnamed$12 = fntype([], @void, cc=C)
- \\@entry = fn(@unnamed$12, {
+ \\@9 = declref("9__anon_0")
+ \\@9__anon_0 = str("entry")
+ \\@unnamed$4 = str("entry")
+ \\@unnamed$5 = export(@unnamed$4, "entry")
+ \\@unnamed$6 = fntype([], @void, cc=C)
+ \\@entry = fn(@unnamed$6, {
\\ %0 = call(@a, [], modifier=auto)
- \\ %1 = return()
+ \\ %1 = returnvoid()
\\})
- \\@unnamed$17 = fntype([], @void, cc=C)
- \\@a = fn(@unnamed$17, {
+ \\@unnamed$8 = fntype([], @void, cc=C)
+ \\@a = fn(@unnamed$8, {
\\ %0 = call(@b, [], modifier=auto)
- \\ %1 = return()
+ \\ %1 = returnvoid()
\\})
- \\@unnamed$22 = fntype([], @void, cc=C)
- \\@b = fn(@unnamed$22, {
+ \\@unnamed$10 = fntype([], @void, cc=C)
+ \\@b = fn(@unnamed$10, {
\\ %0 = call(@a, [], modifier=auto)
- \\ %1 = return()
+ \\ %1 = returnvoid()
\\})
\\
);
@@ -145,65 +138,62 @@ pub fn addCases(ctx: *TestContext) void {
\\@fnty = fntype([], @void, cc=C)
\\
\\@9 = str("entry")
- \\@10 = ref(@9)
- \\@11 = export(@10, @entry)
+ \\@11 = export(@9, "entry")
\\
\\@entry = fn(@fnty, {
\\ %0 = call(@a, [])
- \\ %1 = return()
+ \\ %1 = returnvoid()
\\})
\\
\\@a = fn(@fnty, {
\\ %0 = call(@b, [])
- \\ %1 = return()
+ \\ %1 = returnvoid()
\\})
\\
\\@b = fn(@fnty, {
\\ %9 = compileerror("message")
\\ %0 = call(@a, [])
- \\ %1 = return()
+ \\ %1 = returnvoid()
\\})
,
&[_][]const u8{
- ":19:21: error: message",
+ ":18:21: error: message",
},
);
// Now we remove the call to `a`. `a` and `b` form a cycle, but no entry points are
// referencing either of them. This tests that the cycle is detected, and the error
// goes away.
- case.addZIR(
+ case.addTransform(
\\@void = primitive(void)
\\@fnty = fntype([], @void, cc=C)
\\
\\@9 = str("entry")
- \\@10 = ref(@9)
- \\@11 = export(@10, @entry)
+ \\@11 = export(@9, "entry")
\\
\\@entry = fn(@fnty, {
- \\ %1 = return()
+ \\ %0 = returnvoid()
\\})
\\
\\@a = fn(@fnty, {
\\ %0 = call(@b, [])
- \\ %1 = return()
+ \\ %1 = returnvoid()
\\})
\\
\\@b = fn(@fnty, {
\\ %9 = compileerror("message")
\\ %0 = call(@a, [])
- \\ %1 = return()
+ \\ %1 = returnvoid()
\\})
,
\\@void = primitive(void)
\\@fnty = fntype([], @void, cc=C)
- \\@9 = str("entry")
- \\@10 = ref(@9)
- \\@unnamed$6 = str("entry")
- \\@unnamed$7 = ref(@unnamed$6)
- \\@unnamed$8 = export(@unnamed$7, @entry)
- \\@unnamed$10 = fntype([], @void, cc=C)
- \\@entry = fn(@unnamed$10, {
- \\ %0 = return()
+ \\@9 = declref("9__anon_2")
+ \\@9__anon_2 = str("entry")
+ \\@unnamed$4 = str("entry")
+ \\@unnamed$5 = export(@unnamed$4, "entry")
+ \\@unnamed$6 = fntype([], @void, cc=C)
+ \\@entry = fn(@unnamed$6, {
+ \\ %0 = returnvoid()
\\})
\\
);
@@ -217,272 +207,101 @@ pub fn addCases(ctx: *TestContext) void {
return;
}
- ctx.addZIRCompareOutput(
- "hello world ZIR, update msg",
- &[_][]const u8{
- \\@noreturn = primitive(noreturn)
- \\@void = primitive(void)
- \\@usize = primitive(usize)
- \\@0 = int(0)
- \\@1 = int(1)
- \\@2 = int(2)
- \\@3 = int(3)
- \\
- \\@syscall_array = str("syscall")
- \\@sysoutreg_array = str("={rax}")
- \\@rax_array = str("{rax}")
- \\@rdi_array = str("{rdi}")
- \\@rcx_array = str("rcx")
- \\@r11_array = str("r11")
- \\@rdx_array = str("{rdx}")
- \\@rsi_array = str("{rsi}")
- \\@memory_array = str("memory")
- \\@len_array = str("len")
- \\
- \\@msg = str("Hello, world!\n")
- \\
- \\@start_fnty = fntype([], @noreturn, cc=Naked)
- \\@start = fn(@start_fnty, {
- \\ %SYS_exit_group = int(231)
- \\ %exit_code = as(@usize, @0)
- \\
- \\ %syscall = ref(@syscall_array)
- \\ %sysoutreg = ref(@sysoutreg_array)
- \\ %rax = ref(@rax_array)
- \\ %rdi = ref(@rdi_array)
- \\ %rcx = ref(@rcx_array)
- \\ %rdx = ref(@rdx_array)
- \\ %rsi = ref(@rsi_array)
- \\ %r11 = ref(@r11_array)
- \\ %memory = ref(@memory_array)
- \\
- \\ %SYS_write = as(@usize, @1)
- \\ %STDOUT_FILENO = as(@usize, @1)
- \\
- \\ %msg_ptr = ref(@msg)
- \\ %msg_addr = ptrtoint(%msg_ptr)
- \\
- \\ %len_name = ref(@len_array)
- \\ %msg_len_ptr = fieldptr(%msg_ptr, %len_name)
- \\ %msg_len = deref(%msg_len_ptr)
- \\ %rc_write = asm(%syscall, @usize,
- \\ volatile=1,
- \\ output=%sysoutreg,
- \\ inputs=[%rax, %rdi, %rsi, %rdx],
- \\ clobbers=[%rcx, %r11, %memory],
- \\ args=[%SYS_write, %STDOUT_FILENO, %msg_addr, %msg_len])
- \\
- \\ %rc_exit = asm(%syscall, @usize,
- \\ volatile=1,
- \\ output=%sysoutreg,
- \\ inputs=[%rax, %rdi],
- \\ clobbers=[%rcx, %r11, %memory],
- \\ args=[%SYS_exit_group, %exit_code])
- \\
- \\ %99 = unreachable()
- \\});
- \\
- \\@9 = str("_start")
- \\@10 = ref(@9)
- \\@11 = export(@10, @start)
- ,
- \\@noreturn = primitive(noreturn)
- \\@void = primitive(void)
- \\@usize = primitive(usize)
- \\@0 = int(0)
- \\@1 = int(1)
- \\@2 = int(2)
- \\@3 = int(3)
- \\
- \\@syscall_array = str("syscall")
- \\@sysoutreg_array = str("={rax}")
- \\@rax_array = str("{rax}")
- \\@rdi_array = str("{rdi}")
- \\@rcx_array = str("rcx")
- \\@r11_array = str("r11")
- \\@rdx_array = str("{rdx}")
- \\@rsi_array = str("{rsi}")
- \\@memory_array = str("memory")
- \\@len_array = str("len")
- \\
- \\@msg = str("Hello, world!\n")
- \\@msg2 = str("HELL WORLD\n")
- \\
- \\@start_fnty = fntype([], @noreturn, cc=Naked)
- \\@start = fn(@start_fnty, {
- \\ %SYS_exit_group = int(231)
- \\ %exit_code = as(@usize, @0)
- \\
- \\ %syscall = ref(@syscall_array)
- \\ %sysoutreg = ref(@sysoutreg_array)
- \\ %rax = ref(@rax_array)
- \\ %rdi = ref(@rdi_array)
- \\ %rcx = ref(@rcx_array)
- \\ %rdx = ref(@rdx_array)
- \\ %rsi = ref(@rsi_array)
- \\ %r11 = ref(@r11_array)
- \\ %memory = ref(@memory_array)
- \\
- \\ %SYS_write = as(@usize, @1)
- \\ %STDOUT_FILENO = as(@usize, @1)
- \\
- \\ %msg_ptr = ref(@msg2)
- \\ %msg_addr = ptrtoint(%msg_ptr)
- \\
- \\ %len_name = ref(@len_array)
- \\ %msg_len_ptr = fieldptr(%msg_ptr, %len_name)
- \\ %msg_len = deref(%msg_len_ptr)
- \\ %rc_write = asm(%syscall, @usize,
- \\ volatile=1,
- \\ output=%sysoutreg,
- \\ inputs=[%rax, %rdi, %rsi, %rdx],
- \\ clobbers=[%rcx, %r11, %memory],
- \\ args=[%SYS_write, %STDOUT_FILENO, %msg_addr, %msg_len])
- \\
- \\ %rc_exit = asm(%syscall, @usize,
- \\ volatile=1,
- \\ output=%sysoutreg,
- \\ inputs=[%rax, %rdi],
- \\ clobbers=[%rcx, %r11, %memory],
- \\ args=[%SYS_exit_group, %exit_code])
- \\
- \\ %99 = unreachable()
- \\});
- \\
- \\@9 = str("_start")
- \\@10 = ref(@9)
- \\@11 = export(@10, @start)
- ,
- \\@noreturn = primitive(noreturn)
- \\@void = primitive(void)
- \\@usize = primitive(usize)
- \\@0 = int(0)
- \\@1 = int(1)
- \\@2 = int(2)
- \\@3 = int(3)
- \\
- \\@syscall_array = str("syscall")
- \\@sysoutreg_array = str("={rax}")
- \\@rax_array = str("{rax}")
- \\@rdi_array = str("{rdi}")
- \\@rcx_array = str("rcx")
- \\@r11_array = str("r11")
- \\@rdx_array = str("{rdx}")
- \\@rsi_array = str("{rsi}")
- \\@memory_array = str("memory")
- \\@len_array = str("len")
- \\
- \\@msg = str("Hello, world!\n")
- \\@msg2 = str("Editing the same msg2 decl but this time with a much longer message which will\ncause the data to need to be relocated in virtual address space.\n")
- \\
- \\@start_fnty = fntype([], @noreturn, cc=Naked)
- \\@start = fn(@start_fnty, {
- \\ %SYS_exit_group = int(231)
- \\ %exit_code = as(@usize, @0)
- \\
- \\ %syscall = ref(@syscall_array)
- \\ %sysoutreg = ref(@sysoutreg_array)
- \\ %rax = ref(@rax_array)
- \\ %rdi = ref(@rdi_array)
- \\ %rcx = ref(@rcx_array)
- \\ %rdx = ref(@rdx_array)
- \\ %rsi = ref(@rsi_array)
- \\ %r11 = ref(@r11_array)
- \\ %memory = ref(@memory_array)
- \\
- \\ %SYS_write = as(@usize, @1)
- \\ %STDOUT_FILENO = as(@usize, @1)
- \\
- \\ %msg_ptr = ref(@msg2)
- \\ %msg_addr = ptrtoint(%msg_ptr)
- \\
- \\ %len_name = ref(@len_array)
- \\ %msg_len_ptr = fieldptr(%msg_ptr, %len_name)
- \\ %msg_len = deref(%msg_len_ptr)
- \\ %rc_write = asm(%syscall, @usize,
- \\ volatile=1,
- \\ output=%sysoutreg,
- \\ inputs=[%rax, %rdi, %rsi, %rdx],
- \\ clobbers=[%rcx, %r11, %memory],
- \\ args=[%SYS_write, %STDOUT_FILENO, %msg_addr, %msg_len])
- \\
- \\ %rc_exit = asm(%syscall, @usize,
- \\ volatile=1,
- \\ output=%sysoutreg,
- \\ inputs=[%rax, %rdi],
- \\ clobbers=[%rcx, %r11, %memory],
- \\ args=[%SYS_exit_group, %exit_code])
- \\
- \\ %99 = unreachable()
- \\});
- \\
- \\@9 = str("_start")
- \\@10 = ref(@9)
- \\@11 = export(@10, @start)
- },
- &[_][]const u8{
- \\Hello, world!
- \\
- ,
- \\HELL WORLD
- \\
- ,
- \\Editing the same msg2 decl but this time with a much longer message which will
- \\cause the data to need to be relocated in virtual address space.
- \\
- },
+ ctx.compareOutputZIR("hello world ZIR",
+ \\@noreturn = primitive(noreturn)
+ \\@void = primitive(void)
+ \\@usize = primitive(usize)
+ \\@0 = int(0)
+ \\@1 = int(1)
+ \\@2 = int(2)
+ \\@3 = int(3)
+ \\
+ \\@msg = str("Hello, world!\n")
+ \\
+ \\@start_fnty = fntype([], @noreturn, cc=Naked)
+ \\@start = fn(@start_fnty, {
+ \\ %SYS_exit_group = int(231)
+ \\ %exit_code = as(@usize, @0)
+ \\
+ \\ %syscall = str("syscall")
+ \\ %sysoutreg = str("={rax}")
+ \\ %rax = str("{rax}")
+ \\ %rdi = str("{rdi}")
+ \\ %rcx = str("rcx")
+ \\ %rdx = str("{rdx}")
+ \\ %rsi = str("{rsi}")
+ \\ %r11 = str("r11")
+ \\ %memory = str("memory")
+ \\
+ \\ %SYS_write = as(@usize, @1)
+ \\ %STDOUT_FILENO = as(@usize, @1)
+ \\
+ \\ %msg_addr = ptrtoint(@msg)
+ \\
+ \\ %len_name = str("len")
+ \\ %msg_len_ptr = fieldptr(@msg, %len_name)
+ \\ %msg_len = deref(%msg_len_ptr)
+ \\ %rc_write = asm(%syscall, @usize,
+ \\ volatile=1,
+ \\ output=%sysoutreg,
+ \\ inputs=[%rax, %rdi, %rsi, %rdx],
+ \\ clobbers=[%rcx, %r11, %memory],
+ \\ args=[%SYS_write, %STDOUT_FILENO, %msg_addr, %msg_len])
+ \\
+ \\ %rc_exit = asm(%syscall, @usize,
+ \\ volatile=1,
+ \\ output=%sysoutreg,
+ \\ inputs=[%rax, %rdi],
+ \\ clobbers=[%rcx, %r11, %memory],
+ \\ args=[%SYS_exit_group, %exit_code])
+ \\
+ \\ %99 = unreachable()
+ \\});
+ \\
+ \\@9 = str("_start")
+ \\@11 = export(@9, "start")
+ ,
+ \\Hello, world!
+ \\
);
- ctx.addZIRCompareOutput(
- "function call with no args no return value",
- &[_][]const u8{
- \\@noreturn = primitive(noreturn)
- \\@void = primitive(void)
- \\@usize = primitive(usize)
- \\@0 = int(0)
- \\@1 = int(1)
- \\@2 = int(2)
- \\@3 = int(3)
- \\
- \\@syscall_array = str("syscall")
- \\@sysoutreg_array = str("={rax}")
- \\@rax_array = str("{rax}")
- \\@rdi_array = str("{rdi}")
- \\@rcx_array = str("rcx")
- \\@r11_array = str("r11")
- \\@memory_array = str("memory")
- \\
- \\@exit0_fnty = fntype([], @noreturn)
- \\@exit0 = fn(@exit0_fnty, {
- \\ %SYS_exit_group = int(231)
- \\ %exit_code = as(@usize, @0)
- \\
- \\ %syscall = ref(@syscall_array)
- \\ %sysoutreg = ref(@sysoutreg_array)
- \\ %rax = ref(@rax_array)
- \\ %rdi = ref(@rdi_array)
- \\ %rcx = ref(@rcx_array)
- \\ %r11 = ref(@r11_array)
- \\ %memory = ref(@memory_array)
- \\
- \\ %rc = asm(%syscall, @usize,
- \\ volatile=1,
- \\ output=%sysoutreg,
- \\ inputs=[%rax, %rdi],
- \\ clobbers=[%rcx, %r11, %memory],
- \\ args=[%SYS_exit_group, %exit_code])
- \\
- \\ %99 = unreachable()
- \\});
- \\
- \\@start_fnty = fntype([], @noreturn, cc=Naked)
- \\@start = fn(@start_fnty, {
- \\ %0 = call(@exit0, [])
- \\})
- \\@9 = str("_start")
- \\@10 = ref(@9)
- \\@11 = export(@10, @start)
- },
- &[_][]const u8{""},
- );
+ ctx.compareOutputZIR("function call with no args no return value",
+ \\@noreturn = primitive(noreturn)
+ \\@void = primitive(void)
+ \\@usize = primitive(usize)
+ \\@0 = int(0)
+ \\@1 = int(1)
+ \\@2 = int(2)
+ \\@3 = int(3)
+ \\
+ \\@exit0_fnty = fntype([], @noreturn)
+ \\@exit0 = fn(@exit0_fnty, {
+ \\ %SYS_exit_group = int(231)
+ \\ %exit_code = as(@usize, @0)
+ \\
+ \\ %syscall = str("syscall")
+ \\ %sysoutreg = str("={rax}")
+ \\ %rax = str("{rax}")
+ \\ %rdi = str("{rdi}")
+ \\ %rcx = str("rcx")
+ \\ %r11 = str("r11")
+ \\ %memory = str("memory")
+ \\
+ \\ %rc = asm(%syscall, @usize,
+ \\ volatile=1,
+ \\ output=%sysoutreg,
+ \\ inputs=[%rax, %rdi],
+ \\ clobbers=[%rcx, %r11, %memory],
+ \\ args=[%SYS_exit_group, %exit_code])
+ \\
+ \\ %99 = unreachable()
+ \\});
+ \\
+ \\@start_fnty = fntype([], @noreturn, cc=Naked)
+ \\@start = fn(@start_fnty, {
+ \\ %0 = call(@exit0, [])
+ \\})
+ \\@9 = str("_start")
+ \\@11 = export(@9, "start")
+ , "");
}
diff --git a/test/standalone/guess_number/main.zig b/test/standalone/guess_number/main.zig
index 5a82ec81ee..87f9f9a1e7 100644
--- a/test/standalone/guess_number/main.zig
+++ b/test/standalone/guess_number/main.zig
@@ -4,7 +4,7 @@ const io = std.io;
const fmt = std.fmt;
pub fn main() !void {
- const stdout = io.getStdOut().outStream();
+ const stdout = io.getStdOut().writer();
const stdin = io.getStdIn();
try stdout.print("Welcome to the Guess Number Game in Zig.\n", .{});
diff --git a/test/tests.zig b/test/tests.zig
index 0cf5ec28dd..6598a05ea7 100644
--- a/test/tests.zig
+++ b/test/tests.zig
@@ -537,6 +537,7 @@ pub fn addPkgTests(
these_tests.enable_qemu = is_qemu_enabled;
these_tests.enable_wasmtime = is_wasmtime_enabled;
these_tests.glibc_multi_install_dir = glibc_dir;
+ these_tests.addIncludeDir("test");
step.dependOn(&these_tests.step);
}
diff --git a/test/translate_c.zig b/test/translate_c.zig
index 1c23afdb30..d12b2ab860 100644
--- a/test/translate_c.zig
+++ b/test/translate_c.zig
@@ -3,6 +3,31 @@ const std = @import("std");
const CrossTarget = std.zig.CrossTarget;
pub fn addCases(cases: *tests.TranslateCContext) void {
+ cases.add("initializer list macro",
+ \\typedef struct Color {
+ \\ unsigned char r;
+ \\ unsigned char g;
+ \\ unsigned char b;
+ \\ unsigned char a;
+ \\} Color;
+ \\#define CLITERAL(type) (type)
+ \\#define LIGHTGRAY CLITERAL(Color){ 200, 200, 200, 255 } // Light Gray
+ , &[_][]const u8{ // TODO properly translate this
+ \\pub const struct_Color = extern struct {
+ \\ r: u8,
+ \\ g: u8,
+ \\ b: u8,
+ \\ a: u8,
+ \\};
+ \\pub const Color = struct_Color;
+ ,
+ \\pub inline fn CLITERAL(type_1: anytype) @TypeOf(type_1) {
+ \\ return type_1;
+ \\}
+ ,
+ \\pub const LIGHTGRAY = @import("std").mem.zeroInit(CLITERAL(Color), .{ 200, 200, 200, 255 });
+ });
+
cases.add("complex switch",
\\int main() {
\\ int i = 2;
@@ -21,7 +46,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
cases.add("correct semicolon after infixop",
\\#define __ferror_unlocked_body(_fp) (((_fp)->_flags & _IO_ERR_SEEN) != 0)
, &[_][]const u8{
- \\pub inline fn __ferror_unlocked_body(_fp: var) @TypeOf(((_fp.*._flags) & _IO_ERR_SEEN) != 0) {
+ \\pub inline fn __ferror_unlocked_body(_fp: anytype) @TypeOf(((_fp.*._flags) & _IO_ERR_SEEN) != 0) {
\\ return ((_fp.*._flags) & _IO_ERR_SEEN) != 0;
\\}
});
@@ -30,7 +55,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
\\#define FOO(x) ((x >= 0) + (x >= 0))
\\#define BAR 1 && 2 > 4
, &[_][]const u8{
- \\pub inline fn FOO(x: var) @TypeOf(@boolToInt(x >= 0) + @boolToInt(x >= 0)) {
+ \\pub inline fn FOO(x: anytype) @TypeOf(@boolToInt(x >= 0) + @boolToInt(x >= 0)) {
\\ return @boolToInt(x >= 0) + @boolToInt(x >= 0);
\\}
,
@@ -81,7 +106,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
\\ break :blk bar;
\\};
,
- \\pub inline fn bar(x: var) @TypeOf(baz(1, 2)) {
+ \\pub inline fn bar(x: anytype) @TypeOf(baz(1, 2)) {
\\ return blk: {
\\ _ = &x;
\\ _ = 3;
@@ -1473,7 +1498,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
cases.add("macro pointer cast",
\\#define NRF_GPIO ((NRF_GPIO_Type *) NRF_GPIO_BASE)
, &[_][]const u8{
- \\pub const NRF_GPIO = (if (@typeInfo(@TypeOf(NRF_GPIO_BASE)) == .Pointer) @ptrCast([*c]NRF_GPIO_Type, @alignCast(@alignOf([*c]NRF_GPIO_Type.Child), NRF_GPIO_BASE)) else if (@typeInfo(@TypeOf(NRF_GPIO_BASE)) == .Int and @typeInfo([*c]NRF_GPIO_Type) == .Pointer) @intToPtr([*c]NRF_GPIO_Type, NRF_GPIO_BASE) else @as([*c]NRF_GPIO_Type, NRF_GPIO_BASE));
+ \\pub const NRF_GPIO = (@import("std").meta.cast([*c]NRF_GPIO_Type, NRF_GPIO_BASE));
});
cases.add("basic macro function",
@@ -1483,11 +1508,11 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
, &[_][]const u8{
\\pub extern var c: c_int;
,
- \\pub inline fn BASIC(c_1: var) @TypeOf(c_1 * 2) {
+ \\pub inline fn BASIC(c_1: anytype) @TypeOf(c_1 * 2) {
\\ return c_1 * 2;
\\}
,
- \\pub inline fn FOO(L: var, b: var) @TypeOf(L + b) {
+ \\pub inline fn FOO(L: anytype, b: anytype) @TypeOf(L + b) {
\\ return L + b;
\\}
});
@@ -2123,7 +2148,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
cases.add("macro call",
\\#define CALL(arg) bar(arg)
, &[_][]const u8{
- \\pub inline fn CALL(arg: var) @TypeOf(bar(arg)) {
+ \\pub inline fn CALL(arg: anytype) @TypeOf(bar(arg)) {
\\ return bar(arg);
\\}
});
@@ -2683,11 +2708,11 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
\\#define FOO(bar) baz((void *)(baz))
\\#define BAR (void*) a
, &[_][]const u8{
- \\pub inline fn FOO(bar: var) @TypeOf(baz((if (@typeInfo(@TypeOf(baz)) == .Pointer) @ptrCast(?*c_void, @alignCast(@alignOf(?*c_void.Child), baz)) else if (@typeInfo(@TypeOf(baz)) == .Int and @typeInfo(?*c_void) == .Pointer) @intToPtr(?*c_void, baz) else @as(?*c_void, baz)))) {
- \\ return baz((if (@typeInfo(@TypeOf(baz)) == .Pointer) @ptrCast(?*c_void, @alignCast(@alignOf(?*c_void.Child), baz)) else if (@typeInfo(@TypeOf(baz)) == .Int and @typeInfo(?*c_void) == .Pointer) @intToPtr(?*c_void, baz) else @as(?*c_void, baz)));
+ \\pub inline fn FOO(bar: anytype) @TypeOf(baz((@import("std").meta.cast(?*c_void, baz)))) {
+ \\ return baz((@import("std").meta.cast(?*c_void, baz)));
\\}
,
- \\pub const BAR = (if (@typeInfo(@TypeOf(a)) == .Pointer) @ptrCast(?*c_void, @alignCast(@alignOf(?*c_void.Child), a)) else if (@typeInfo(@TypeOf(a)) == .Int and @typeInfo(?*c_void) == .Pointer) @intToPtr(?*c_void, a) else @as(?*c_void, a));
+ \\pub const BAR = (@import("std").meta.cast(?*c_void, a));
});
cases.add("macro conditional operator",
@@ -2713,11 +2738,11 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
\\#define MIN(a, b) ((b) < (a) ? (b) : (a))
\\#define MAX(a, b) ((b) > (a) ? (b) : (a))
, &[_][]const u8{
- \\pub inline fn MIN(a: var, b: var) @TypeOf(if (b < a) b else a) {
+ \\pub inline fn MIN(a: anytype, b: anytype) @TypeOf(if (b < a) b else a) {
\\ return if (b < a) b else a;
\\}
,
- \\pub inline fn MAX(a: var, b: var) @TypeOf(if (b > a) b else a) {
+ \\pub inline fn MAX(a: anytype, b: anytype) @TypeOf(if (b > a) b else a) {
\\ return if (b > a) b else a;
\\}
});
@@ -2797,7 +2822,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
\\pub fn a() callconv(.C) void {}
\\pub fn b() callconv(.C) void {}
\\pub export fn c() void {}
- \\pub fn foo() callconv(.C) void {}
+ \\pub fn foo(...) callconv(.C) void {}
});
cases.add("casting away const and volatile",
@@ -2905,8 +2930,8 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
\\#define DefaultScreen(dpy) (((_XPrivDisplay)(dpy))->default_screen)
\\
, &[_][]const u8{
- \\pub inline fn DefaultScreen(dpy: var) @TypeOf((if (@typeInfo(@TypeOf(dpy)) == .Pointer) @ptrCast(_XPrivDisplay, @alignCast(@alignOf(_XPrivDisplay.Child), dpy)) else if (@typeInfo(@TypeOf(dpy)) == .Int and @typeInfo(_XPrivDisplay) == .Pointer) @intToPtr(_XPrivDisplay, dpy) else @as(_XPrivDisplay, dpy)).*.default_screen) {
- \\ return (if (@typeInfo(@TypeOf(dpy)) == .Pointer) @ptrCast(_XPrivDisplay, @alignCast(@alignOf(_XPrivDisplay.Child), dpy)) else if (@typeInfo(@TypeOf(dpy)) == .Int and @typeInfo(_XPrivDisplay) == .Pointer) @intToPtr(_XPrivDisplay, dpy) else @as(_XPrivDisplay, dpy)).*.default_screen;
+ \\pub inline fn DefaultScreen(dpy: anytype) @TypeOf((@import("std").meta.cast(_XPrivDisplay, dpy)).*.default_screen) {
+ \\ return (@import("std").meta.cast(_XPrivDisplay, dpy)).*.default_screen;
\\}
});
@@ -2914,9 +2939,9 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
\\#define NULL ((void*)0)
\\#define FOO ((int)0x8000)
, &[_][]const u8{
- \\pub const NULL = (if (@typeInfo(?*c_void) == .Pointer) @intToPtr(?*c_void, 0) else @as(?*c_void, 0));
+ \\pub const NULL = (@import("std").meta.cast(?*c_void, 0));
,
- \\pub const FOO = (if (@typeInfo(c_int) == .Pointer) @intToPtr(c_int, 0x8000) else @as(c_int, 0x8000));
+ \\pub const FOO = (@import("std").meta.cast(c_int, 0x8000));
});
if (std.Target.current.abi == .msvc) {
The code samples in this document are compiled and tested as part of the main test suite of Zig. +
+This HTML document depends on no external files, so you can use it offline.
@@ -231,26 +233,113 @@ const std = @import("std"); pub fn main() !void { - const stdout = std.io.getStdOut().outStream(); + const stdout = std.io.getStdOut().writer(); try stdout.print("Hello, {}!\n", .{"world"}); } {#code_end#}
- Usually you don't want to write to stdout. You want to write to stderr. And you
- don't care if it fails. It's more like a warning message that you want
- to emit. For that you can use a simpler API:
+ The Zig code sample above demonstrates one way to create a program that will output Hello, world!.
+ The code sample shows the contents of a file named hello.zig. Files storing Zig
+ source code are {#link|UTF-8 encoded|Source Encoding#} text files. The files storing
+ Zig source code are usually named with the .zig extension.
+
+ Following the hello.zig Zig code sample, the {#link|Zig Build System#} is used
+ to build an executable program from the hello.zig source code. Then, the
+ hello program is executed showing its output Hello, world!. The
+ lines beginning with $ represent command line prompts and a command.
+ Everything else is program output.
+
+ The code sample begins by adding Zig's Standard Library to the build using the {#link|@import#} builtin function.
+ The {#syntax#}@import("std"){#endsyntax#} function call creates a structure to represent the Standard Library.
+ The code then makes a {#link|top-level declaration|Global Variables#} of a
+ {#link|constant identifier|Assignment#}, named std, for easy access to
+ Zig's standard library.
+
+ Next, a {#link|public function|Functions#}, {#syntax#}pub fn{#endsyntax#}, named main
+ is declared. The main function is necessary because it tells the Zig compiler where the start of
+ the program exists. Programs designed to be executed will need a {#syntax#}pub fn main{#endsyntax#} function.
+ For more advanced use cases, Zig offers other features to inform the compiler where the start of
+ the program exists. Libraries, on the other hand, do not need a main function because
+ library code is usually called by other programs.
+
+ A function is a block of any number of statements and expressions that, as a whole, perform a task. + Functions may or may not return data after they are done performing their task. If a function + cannot perform its task, it might return an error. Zig makes all of this explicit. +
+
+ In the hello.zig code sample, the main function is declared
+ with the {#syntax#}!void{#endsyntax#} return type. This return type is known as an {#link|Error Union Type#}.
+ This syntax tells the Zig compiler that the function will either return an
+ error or a value. An error union type combines an {#link|Error Set Type#} and a {#link|Primitive Type|Primitive Types#}.
+ The full form of an error union type is
+ <error set type>{#syntax#}!{#endsyntax#}<primitive type>. In the code
+ sample, the error set type is not explicitly written on the left side of the {#syntax#}!{#endsyntax#} operator.
+ When written this way, the error set type is a special kind of error union type that has an
+ {#link|inferred error set type|Inferred Error Sets#}. The {#syntax#}void{#endsyntax#} after the {#syntax#}!{#endsyntax#} operator
+ tells the compiler that the function will not return a value under normal circumstances (i.e. no errors occur).
+
+ Note to experienced programmers: Zig also has the boolean {#link|operator|Operators#} {#syntax#}!a{#endsyntax#}
+ where {#syntax#}a{#endsyntax#} is a value of type {#syntax#}bool{#endsyntax#}. Error union types contain the
+ name of the type in the syntax: {#syntax#}!{#endsyntax#}<primitive type>.
+
+ In Zig, a function's block of statements and expressions are surrounded by { and
+ } curly-braces. Inside of the main function are expressions that perform
+ the task of outputting Hello, world! to standard output.
+
+ First, a constant identifier, stdout, is initialized to represent standard output's
+ writer. Then, the program tries to print the Hello, world!
+ message to standard output.
+
+ Functions sometimes need information to perform their task. In Zig, information is passed
+ to functions between open ( and close ) parenthesis placed after
+ the function's name. This information is also known as arguments. When there are
+ multiple arguments passed to a function, they are separated by commas ,.
+
+ The two arguments passed to the stdout.print() function, "Hello, {}!\n"
+ and .{"world"}, are evaluated at {#link|compile-time|comptime#}. The code sample is
+ purposely written to show how to perform {#link|string|String Literals and Character Literals#}
+ substitution in the print function. The curly-braces inside of the first argument
+ are substituted with the compile-time known value inside of the second argument
+ (known as an {#link|anonymous struct literal|Anonymous Struct Literals#}). The \n
+ inside of the double-quotes of the first argument is the {#link|escape sequence|Escape Sequences#} for the
+ newline character. The {#link|try#} expression evaluates the result of stdout.print.
+ If the result is an error, then the {#syntax#}try{#endsyntax#} expression will return from
+ main with the error. Otherwise, the program will continue. In this case, there are no
+ more statements or expressions left to execute in the main function, so the program exits.
+
+ In Zig, the standard output writer's print function is allowed to fail because
+ it is actually a function defined as part of a generic Writer. Consider a generic Writer that
+ represents writing data to a file. When the disk is full, a write to the file will fail.
+ However, we typically do not expect writing text to the standard output to fail. To avoid having
+ to handle the failure case of printing to standard output, you can use alternate functions: the
+ std.log function for proper logging or the std.debug.print function.
+ This documentation will use the latter option to print to standard error (stderr) and silently return
+ on failure. The next code sample, hello_again.zig demonstrates the use of
+ std.debug.print.
+
- Note that you can leave off the {#syntax#}!{#endsyntax#} from the return type because {#syntax#}warn{#endsyntax#} cannot fail.
+ Note that you can leave off the {#syntax#}!{#endsyntax#} from the return type because std.debug.print cannot fail.
User documentation that doesn't belong to whatever + immediately follows it, like package-level documentation, goes + in top-level doc comments. A top-level doc comment is one that + begins with two slashes and an exclamation point: + {#syntax#}//!{#endsyntax#}.
+ {#code_begin|syntax|tldoc_comments#} +//! This module provides functions for retrieving the current date and +//! time with varying degrees of precision and accuracy. It does not +//! depend on libc, but will use functions from it if available. + {#code_end#} + {#header_close#} {#header_close#} {#header_open|Values#} {#code_begin|exe|values#} // Top-level declarations are order-independent: -const warn = std.debug.warn; +const print = std.debug.print; const std = @import("std"); const os = std.os; const assert = std.debug.assert; @@ -315,14 +416,14 @@ const assert = std.debug.assert; pub fn main() void { // integers const one_plus_one: i32 = 1 + 1; - warn("1 + 1 = {}\n", .{one_plus_one}); + print("1 + 1 = {}\n", .{one_plus_one}); // floats const seven_div_three: f32 = 7.0 / 3.0; - warn("7.0 / 3.0 = {}\n", .{seven_div_three}); + print("7.0 / 3.0 = {}\n", .{seven_div_three}); // boolean - warn("{}\n{}\n{}\n", .{ + print("{}\n{}\n{}\n", .{ true and false, true or false, !true, @@ -332,7 +433,7 @@ pub fn main() void { var optional_value: ?[]const u8 = null; assert(optional_value == null); - warn("\noptional 1\ntype: {}\nvalue: {}\n", .{ + print("\noptional 1\ntype: {}\nvalue: {}\n", .{ @typeName(@TypeOf(optional_value)), optional_value, }); @@ -340,7 +441,7 @@ pub fn main() void { optional_value = "hi"; assert(optional_value != null); - warn("\noptional 2\ntype: {}\nvalue: {}\n", .{ + print("\noptional 2\ntype: {}\nvalue: {}\n", .{ @typeName(@TypeOf(optional_value)), optional_value, }); @@ -348,14 +449,14 @@ pub fn main() void { // error union var number_or_error: anyerror!i32 = error.ArgNotFound; - warn("\nerror union 1\ntype: {}\nvalue: {}\n", .{ + print("\nerror union 1\ntype: {}\nvalue: {}\n", .{ @typeName(@TypeOf(number_or_error)), number_or_error, }); number_or_error = 1234; - warn("\nerror union 2\ntype: {}\nvalue: {}\n", .{ + print("\nerror union 2\ntype: {}\nvalue: {}\n", .{ @typeName(@TypeOf(number_or_error)), number_or_error, }); @@ -994,15 +1095,15 @@ export fn foo_optimized(x: f64) f64 { which operates in strict mode. {#code_begin|exe|float_mode#} {#code_link_object|foo#} -const warn = @import("std").debug.warn; +const print = @import("std").debug.print; extern fn foo_strict(x: f64) f64; extern fn foo_optimized(x: f64) f64; pub fn main() void { const x = 0.001; - warn("optimized = {}\n", .{foo_optimized(x)}); - warn("strict = {}\n", .{foo_strict(x)}); + print("optimized = {}\n", .{foo_optimized(x)}); + print("strict = {}\n", .{foo_strict(x)}); } {#code_end#} {#see_also|@setFloatMode|Division by Zero#} @@ -1786,7 +1887,7 @@ test "fully anonymous list literal" { dump(.{ @as(u32, 1234), @as(f64, 12.34), true, "hi"}); } -fn dump(args: var) void { +fn dump(args: anytype) void { assert(args.@"0" == 1234); assert(args.@"1" == 12.34); assert(args.@"2"); @@ -1849,7 +1950,7 @@ test "null terminated array" { {#header_open|Vectors#}- A vector is a group of {#link|Integers#}, {#link|Floats#}, or {#link|Pointers#} which are operated on + A vector is a group of booleans, {#link|Integers#}, {#link|Floats#}, or {#link|Pointers#} which are operated on in parallel using a single instruction ({#link|SIMD#}). Vector types are created with the builtin function {#link|@Type#}, or using the shorthand as {#syntax#}std.meta.Vector{#endsyntax#}.
@@ -2668,9 +2769,9 @@ const std = @import("std"); pub fn main() void { const Foo = struct {}; - std.debug.warn("variable: {}\n", .{@typeName(Foo)}); - std.debug.warn("anonymous: {}\n", .{@typeName(struct {})}); - std.debug.warn("function: {}\n", .{@typeName(List(i32))}); + std.debug.print("variable: {}\n", .{@typeName(Foo)}); + std.debug.print("anonymous: {}\n", .{@typeName(struct {})}); + std.debug.print("function: {}\n", .{@typeName(List(i32))}); } fn List(comptime T: type) type { @@ -2718,7 +2819,7 @@ test "fully anonymous struct" { }); } -fn dump(args: var) void { +fn dump(args: anytype) void { assert(args.int == 1234); assert(args.float == 12.34); assert(args.b); @@ -3862,6 +3963,48 @@ test "if error union" { unreachable; } } + +test "if error union with optional" { + // If expressions test for errors before unwrapping optionals. + // The |optional_value| capture's type is ?u32. + + const a: anyerror!?u32 = 0; + if (a) |optional_value| { + assert(optional_value.? == 0); + } else |err| { + unreachable; + } + + const b: anyerror!?u32 = null; + if (b) |optional_value| { + assert(optional_value == null); + } else |err| { + unreachable; + } + + const c: anyerror!?u32 = error.BadValue; + if (c) |optional_value| { + unreachable; + } else |err| { + assert(err == error.BadValue); + } + + // Access the value by reference by using a pointer capture each time. + var d: anyerror!?u32 = 3; + if (d) |*optional_value| { + if (optional_value.*) |*value| { + value.* = 9; + } + } else |err| { + unreachable; + } + + if (d) |optional_value| { + assert(optional_value.? == 9); + } else |err| { + unreachable; + } +} {#code_end#} {#see_also|Optionals|Errors#} {#header_close#} @@ -3869,7 +4012,7 @@ test "if error union" { {#code_begin|test|defer#} const std = @import("std"); const assert = std.debug.assert; -const warn = std.debug.warn; +const print = std.debug.print; // defer will execute an expression at the end of the current scope. fn deferExample() usize { @@ -3892,18 +4035,18 @@ test "defer basics" { // If multiple defer statements are specified, they will be executed in // the reverse order they were run. fn deferUnwindExample() void { - warn("\n", .{}); + print("\n", .{}); defer { - warn("1 ", .{}); + print("1 ", .{}); } defer { - warn("2 ", .{}); + print("2 ", .{}); } if (false) { // defers are not run if they are never executed. defer { - warn("3 ", .{}); + print("3 ", .{}); } } } @@ -3918,15 +4061,15 @@ test "defer unwinding" { // This is especially useful in allowing a function to clean up properly // on error, and replaces goto error handling tactics as seen in c. fn deferErrorExample(is_error: bool) !void { - warn("\nstart of function\n", .{}); + print("\nstart of function\n", .{}); // This will always be executed on exit defer { - warn("end of function\n", .{}); + print("end of function\n", .{}); } errdefer { - warn("encountered an error!\n", .{}); + print("encountered an error!\n", .{}); } if (is_error) { @@ -4140,14 +4283,14 @@ test "pass struct to function" { {#header_close#} {#header_open|Function Parameter Type Inference#}- Function parameters can be declared with {#syntax#}var{#endsyntax#} in place of the type. + Function parameters can be declared with {#syntax#}anytype{#endsyntax#} in place of the type. In this case the parameter types will be inferred when the function is called. Use {#link|@TypeOf#} and {#link|@typeInfo#} to get information about the inferred type.
{#code_begin|test#} const assert = @import("std").debug.assert; -fn addFortyTwo(x: var) @TypeOf(x) { +fn addFortyTwo(x: anytype) @TypeOf(x) { return x + 42; } @@ -5364,11 +5507,11 @@ const std = @import("std"); const assert = std.debug.assert; test "turn HashMap into a set with void" { - var map = std.HashMap(i32, void, hash_i32, eql_i32).init(std.testing.allocator); + var map = std.AutoHashMap(i32, void).init(std.testing.allocator); defer map.deinit(); - _ = try map.put(1, {}); - _ = try map.put(2, {}); + try map.put(1, {}); + try map.put(2, {}); assert(map.contains(2)); assert(!map.contains(3)); @@ -5376,14 +5519,6 @@ test "turn HashMap into a set with void" { _ = map.remove(2); assert(!map.contains(2)); } - -fn hash_i32(x: i32) u32 { - return @bitCast(u32, x); -} - -fn eql_i32(a: i32, b: i32) bool { - return a == b; -} {#code_end#}Note that this is different from using a dummy value for the hash map value. By using {#syntax#}void{#endsyntax#} as the type of the value, the hash map entry type has no value field, and @@ -5925,13 +6060,13 @@ const Node = struct { Putting all of this together, let's see how {#syntax#}printf{#endsyntax#} works in Zig.
{#code_begin|exe|printf#} -const warn = @import("std").debug.warn; +const print = @import("std").debug.print; const a_number: i32 = 1234; const a_string = "foobar"; pub fn main() void { - warn("here is a string: '{}' here is a number: {}\n", .{a_string, a_number}); + print("here is a string: '{}' here is a number: {}\n", .{a_string, a_number}); } {#code_end#} @@ -5941,7 +6076,7 @@ pub fn main() void { {#code_begin|syntax#} /// Calls print and then flushes the buffer. -pub fn printf(self: *OutStream, comptime format: []const u8, args: var) anyerror!void { +pub fn printf(self: *OutStream, comptime format: []const u8, args: anytype) anyerror!void { const State = enum { Start, OpenBrace, @@ -6027,7 +6162,7 @@ pub fn printf(self: *OutStream, arg0: i32, arg1: []const u8) !void { on the type: {#code_begin|syntax#} -pub fn printValue(self: *OutStream, value: var) !void { +pub fn printValue(self: *OutStream, value: anytype) !void { switch (@typeInfo(@TypeOf(value))) { .Int => { return self.printInt(T, value); @@ -6045,13 +6180,13 @@ pub fn printValue(self: *OutStream, value: var) !void { And now, what happens if we give too many arguments to {#syntax#}printf{#endsyntax#}? {#code_begin|test_err|Unused arguments#} -const warn = @import("std").debug.warn; +const print = @import("std").debug.print; const a_number: i32 = 1234; const a_string = "foobar"; test "printf too many arguments" { - warn("here is a string: '{}' here is a number: {}\n", .{ + print("here is a string: '{}' here is a number: {}\n", .{ a_string, a_number, a_number, @@ -6066,14 +6201,14 @@ test "printf too many arguments" { only that it is a compile-time known value that can be coerced to a {#syntax#}[]const u8{#endsyntax#}: {#code_begin|exe|printf#} -const warn = @import("std").debug.warn; +const print = @import("std").debug.print; const a_number: i32 = 1234; const a_string = "foobar"; const fmt = "here is a string: '{}' here is a number: {}\n"; pub fn main() void { - warn(fmt, .{a_string, a_number}); + print(fmt, .{a_string, a_number}); } {#code_end#}@@ -6511,7 +6646,7 @@ pub fn main() void { fn amainWrap() void { amain() catch |e| { - std.debug.warn("{}\n", .{e}); + std.debug.print("{}\n", .{e}); if (@errorReturnTrace()) |trace| { std.debug.dumpStackTrace(trace.*); } @@ -6541,8 +6676,8 @@ fn amain() !void { const download_text = try await download_frame; defer allocator.free(download_text); - std.debug.warn("download_text: {}\n", .{download_text}); - std.debug.warn("file_text: {}\n", .{file_text}); + std.debug.print("download_text: {}\n", .{download_text}); + std.debug.print("file_text: {}\n", .{file_text}); } var global_download_frame: anyframe = undefined; @@ -6552,7 +6687,7 @@ fn fetchUrl(allocator: *Allocator, url: []const u8) ![]u8 { suspend { global_download_frame = @frame(); } - std.debug.warn("fetchUrl returning\n", .{}); + std.debug.print("fetchUrl returning\n", .{}); return result; } @@ -6563,7 +6698,7 @@ fn readFile(allocator: *Allocator, filename: []const u8) ![]u8 { suspend { global_file_frame = @frame(); } - std.debug.warn("readFile returning\n", .{}); + std.debug.print("readFile returning\n", .{}); return result; } {#code_end#} @@ -6581,7 +6716,7 @@ pub fn main() void { fn amainWrap() void { amain() catch |e| { - std.debug.warn("{}\n", .{e}); + std.debug.print("{}\n", .{e}); if (@errorReturnTrace()) |trace| { std.debug.dumpStackTrace(trace.*); } @@ -6611,21 +6746,21 @@ fn amain() !void { const download_text = try await download_frame; defer allocator.free(download_text); - std.debug.warn("download_text: {}\n", .{download_text}); - std.debug.warn("file_text: {}\n", .{file_text}); + std.debug.print("download_text: {}\n", .{download_text}); + std.debug.print("file_text: {}\n", .{file_text}); } fn fetchUrl(allocator: *Allocator, url: []const u8) ![]u8 { const result = try std.mem.dupe(allocator, u8, "this is the downloaded url contents"); errdefer allocator.free(result); - std.debug.warn("fetchUrl returning\n", .{}); + std.debug.print("fetchUrl returning\n", .{}); return result; } fn readFile(allocator: *Allocator, filename: []const u8) ![]u8 { const result = try std.mem.dupe(allocator, u8, "this is the file contents"); errdefer allocator.free(result); - std.debug.warn("readFile returning\n", .{}); + std.debug.print("readFile returning\n", .{}); return result; } {#code_end#} @@ -6653,7 +6788,7 @@ fn readFile(allocator: *Allocator, filename: []const u8) ![]u8 {
{#header_close#} {#header_open|@alignCast#} -{#syntax#}@alignCast(comptime alignment: u29, ptr: var) var{#endsyntax#}
+ {#syntax#}@alignCast(comptime alignment: u29, ptr: anytype) anytype{#endsyntax#}
{#syntax#}ptr{#endsyntax#} can be {#syntax#}*T{#endsyntax#}, {#syntax#}fn(){#endsyntax#}, {#syntax#}?*T{#endsyntax#}, {#syntax#}?fn(){#endsyntax#}, or {#syntax#}[]T{#endsyntax#}. It returns the same type as {#syntax#}ptr{#endsyntax#} @@ -6690,7 +6825,7 @@ comptime { {#header_close#} {#header_open|@asyncCall#} -
{#syntax#}@asyncCall(frame_buffer: []align(@alignOf(@Frame(anyAsyncFunction))) u8, result_ptr, function_ptr, args: ...) anyframe->T{#endsyntax#}
+ {#syntax#}@asyncCall(frame_buffer: []align(@alignOf(@Frame(anyAsyncFunction))) u8, result_ptr, function_ptr, args: anytype) anyframe->T{#endsyntax#}
{#syntax#}@asyncCall{#endsyntax#} performs an {#syntax#}async{#endsyntax#} call on a function pointer, which may or may not be an {#link|async function|Async Functions#}. @@ -6717,7 +6852,7 @@ test "async fn pointer in a struct field" { }; var foo = Foo{ .bar = func }; var bytes: [64]u8 align(@alignOf(@Frame(func))) = undefined; - const f = @asyncCall(&bytes, {}, foo.bar, &data); + const f = @asyncCall(&bytes, {}, foo.bar, .{&data}); assert(data == 2); resume f; assert(data == 4); @@ -6778,7 +6913,7 @@ fn func(y: *i32) void {
{#header_close#} {#header_open|@bitCast#} -{#syntax#}@bitCast(comptime DestType: type, value: var) DestType{#endsyntax#}
+ {#syntax#}@bitCast(comptime DestType: type, value: anytype) DestType{#endsyntax#}
Converts a value of one type to another type.
@@ -6899,7 +7034,7 @@ fn func(y: *i32) void { {#header_close#} {#header_open|@call#} -{#syntax#}@call(options: std.builtin.CallOptions, function: var, args: var) var{#endsyntax#}
+ {#syntax#}@call(options: std.builtin.CallOptions, function: anytype, args: anytype) anytype{#endsyntax#}
Calls a function, in the same way that invoking an expression with parentheses does:
@@ -7121,7 +7256,7 @@ fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_val compile-time executing code. {#code_begin|test_err|found compile log statement#} -const warn = @import("std").debug.warn; +const print = @import("std").debug.print; const num1 = blk: { var val1: i32 = 99; @@ -7133,7 +7268,7 @@ const num1 = blk: { test "main" { @compileLog("comptime in main"); - warn("Runtime in main, num1 = {}.\n", .{num1}); + print("Runtime in main, num1 = {}.\n", .{num1}); } {#code_end#}@@ -7145,7 +7280,7 @@ test "main" { program compiles successfully and the generated executable prints:
{#code_begin|test#} -const warn = @import("std").debug.warn; +const print = @import("std").debug.print; const num1 = blk: { var val1: i32 = 99; @@ -7154,7 +7289,7 @@ const num1 = blk: { }; test "main" { - warn("Runtime in main, num1 = {}.\n", .{num1}); + print("Runtime in main, num1 = {}.\n", .{num1}); } {#code_end#} {#header_close#} @@ -7246,7 +7381,7 @@ test "main" { {#header_close#} {#header_open|@enumToInt#} -{#syntax#}@enumToInt(enum_or_tagged_union: var) var{#endsyntax#}
+ {#syntax#}@enumToInt(enum_or_tagged_union: anytype) anytype{#endsyntax#}
Converts an enumeration value into its integer tag type. When a tagged union is passed, the tag value is used as the enumeration value. @@ -7281,7 +7416,7 @@ test "main" { {#header_close#} {#header_open|@errorToInt#} -
{#syntax#}@errorToInt(err: var) std.meta.IntType(false, @sizeOf(anyerror) * 8){#endsyntax#}
+ {#syntax#}@errorToInt(err: anytype) std.meta.IntType(false, @sizeOf(anyerror) * 8){#endsyntax#}
Supports the following types:
@@ -7301,7 +7436,7 @@ test "main" { {#header_close#} {#header_open|@errSetCast#} -{#syntax#}@errSetCast(comptime T: DestType, value: var) DestType{#endsyntax#}
+ {#syntax#}@errSetCast(comptime T: DestType, value: anytype) DestType{#endsyntax#}
Converts an error value from one error set to another error set. Attempting to convert an error which is not in the destination error set results in safety-protected {#link|Undefined Behavior#}. @@ -7309,7 +7444,7 @@ test "main" { {#header_close#} {#header_open|@export#} -
{#syntax#}@export(target: var, comptime options: std.builtin.ExportOptions) void{#endsyntax#}
+ {#syntax#}@export(target: anytype, comptime options: std.builtin.ExportOptions) void{#endsyntax#}
Creates a symbol in the output object file.
@@ -7354,7 +7489,7 @@ export fn @"A function name that is a complete sentence."() void {} {#header_close#} {#header_open|@field#} -{#syntax#}@field(lhs: var, comptime field_name: []const u8) (field){#endsyntax#}
+ {#syntax#}@field(lhs: anytype, comptime field_name: []const u8) (field){#endsyntax#}
Performs field access by a compile-time string.
{#code_begin|test#} @@ -7388,7 +7523,7 @@ test "field access by string" { {#header_close#} {#header_open|@floatCast#} -{#syntax#}@floatCast(comptime DestType: type, value: var) DestType{#endsyntax#}
+ {#syntax#}@floatCast(comptime DestType: type, value: anytype) DestType{#endsyntax#}
Convert from one float type to another. This cast is safe, but may cause the numeric value to lose precision. @@ -7396,7 +7531,7 @@ test "field access by string" { {#header_close#} {#header_open|@floatToInt#} -
{#syntax#}@floatToInt(comptime DestType: type, float: var) DestType{#endsyntax#}
+ {#syntax#}@floatToInt(comptime DestType: type, float: anytype) DestType{#endsyntax#}
Converts the integer part of a floating point number to the destination type.
@@ -7422,7 +7557,7 @@ test "field access by string" { {#header_close#} {#header_open|@Frame#} -{#syntax#}@Frame(func: var) type{#endsyntax#}
+ {#syntax#}@Frame(func: anytype) type{#endsyntax#}
This function returns the frame type of a function. This works for {#link|Async Functions#} as well as any function without a specific calling convention. @@ -7531,7 +7666,7 @@ test "@hasDecl" { source file than the one they are declared in.
- {#syntax#}path{#endsyntax#} can be a relative or absolute path, or it can be the name of a package. + {#syntax#}path{#endsyntax#} can be a relative path or it can be the name of a package. If it is a relative path, it is relative to the file that contains the {#syntax#}@import{#endsyntax#} function call.
@@ -7548,7 +7683,7 @@ test "@hasDecl" { {#header_close#} {#header_open|@intCast#} -{#syntax#}@intCast(comptime DestType: type, int: var) DestType{#endsyntax#}
+ {#syntax#}@intCast(comptime DestType: type, int: anytype) DestType{#endsyntax#}
Converts an integer to another integer while keeping the same numerical value. Attempting to convert a number which is out of range of the destination type results in @@ -7589,7 +7724,7 @@ test "@hasDecl" { {#header_close#} {#header_open|@intToFloat#} -
{#syntax#}@intToFloat(comptime DestType: type, int: var) DestType{#endsyntax#}
+ {#syntax#}@intToFloat(comptime DestType: type, int: anytype) DestType{#endsyntax#}
Converts an integer to the closest floating point representation. To convert the other way, use {#link|@floatToInt#}. This cast is always safe.
@@ -7740,7 +7875,7 @@ test "@wasmMemoryGrow" { {#header_close#} {#header_open|@ptrCast#} -{#syntax#}@ptrCast(comptime DestType: type, value: var) DestType{#endsyntax#}
+ {#syntax#}@ptrCast(comptime DestType: type, value: anytype) DestType{#endsyntax#}
Converts a pointer of one type to a pointer of another type.
@@ -7751,7 +7886,7 @@ test "@wasmMemoryGrow" { {#header_close#} {#header_open|@ptrToInt#} -{#syntax#}@ptrToInt(value: var) usize{#endsyntax#}
+ {#syntax#}@ptrToInt(value: anytype) usize{#endsyntax#}
Converts {#syntax#}value{#endsyntax#} to a {#syntax#}usize{#endsyntax#} which is the address of the pointer. {#syntax#}value{#endsyntax#} can be one of these types:
@@ -8009,7 +8144,7 @@ test "@setRuntimeSafety" { {#header_close#} {#header_open|@splat#} -{#syntax#}@splat(comptime len: u32, scalar: var) std.meta.Vector(len, @TypeOf(scalar)){#endsyntax#}
+ {#syntax#}@splat(comptime len: u32, scalar: anytype) std.meta.Vector(len, @TypeOf(scalar)){#endsyntax#}
Produces a vector of length {#syntax#}len{#endsyntax#} where each element is the value {#syntax#}scalar{#endsyntax#}: @@ -8031,9 +8166,31 @@ test "vector @splat" {
{#see_also|Vectors|@shuffle#} {#header_close#} + {#header_open|@src#} +{#syntax#}@src() std.builtin.SourceLocation{#endsyntax#}
+ + Returns a {#syntax#}SourceLocation{#endsyntax#} struct representing the function's name and location in the source code. This must be called in a function. +
+ {#code_begin|test#} +const std = @import("std"); +const expect = std.testing.expect; +test "@src" { + doTheTest(); +} + +fn doTheTest() void { + const src = @src(); + + expect(src.line == 9); + expect(src.column == 17); + expect(std.mem.endsWith(u8, src.fn_name, "doTheTest")); + expect(std.mem.endsWith(u8, src.file, "test.zig")); +} + {#code_end#} + {#header_close#} {#header_open|@sqrt#} -{#syntax#}@sqrt(value: var) @TypeOf(value){#endsyntax#}
+ {#syntax#}@sqrt(value: anytype) @TypeOf(value){#endsyntax#}
Performs the square root of a floating point number. Uses a dedicated hardware instruction when available. @@ -8044,7 +8201,7 @@ test "vector @splat" {
{#header_close#} {#header_open|@sin#} -{#syntax#}@sin(value: var) @TypeOf(value){#endsyntax#}
+ {#syntax#}@sin(value: anytype) @TypeOf(value){#endsyntax#}
Sine trigometric function on a floating point number. Uses a dedicated hardware instruction when available. @@ -8055,7 +8212,7 @@ test "vector @splat" {
{#header_close#} {#header_open|@cos#} -{#syntax#}@cos(value: var) @TypeOf(value){#endsyntax#}
+ {#syntax#}@cos(value: anytype) @TypeOf(value){#endsyntax#}
Cosine trigometric function on a floating point number. Uses a dedicated hardware instruction when available. @@ -8066,7 +8223,7 @@ test "vector @splat" {
{#header_close#} {#header_open|@exp#} -{#syntax#}@exp(value: var) @TypeOf(value){#endsyntax#}
+ {#syntax#}@exp(value: anytype) @TypeOf(value){#endsyntax#}
Base-e exponential function on a floating point number. Uses a dedicated hardware instruction when available. @@ -8077,7 +8234,7 @@ test "vector @splat" {
{#header_close#} {#header_open|@exp2#} -{#syntax#}@exp2(value: var) @TypeOf(value){#endsyntax#}
+ {#syntax#}@exp2(value: anytype) @TypeOf(value){#endsyntax#}
Base-2 exponential function on a floating point number. Uses a dedicated hardware instruction when available. @@ -8088,7 +8245,7 @@ test "vector @splat" {
{#header_close#} {#header_open|@log#} -{#syntax#}@log(value: var) @TypeOf(value){#endsyntax#}
+ {#syntax#}@log(value: anytype) @TypeOf(value){#endsyntax#}
Returns the natural logarithm of a floating point number. Uses a dedicated hardware instruction when available. @@ -8099,7 +8256,7 @@ test "vector @splat" {
{#header_close#} {#header_open|@log2#} -{#syntax#}@log2(value: var) @TypeOf(value){#endsyntax#}
+ {#syntax#}@log2(value: anytype) @TypeOf(value){#endsyntax#}
Returns the logarithm to the base 2 of a floating point number. Uses a dedicated hardware instruction when available. @@ -8110,7 +8267,7 @@ test "vector @splat" {
{#header_close#} {#header_open|@log10#} -{#syntax#}@log10(value: var) @TypeOf(value){#endsyntax#}
+ {#syntax#}@log10(value: anytype) @TypeOf(value){#endsyntax#}
Returns the logarithm to the base 10 of a floating point number. Uses a dedicated hardware instruction when available. @@ -8121,7 +8278,7 @@ test "vector @splat" {
{#header_close#} {#header_open|@fabs#} -{#syntax#}@fabs(value: var) @TypeOf(value){#endsyntax#}
+ {#syntax#}@fabs(value: anytype) @TypeOf(value){#endsyntax#}
Returns the absolute value of a floating point number. Uses a dedicated hardware instruction when available. @@ -8132,7 +8289,7 @@ test "vector @splat" {
{#header_close#} {#header_open|@floor#} -{#syntax#}@floor(value: var) @TypeOf(value){#endsyntax#}
+ {#syntax#}@floor(value: anytype) @TypeOf(value){#endsyntax#}
Returns the largest integral value not greater than the given floating point number. Uses a dedicated hardware instruction when available. @@ -8143,7 +8300,7 @@ test "vector @splat" {
{#header_close#} {#header_open|@ceil#} -{#syntax#}@ceil(value: var) @TypeOf(value){#endsyntax#}
+ {#syntax#}@ceil(value: anytype) @TypeOf(value){#endsyntax#}
Returns the largest integral value not less than the given floating point number. Uses a dedicated hardware instruction when available. @@ -8154,7 +8311,7 @@ test "vector @splat" {
{#header_close#} {#header_open|@trunc#} -{#syntax#}@trunc(value: var) @TypeOf(value){#endsyntax#}
+ {#syntax#}@trunc(value: anytype) @TypeOf(value){#endsyntax#}
Rounds the given floating point number to an integer, towards zero. Uses a dedicated hardware instruction when available. @@ -8165,7 +8322,7 @@ test "vector @splat" {
{#header_close#} {#header_open|@round#} -{#syntax#}@round(value: var) @TypeOf(value){#endsyntax#}
+ {#syntax#}@round(value: anytype) @TypeOf(value){#endsyntax#}
Rounds the given floating point number to an integer, away from zero. Uses a dedicated hardware instruction when available. @@ -8186,7 +8343,7 @@ test "vector @splat" { {#header_close#} {#header_open|@tagName#} -
{#syntax#}@tagName(value: var) []const u8{#endsyntax#}
+ {#syntax#}@tagName(value: anytype) []const u8{#endsyntax#}
Converts an enum value or union value to a slice of bytes representing the name.
If the enum is non-exhaustive and the tag value does not map to a name, it invokes safety-checked {#link|Undefined Behavior#}.
@@ -8205,7 +8362,7 @@ test "vector @splat" { {#header_open|@This#}{#syntax#}@This() type{#endsyntax#}
- Returns the innermost struct or union that this function call is inside. + Returns the innermost struct, enum, or union that this function call is inside. This can be useful for an anonymous struct that needs to refer to itself:
{#code_begin|test#} @@ -8237,7 +8394,7 @@ fn List(comptime T: type) type { {#header_close#} {#header_open|@truncate#} -{#syntax#}@truncate(comptime T: type, integer: var) T{#endsyntax#}
+ {#syntax#}@truncate(comptime T: type, integer: anytype) T{#endsyntax#}
This function truncates bits from an integer type, resulting in a smaller or same-sized integer type. @@ -8380,6 +8537,7 @@ fn foo(comptime T: type, ptr: *T) T { {#header_close#} {#header_open|Opaque Types#} +
{#syntax#}@Type(.Opaque){#endsyntax#} creates a new type with an unknown (but non-zero) size and alignment.
@@ -8555,7 +8713,7 @@ const std = @import("std"); pub fn main() void { var value: i32 = -1; var unsigned = @intCast(u32, value); - std.debug.warn("value: {}\n", .{unsigned}); + std.debug.print("value: {}\n", .{unsigned}); } {#code_end#}
@@ -8577,7 +8735,7 @@ const std = @import("std"); pub fn main() void { var spartan_count: u16 = 300; const byte = @intCast(u8, spartan_count); - std.debug.warn("value: {}\n", .{byte}); + std.debug.print("value: {}\n", .{byte}); } {#code_end#}
@@ -8611,7 +8769,7 @@ const std = @import("std"); pub fn main() void { var byte: u8 = 255; byte += 1; - std.debug.warn("value: {}\n", .{byte}); + std.debug.print("value: {}\n", .{byte}); } {#code_end#} {#header_close#} @@ -8629,16 +8787,16 @@ pub fn main() void {
Example of catching an overflow for addition:
{#code_begin|exe_err#} const math = @import("std").math; -const warn = @import("std").debug.warn; +const print = @import("std").debug.print; pub fn main() !void { var byte: u8 = 255; byte = if (math.add(u8, byte, 1)) |result| result else |err| { - warn("unable to add one: {}\n", .{@errorName(err)}); + print("unable to add one: {}\n", .{@errorName(err)}); return err; }; - warn("result: {}\n", .{byte}); + print("result: {}\n", .{byte}); } {#code_end#} {#header_close#} @@ -8657,15 +8815,15 @@ pub fn main() !void { Example of {#link|@addWithOverflow#}: {#code_begin|exe#} -const warn = @import("std").debug.warn; +const print = @import("std").debug.print; pub fn main() void { var byte: u8 = 255; var result: u8 = undefined; if (@addWithOverflow(u8, byte, 10, &result)) { - warn("overflowed result: {}\n", .{result}); + print("overflowed result: {}\n", .{result}); } else { - warn("result: {}\n", .{result}); + print("result: {}\n", .{result}); } } {#code_end#} @@ -8710,7 +8868,7 @@ const std = @import("std"); pub fn main() void { var x: u8 = 0b01010101; var y = @shlExact(x, 2); - std.debug.warn("value: {}\n", .{y}); + std.debug.print("value: {}\n", .{y}); } {#code_end#} {#header_close#} @@ -8728,7 +8886,7 @@ const std = @import("std"); pub fn main() void { var x: u8 = 0b10101010; var y = @shrExact(x, 2); - std.debug.warn("value: {}\n", .{y}); + std.debug.print("value: {}\n", .{y}); } {#code_end#} {#header_close#} @@ -8749,7 +8907,7 @@ pub fn main() void { var a: u32 = 1; var b: u32 = 0; var c = a / b; - std.debug.warn("value: {}\n", .{c}); + std.debug.print("value: {}\n", .{c}); } {#code_end#} {#header_close#} @@ -8770,7 +8928,7 @@ pub fn main() void { var a: u32 = 10; var b: u32 = 0; var c = a % b; - std.debug.warn("value: {}\n", .{c}); + std.debug.print("value: {}\n", .{c}); } {#code_end#} {#header_close#} @@ -8791,7 +8949,7 @@ pub fn main() void { var a: u32 = 10; var b: u32 = 3; var c = @divExact(a, b); - std.debug.warn("value: {}\n", .{c}); + std.debug.print("value: {}\n", .{c}); } {#code_end#} {#header_close#} @@ -8810,20 +8968,20 @@ const std = @import("std"); pub fn main() void { var optional_number: ?i32 = null; var number = optional_number.?; - std.debug.warn("value: {}\n", .{number}); + std.debug.print("value: {}\n", .{number}); } {#code_end#}One way to avoid this crash is to test for null instead of assuming non-null, with the {#syntax#}if{#endsyntax#} expression:
{#code_begin|exe|test#} -const warn = @import("std").debug.warn; +const print = @import("std").debug.print; pub fn main() void { const optional_number: ?i32 = null; if (optional_number) |number| { - warn("got number: {}\n", .{number}); + print("got number: {}\n", .{number}); } else { - warn("it's null\n", .{}); + print("it's null\n", .{}); } } {#code_end#} @@ -8846,7 +9004,7 @@ const std = @import("std"); pub fn main() void { const number = getNumberOrFail() catch unreachable; - std.debug.warn("value: {}\n", .{number}); + std.debug.print("value: {}\n", .{number}); } fn getNumberOrFail() !i32 { @@ -8856,15 +9014,15 @@ fn getNumberOrFail() !i32 {One way to avoid this crash is to test for an error instead of assuming a successful result, with the {#syntax#}if{#endsyntax#} expression:
{#code_begin|exe#} -const warn = @import("std").debug.warn; +const print = @import("std").debug.print; pub fn main() void { const result = getNumberOrFail(); if (result) |number| { - warn("got number: {}\n", .{number}); + print("got number: {}\n", .{number}); } else |err| { - warn("got error: {}\n", .{@errorName(err)}); + print("got error: {}\n", .{@errorName(err)}); } } @@ -8891,7 +9049,7 @@ pub fn main() void { var err = error.AnError; var number = @errorToInt(err) + 500; var invalid_err = @intToError(number); - std.debug.warn("value: {}\n", .{number}); + std.debug.print("value: {}\n", .{number}); } {#code_end#} {#header_close#} @@ -8921,7 +9079,7 @@ const Foo = enum { pub fn main() void { var a: u2 = 3; var b = @intToEnum(Foo, a); - std.debug.warn("value: {}\n", .{@tagName(b)}); + std.debug.print("value: {}\n", .{@tagName(b)}); } {#code_end#} {#header_close#} @@ -8958,7 +9116,7 @@ pub fn main() void { } fn foo(set1: Set1) void { const x = @errSetCast(Set2, set1); - std.debug.warn("value: {}\n", .{x}); + std.debug.print("value: {}\n", .{x}); } {#code_end#} {#header_close#} @@ -9015,7 +9173,7 @@ pub fn main() void { fn bar(f: *Foo) void { f.float = 12.34; - std.debug.warn("value: {}\n", .{f.float}); + std.debug.print("value: {}\n", .{f.float}); } {#code_end#}@@ -9039,7 +9197,7 @@ pub fn main() void { fn bar(f: *Foo) void { f.* = Foo{ .float = 12.34 }; - std.debug.warn("value: {}\n", .{f.float}); + std.debug.print("value: {}\n", .{f.float}); } {#code_end#}
@@ -9058,7 +9216,7 @@ pub fn main() void { var f = Foo{ .int = 42 }; f = Foo{ .float = undefined }; bar(&f); - std.debug.warn("value: {}\n", .{f.float}); + std.debug.print("value: {}\n", .{f.float}); } fn bar(f: *Foo) void { @@ -9178,7 +9336,7 @@ pub fn main() !void { const allocator = &arena.allocator; const ptr = try allocator.create(i32); - std.debug.warn("ptr={*}\n", .{ptr}); + std.debug.print("ptr={*}\n", .{ptr}); } {#code_end#} When using this kind of allocator, there is no need to free anything manually. Everything @@ -9712,7 +9870,7 @@ pub fn main() !void { defer std.process.argsFree(std.heap.page_allocator, args); for (args) |arg, i| { - std.debug.warn("{}: {}\n", .{i, arg}); + std.debug.print("{}: {}\n", .{i, arg}); } } {#code_end#} @@ -9734,12 +9892,12 @@ pub fn main() !void { try preopens.populate(); for (preopens.asSlice()) |preopen, i| { - std.debug.warn("{}: {}\n", .{ i, preopen }); + std.debug.print("{}: {}\n", .{ i, preopen }); } } {#code_end#}
$ wasmtime --dir=. preopens.wasm
-0: { .fd = 3, .Dir = '.' }
+0: Preopen{ .fd = 3, .type = PreopenType{ .Dir = '.' } }