wip2
This commit is contained in:
David Gonzalez Martin
parent
b5e762c2b9
commit
ebac108da4
@ -2294,6 +2294,14 @@ const Bitcode = struct {
|
||||
assign_id = 47, // [distinct, ...]
|
||||
};
|
||||
|
||||
const OperandBundleTagCode = enum(u8) {
|
||||
operand_bundle_tag = 1,
|
||||
};
|
||||
|
||||
const SyncScopeNameCode = enum(u8) {
|
||||
sync_scope_name = 1,
|
||||
};
|
||||
|
||||
fn print_hex_slice(bytes: []const u8) void {
|
||||
for (bytes, 0..) |b, i| {
|
||||
if (i % 4 == 0) {
|
||||
@ -3020,13 +3028,11 @@ const Bitcode = struct {
|
||||
|
||||
writer.write_sync_scope_names();
|
||||
|
||||
// TODO: functions
|
||||
// for (functions) |function| {
|
||||
// if (!function.is_declaration) {
|
||||
// write.write_function(function);
|
||||
// }
|
||||
// }
|
||||
//
|
||||
for (&dummy_functions) |*function| {
|
||||
if (!function.is_declaration) {
|
||||
writer.write_function(function);
|
||||
}
|
||||
}
|
||||
|
||||
// TODO: module summary
|
||||
// if (index) {
|
||||
@ -3041,6 +3047,12 @@ const Bitcode = struct {
|
||||
}
|
||||
}
|
||||
|
||||
fn write_function(writer: *Writer, function: *const DummyFunction) void {
|
||||
_ = writer; // autofix
|
||||
_ = function; // autofix
|
||||
unreachable;
|
||||
}
|
||||
|
||||
fn write_symtab(writer: *Writer) void {
|
||||
// TODO:
|
||||
const symtab_block align(4) = [_]u8{
|
||||
@ -3630,45 +3642,45 @@ const Bitcode = struct {
|
||||
if (attribute_groups.len > 0) {
|
||||
writer.enter_subblock(.parameter_attribute_group, 3);
|
||||
const start = writer.buffer.length * 4;
|
||||
var records = std.BoundedArray(u64, 4096){};
|
||||
var record_buffer = std.BoundedArray(u64, 4096){};
|
||||
|
||||
for (attribute_groups, 0..) |attribute_group, attribute_group_index| {
|
||||
std.debug.print("====\nWriting attribute group #{}...\n====\n", .{attribute_group_index});
|
||||
defer std.debug.print("====\nEnded attribute group #{}...\n====\n", .{attribute_group_index});
|
||||
records.appendAssumeCapacity(attribute_group_index + 1);
|
||||
records.appendAssumeCapacity(attribute_group.parameter_index);
|
||||
record_buffer.appendAssumeCapacity(attribute_group_index + 1);
|
||||
record_buffer.appendAssumeCapacity(attribute_group.parameter_index);
|
||||
|
||||
for (attribute_group.attributes) |attribute| {
|
||||
switch (attribute) {
|
||||
.enumeration => |e| {
|
||||
records.appendAssumeCapacity(0);
|
||||
records.appendAssumeCapacity(@intFromEnum(e));
|
||||
record_buffer.appendAssumeCapacity(0);
|
||||
record_buffer.appendAssumeCapacity(@intFromEnum(e));
|
||||
},
|
||||
.int => |i| {
|
||||
records.appendAssumeCapacity(1);
|
||||
records.appendAssumeCapacity(@intFromEnum(i.key));
|
||||
records.appendAssumeCapacity(i.value);
|
||||
record_buffer.appendAssumeCapacity(1);
|
||||
record_buffer.appendAssumeCapacity(@intFromEnum(i.key));
|
||||
record_buffer.appendAssumeCapacity(i.value);
|
||||
},
|
||||
.string => |s| {
|
||||
records.appendAssumeCapacity(@as(u64, 3) + @intFromBool(s.value.len > 0));
|
||||
record_buffer.appendAssumeCapacity(@as(u64, 3) + @intFromBool(s.value.len > 0));
|
||||
for (s.key) |b| {
|
||||
records.appendAssumeCapacity(b);
|
||||
record_buffer.appendAssumeCapacity(b);
|
||||
}
|
||||
records.appendAssumeCapacity(0);
|
||||
record_buffer.appendAssumeCapacity(0);
|
||||
|
||||
if (s.value.len > 0) {
|
||||
for (s.value) |b| {
|
||||
records.appendAssumeCapacity(b);
|
||||
record_buffer.appendAssumeCapacity(b);
|
||||
}
|
||||
records.appendAssumeCapacity(0);
|
||||
record_buffer.appendAssumeCapacity(0);
|
||||
}
|
||||
},
|
||||
else => |t| @panic(@tagName(t)),
|
||||
}
|
||||
}
|
||||
|
||||
writer.emit_record(u64, @intFromEnum(AttributeCode.group_entry), records.constSlice(), 0);
|
||||
records.resize(0) catch unreachable;
|
||||
writer.emit_record(u64, @intFromEnum(AttributeCode.group_entry), record_buffer.constSlice(), 0);
|
||||
record_buffer.resize(0) catch unreachable;
|
||||
}
|
||||
|
||||
writer.exit_block();
|
||||
@ -3695,17 +3707,17 @@ const Bitcode = struct {
|
||||
|
||||
const start = writer.buffer.length * 4;
|
||||
|
||||
var records = std.BoundedArray(u64, 4096){};
|
||||
var record_buffer = std.BoundedArray(u64, 4096){};
|
||||
for (attribute_lists) |attribute_list| {
|
||||
for (attribute_list.attribute_groups) |attribute_group_index| {
|
||||
const attribute_group = attribute_groups[attribute_group_index - 1];
|
||||
if (attribute_group.attributes.len > 0) {
|
||||
records.appendAssumeCapacity(attribute_group_index);
|
||||
record_buffer.appendAssumeCapacity(attribute_group_index);
|
||||
}
|
||||
}
|
||||
|
||||
writer.emit_record(u64, @intFromEnum(AttributeCode.entry), records.constSlice(), 0);
|
||||
records.resize(0) catch unreachable;
|
||||
writer.emit_record(u64, @intFromEnum(AttributeCode.entry), record_buffer.constSlice(), 0);
|
||||
record_buffer.resize(0) catch unreachable;
|
||||
}
|
||||
|
||||
writer.exit_block();
|
||||
@ -3961,16 +3973,16 @@ const Bitcode = struct {
|
||||
_ = abbreviations; // autofix
|
||||
|
||||
|
||||
var records = std.BoundedArray(u64, 64){};
|
||||
var record_buffer = std.BoundedArray(u64, 64){};
|
||||
|
||||
// Hardcoded:
|
||||
{
|
||||
std.debug.print("SETTYPE\n", .{});
|
||||
defer std.debug.print("END SETTYPE\n", .{});
|
||||
// Type 1: i32
|
||||
records.appendAssumeCapacity(1);
|
||||
writer.emit_record(u64, @intFromEnum(ConstantCode.set_type), records.constSlice(), @intFromEnum(ConstantAbbreviationId.set_type));
|
||||
records.resize(0) catch unreachable;
|
||||
record_buffer.appendAssumeCapacity(1);
|
||||
writer.emit_record(u64, @intFromEnum(ConstantCode.set_type), record_buffer.constSlice(), @intFromEnum(ConstantAbbreviationId.set_type));
|
||||
record_buffer.resize(0) catch unreachable;
|
||||
}
|
||||
|
||||
const Integer = struct{
|
||||
@ -3980,11 +3992,11 @@ const Bitcode = struct {
|
||||
const integers = [7]u64{7, 5, 2, 3, 1, 4, 8};
|
||||
for (integers) |int| {
|
||||
const v = encode_signed_int(int);
|
||||
records.appendAssumeCapacity(v);
|
||||
record_buffer.appendAssumeCapacity(v);
|
||||
const code = ConstantCode.integer;
|
||||
const abbreviation = ConstantAbbreviationId.integer;
|
||||
writer.emit_record(u64, @intFromEnum(code), records.constSlice(), @intFromEnum(abbreviation));
|
||||
records.resize(0) catch unreachable;
|
||||
writer.emit_record(u64, @intFromEnum(code), record_buffer.constSlice(), @intFromEnum(abbreviation));
|
||||
record_buffer.resize(0) catch unreachable;
|
||||
}
|
||||
|
||||
writer.exit_block();
|
||||
@ -4053,18 +4065,18 @@ const Bitcode = struct {
|
||||
"coro.outside.frame",
|
||||
};
|
||||
|
||||
var records = std.BoundedArray(u64, 64){};
|
||||
var record_buffer = std.BoundedArray(u64, 64){};
|
||||
|
||||
for (names, 0..) |name, name_index| {
|
||||
records.appendAssumeCapacity(name_index);
|
||||
record_buffer.appendAssumeCapacity(name_index);
|
||||
|
||||
for (name) |b| {
|
||||
records.appendAssumeCapacity(b);
|
||||
record_buffer.appendAssumeCapacity(b);
|
||||
}
|
||||
|
||||
writer.emit_record(u64, @intFromEnum(MetadataCode.kind), records.constSlice(), 0);
|
||||
writer.emit_record(u64, @intFromEnum(MetadataCode.kind), record_buffer.constSlice(), 0);
|
||||
|
||||
records.resize(0) catch unreachable;
|
||||
record_buffer.resize(0) catch unreachable;
|
||||
}
|
||||
|
||||
writer.exit_block();
|
||||
@ -4076,9 +4088,646 @@ const Bitcode = struct {
|
||||
std.testing.expectEqualSlices(u8, expected, have) catch unreachable;
|
||||
}
|
||||
|
||||
fn create_di_location_abbreviation(writer: *Writer) u32 {
|
||||
const abbreviation = writer.abbreviation_buffer.append(.{});
|
||||
abbreviation.add_literal(@intFromEnum(MetadataCode.location));
|
||||
abbreviation.add_with_encoding(.{ .encoding = .fixed, .value = 1 });
|
||||
abbreviation.add_with_encoding(.{ .encoding = .vbr, .value = 6 });
|
||||
abbreviation.add_with_encoding(.{ .encoding = .vbr, .value = 8 });
|
||||
abbreviation.add_with_encoding(.{ .encoding = .vbr, .value = 6 });
|
||||
abbreviation.add_with_encoding(.{ .encoding = .vbr, .value = 6 });
|
||||
abbreviation.add_with_encoding(.{ .encoding = .fixed, .value = 1 });
|
||||
|
||||
const result = writer.emit_abbreviation(abbreviation);
|
||||
return result;
|
||||
}
|
||||
|
||||
fn create_generic_di_node_abbreviation(writer: *Writer) u32 {
|
||||
const abbreviation = writer.abbreviation_buffer.append(.{});
|
||||
abbreviation.add_literal(@intFromEnum(MetadataCode.generic_debug));
|
||||
abbreviation.add_with_encoding(.{ .encoding = .fixed, .value = 1 });
|
||||
abbreviation.add_with_encoding(.{ .encoding = .vbr, .value = 6 });
|
||||
abbreviation.add_with_encoding(.{ .encoding = .fixed, .value = 1 });
|
||||
abbreviation.add_with_encoding(.{ .encoding = .vbr, .value = 6 });
|
||||
abbreviation.add_with_encoding(.{ .encoding = .array });
|
||||
abbreviation.add_with_encoding(.{ .encoding = .vbr, .value = 6 });
|
||||
|
||||
const result = writer.emit_abbreviation(abbreviation);
|
||||
return result;
|
||||
}
|
||||
|
||||
fn write_module_metadata(writer: *Writer) void {
|
||||
_ = writer; // autofix
|
||||
// TODO:
|
||||
const dbg align(4) = [_]u8 {
|
||||
0x79, 0x20, 0x00, 0x00,
|
||||
0x6a, 0x00, 0x00, 0x00,
|
||||
0x72, 0x1e, 0x48, 0x20,
|
||||
0x43, 0x88, 0x0c, 0x19,
|
||||
0x09, 0x72, 0x32, 0x48,
|
||||
0x20, 0x23, 0x81, 0x8c,
|
||||
0x91, 0x91, 0xd1, 0x44,
|
||||
0xa0, 0x10, 0x28, 0x64,
|
||||
0x3c, 0x31, 0x32, 0x42,
|
||||
0x8e, 0x90, 0x21, 0xa3,
|
||||
0xb8, 0x30, 0xf4, 0x01,
|
||||
0xc6, 0x02, 0x06, 0xe8,
|
||||
0xd0, 0x48, 0x4a, 0x92,
|
||||
0x1c, 0x0d, 0x00, 0x00,
|
||||
0x6d, 0x61, 0x69, 0x6e,
|
||||
0x2e, 0x63, 0x2f, 0x68,
|
||||
0x6f, 0x6d, 0x65, 0x2f,
|
||||
0x64, 0x61, 0x76, 0x69,
|
||||
0x64, 0x64, 0x35, 0x36,
|
||||
0x65, 0x30, 0x63, 0x30,
|
||||
0x39, 0x62, 0x30, 0x32,
|
||||
0x32, 0x33, 0x37, 0x61,
|
||||
0x61, 0x37, 0x38, 0x63,
|
||||
0x61, 0x62, 0x39, 0x39,
|
||||
0x64, 0x35, 0x36, 0x65,
|
||||
0x65, 0x65, 0x36, 0x63,
|
||||
0x63, 0x63, 0x6c, 0x61,
|
||||
0x6e, 0x67, 0x20, 0x76,
|
||||
0x65, 0x72, 0x73, 0x69,
|
||||
0x6f, 0x6e, 0x20, 0x31,
|
||||
0x38, 0x2e, 0x31, 0x2e,
|
||||
0x36, 0x20, 0x28, 0x68,
|
||||
0x74, 0x74, 0x70, 0x73,
|
||||
0x3a, 0x2f, 0x2f, 0x67,
|
||||
0x69, 0x74, 0x68, 0x75,
|
||||
0x62, 0x2e, 0x63, 0x6f,
|
||||
0x6d, 0x2f, 0x6c, 0x6c,
|
||||
0x76, 0x6d, 0x2f, 0x6c,
|
||||
0x6c, 0x76, 0x6d, 0x2d,
|
||||
0x70, 0x72, 0x6f, 0x6a,
|
||||
0x65, 0x63, 0x74, 0x2e,
|
||||
0x67, 0x69, 0x74, 0x20,
|
||||
0x62, 0x63, 0x65, 0x39,
|
||||
0x33, 0x39, 0x33, 0x32,
|
||||
0x39, 0x31, 0x61, 0x32,
|
||||
0x64, 0x61, 0x61, 0x38,
|
||||
0x30, 0x30, 0x36, 0x64,
|
||||
0x31, 0x64, 0x61, 0x36,
|
||||
0x32, 0x39, 0x61, 0x61,
|
||||
0x32, 0x37, 0x36, 0x35,
|
||||
0x65, 0x30, 0x30, 0x66,
|
||||
0x34, 0x65, 0x37, 0x30,
|
||||
0x29, 0x44, 0x77, 0x61,
|
||||
0x72, 0x66, 0x20, 0x56,
|
||||
0x65, 0x72, 0x73, 0x69,
|
||||
0x6f, 0x6e, 0x44, 0x65,
|
||||
0x62, 0x75, 0x67, 0x20,
|
||||
0x49, 0x6e, 0x66, 0x6f,
|
||||
0x20, 0x56, 0x65, 0x72,
|
||||
0x73, 0x69, 0x6f, 0x6e,
|
||||
0x77, 0x63, 0x68, 0x61,
|
||||
0x72, 0x5f, 0x73, 0x69,
|
||||
0x7a, 0x65, 0x50, 0x49,
|
||||
0x43, 0x20, 0x4c, 0x65,
|
||||
0x76, 0x65, 0x6c, 0x50,
|
||||
0x49, 0x45, 0x20, 0x4c,
|
||||
0x65, 0x76, 0x65, 0x6c,
|
||||
0x75, 0x77, 0x74, 0x61,
|
||||
0x62, 0x6c, 0x65, 0x66,
|
||||
0x72, 0x61, 0x6d, 0x65,
|
||||
0x2d, 0x70, 0x6f, 0x69,
|
||||
0x6e, 0x74, 0x65, 0x72,
|
||||
0x23, 0x08, 0x81, 0x30,
|
||||
0x82, 0x10, 0x0c, 0x23,
|
||||
0x08, 0x01, 0x31, 0x82,
|
||||
0x10, 0x14, 0x23, 0x08,
|
||||
0x81, 0x31, 0x82, 0x10,
|
||||
0x1c, 0x23, 0x08, 0x01,
|
||||
0x32, 0x94, 0x15, 0x74,
|
||||
0x14, 0x01, 0x00, 0x00,
|
||||
0x10, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x02, 0x00, 0x00, 0x03,
|
||||
0x15, 0x40, 0x20, 0x04,
|
||||
0xc3, 0x0c, 0x03, 0x53,
|
||||
0x34, 0x33, 0x0c, 0x8e,
|
||||
0xf1, 0xcc, 0x30, 0x40,
|
||||
0x47, 0x34, 0xc3, 0x20,
|
||||
0x21, 0xce, 0x0c, 0x03,
|
||||
0x93, 0x38, 0x33, 0x0c,
|
||||
0x8c, 0xe2, 0xcc, 0x30,
|
||||
0x30, 0x8b, 0x33, 0x43,
|
||||
0x40, 0xc8, 0x48, 0x60,
|
||||
0x82, 0x72, 0x61, 0x63,
|
||||
0xb3, 0x6b, 0x73, 0x21,
|
||||
0x13, 0x3b, 0x73, 0x19,
|
||||
0xab, 0x1b, 0x25, 0x90,
|
||||
0x32, 0x62, 0x63, 0xb3,
|
||||
0x6b, 0x73, 0x69, 0x7b,
|
||||
0x23, 0xab, 0x63, 0x2b,
|
||||
0x73, 0x31, 0x63, 0x0b,
|
||||
0x3b, 0x9b, 0x1b, 0xe5,
|
||||
0xa0, 0x2a, 0xeb, 0xc2,
|
||||
0x32, 0x2d, 0x15, 0x36,
|
||||
0x36, 0xbb, 0x36, 0x97,
|
||||
0x34, 0xb2, 0x32, 0x37,
|
||||
0xba, 0x51, 0x82, 0x0d,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
};
|
||||
const start = writer.buffer.length * 4;
|
||||
// _ = start; // autofix
|
||||
writer.append_bytes(&dbg);
|
||||
const end = writer.buffer.length * 4;
|
||||
const expected = debug_main_bitcode[start..end];
|
||||
const have = writer.get_byte_slice()[start..end];
|
||||
std.testing.expectEqualSlices(u8, expected, have) catch unreachable;
|
||||
// writer.buffer.
|
||||
|
||||
// writer.enter_subblock(.metadata, 4);
|
||||
//
|
||||
// const start = writer.buffer.length * 4;
|
||||
//
|
||||
// const di_location_abbreviation = writer.create_di_location_abbreviation();
|
||||
// _ = di_location_abbreviation; // autofix
|
||||
// const generic_di_node_abbreviation = writer.create_generic_di_node_abbreviation();
|
||||
// _ = generic_di_node_abbreviation; // autofix
|
||||
// const offset_abbreviation = blk: {
|
||||
// const abbreviation = writer.abbreviation_buffer.append(.{});
|
||||
// abbreviation.add_literal(@intFromEnum(MetadataCode.index_offset));
|
||||
// abbreviation.add_with_encoding(.{ .encoding = .fixed, .value = 32 });
|
||||
// abbreviation.add_with_encoding(.{ .encoding = .fixed, .value = 32 });
|
||||
//
|
||||
// const result = writer.emit_abbreviation(abbreviation);
|
||||
// break :blk result;
|
||||
// };
|
||||
// _ = offset_abbreviation; // autofix
|
||||
// const index_abbreviation = blk: {
|
||||
// const abbreviation = writer.abbreviation_buffer.append(.{});
|
||||
// abbreviation.add_literal(@intFromEnum(MetadataCode.index));
|
||||
// abbreviation.add_with_encoding(.{ .encoding = .array });
|
||||
// abbreviation.add_with_encoding(.{ .encoding = .vbr, .value = 6 });
|
||||
//
|
||||
// const result = writer.emit_abbreviation(abbreviation);
|
||||
// break :blk result;
|
||||
// };
|
||||
// _ = index_abbreviation; // autofix
|
||||
//
|
||||
// var record_buffer = std.BoundedArray(u64, 64){};
|
||||
// const metadata_strings: []const []const u8 = &.{
|
||||
// "main.c",
|
||||
// "/home/david",
|
||||
// "d56e0c09b02237aa78cab99d56eee6cc",
|
||||
// "clang version 18.1.6 (https://github.com/llvm/llvm-project.git bce9393291a2daa8006d1da629aa2765e00f4e70)",
|
||||
// "Dwarf Version",
|
||||
// "Debug Info Version",
|
||||
// "wchar_size",
|
||||
// "PIC Level",
|
||||
// "PIE Level",
|
||||
// "uwtable",
|
||||
// "frame-pointer",
|
||||
// };
|
||||
// writer.write_metadata_strings(metadata_strings, &record_buffer);
|
||||
//
|
||||
// // TODO: check LLVM code, non-md-string > index_threshold
|
||||
//
|
||||
// const index_offset_record_bit_position = writer.get_bit_position();
|
||||
// _ = index_offset_record_bit_position; // autofix
|
||||
// // TODO:
|
||||
// writer.write_metadata_records(&record_buffer);
|
||||
// // TODO: more threshold
|
||||
//
|
||||
// writer.write_named_metadata(&record_buffer);
|
||||
//
|
||||
// writer.exit_block();
|
||||
//
|
||||
// const dbg = [_]u8 {
|
||||
// 0x79, 0x20, 0x00, 0x00,
|
||||
// 0x6a, 0x00, 0x00, 0x00,
|
||||
// 0x72, 0x1e, 0x48, 0x20,
|
||||
// 0x43, 0x88, 0x0c, 0x19,
|
||||
// 0x09, 0x72, 0x32, 0x48,
|
||||
// 0x20, 0x23, 0x81, 0x8c,
|
||||
// 0x91, 0x91, 0xd1, 0x44,
|
||||
// 0xa0, 0x10, 0x28, 0x64,
|
||||
// 0x3c, 0x31, 0x32, 0x42,
|
||||
// 0x8e, 0x90, 0x21, 0xa3,
|
||||
// 0xb8, 0x30, 0xf4, 0x01,
|
||||
// 0xc6, 0x02, 0x06, 0xe8,
|
||||
// 0xd0, 0x48, 0x4a, 0x92,
|
||||
// 0x1c, 0x0d, 0x00, 0x00,
|
||||
// 0x6d, 0x61, 0x69, 0x6e,
|
||||
// 0x2e, 0x63, 0x2f, 0x68,
|
||||
// 0x6f, 0x6d, 0x65, 0x2f,
|
||||
// 0x64, 0x61, 0x76, 0x69,
|
||||
// 0x64, 0x64, 0x35, 0x36,
|
||||
// 0x65, 0x30, 0x63, 0x30,
|
||||
// 0x39, 0x62, 0x30, 0x32,
|
||||
// 0x32, 0x33, 0x37, 0x61,
|
||||
// 0x61, 0x37, 0x38, 0x63,
|
||||
// 0x61, 0x62, 0x39, 0x39,
|
||||
// 0x64, 0x35, 0x36, 0x65,
|
||||
// 0x65, 0x65, 0x36, 0x63,
|
||||
// 0x63, 0x63, 0x6c, 0x61,
|
||||
// 0x6e, 0x67, 0x20, 0x76,
|
||||
// 0x65, 0x72, 0x73, 0x69,
|
||||
// 0x6f, 0x6e, 0x20, 0x31,
|
||||
// 0x38, 0x2e, 0x31, 0x2e,
|
||||
// 0x36, 0x20, 0x28, 0x68,
|
||||
// 0x74, 0x74, 0x70, 0x73,
|
||||
// 0x3a, 0x2f, 0x2f, 0x67,
|
||||
// 0x69, 0x74, 0x68, 0x75,
|
||||
// 0x62, 0x2e, 0x63, 0x6f,
|
||||
// 0x6d, 0x2f, 0x6c, 0x6c,
|
||||
// 0x76, 0x6d, 0x2f, 0x6c,
|
||||
// 0x6c, 0x76, 0x6d, 0x2d,
|
||||
// 0x70, 0x72, 0x6f, 0x6a,
|
||||
// 0x65, 0x63, 0x74, 0x2e,
|
||||
// 0x67, 0x69, 0x74, 0x20,
|
||||
// 0x62, 0x63, 0x65, 0x39,
|
||||
// 0x33, 0x39, 0x33, 0x32,
|
||||
// 0x39, 0x31, 0x61, 0x32,
|
||||
// 0x64, 0x61, 0x61, 0x38,
|
||||
// 0x30, 0x30, 0x36, 0x64,
|
||||
// 0x31, 0x64, 0x61, 0x36,
|
||||
// 0x32, 0x39, 0x61, 0x61,
|
||||
// 0x32, 0x37, 0x36, 0x35,
|
||||
// 0x65, 0x30, 0x30, 0x66,
|
||||
// 0x34, 0x65, 0x37, 0x30,
|
||||
// 0x29, 0x44, 0x77, 0x61,
|
||||
// 0x72, 0x66, 0x20, 0x56,
|
||||
// 0x65, 0x72, 0x73, 0x69,
|
||||
// 0x6f, 0x6e, 0x44, 0x65,
|
||||
// 0x62, 0x75, 0x67, 0x20,
|
||||
// 0x49, 0x6e, 0x66, 0x6f,
|
||||
// 0x20, 0x56, 0x65, 0x72,
|
||||
// 0x73, 0x69, 0x6f, 0x6e,
|
||||
// 0x77, 0x63, 0x68, 0x61,
|
||||
// 0x72, 0x5f, 0x73, 0x69,
|
||||
// 0x7a, 0x65, 0x50, 0x49,
|
||||
// 0x43, 0x20, 0x4c, 0x65,
|
||||
// 0x76, 0x65, 0x6c, 0x50,
|
||||
// 0x49, 0x45, 0x20, 0x4c,
|
||||
// 0x65, 0x76, 0x65, 0x6c,
|
||||
// 0x75, 0x77, 0x74, 0x61,
|
||||
// 0x62, 0x6c, 0x65, 0x66,
|
||||
// 0x72, 0x61, 0x6d, 0x65,
|
||||
// 0x2d, 0x70, 0x6f, 0x69,
|
||||
// 0x6e, 0x74, 0x65, 0x72,
|
||||
// 0x23, 0x08, 0x81, 0x30,
|
||||
// 0x82, 0x10, 0x0c, 0x23,
|
||||
// 0x08, 0x01, 0x31, 0x82,
|
||||
// 0x10, 0x14, 0x23, 0x08,
|
||||
// 0x81, 0x31, 0x82, 0x10,
|
||||
// 0x1c, 0x23, 0x08, 0x01,
|
||||
// 0x32, 0x94, 0x15, 0x74,
|
||||
// 0x14, 0x01, 0x00, 0x00,
|
||||
// 0x10, 0x00, 0x00, 0x00,
|
||||
// 0x00, 0x00, 0x00, 0x00,
|
||||
// 0x02, 0x00, 0x00, 0x03,
|
||||
// 0x15, 0x40, 0x20, 0x04,
|
||||
// 0xc3, 0x0c, 0x03, 0x53,
|
||||
// 0x34, 0x33, 0x0c, 0x8e,
|
||||
// 0xf1, 0xcc, 0x30, 0x40,
|
||||
// 0x47, 0x34, 0xc3, 0x20,
|
||||
// 0x21, 0xce, 0x0c, 0x03,
|
||||
// 0x93, 0x38, 0x33, 0x0c,
|
||||
// 0x8c, 0xe2, 0xcc, 0x30,
|
||||
// 0x30, 0x8b, 0x33, 0x43,
|
||||
// 0x40, 0xc8, 0x48, 0x60,
|
||||
// 0x82, 0x72, 0x61, 0x63,
|
||||
// 0xb3, 0x6b, 0x73, 0x21,
|
||||
// 0x13, 0x3b, 0x73, 0x19,
|
||||
// 0xab, 0x1b, 0x25, 0x90,
|
||||
// 0x32, 0x62, 0x63, 0xb3,
|
||||
// 0x6b, 0x73, 0x69, 0x7b,
|
||||
// 0x23, 0xab, 0x63, 0x2b,
|
||||
// 0x73, 0x31, 0x63, 0x0b,
|
||||
// 0x3b, 0x9b, 0x1b, 0xe5,
|
||||
// 0xa0, 0x2a, 0xeb, 0xc2,
|
||||
// 0x32, 0x2d, 0x15, 0x36,
|
||||
// 0x36, 0xbb, 0x36, 0x97,
|
||||
// 0x34, 0xb2, 0x32, 0x37,
|
||||
// 0xba, 0x51, 0x82, 0x0d,
|
||||
// 0x00, 0x00, 0x00, 0x00,
|
||||
// };
|
||||
// const end = writer.buffer.length * 4;
|
||||
// const expected = debug_main_bitcode[start..end];
|
||||
// const have = writer.get_byte_slice()[start..end];
|
||||
// if (dbg.len >= have.len) {
|
||||
// const diff = dbg.len - have.len;
|
||||
// std.debug.print("Diff: {}\n", .{diff});
|
||||
// }
|
||||
// // print_hex_slice(expected);
|
||||
// std.debug.print("\n\nStart: {}\n", .{start});
|
||||
// std.testing.expectEqualSlices(u8, expected, have) catch unreachable;
|
||||
}
|
||||
|
||||
fn create_named_metadata_abbreviation(writer: *Writer) u32 {
|
||||
const abbreviation = writer.abbreviation_buffer.append(.{});
|
||||
abbreviation.add_literal(@intFromEnum(MetadataCode.name));
|
||||
abbreviation.add_with_encoding(.{ .encoding = .array });
|
||||
abbreviation.add_with_encoding(.{ .encoding = .fixed, .value = 8 });
|
||||
|
||||
const result = writer.emit_abbreviation(abbreviation);
|
||||
return result;
|
||||
}
|
||||
|
||||
const DummyNamedNode = struct {
|
||||
name: []const u8,
|
||||
operands: []const u32,
|
||||
};
|
||||
const dummy_named_nodes =[3]DummyNamedNode{
|
||||
.{
|
||||
.name = "llvm.dbg.cu",
|
||||
.operands = &.{0},
|
||||
},
|
||||
.{
|
||||
.name = "llvm.module.flags",
|
||||
.operands = &.{0},
|
||||
},
|
||||
.{
|
||||
.name = "llvm.ident",
|
||||
.operands = &.{0},
|
||||
},
|
||||
};
|
||||
|
||||
fn write_named_metadata(writer: *Writer, record_buffer: *std.BoundedArray(u64, 64)) void {
|
||||
const abbreviation = writer.create_named_metadata_abbreviation();
|
||||
for (dummy_named_nodes) |named_node| {
|
||||
for (named_node.name) |b| {
|
||||
record_buffer.appendAssumeCapacity(b);
|
||||
}
|
||||
|
||||
writer.emit_record(u64, @intFromEnum(MetadataCode.name), record_buffer.constSlice(), abbreviation);
|
||||
record_buffer.resize(0) catch unreachable;
|
||||
|
||||
for (named_node.operands) |operand| {
|
||||
record_buffer.appendAssumeCapacity(operand);
|
||||
}
|
||||
|
||||
writer.emit_record(u64, @intFromEnum(MetadataCode.named_node), record_buffer.constSlice(), 0);
|
||||
record_buffer.resize(0) catch unreachable;
|
||||
}
|
||||
}
|
||||
|
||||
const DummyMetadataRecord = union(enum) {
|
||||
value: @This().Value,
|
||||
node: @This().Node,
|
||||
compile_unit: @This().CompileUnit,
|
||||
file: @This().File,
|
||||
// name: @This().Name,
|
||||
// named_node: @This().NamedNode,
|
||||
const Value = struct{
|
||||
type_id: u32,
|
||||
value_id: u32,
|
||||
};
|
||||
|
||||
const Node = struct{
|
||||
ops: []const u8,
|
||||
};
|
||||
|
||||
const CompileUnit = struct{
|
||||
source_language: u32,
|
||||
file: u32,
|
||||
raw_producer: u32,
|
||||
is_optimized: bool,
|
||||
raw_flags: u32,
|
||||
runtime_version: u32,
|
||||
raw_split_debug_filename: u32,
|
||||
debug_emission_kind: LLVM.DebugInfo.CompileUnit.EmissionKind,
|
||||
enum_types: u32,
|
||||
retained_types: u32,
|
||||
subprograms: u32 = 0,
|
||||
global_variables: u32,
|
||||
imported_entities: u32,
|
||||
dwoid: u32,
|
||||
macros: u32,
|
||||
split_debug_inlining: bool,
|
||||
debug_info_for_profiling: bool,
|
||||
name_table_kind: LLVM.DebugInfo.CompileUnit.NameTableKind,
|
||||
ranges_base_address: u32,
|
||||
sysroot: u32,
|
||||
sdk: u32,
|
||||
};
|
||||
|
||||
const File = struct{
|
||||
is_distinct: bool,
|
||||
filename: u32,
|
||||
directory: u32,
|
||||
checksum_kind: u32,
|
||||
checksum_value: u32,
|
||||
source: u32,
|
||||
};
|
||||
|
||||
// const Name = struct {
|
||||
// };
|
||||
// const NamedNode = struct{
|
||||
// };
|
||||
};
|
||||
|
||||
const source_language = 2;
|
||||
const dummy_metadata_records = [17]DummyMetadataRecord{
|
||||
.{ .value = .{ .type_id = 1, .value_id = 2 } },
|
||||
.{ .value = .{ .type_id = 1, .value_id = 3 } },
|
||||
.{ .value = .{ .type_id = 1, .value_id = 4 } },
|
||||
.{ .value = .{ .type_id = 1, .value_id = 5 } },
|
||||
.{ .value = .{ .type_id = 1, .value_id = 6 } },
|
||||
.{ .value = .{ .type_id = 1, .value_id = 7 } },
|
||||
.{ .value = .{ .type_id = 1, .value_id = 8 } },
|
||||
.{
|
||||
.compile_unit = .{
|
||||
.source_language = source_language,
|
||||
.file = 0,
|
||||
.raw_producer = 0,
|
||||
.is_optimized = false,
|
||||
.raw_flags = 0,
|
||||
.runtime_version = 0,
|
||||
.raw_split_debug_filename = 0,
|
||||
.debug_emission_kind = .full_debug,
|
||||
.enum_types = 0,
|
||||
.retained_types = 0,
|
||||
.subprograms = 0,
|
||||
.global_variables = 0,
|
||||
.imported_entities = 0,
|
||||
.dwoid = 0,
|
||||
.macros = 0,
|
||||
.split_debug_inlining = false,
|
||||
.debug_info_for_profiling = false,
|
||||
.name_table_kind = .default,
|
||||
.ranges_base_address = 0,
|
||||
.sysroot = 0,
|
||||
.sdk = 0,
|
||||
},
|
||||
},
|
||||
.{
|
||||
.file = .{
|
||||
.is_distinct = false,
|
||||
.filename = 0,
|
||||
.directory = 0,
|
||||
.checksum_kind = 0,
|
||||
.checksum_value = 0,
|
||||
.source = 0,
|
||||
},
|
||||
},
|
||||
.{ .node = .{ .ops = &.{ 12, } } },
|
||||
.{ .node = .{ .ops = &.{ 14, } } },
|
||||
.{ .node = .{ .ops = &.{ 16, } } },
|
||||
.{ .node = .{ .ops = &.{ 18, } } },
|
||||
.{ .node = .{ .ops = &.{ 12, } } },
|
||||
.{ .node = .{ .ops = &.{ 12, } } },
|
||||
.{ .node = .{ .ops = &.{ 12, } } },
|
||||
.{ .node = .{ .ops = &.{ 4 } } },
|
||||
|
||||
// .{ .node = .{ .ops = &.{ 12, 5, 13 } } },
|
||||
// .{ .node = .{ .ops = &.{ 14, 6, 15 } } },
|
||||
// .{ .node = .{ .ops = &.{ 16, 7, 17 } } },
|
||||
// .{ .node = .{ .ops = &.{ 18, 8, 14 } } },
|
||||
// .{ .node = .{ .ops = &.{ 12, 9, 14 } } },
|
||||
// .{ .node = .{ .ops = &.{ 12, 10, 14 } } },
|
||||
// .{ .node = .{ .ops = &.{ 12, 11, 14 } } },
|
||||
// .{ .node = .{ .ops = &.{ 4 } } },
|
||||
};
|
||||
|
||||
fn write_metadata_records(writer: *Writer, record: *std.BoundedArray(u64, 64)) void {
|
||||
var node_first = true;
|
||||
var node_a: u32 = 0;
|
||||
for (dummy_metadata_records) |metadata_record| {
|
||||
switch (metadata_record) {
|
||||
.value => |v| {
|
||||
record.appendAssumeCapacity(v.type_id);
|
||||
record.appendAssumeCapacity(v.value_id);
|
||||
writer.emit_record(u64, @intFromEnum(MetadataCode.value), record.constSlice(), 0);
|
||||
record.resize(0) catch unreachable;
|
||||
},
|
||||
.compile_unit => |cu| {
|
||||
const is_distinct = true;
|
||||
record.appendAssumeCapacity(@intFromBool(is_distinct));
|
||||
record.appendAssumeCapacity(cu.source_language);
|
||||
record.appendAssumeCapacity(cu.file);
|
||||
record.appendAssumeCapacity(cu.raw_producer);
|
||||
record.appendAssumeCapacity(@intFromBool(cu.is_optimized));
|
||||
record.appendAssumeCapacity(cu.raw_flags);
|
||||
record.appendAssumeCapacity(cu.runtime_version);
|
||||
record.appendAssumeCapacity(cu.raw_split_debug_filename);
|
||||
record.appendAssumeCapacity(@intFromEnum(cu.debug_emission_kind));
|
||||
record.appendAssumeCapacity(cu.enum_types);
|
||||
record.appendAssumeCapacity(cu.retained_types);
|
||||
record.appendAssumeCapacity(cu.subprograms);
|
||||
record.appendAssumeCapacity(cu.global_variables);
|
||||
record.appendAssumeCapacity(cu.imported_entities);
|
||||
record.appendAssumeCapacity(cu.dwoid);
|
||||
record.appendAssumeCapacity(cu.macros);
|
||||
record.appendAssumeCapacity(@intFromBool(cu.split_debug_inlining));
|
||||
record.appendAssumeCapacity(@intFromBool(cu.debug_info_for_profiling));
|
||||
record.appendAssumeCapacity(@intFromEnum(cu.name_table_kind));
|
||||
record.appendAssumeCapacity(cu.ranges_base_address);
|
||||
record.appendAssumeCapacity(cu.sysroot);
|
||||
record.appendAssumeCapacity(cu.sdk);
|
||||
|
||||
const abbreviation = writer.abbreviation_buffer.append(.{});
|
||||
abbreviation.add_literal(20);
|
||||
abbreviation.add_literal(1);
|
||||
abbreviation.add_literal(source_language);
|
||||
abbreviation.add_with_encoding(.{ .encoding = .vbr, .value = 16 });
|
||||
abbreviation.add_with_encoding(.{ .encoding = .vbr, .value = 16 });
|
||||
abbreviation.add_with_encoding(.{ .encoding = .fixed, .value = 1 });
|
||||
abbreviation.add_literal(0);
|
||||
abbreviation.add_literal(0);
|
||||
abbreviation.add_literal(0);
|
||||
abbreviation.add_literal(1);
|
||||
abbreviation.add_with_encoding(.{ .encoding = .vbr, .value = 16 });
|
||||
abbreviation.add_literal(0);
|
||||
abbreviation.add_literal(0);
|
||||
abbreviation.add_with_encoding(.{ .encoding = .vbr, .value = 16 });
|
||||
abbreviation.add_literal(0);
|
||||
abbreviation.add_literal(0);
|
||||
abbreviation.add_literal(0);
|
||||
abbreviation.add_literal(0);
|
||||
abbreviation.add_literal(0);
|
||||
abbreviation.add_literal(0);
|
||||
abbreviation.add_literal(0);
|
||||
abbreviation.add_literal(0);
|
||||
abbreviation.add_literal(0);
|
||||
|
||||
const a = writer.emit_abbreviation(abbreviation);
|
||||
writer.emit_record(u64, @intFromEnum(MetadataCode.compile_unit), record.constSlice(), a);
|
||||
record.resize(0) catch unreachable;
|
||||
},
|
||||
.file => |file| {
|
||||
record.appendAssumeCapacity(@intFromBool(file.is_distinct));
|
||||
record.appendAssumeCapacity(file.filename);
|
||||
record.appendAssumeCapacity(file.directory);
|
||||
record.appendAssumeCapacity(file.checksum_kind);
|
||||
record.appendAssumeCapacity(file.checksum_value);
|
||||
|
||||
|
||||
const abbreviation = writer.abbreviation_buffer.append(.{});
|
||||
abbreviation.add_literal(16);
|
||||
abbreviation.add_literal(0);
|
||||
abbreviation.add_with_encoding(.{ .encoding = .vbr, .value = 16 });
|
||||
abbreviation.add_with_encoding(.{ .encoding = .vbr, .value = 16 });
|
||||
abbreviation.add_literal(0);
|
||||
abbreviation.add_literal(0);
|
||||
|
||||
const a = writer.emit_abbreviation(abbreviation);
|
||||
writer.emit_record(u64, @intFromEnum(MetadataCode.file), record.constSlice(), a);
|
||||
record.resize(0) catch unreachable;
|
||||
},
|
||||
.node => |node| {
|
||||
for (node.ops) |op| {
|
||||
record.appendAssumeCapacity(op);
|
||||
}
|
||||
|
||||
if (node_first) {
|
||||
const abbreviation = writer.abbreviation_buffer.append(.{});
|
||||
abbreviation.add_literal(3);
|
||||
abbreviation.add_with_encoding(.{ .encoding = .vbr, .value = 16 });
|
||||
const a = writer.emit_abbreviation(abbreviation);
|
||||
node_a = a;
|
||||
node_first = false;
|
||||
}
|
||||
|
||||
writer.emit_record(u64, @intFromEnum(MetadataCode.node), record.constSlice(), node_a);
|
||||
record.resize(0) catch unreachable;
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn write_metadata_strings(writer: *Writer, strings: []const []const u8, record_buffer: *std.BoundedArray(u64, 64)) void {
|
||||
if (strings.len > 0) {
|
||||
record_buffer.appendAssumeCapacity(@intFromEnum(MetadataCode.strings));
|
||||
record_buffer.appendAssumeCapacity(strings.len);
|
||||
|
||||
var blob = blk: {
|
||||
var blob_writer = Writer{};
|
||||
for (strings) |string| {
|
||||
blob_writer.emit_vbr(@intCast(string.len), 6);
|
||||
}
|
||||
|
||||
blob_writer.flush();
|
||||
var blob = PinnedArray(u8){};
|
||||
blob.append_slice(blob_writer.get_byte_slice());
|
||||
break :blk blob;
|
||||
};
|
||||
record_buffer.appendAssumeCapacity(blob.length);
|
||||
|
||||
for (strings) |string| {
|
||||
blob.append_slice(string);
|
||||
}
|
||||
|
||||
const strings_abbreviation = writer.create_metadata_strings_abbreviation();
|
||||
writer.emit_record_with_blob(u64, strings_abbreviation, record_buffer.constSlice(), blob.slice());
|
||||
record_buffer.resize(0) catch unreachable;
|
||||
}
|
||||
}
|
||||
|
||||
fn create_metadata_strings_abbreviation(writer: *Writer) u32 {
|
||||
const abbreviation = writer.abbreviation_buffer.append(.{});
|
||||
abbreviation.add_literal(@intFromEnum(MetadataCode.strings));
|
||||
abbreviation.add_with_encoding(.{ .encoding = .vbr, .value = 6 });
|
||||
abbreviation.add_with_encoding(.{ .encoding = .vbr, .value = 6 });
|
||||
abbreviation.add_with_encoding(.{ .encoding = .blob });
|
||||
|
||||
const result = writer.emit_abbreviation(abbreviation);
|
||||
return result;
|
||||
}
|
||||
|
||||
fn emit_record_with_blob(writer: *Writer, comptime T: type, abbreviation: u32, values: []const T, blob: []const u8) void {
|
||||
writer.emit_record_with_abbrev_impl(T, abbreviation, values, blob, null);
|
||||
}
|
||||
|
||||
fn write_use_list_block(writer: *Writer, function: ?*u32) void {
|
||||
@ -4087,12 +4736,67 @@ const Bitcode = struct {
|
||||
// TODO:
|
||||
}
|
||||
|
||||
const dummy_tags = [_][]const u8{
|
||||
"deopt",
|
||||
"funclet",
|
||||
"gc-transition",
|
||||
"cfguardtarget",
|
||||
"preallocated",
|
||||
"gc-live",
|
||||
"clang.arc.attachedcall",
|
||||
"ptrauth",
|
||||
"kcfi",
|
||||
"convergencectrl",
|
||||
};
|
||||
|
||||
fn write_operand_bundle_tags(writer: *Writer) void {
|
||||
_ = writer; // autofix
|
||||
if (dummy_tags.len > 0) {
|
||||
writer.enter_subblock(.operand_bundle_tags, 3);
|
||||
|
||||
const start = writer.buffer.length * 4;
|
||||
var record = std.BoundedArray(u64, 64){};
|
||||
for (dummy_tags) |tag| {
|
||||
for (tag) |b| {
|
||||
record.appendAssumeCapacity(b);
|
||||
}
|
||||
|
||||
writer.emit_record(u64, @intFromEnum(OperandBundleTagCode.operand_bundle_tag), record.constSlice(), 0);
|
||||
record.resize(0) catch unreachable;
|
||||
}
|
||||
|
||||
writer.exit_block();
|
||||
|
||||
const end = writer.buffer.length * 4;
|
||||
const expected = debug_main_bitcode[start..end];
|
||||
const have = writer.get_byte_slice()[start..end];
|
||||
std.testing.expectEqualSlices(u8, expected, have) catch unreachable;
|
||||
}
|
||||
}
|
||||
|
||||
const dummy_sync_scope_names = [_][]const u8{"singlethread", ""};
|
||||
|
||||
fn write_sync_scope_names(writer: *Writer) void {
|
||||
_ = writer; // autofix
|
||||
if (dummy_sync_scope_names.len > 0) {
|
||||
writer.enter_subblock(.sync_scope_names, 2);
|
||||
|
||||
const start = writer.buffer.length * 4;
|
||||
var record = std.BoundedArray(u64, 64){};
|
||||
for (dummy_sync_scope_names) |name| {
|
||||
for (name) |b| {
|
||||
record.appendAssumeCapacity(b);
|
||||
}
|
||||
|
||||
writer.emit_record(u64, @intFromEnum(SyncScopeNameCode.sync_scope_name), record.constSlice(), 0);
|
||||
record.resize(0) catch unreachable;
|
||||
}
|
||||
|
||||
writer.exit_block();
|
||||
|
||||
const end = writer.buffer.length * 4;
|
||||
const expected = debug_main_bitcode[start..end];
|
||||
const have = writer.get_byte_slice()[start..end];
|
||||
std.testing.expectEqualSlices(u8, expected, have) catch unreachable;
|
||||
}
|
||||
}
|
||||
|
||||
fn write_value_symbol_table_forward_declaration(writer: *Writer) void {
|
||||
@ -4159,7 +4863,7 @@ const Bitcode = struct {
|
||||
|
||||
fn write_raw(writer: *Writer, value: u32) void {
|
||||
std.debug.print("[{}-{}] Flushing buffer 0x{x}\n", .{writer.buffer.length, writer.buffer.length * 4, value});
|
||||
// if (writer.buffer.length == (712) / 4 - 1) @breakpoint();
|
||||
if (writer.buffer.length == (1884) / 4 - 1) @breakpoint();
|
||||
// if (writer.buffer.length == (152 + 32) / 4) @breakpoint();
|
||||
_ = writer.buffer.append(value);
|
||||
}
|
||||
@ -4272,6 +4976,10 @@ const Bitcode = struct {
|
||||
std.testing.expectEqualSlices(u8, &identification_block, writer.get_byte_slice()[4..]) catch unreachable;
|
||||
}
|
||||
|
||||
fn get_bit_position(writer: *Writer) u32 {
|
||||
return writer.buffer.length * @bitSizeOf(u32) + writer.current_bit;
|
||||
}
|
||||
|
||||
fn exit_block(writer: *Writer) void {
|
||||
assert(writer.block_scope.length != 0);
|
||||
|
||||
@ -4366,7 +5074,13 @@ const Bitcode = struct {
|
||||
}
|
||||
}
|
||||
} else if (operand.encoding == .blob) {
|
||||
if (string) |s| {
|
||||
assert(record_index == values.len);
|
||||
assert(s.len > 0);
|
||||
writer.emit_blob(s, true);
|
||||
} else {
|
||||
unreachable;
|
||||
}
|
||||
} else {
|
||||
assert(record_index < values.len);
|
||||
writer.emit_abbreviated_field(T, operand, values[record_index]);
|
||||
@ -4376,6 +5090,18 @@ const Bitcode = struct {
|
||||
assert(record_index == values.len);
|
||||
}
|
||||
|
||||
fn emit_blob(writer: *Writer, blob: []const u8, should_emit_size: bool) void {
|
||||
if (should_emit_size) {
|
||||
writer.emit_vbr(@intCast(blob.len), 6);
|
||||
}
|
||||
|
||||
writer.flush();
|
||||
|
||||
// TODO: warning this can cause issues
|
||||
writer.append_bytes(blob);
|
||||
// align the buffer?
|
||||
}
|
||||
|
||||
fn emit_abbreviated_field(writer: *Writer, comptime T: type, operand: *Abbreviation.Op, value: T) void {
|
||||
assert(!operand.is_literal);
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user