srctree

fn addIdentifier(c: *Context, bytes: []const u8) Allocator.Error!TokenIndex {

if (std.zig.primitives.isPrimitive(bytes))

return c.addTokenFmt(.identifier, "@\"{s}\"", .{bytes});

}

 

fn listToSpan(c: *Context, list: []const NodeIndex) Allocator.Error!NodeSubRange {

members[1] = 0;

 

for (payload.fields, 0..) |field, i| {

_ = try c.addToken(.colon, ":");

const type_expr = try renderNode(c, field.type);

 

.main_token = try c.addToken(.period, "."),

.data = .{

.lhs = lhs,

},

});

}

 

.fail = fail,

.skip = skip,

.leak = leak,

},

});

},

 

try printEnum(self, out, T, info, indent);

 

if (name) |some| {

std.zig.fmtId(some),

std.zig.fmtId(@typeName(T)),

std.zig.fmtId(@tagName(value)),

try printStruct(self, out, T, info, indent);

 

if (name) |some| {

std.zig.fmtId(some),

std.zig.fmtId(@typeName(T)),

});

 

inline for (val.fields) |field| {

try out.writeByteNTimes(' ', indent);

}

 

if (!val.is_exhaustive) {

 

// If the type name doesn't contains a '.' the type is from zig builtins.

if (std.mem.containsAtLeast(u8, type_name, 1, ".")) {

} else {

}

 

if (field.default_value != null) {

} else {

inline for (struct_val.fields) |field| {

try out.writeByteNTimes(' ', indent);

 

const field_name = @field(val, field.name);

switch (@typeInfo(@TypeOf(field_name))) {

 

pub const string_literal = @import("zig/string_literal.zig");

pub const number_literal = @import("zig/number_literal.zig");

pub const primitives = @import("zig/primitives.zig");

pub const Ast = @import("zig/Ast.zig");

pub const AstGen = @import("zig/AstGen.zig");

pub const Zir = @import("zig/Zir.zig");

const assert = std.debug.assert;

const Allocator = std.mem.Allocator;

 

pub fn fmtId(bytes: []const u8) std.fmt.Formatter(formatId) {

return .{ .data = bytes };

}

 

fn formatId(

bytes: []const u8,

options: std.fmt.FormatOptions,

writer: anytype,

) !void {

return writer.writeAll(bytes);

}

try writer.writeAll("@\"");

return .{ .data = bytes };

}

 

const expectFmt = std.testing.expectFmt;

try expectFmt("\\x0f", "{}", .{fmtEscapes("\x0f")});

try expectFmt(

\\" \\ hi \x07 \x11 " derp \'"

 

pub fn isValidId(bytes: []const u8) bool {

if (bytes.len == 0) return false;

for (bytes, 0..) |c, i| {

switch (c) {

'_', 'a'...'z', 'A'...'Z' => {},

try std.testing.expect(isValidId("i386"));

}

 

pub fn readSourceFileToEndAlloc(

allocator: Allocator,

input: std.fs.File,

 

return renderQuotedIdentifier(r, token_index, space, false);

}

 

.eagerly_unquote => return renderQuotedIdentifier(r, token_index, space, true),

.eagerly_unquote_except_underscore,

.preserve_when_shadowing,

 

\\/// feature detection (i.e. with `@hasDecl` or `@hasField`) over version checks.

\\pub const zig_version = std.SemanticVersion.parse(zig_version_string) catch unreachable;

\\pub const zig_version_string = "{s}";

\\

\\pub const is_test = {};

\\pub const single_threaded = {};

\\pub const cpu: std.Target.Cpu = .{{

\\

, .{

build_options.version,

const index = @as(std.Target.Cpu.Feature.Set.Index, @intCast(index_usize));

const is_enabled = target.cpu.features.isEnabled(index);

if (is_enabled) {

}

}

try buffer.writer().print(

\\ }}),

\\}};

\\pub const os = std.Target.Os{{

\\ .version_range = .{{

,

.{std.zig.fmtId(@tagName(target.os.tag))},

const link_libc = opts.link_libc;

 

try buffer.writer().print(

\\pub const link_libc = {};

\\pub const link_libcpp = {};

\\pub const have_error_return_tracing = {};

\\pub const position_independent_code = {};

\\pub const position_independent_executable = {};

\\pub const strip_debug_info = {};

\\pub const omit_frame_pointer = {};

\\

, .{

});

 

if (target.os.tag == .wasi) {

try buffer.writer().print(

\\

}

 

if (opts.is_test) {

 

if (comptime std.mem.eql(u8, specifier, "")) {

try writer.writeAll(s);

} else if (comptime std.mem.eql(u8, specifier, "i")) {

} else @compileError("invalid format string '" ++ specifier ++ "' for '" ++ @typeName(NullTerminatedString) ++ "'");

}

 

 

std.zig.fmtEscapes(&hex_digest),

});

 

std.zig.fmtId(name), new_node_init,

});

 

 

const decl_name = self.code.nullTerminatedString(extra.decl_name);

 

try self.writeInstRef(stream, extra.namespace);

try self.writeInstRef(stream, extra.options);

try stream.writeAll(") ");

try self.writeSrc(stream, inst_data.src());

 

const name = self.code.nullTerminatedString(output.data.name);

const constraint = self.code.nullTerminatedString(output.data.constraint);

std.zig.fmtId(name), std.zig.fmtEscapes(constraint),

});

try self.writeFlag(stream, "->", is_type);

 

const name = self.code.nullTerminatedString(input.data.name);

const constraint = self.code.nullTerminatedString(input.data.constraint);

std.zig.fmtId(name), std.zig.fmtEscapes(constraint),

});

try self.writeInstRef(stream, input.data.operand);

const str_index = self.code.extra[extra_i];

extra_i += 1;

const clobber = self.code.nullTerminatedString(@enumFromInt(str_index));

if (i + 1 < clobbers_len) {

try stream.writeAll(", ");

}

try self.writeFlag(stream, "comptime ", field.is_comptime);

if (field.name != .empty) {

const field_name = self.code.nullTerminatedString(field.name);

} else {

try stream.print("@\"{d}\": ", .{i});

}

 

try self.writeDocComment(stream, doc_comment_index);

try stream.writeByteNTimes(' ', self.indent);

 

if (has_type) {

const field_type = @as(Zir.Inst.Ref, @enumFromInt(self.code.extra[extra_index]));

try self.writeDocComment(stream, doc_comment_index);

 

try stream.writeByteNTimes(' ', self.indent);

 

if (has_tag_value) {

const tag_value_ref = @as(Zir.Inst.Ref, @enumFromInt(self.code.extra[extra_index]));

const doc_comment_index: Zir.NullTerminatedString = @enumFromInt(self.code.extra[extra_index + 1]);

try self.writeDocComment(stream, doc_comment_index);

try stream.writeByteNTimes(' ', self.indent);

}

 

self.indent -= 2;

 

);

 

for (extensions) |ext| {

}

 

try writer.writeAll(

// but there aren't so many total aliases and that would add more overhead in total. We will

// just filter those out when needed.

 

 

for (instructions) |inst| {

try writer.print(

 

const kind = all_operand_kinds.get(.{ set_name, operand.kind }) orelse

all_operand_kinds.get(.{ "core", operand.kind }).?;

}

 

try writer.writeAll(

\\

);

for (operands) |operand| {

}

try writer.writeAll(

\\

.Literal => "literal",

.Composite => "composite",

};

}

try writer.writeAll(

\\ };

switch (operand.category) {

.BitEnum, .ValueEnum => {},

else => {

continue;

},

}

 

for (operand.enumerants.?) |enumerant| {

if (enumerant.value == .bitflag and std.mem.eql(u8, enumerant.enumerant, "None")) {

continue;

if (i != 0)

try writer.writeAll(", ");

// Note, param.quantifier will always be one.

}

try writer.writeAll("}}");

}

try writer.writeAll("pub const Opcode = enum(u16) {\n");

for (instructions_indices) |i| {

const inst = instructions[i];

}

 

try writer.writeAll(

);

 

for (aliases.items) |alias| {

std.zig.fmtId(instructions[alias.inst].opname),

std.zig.fmtId(instructions[alias.alias].opname),

});

 

for (instructions_indices) |i| {

const inst = instructions[i];

try renderInstructionClass(writer, inst.class.?);

try writer.writeAll(",\n");

}

 

const enum_indices = enum_map.values();

 

 

for (enum_indices) |i| {

const enumerant = enumerants[i];

// if (enumerant.value != .int) return error.InvalidRegistry;

 

switch (enumerant.value) {

}

}

 

try writer.writeByte('\n');

 

for (aliases.items) |alias| {

std.zig.fmtId(enumerants[alias.enumerant].enumerant),

std.zig.fmtId(enumeration.kind),

std.zig.fmtId(enumerants[alias.alias].enumerant),

enumeration: OperandKind,

extended_structs: ExtendedStructSet,

) !void {

 

var flags_by_bitpos = [_]?usize{null} ** 32;

const enumerants = enumeration.enumerants orelse return error.InvalidRegistry;

 

for (flags_by_bitpos, 0..) |maybe_flag_index, bitpos| {

if (maybe_flag_index) |flag_index| {

} else {

try writer.print("_reserved_bit_{}", .{bitpos});

}

try writer.writeByte('\n');

 

for (aliases.items) |alias| {

std.zig.fmtId(enumerants[alias.flag].enumerant),

std.zig.fmtId(enumeration.kind),

std.zig.fmtId(enumerants[flags_by_bitpos[alias.alias].?].enumerant),

}

 

// Assume there are no duplicate 'name' fields.

return;

}

 

}

}

 

 

// For fields derived from type name, there could be any amount.

// Simply check against all other fields, and if another similar one exists, add a number.

 

_ = fields.next() orelse return error.Incomplete;

const name = fields.next() orelse return error.Incomplete;

 

}

 

try writer.writeAll("};\n\n");

const name = fields.next() orelse return error.Incomplete;

 

const fixed_name = if (stdlib_renames.get(name)) |fixed| fixed else name;

}

 

try writer.writeAll("};\n\n");

const name = fields.next() orelse return error.Incomplete;

 

const fixed_name = if (stdlib_renames.get(name)) |fixed| fixed else name;

}

 

// TODO: maybe extract these from arch/arm/include/uapi/asm/unistd.h

if (mem.eql(u8, abi, "32")) continue;

const name = fields.next() orelse return error.Incomplete;

 

}

 

try writer.writeAll("};\n\n");

const name = fields.next() orelse return error.Incomplete;

if (mem.startsWith(u8, name, "unused")) continue;

 

}

 

try writer.writeAll("};\n\n");

const name = fields.next() orelse return error.Incomplete;

const fixed_name = if (stdlib_renames.get(name)) |fixed| fixed else name;

 

}

 

try writer.writeAll("};\n\n");

if (mem.eql(u8, abi, "spu")) {

continue;

} else if (mem.eql(u8, abi, "32")) {

} else if (mem.eql(u8, abi, "64")) {

} else { // common/nospu

}

}

 

if (mem.eql(u8, name, "syscalls")) break :loop;

 

const fixed_name = if (stdlib_renames.get(name)) |fixed| fixed else name;

}

 

try writer.writeAll("};\n\n");

if (mem.eql(u8, name, "syscalls")) break :loop;

 

const fixed_name = if (stdlib_renames.get(name)) |fixed| fixed else name;

}

 

try writer.writeAll(

 

);

 

for (all_features.items) |feature| {

}

 

try w.writeAll(

for (all_features.items) |feature| {

if (feature.llvm_name) |llvm_name| {

try w.print(

\\ .llvm_name = "{}",

\\ .description = "{}",

\\ .dependencies = featureSet(&[_]Feature{{

);

} else {

try w.print(

\\ .llvm_name = null,

\\ .description = "{}",

\\ .dependencies = featureSet(&[_]Feature{{

} else {

try w.writeAll("\n");

for (dependencies.items) |dep| {

}

try w.writeAll(

\\ }),

} else {

try w.writeAll("\n");

for (cpu_features.items) |feature_zig_name| {

}

try w.writeAll(

\\ }),

 

}

 

for (extensions) |ext| {

}

 

for (capabilities) |cap| {

}

 

try w.writeAll(

// TODO: Extension dependencies.

for (extensions) |ext| {

try w.print(

\\ .llvm_name = null,

\\ .description = "SPIR-V extension {s}",

\\ .dependencies = featureSet(&[_]Feature{{}}),

// TODO: Capability extension dependencies.

for (capabilities) |cap| {

try w.print(

\\ .llvm_name = null,

\\ .description = "Enable SPIR-V capability {s}",

\\ .dependencies = featureSet(&[_]Feature{{

}

 

for (cap.capabilities) |cap_dep| {

}

 

try w.writeAll(