std.debug.Dwarf.expression.assert
别名
别名目标 std.debug.assert
std.debug.Dwarf.expression.Builder
类型函数
pub fn Builder(comptime options: Options) type
参数
options: Options
writeOpcodewriteLiteralwriteConstwriteConstxwriteConstTypewriteAddrwriteAddrxwriteFbregwriteBregwriteBregxwriteRegvalTypewritePickwriteDerefSizewriteXDerefSizewriteDerefTypewriteXDerefTypewritePlusUconstwriteSkipwriteBrawriteCallwriteCallRefwriteConvertwriteReinterpretwriteEntryValuewriteRegwriteRegxwriteImplicitValue
std.debug.Dwarf.expression.Builder.writeAddr
函数
pub fn writeAddr(writer: *Writer, value: addr_type) !void
参数
writer: *Writer
value: addr_type
std.debug.Dwarf.expression.Builder.writeAddrx
函数
pub fn writeAddrx(writer: *Writer, debug_addr_offset: anytype) !void
参数
writer: *Writer
std.debug.Dwarf.expression.Builder.writeBra
函数
pub fn writeBra(writer: *Writer, offset: i16) !void
参数
writer: *Writer
offset: i16
std.debug.Dwarf.expression.Builder.writeBreg
函数
pub fn writeBreg(writer: *Writer, register: u8, offset: anytype) !void
参数
writer: *Writer
register: u8
std.debug.Dwarf.expression.Builder.writeBregx
函数
pub fn writeBregx(writer: *Writer, register: anytype, offset: anytype) !void
参数
writer: *Writer
std.debug.Dwarf.expression.Builder.writeCall
函数
pub fn writeCall(writer: *Writer, comptime T: type, offset: T) !void
参数
std.debug.Dwarf.expression.Builder.writeCallRef
函数
pub fn writeCallRef(writer: *Writer, comptime is_64: bool, value: if (is_64) u64 else u32) !void
参数
std.debug.Dwarf.expression.Builder.writeConst
函数
pub fn writeConst(writer: *Writer, comptime T: type, value: T) !void
参数
std.debug.Dwarf.expression.Builder.writeConstType
函数
pub fn writeConstType(writer: *Writer, die_offset: anytype, value_bytes: []const u8) !void
参数
writer: *Writer
value_bytes: []const u8
std.debug.Dwarf.expression.Builder.writeConstx
函数
pub fn writeConstx(writer: *Writer, debug_addr_offset: anytype) !void
参数
writer: *Writer
std.debug.Dwarf.expression.Builder.writeConvert
函数
pub fn writeConvert(writer: *Writer, die_offset: anytype) !void
参数
writer: *Writer
std.debug.Dwarf.expression.Builder.writeDerefSize
函数
pub fn writeDerefSize(writer: *Writer, size: u8) !void
参数
writer: *Writer
size: u8
std.debug.Dwarf.expression.Builder.writeDerefType
函数
pub fn writeDerefType(writer: *Writer, size: u8, die_offset: anytype) !void
参数
writer: *Writer
size: u8
std.debug.Dwarf.expression.Builder.writeEntryValue
函数
pub fn writeEntryValue(writer: *Writer, expression: []const u8) !void
参数
writer: *Writer
expression: []const u8
std.debug.Dwarf.expression.Builder.writeFbreg
函数
pub fn writeFbreg(writer: *Writer, offset: anytype) !void
参数
writer: *Writer
std.debug.Dwarf.expression.Builder.writeImplicitValue
函数
pub fn writeImplicitValue(writer: *Writer, value_bytes: []const u8) !void
参数
writer: *Writer
value_bytes: []const u8
std.debug.Dwarf.expression.Builder.writeLiteral
函数
pub fn writeLiteral(writer: *Writer, literal: u8) !void
参数
writer: *Writer
literal: u8
std.debug.Dwarf.expression.Builder.writeOpcode
函数
零操作数指令
pub fn writeOpcode(writer: *Writer, comptime opcode: u8) !void
参数
writer: *Writer
opcode: u8
std.debug.Dwarf.expression.Builder.writePick
函数
pub fn writePick(writer: *Writer, index: u8) !void
参数
writer: *Writer
index: u8
std.debug.Dwarf.expression.Builder.writePlusUconst
函数
pub fn writePlusUconst(writer: *Writer, uint_value: anytype) !void
参数
writer: *Writer
std.debug.Dwarf.expression.Builder.writeReg
函数
pub fn writeReg(writer: *Writer, register: u8) !void
参数
writer: *Writer
register: u8
std.debug.Dwarf.expression.Builder.writeRegvalType
函数
pub fn writeRegvalType(writer: *Writer, register: anytype, offset: anytype) !void
参数
writer: *Writer
std.debug.Dwarf.expression.Builder.writeRegx
函数
pub fn writeRegx(writer: *Writer, register: anytype) !void
参数
writer: *Writer
std.debug.Dwarf.expression.Builder.writeReinterpret
函数
pub fn writeReinterpret(writer: *Writer, die_offset: anytype) !void
参数
writer: *Writer
std.debug.Dwarf.expression.Builder.writeSkip
函数
pub fn writeSkip(writer: *Writer, offset: i16) !void
参数
writer: *Writer
offset: i16
std.debug.Dwarf.expression.Builder.writeXDerefSize
函数
pub fn writeXDerefSize(writer: *Writer, size: u8) !void
参数
writer: *Writer
size: u8
std.debug.Dwarf.expression.Builder.writeXDerefType
函数
pub fn writeXDerefType(writer: *Writer, size: u8, die_offset: anytype) !void
参数
writer: *Writer
size: u8
std.debug.Dwarf.expression.builtin
常量
std.debug.Dwarf.expression.Context
容器
表达式可在不同上下文中求值,每种上下文都需要各自的一组输入。 调用者应指定与其上下文相关的全部字段。 若表达式需要某字段,但上下文未提供,则返回 error.IncompleteExpressionContext。
字段
format: std.dwarf.Format = .@"32"此表达式所在节的 dwarf 格式
compile_unit: ?*const std.debug.Dwarf.CompileUnit = null此表达式关联的编译单元(如果有)。
object_address: ?*const anyopaque = null对用户提供的表达式求值时,此值是正在求值的对象的地址。
debug_addr: ?[]const u8 = null.debug_addr 节
cpu_context: ?*std.debug.cpu_context.Native = null
cfa: ?usize = null在 CFI 上下文中为调用帧地址
entry_value_context: bool = false此表达式是 OP.entry_value 指令中的子表达式
std.debug.Dwarf.expression.Error
错误集合
错误
- DivisionByZero
- EndOfStream
- IncompatibleRegisterSize
- IncompleteExpressionContext
- InvalidCFAOpcode
- InvalidExpression
- InvalidFrameBase
- InvalidIntegralTypeSize
- InvalidRegister
- InvalidSubExpression
- InvalidTypeLength
- OutOfMemory
- Overflow
- ReadFailed
- TruncatedIntegralType
- UnimplementedExpressionCall
- UnimplementedOpcode
- UnimplementedTypeConversion
- UnimplementedTypedComparison
- UnimplementedUserOpcode
- UnknownExpressionOpcode
- UnsupportedRegister DwarfRegisterError
std.debug.Dwarf.expression.fp_reg_num
常量
std.debug.Dwarf.expression.ip_reg_num
常量
std.debug.Dwarf.expression.isOpcodeRegisterLocation
函数
fn isOpcodeRegisterLocation(opcode: u8) bool
参数
opcode: u8
std.debug.Dwarf.expression.isOpcodeValidInCFA
函数
fn isOpcodeValidInCFA(opcode: u8) bool
参数
opcode: u8
std.debug.Dwarf.expression.leb
别名
别名目标 std.leb
std.debug.Dwarf.expression.mem
别名
别名目标 std.mem
std.debug.Dwarf.expression.native_arch
常量
std.debug.Dwarf.expression.native_endian
常量
std.debug.Dwarf.expression.OP
别名
别名目标 std.dwarf.OP
std.debug.Dwarf.expression.Options
容器
字段
addr_size: u8 = @sizeOf(usize)目标架构的地址大小
endian: std.builtin.Endian = native_endian目标架构的字节序
call_frame_context: bool = false将栈机限制为调用帧指令所用操作码的子集
std.debug.Dwarf.expression.regNative
别名
std.debug.Dwarf.expression.sp_reg_num
常量
std.debug.Dwarf.expression.StackMachine
类型函数
能够解码并运行 DWARF 表达式的栈机器。 可为非本机地址大小及字节序解码表达式, 但仅在当前目标与配置一致时才能执行。
pub fn StackMachine(comptime options: Options) type
参数
options: Options
字段
std.debug.Dwarf.expression.StackMachine.deinit
函数
pub fn deinit(self: *Self, allocator: std.mem.Allocator) void
参数
std.debug.Dwarf.expression.StackMachine.generic
函数
fn generic(value: anytype) Operand
std.debug.Dwarf.expression.StackMachine.Operand
容器
字段
generic: addr_type
register: u8
type_size: u8
branch_offset: i16
base_register: struct {
base_register: u8,
offset: i64,
}
composite_location: struct {
size: u64,
offset: i64,
}
block: []const u8
register_type: struct {
register: u8,
type_offset: addr_type,
}
const_type: struct {
type_offset: addr_type,
value_bytes: []const u8,
}
deref_type: struct {
size: u8,
type_offset: addr_type,
}
std.debug.Dwarf.expression.StackMachine.readOperand
函数
pub fn readOperand(reader: *std.Io.Reader, opcode: u8, context: Context) !?Operand
参数
std.debug.Dwarf.expression.StackMachine.reset
函数
pub fn reset(self: *Self) void
参数
self: *Self
std.debug.Dwarf.expression.StackMachine.run
函数
pub fn run( self: *Self, expression: []const u8, allocator: std.mem.Allocator, context: Context, initial_value: ?usize, ) Error!?Value
参数
self: *Self
expression: []const u8
allocator: std.mem.Allocator
context: Context
initial_value: ?usize
错误
- DivisionByZero
- EndOfStream
- IncompatibleRegisterSize
- IncompleteExpressionContext
- InvalidCFAOpcode
- InvalidExpression
- InvalidFrameBase
- InvalidIntegralTypeSize
- InvalidRegister
- InvalidSubExpression
- InvalidTypeLength
- OutOfMemory
- Overflow
- ReadFailed
- TruncatedIntegralType
- UnimplementedExpressionCall
- UnimplementedOpcode
- UnimplementedTypeConversion
- UnimplementedTypedComparison
- UnimplementedUserOpcode
- UnknownExpressionOpcode
- UnsupportedRegister DwarfRegisterError
std.debug.Dwarf.expression.StackMachine.Self
别名
std.debug.Dwarf.expression.StackMachine.step
函数
从 stream 读取操作码及其操作数,然后执行
pub fn step( self: *Self, stream: *std.Io.Reader, allocator: std.mem.Allocator, context: Context, ) Error!bool
参数
错误
- DivisionByZero
- EndOfStream
- IncompatibleRegisterSize
- IncompleteExpressionContext
- InvalidCFAOpcode
- InvalidExpression
- InvalidFrameBase
- InvalidIntegralTypeSize
- InvalidRegister
- InvalidSubExpression
- InvalidTypeLength
- OutOfMemory
- Overflow
- ReadFailed
- TruncatedIntegralType
- UnimplementedExpressionCall
- UnimplementedOpcode
- UnimplementedTypeConversion
- UnimplementedTypedComparison
- UnimplementedUserOpcode
- UnknownExpressionOpcode
- UnsupportedRegister DwarfRegisterError
std.debug.Dwarf.expression.StackMachine.Value
容器
字段
generic: addr_type
regval_type: struct {
// DW_TAG_base_type DIE 的偏移量
type_offset: addr_type,
type_size: u8,
value: addr_type,
}
const_type: struct {
// DW_TAG_base_type DIE 的偏移量
type_offset: addr_type,
// 由指令流提供存储
value_bytes: []const u8,
}
std.debug.Dwarf.expression.StackMachine.Value.asIntegral
函数
pub fn asIntegral(self: Value) !addr_type
参数
self: Value
std.debug.Dwarf.expression.std
别名
别名目标 std
std.debug.Dwarf.expression.testing
别名
别名目标 std.testing
std.debug.Dwarf.expression.Writer
别名
别名目标 std.Io.Writer
源码
std/debug/Dwarf/expression.zig
const builtin = @import("builtin");
const native_arch = builtin.cpu.arch;
const native_endian = native_arch.endian();
const std = @import("std");
const leb = std.leb;
const OP = std.dwarf.OP;
const mem = std.mem;
const assert = std.debug.assert;
const testing = std.testing;
const Writer = std.Io.Writer;
const regNative = std.debug.Dwarf.SelfUnwinder.regNative;
const ip_reg_num = std.debug.Dwarf.ipRegNum(native_arch).?;
const fp_reg_num = std.debug.Dwarf.fpRegNum(native_arch);
const sp_reg_num = std.debug.Dwarf.spRegNum(native_arch);
/// 表达式可在不同上下文中求值,每种上下文都需要各自的一组输入。
/// 调用者应指定与其上下文相关的全部字段。
/// 若表达式需要某字段,但上下文未提供,则返回 error.IncompleteExpressionContext。
pub const Context = struct {
/// 此表达式所在节的 dwarf 格式
format: std.dwarf.Format = .@"32",
/// 此表达式关联的编译单元(如果有)。
compile_unit: ?*const std.debug.Dwarf.CompileUnit = null,
/// 对用户提供的表达式求值时,此值是正在求值的对象的地址。
object_address: ?*const anyopaque = null,
/// .debug_addr 节
debug_addr: ?[]const u8 = null,
cpu_context: ?*std.debug.cpu_context.Native = null,
/// 在 CFI 上下文中为调用帧地址
cfa: ?usize = null,
/// 此表达式是 OP.entry_value 指令中的子表达式
entry_value_context: bool = false,
};
pub const Options = struct {
/// 目标架构的地址大小
addr_size: u8 = @sizeOf(usize),
/// 目标架构的字节序
endian: std.builtin.Endian = native_endian,
/// 将栈机限制为调用帧指令所用操作码的子集
call_frame_context: bool = false,
};
// 显式定义,以支持执行子表达式
pub const Error = error{
UnimplementedExpressionCall,
UnimplementedOpcode,
UnimplementedUserOpcode,
UnimplementedTypedComparison,
UnimplementedTypeConversion,
UnknownExpressionOpcode,
IncompleteExpressionContext,
InvalidCFAOpcode,
InvalidExpression,
InvalidFrameBase,
InvalidIntegralTypeSize,
InvalidRegister,
InvalidSubExpression,
InvalidTypeLength,
TruncatedIntegralType,
IncompatibleRegisterSize,
} || std.debug.cpu_context.DwarfRegisterError || error{ EndOfStream, Overflow, OutOfMemory, DivisionByZero, ReadFailed };
/// 能够解码并运行 DWARF 表达式的栈机器。
/// 可为非本机地址大小及字节序解码表达式,
/// 但仅在当前目标与配置一致时才能执行。
pub fn StackMachine(comptime options: Options) type {
const addr_type = switch (options.addr_size) {
2 => u16,
4 => u32,
8 => u64,
else => @compileError("Unsupported address size of " ++ options.addr_size),
};
const addr_type_signed = switch (options.addr_size) {
2 => i16,
4 => i32,
8 => i64,
else => @compileError("Unsupported address size of " ++ options.addr_size),
};
return struct {
const Self = @This();
const Operand = union(enum) {
generic: addr_type,
register: u8,
type_size: u8,
branch_offset: i16,
base_register: struct {
base_register: u8,
offset: i64,
},
composite_location: struct {
size: u64,
offset: i64,
},
block: []const u8,
register_type: struct {
register: u8,
type_offset: addr_type,
},
const_type: struct {
type_offset: addr_type,
value_bytes: []const u8,
},
deref_type: struct {
size: u8,
type_offset: addr_type,
},
};
const Value = union(enum) {
generic: addr_type,
// 最大为一个寄存器大小的有类型值
regval_type: struct {
// DW_TAG_base_type DIE 的偏移量
type_offset: addr_type,
type_size: u8,
value: addr_type,
},
// 直接在指令流中指定的带类型值。
const_type: struct {
// DW_TAG_base_type DIE 的偏移量
type_offset: addr_type,
// 由指令流提供存储
value_bytes: []const u8,
},
pub fn asIntegral(self: Value) !addr_type {
return switch (self) {
.generic => |v| v,
// TODO: 对于这两个分支,是否应查找类型并断言其为整数类型?
.regval_type => |regval_type| regval_type.value,
.const_type => |const_type| {
const value: u64 = switch (const_type.value_bytes.len) {
1 => mem.readInt(u8, const_type.value_bytes[0..1], native_endian),
2 => mem.readInt(u16, const_type.value_bytes[0..2], native_endian),
4 => mem.readInt(u32, const_type.value_bytes[0..4], native_endian),
8 => mem.readInt(u64, const_type.value_bytes[0..8], native_endian),
else => return error.InvalidIntegralTypeSize,
};
return std.math.cast(addr_type, value) orelse error.TruncatedIntegralType;
},
};
}
};
stack: std.ArrayList(Value) = .empty,
pub fn reset(self: *Self) void {
self.stack.clearRetainingCapacity();
}
pub fn deinit(self: *Self, allocator: std.mem.Allocator) void {
self.stack.deinit(allocator);
}
fn generic(value: anytype) Operand {
const int_info = @typeInfo(@TypeOf(value)).int;
if (@sizeOf(@TypeOf(value)) > options.addr_size) {
return .{ .generic = switch (int_info.signedness) {
.signed => @bitCast(@as(addr_type_signed, @truncate(value))),
.unsigned => @truncate(value),
} };
} else {
return .{ .generic = switch (int_info.signedness) {
.signed => @bitCast(@as(addr_type_signed, @intCast(value))),
.unsigned => @intCast(value),
} };
}
}
pub fn readOperand(reader: *std.Io.Reader, opcode: u8, context: Context) !?Operand {
return switch (opcode) {
OP.addr => generic(try reader.takeInt(addr_type, options.endian)),
OP.call_ref => switch (context.format) {
.@"32" => generic(try reader.takeInt(u32, options.endian)),
.@"64" => generic(try reader.takeInt(u64, options.endian)),
},
OP.const1u,
OP.pick,
=> generic(try reader.takeByte()),
OP.deref_size,
OP.xderef_size,
=> .{ .type_size = try reader.takeByte() },
OP.const1s => generic(try reader.takeByteSigned()),
OP.const2u,
OP.call2,
=> generic(try reader.takeInt(u16, options.endian)),
OP.call4 => generic(try reader.takeInt(u32, options.endian)),
OP.const2s => generic(try reader.takeInt(i16, options.endian)),
OP.bra,
OP.skip,
=> .{ .branch_offset = try reader.takeInt(i16, options.endian) },
OP.const4u => generic(try reader.takeInt(u32, options.endian)),
OP.const4s => generic(try reader.takeInt(i32, options.endian)),
OP.const8u => generic(try reader.takeInt(u64, options.endian)),
OP.const8s => generic(try reader.takeInt(i64, options.endian)),
OP.constu,
OP.plus_uconst,
OP.addrx,
OP.constx,
OP.convert,
OP.reinterpret,
=> generic(try reader.takeLeb128(u64)),
OP.consts,
OP.fbreg,
=> generic(try reader.takeLeb128(i64)),
OP.lit0...OP.lit31 => |n| generic(n - OP.lit0),
OP.reg0...OP.reg31 => |n| .{ .register = n - OP.reg0 },
OP.breg0...OP.breg31 => |n| .{ .base_register = .{
.base_register = n - OP.breg0,
.offset = try reader.takeLeb128(i64),
} },
OP.regx => .{ .register = try reader.takeLeb128(u8) },
OP.bregx => blk: {
const base_register = try reader.takeLeb128(u8);
const offset = try reader.takeLeb128(i64);
break :blk .{ .base_register = .{
.base_register = base_register,
.offset = offset,
} };
},
OP.regval_type => blk: {
const register = try reader.takeLeb128(u8);
const type_offset = try reader.takeLeb128(addr_type);
break :blk .{ .register_type = .{
.register = register,
.type_offset = type_offset,
} };
},
OP.piece => .{
.composite_location = .{
.size = try reader.takeLeb128(u8),
.offset = 0,
},
},
OP.bit_piece => blk: {
const size = try reader.takeLeb128(u8);
const offset = try reader.takeLeb128(i64);
break :blk .{ .composite_location = .{
.size = size,
.offset = offset,
} };
},
OP.implicit_value, OP.entry_value => blk: {
const size = try reader.takeLeb128(u8);
const block = try reader.take(size);
break :blk .{ .block = block };
},
OP.const_type => blk: {
const type_offset = try reader.takeLeb128(addr_type);
const size = try reader.takeByte();
const value_bytes = try reader.take(size);
break :blk .{ .const_type = .{
.type_offset = type_offset,
.value_bytes = value_bytes,
} };
},
OP.deref_type,
OP.xderef_type,
=> .{
.deref_type = .{
.size = try reader.takeByte(),
.type_offset = try reader.takeLeb128(addr_type),
},
},
OP.lo_user...OP.hi_user => return error.UnimplementedUserOpcode,
else => null,
};
}
pub fn run(
self: *Self,
expression: []const u8,
allocator: std.mem.Allocator,
context: Context,
initial_value: ?usize,
) Error!?Value {
if (initial_value) |i| try self.stack.append(allocator, .{ .generic = i });
var stream: std.Io.Reader = .fixed(expression);
while (try self.step(&stream, allocator, context)) {}
if (self.stack.items.len == 0) return null;
return self.stack.items[self.stack.items.len - 1];
}
/// 从 `stream` 读取操作码及其操作数,然后执行
pub fn step(
self: *Self,
stream: *std.Io.Reader,
allocator: std.mem.Allocator,
context: Context,
) Error!bool {
if (@sizeOf(usize) != @sizeOf(addr_type) or options.endian != native_endian)
@compileError("Execution of non-native address sizes / endianness is not supported");
const opcode = try stream.takeByte();
if (options.call_frame_context and !isOpcodeValidInCFA(opcode)) return error.InvalidCFAOpcode;
const operand = try readOperand(stream, opcode, context);
switch (opcode) {
// 2.5.1.1:字面量编码
OP.lit0...OP.lit31,
OP.addr,
OP.const1u,
OP.const2u,
OP.const4u,
OP.const8u,
OP.const1s,
OP.const2s,
OP.const4s,
OP.const8s,
OP.constu,
OP.consts,
=> try self.stack.append(allocator, .{ .generic = operand.?.generic }),
OP.const_type => {
const const_type = operand.?.const_type;
try self.stack.append(allocator, .{ .const_type = .{
.type_offset = const_type.type_offset,
.value_bytes = const_type.value_bytes,
} });
},
OP.addrx,
OP.constx,
=> {
if (context.compile_unit == null) return error.IncompleteExpressionContext;
if (context.debug_addr == null) return error.IncompleteExpressionContext;
const debug_addr_index = operand.?.generic;
const offset = context.compile_unit.?.addr_base + debug_addr_index;
if (offset >= context.debug_addr.?.len) return error.InvalidExpression;
const value = mem.readInt(usize, context.debug_addr.?[offset..][0..@sizeOf(usize)], native_endian);
try self.stack.append(allocator, .{ .generic = value });
},
// 2.5.1.2:寄存器值
OP.fbreg => {
if (context.compile_unit == null) return error.IncompleteExpressionContext;
if (context.compile_unit.?.frame_base == null) return error.IncompleteExpressionContext;
const offset: i64 = @intCast(operand.?.generic);
_ = offset;
switch (context.compile_unit.?.frame_base.?.*) {
.exprloc => {
// TODO: 在嵌套栈机中运行此表达式
return error.UnimplementedOpcode;
},
.loclistx => {
// TODO: 从 .debug_loclists 读取值
return error.UnimplementedOpcode;
},
.sec_offset => {
// TODO: 从 .debug_loclists 读取值
return error.UnimplementedOpcode;
},
else => return error.InvalidFrameBase,
}
},
OP.breg0...OP.breg31,
OP.bregx,
=> {
const cpu_context = context.cpu_context orelse return error.IncompleteExpressionContext;
const br = operand.?.base_register;
const value: i64 = @intCast((try regNative(cpu_context, br.base_register)).*);
try self.stack.append(allocator, .{ .generic = @intCast(value + br.offset) });
},
OP.regval_type => {
const cpu_context = context.cpu_context orelse return error.IncompleteExpressionContext;
const rt = operand.?.register_type;
try self.stack.append(allocator, .{
.regval_type = .{
.type_offset = rt.type_offset,
.type_size = @sizeOf(addr_type),
.value = @intCast((try regNative(cpu_context, rt.register)).*),
},
});
},
// 2.5.1.3:栈操作
OP.dup => {
if (self.stack.items.len == 0) return error.InvalidExpression;
try self.stack.append(allocator, self.stack.items[self.stack.items.len - 1]);
},
OP.drop => {
_ = self.stack.pop();
},
OP.pick, OP.over => {
const stack_index = if (opcode == OP.over) 1 else operand.?.generic;
if (stack_index >= self.stack.items.len) return error.InvalidExpression;
try self.stack.append(allocator, self.stack.items[self.stack.items.len - 1 - stack_index]);
},
OP.swap => {
if (self.stack.items.len < 2) return error.InvalidExpression;
mem.swap(Value, &self.stack.items[self.stack.items.len - 1], &self.stack.items[self.stack.items.len - 2]);
},
OP.rot => {
if (self.stack.items.len < 3) return error.InvalidExpression;
const first = self.stack.items[self.stack.items.len - 1];
self.stack.items[self.stack.items.len - 1] = self.stack.items[self.stack.items.len - 2];
self.stack.items[self.stack.items.len - 2] = self.stack.items[self.stack.items.len - 3];
self.stack.items[self.stack.items.len - 3] = first;
},
OP.deref,
OP.xderef,
OP.deref_size,
OP.xderef_size,
OP.deref_type,
OP.xderef_type,
=> {
if (self.stack.items.len == 0) return error.InvalidExpression;
const addr = try self.stack.items[self.stack.items.len - 1].asIntegral();
const addr_space_identifier: ?usize = switch (opcode) {
OP.xderef,
OP.xderef_size,
OP.xderef_type,
=> blk: {
_ = self.stack.pop();
if (self.stack.items.len == 0) return error.InvalidExpression;
break :blk try self.stack.items[self.stack.items.len - 1].asIntegral();
},
else => null,
};
// 地址计算中使用 addr_space_identifier 的方式由实现定义。
// 若存在使用该标识符的架构,需要更新此代码以处理。
_ = addr_space_identifier;
const size = switch (opcode) {
OP.deref,
OP.xderef,
=> @sizeOf(addr_type),
OP.deref_size,
OP.xderef_size,
=> operand.?.type_size,
OP.deref_type,
OP.xderef_type,
=> operand.?.deref_type.size,
else => unreachable,
};
const value: addr_type = std.math.cast(addr_type, @as(u64, switch (size) {
1 => @as(*const u8, @ptrFromInt(addr)).*,
2 => @as(*const u16, @ptrFromInt(addr)).*,
4 => @as(*const u32, @ptrFromInt(addr)).*,
8 => @as(*const u64, @ptrFromInt(addr)).*,
else => return error.InvalidExpression,
})) orelse return error.InvalidExpression;
switch (opcode) {
OP.deref_type,
OP.xderef_type,
=> {
self.stack.items[self.stack.items.len - 1] = .{
.regval_type = .{
.type_offset = operand.?.deref_type.type_offset,
.type_size = operand.?.deref_type.size,
.value = value,
},
};
},
else => {
self.stack.items[self.stack.items.len - 1] = .{ .generic = value };
},
}
},
OP.push_object_address => {
// 在子表达式中,`push_object_address` 没有意义(依照规范),
// 因此将其视为空操作。
if (!context.entry_value_context) {
if (context.object_address == null) return error.IncompleteExpressionContext;
try self.stack.append(allocator, .{ .generic = @intFromPtr(context.object_address.?) });
}
},
OP.form_tls_address => {
return error.UnimplementedOpcode;
},
OP.call_frame_cfa => {
if (context.cfa) |cfa| {
try self.stack.append(allocator, .{ .generic = cfa });
} else return error.IncompleteExpressionContext;
},
// 2.5.1.4:算术与逻辑运算
OP.abs => {
if (self.stack.items.len == 0) return error.InvalidExpression;
const value: isize = @bitCast(try self.stack.items[self.stack.items.len - 1].asIntegral());
self.stack.items[self.stack.items.len - 1] = .{
.generic = @abs(value),
};
},
OP.@"and" => {
if (self.stack.items.len < 2) return error.InvalidExpression;
const a = try self.stack.pop().?.asIntegral();
self.stack.items[self.stack.items.len - 1] = .{
.generic = a & try self.stack.items[self.stack.items.len - 1].asIntegral(),
};
},
OP.div => {
if (self.stack.items.len < 2) return error.InvalidExpression;
const a: isize = @bitCast(try self.stack.pop().?.asIntegral());
const b: isize = @bitCast(try self.stack.items[self.stack.items.len - 1].asIntegral());
self.stack.items[self.stack.items.len - 1] = .{
.generic = @bitCast(try std.math.divTrunc(isize, b, a)),
};
},
OP.minus => {
if (self.stack.items.len < 2) return error.InvalidExpression;
const b = try self.stack.pop().?.asIntegral();
self.stack.items[self.stack.items.len - 1] = .{
.generic = try std.math.sub(addr_type, try self.stack.items[self.stack.items.len - 1].asIntegral(), b),
};
},
OP.mod => {
if (self.stack.items.len < 2) return error.InvalidExpression;
const a: isize = @bitCast(try self.stack.pop().?.asIntegral());
const b: isize = @bitCast(try self.stack.items[self.stack.items.len - 1].asIntegral());
self.stack.items[self.stack.items.len - 1] = .{
.generic = @bitCast(@mod(b, a)),
};
},
OP.mul => {
if (self.stack.items.len < 2) return error.InvalidExpression;
const a: isize = @bitCast(try self.stack.pop().?.asIntegral());
const b: isize = @bitCast(try self.stack.items[self.stack.items.len - 1].asIntegral());
self.stack.items[self.stack.items.len - 1] = .{
.generic = @bitCast(@mulWithOverflow(a, b)[0]),
};
},
OP.neg => {
if (self.stack.items.len == 0) return error.InvalidExpression;
self.stack.items[self.stack.items.len - 1] = .{
.generic = @bitCast(
try std.math.negate(
@as(isize, @bitCast(try self.stack.items[self.stack.items.len - 1].asIntegral())),
),
),
};
},
OP.not => {
if (self.stack.items.len == 0) return error.InvalidExpression;
self.stack.items[self.stack.items.len - 1] = .{
.generic = ~try self.stack.items[self.stack.items.len - 1].asIntegral(),
};
},
OP.@"or" => {
if (self.stack.items.len < 2) return error.InvalidExpression;
const a = try self.stack.pop().?.asIntegral();
self.stack.items[self.stack.items.len - 1] = .{
.generic = a | try self.stack.items[self.stack.items.len - 1].asIntegral(),
};
},
OP.plus => {
if (self.stack.items.len < 2) return error.InvalidExpression;
const b = try self.stack.pop().?.asIntegral();
self.stack.items[self.stack.items.len - 1] = .{
.generic = try std.math.add(addr_type, try self.stack.items[self.stack.items.len - 1].asIntegral(), b),
};
},
OP.plus_uconst => {
if (self.stack.items.len == 0) return error.InvalidExpression;
const constant = operand.?.generic;
self.stack.items[self.stack.items.len - 1] = .{
.generic = try std.math.add(addr_type, try self.stack.items[self.stack.items.len - 1].asIntegral(), constant),
};
},
OP.shl => {
if (self.stack.items.len < 2) return error.InvalidExpression;
const a = try self.stack.pop().?.asIntegral();
const b = try self.stack.items[self.stack.items.len - 1].asIntegral();
self.stack.items[self.stack.items.len - 1] = .{
.generic = std.math.shl(usize, b, a),
};
},
OP.shr => {
if (self.stack.items.len < 2) return error.InvalidExpression;
const a = try self.stack.pop().?.asIntegral();
const b = try self.stack.items[self.stack.items.len - 1].asIntegral();
self.stack.items[self.stack.items.len - 1] = .{
.generic = std.math.shr(usize, b, a),
};
},
OP.shra => {
if (self.stack.items.len < 2) return error.InvalidExpression;
const a = try self.stack.pop().?.asIntegral();
const b: isize = @bitCast(try self.stack.items[self.stack.items.len - 1].asIntegral());
self.stack.items[self.stack.items.len - 1] = .{
.generic = @bitCast(std.math.shr(isize, b, a)),
};
},
OP.xor => {
if (self.stack.items.len < 2) return error.InvalidExpression;
const a = try self.stack.pop().?.asIntegral();
self.stack.items[self.stack.items.len - 1] = .{
.generic = a ^ try self.stack.items[self.stack.items.len - 1].asIntegral(),
};
},
// 2.5.1.5:控制流操作
OP.le,
OP.ge,
OP.eq,
OP.lt,
OP.gt,
OP.ne,
=> {
if (self.stack.items.len < 2) return error.InvalidExpression;
const a = self.stack.pop().?;
const b = self.stack.items[self.stack.items.len - 1];
if (a == .generic and b == .generic) {
const a_int: isize = @bitCast(a.asIntegral() catch unreachable);
const b_int: isize = @bitCast(b.asIntegral() catch unreachable);
const result = @intFromBool(switch (opcode) {
OP.le => b_int <= a_int,
OP.ge => b_int >= a_int,
OP.eq => b_int == a_int,
OP.lt => b_int < a_int,
OP.gt => b_int > a_int,
OP.ne => b_int != a_int,
else => unreachable,
});
self.stack.items[self.stack.items.len - 1] = .{ .generic = result };
} else {
// TODO: 加载这些值引用的类型,找到其比较运算符并执行。
return error.UnimplementedTypedComparison;
}
},
OP.skip, OP.bra => {
const branch_offset = operand.?.branch_offset;
const condition = if (opcode == OP.bra) blk: {
if (self.stack.items.len == 0) return error.InvalidExpression;
break :blk try self.stack.pop().?.asIntegral() != 0;
} else true;
if (condition) {
const new_pos = std.math.cast(
usize,
try std.math.add(isize, @as(isize, @intCast(stream.seek)), branch_offset),
) orelse return error.InvalidExpression;
if (new_pos < 0 or new_pos > stream.buffer.len) return error.InvalidExpression;
stream.seek = new_pos;
}
},
OP.call2,
OP.call4,
OP.call_ref,
=> {
const debug_info_offset = operand.?.generic;
_ = debug_info_offset;
// TODO: 加载 .debug_info 节中位于 debug_info_offset 的 DIE 条目;规范允许它
// 位于不同于包含此表达式的文件的可执行文件或共享目标文件中。
// 将控制转移到 DW_AT_location 属性,以当前栈为输入。
return error.UnimplementedExpressionCall;
},
// 2.5.1.6:类型转换
OP.convert => {
if (self.stack.items.len == 0) return error.InvalidExpression;
const type_offset = operand.?.generic;
// TODO: 加载 context.compile_unit 中的 DW_TAG_base_type 条目,并验证两个类型的大小相同。
const value = self.stack.items[self.stack.items.len - 1];
if (type_offset == 0) {
self.stack.items[self.stack.items.len - 1] = .{ .generic = try value.asIntegral() };
} else {
// TODO: 加载 context.compile_unit 中的 DW_TAG_base_type 条目,查找从
// 旧类型到新类型的转换运算符,并执行它。
return error.UnimplementedTypeConversion;
}
},
OP.reinterpret => {
if (self.stack.items.len == 0) return error.InvalidExpression;
const type_offset = operand.?.generic;
// TODO: 加载 context.compile_unit 中的 DW_TAG_base_type 条目,并验证两个类型的大小相同。
const value = self.stack.items[self.stack.items.len - 1];
if (type_offset == 0) {
self.stack.items[self.stack.items.len - 1] = .{ .generic = try value.asIntegral() };
} else {
self.stack.items[self.stack.items.len - 1] = switch (value) {
.generic => |v| .{
.regval_type = .{
.type_offset = type_offset,
.type_size = @sizeOf(addr_type),
.value = v,
},
},
.regval_type => |r| .{
.regval_type = .{
.type_offset = type_offset,
.type_size = r.type_size,
.value = r.value,
},
},
.const_type => |c| .{
.const_type = .{
.type_offset = type_offset,
.value_bytes = c.value_bytes,
},
},
};
}
},
// 2.5.1.7:特殊操作
OP.nop => {},
OP.entry_value => {
const block = operand.?.block;
if (block.len == 0) return error.InvalidSubExpression;
// TODO: 规范规定,此子表达式需要观察进入当前子程序时
// 的状态(即寄存器)。如果不是在栈帧展开操作结束时
// 调用,则需要额外的 cpu_context.Native 来保存该状态。
if (isOpcodeRegisterLocation(block[0])) {
const cpu_context = context.cpu_context orelse return error.IncompleteExpressionContext;
var block_stream: std.Io.Reader = .fixed(block);
const register = (try readOperand(&block_stream, block[0], context)).?.register;
const value = (try regNative(cpu_context, register)).*;
try self.stack.append(allocator, .{ .generic = @intCast(value) });
} else {
var stack_machine: Self = .{};
defer stack_machine.deinit(allocator);
var sub_context = context;
sub_context.entry_value_context = true;
const result = try stack_machine.run(block, allocator, sub_context, null);
try self.stack.append(allocator, result orelse return error.InvalidSubExpression);
}
},
// readOperand 已处理这些内容
OP.lo_user...OP.hi_user => unreachable,
else => {
// std.debug.print("Unknown DWARF expression opcode: {x}\n", .{opcode});
return error.UnknownExpressionOpcode;
},
}
return stream.seek < stream.buffer.len;
}
};
}
pub fn Builder(comptime options: Options) type {
const addr_type = switch (options.addr_size) {
2 => u16,
4 => u32,
8 => u64,
else => @compileError("Unsupported address size of " ++ options.addr_size),
};
return struct {
/// 零操作数指令
pub fn writeOpcode(writer: *Writer, comptime opcode: u8) !void {
if (options.call_frame_context and !comptime isOpcodeValidInCFA(opcode)) return error.InvalidCFAOpcode;
switch (opcode) {
OP.dup,
OP.drop,
OP.over,
OP.swap,
OP.rot,
OP.deref,
OP.xderef,
OP.push_object_address,
OP.form_tls_address,
OP.call_frame_cfa,
OP.abs,
OP.@"and",
OP.div,
OP.minus,
OP.mod,
OP.mul,
OP.neg,
OP.not,
OP.@"or",
OP.plus,
OP.shl,
OP.shr,
OP.shra,
OP.xor,
OP.le,
OP.ge,
OP.eq,
OP.lt,
OP.gt,
OP.ne,
OP.nop,
OP.stack_value,
=> try writer.writeByte(opcode),
else => @compileError("This opcode requires operands, use `write<Opcode>()` instead"),
}
}
// 2.5.1.1:字面量编码
pub fn writeLiteral(writer: *Writer, literal: u8) !void {
switch (literal) {
0...31 => |n| try writer.writeByte(n + OP.lit0),
else => return error.InvalidLiteral,
}
}
pub fn writeConst(writer: *Writer, comptime T: type, value: T) !void {
if (@typeInfo(T) != .int) @compileError("Constants must be integers");
switch (T) {
u8, i8, u16, i16, u32, i32, u64, i64 => {
try writer.writeByte(switch (T) {
u8 => OP.const1u,
i8 => OP.const1s,
u16 => OP.const2u,
i16 => OP.const2s,
u32 => OP.const4u,
i32 => OP.const4s,
u64 => OP.const8u,
i64 => OP.const8s,
else => unreachable,
});
try writer.writeInt(T, value, options.endian);
},
else => switch (@typeInfo(T).int.signedness) {
.unsigned => {
try writer.writeByte(OP.constu);
try writer.writeUleb128(value);
},
.signed => {
try writer.writeByte(OP.consts);
try writer.writeLeb128(value);
},
},
}
}
pub fn writeConstx(writer: *Writer, debug_addr_offset: anytype) !void {
try writer.writeByte(OP.constx);
try writer.writeUleb128(debug_addr_offset);
}
pub fn writeConstType(writer: *Writer, die_offset: anytype, value_bytes: []const u8) !void {
if (options.call_frame_context) return error.InvalidCFAOpcode;
if (value_bytes.len > 0xff) return error.InvalidTypeLength;
try writer.writeByte(OP.const_type);
try writer.writeUleb128(die_offset);
try writer.writeByte(@intCast(value_bytes.len));
try writer.writeAll(value_bytes);
}
pub fn writeAddr(writer: *Writer, value: addr_type) !void {
try writer.writeByte(OP.addr);
try writer.writeInt(addr_type, value, options.endian);
}
pub fn writeAddrx(writer: *Writer, debug_addr_offset: anytype) !void {
if (options.call_frame_context) return error.InvalidCFAOpcode;
try writer.writeByte(OP.addrx);
try writer.writeUleb128(debug_addr_offset);
}
// 2.5.1.2:寄存器值
pub fn writeFbreg(writer: *Writer, offset: anytype) !void {
try writer.writeByte(OP.fbreg);
try writer.writeSleb128(offset);
}
pub fn writeBreg(writer: *Writer, register: u8, offset: anytype) !void {
if (register > 31) return error.InvalidRegister;
try writer.writeByte(OP.breg0 + register);
try writer.writeSleb128(offset);
}
pub fn writeBregx(writer: *Writer, register: anytype, offset: anytype) !void {
try writer.writeByte(OP.bregx);
try writer.writeUleb128(register);
try writer.writeSleb128(offset);
}
pub fn writeRegvalType(writer: *Writer, register: anytype, offset: anytype) !void {
if (options.call_frame_context) return error.InvalidCFAOpcode;
try writer.writeByte(OP.regval_type);
try writer.writeUleb128(register);
try writer.writeUleb128(offset);
}
// 2.5.1.3:栈操作
pub fn writePick(writer: *Writer, index: u8) !void {
try writer.writeByte(OP.pick);
try writer.writeByte(index);
}
pub fn writeDerefSize(writer: *Writer, size: u8) !void {
try writer.writeByte(OP.deref_size);
try writer.writeByte(size);
}
pub fn writeXDerefSize(writer: *Writer, size: u8) !void {
try writer.writeByte(OP.xderef_size);
try writer.writeByte(size);
}
pub fn writeDerefType(writer: *Writer, size: u8, die_offset: anytype) !void {
if (options.call_frame_context) return error.InvalidCFAOpcode;
try writer.writeByte(OP.deref_type);
try writer.writeByte(size);
try writer.writeUleb128(die_offset);
}
pub fn writeXDerefType(writer: *Writer, size: u8, die_offset: anytype) !void {
try writer.writeByte(OP.xderef_type);
try writer.writeByte(size);
try writer.writeUleb128(die_offset);
}
// 2.5.1.4:算术与逻辑运算
pub fn writePlusUconst(writer: *Writer, uint_value: anytype) !void {
try writer.writeByte(OP.plus_uconst);
try writer.writeUleb128(uint_value);
}
// 2.5.1.5:控制流操作
pub fn writeSkip(writer: *Writer, offset: i16) !void {
try writer.writeByte(OP.skip);
try writer.writeInt(i16, offset, options.endian);
}
pub fn writeBra(writer: *Writer, offset: i16) !void {
try writer.writeByte(OP.bra);
try writer.writeInt(i16, offset, options.endian);
}
pub fn writeCall(writer: *Writer, comptime T: type, offset: T) !void {
if (options.call_frame_context) return error.InvalidCFAOpcode;
switch (T) {
u16 => try writer.writeByte(OP.call2),
u32 => try writer.writeByte(OP.call4),
else => @compileError("Call operand must be a 2 or 4 byte offset"),
}
try writer.writeInt(T, offset, options.endian);
}
pub fn writeCallRef(writer: *Writer, comptime is_64: bool, value: if (is_64) u64 else u32) !void {
if (options.call_frame_context) return error.InvalidCFAOpcode;
try writer.writeByte(OP.call_ref);
try writer.writeInt(if (is_64) u64 else u32, value, options.endian);
}
pub fn writeConvert(writer: *Writer, die_offset: anytype) !void {
if (options.call_frame_context) return error.InvalidCFAOpcode;
try writer.writeByte(OP.convert);
try writer.writeUleb128(die_offset);
}
pub fn writeReinterpret(writer: *Writer, die_offset: anytype) !void {
if (options.call_frame_context) return error.InvalidCFAOpcode;
try writer.writeByte(OP.reinterpret);
try writer.writeUleb128(die_offset);
}
// 2.5.1.7:特殊操作
pub fn writeEntryValue(writer: *Writer, expression: []const u8) !void {
try writer.writeByte(OP.entry_value);
try writer.writeUleb128(expression.len);
try writer.writeAll(expression);
}
// 2.6:位置描述
pub fn writeReg(writer: *Writer, register: u8) !void {
try writer.writeByte(OP.reg0 + register);
}
pub fn writeRegx(writer: *Writer, register: anytype) !void {
try writer.writeByte(OP.regx);
try writer.writeUleb128(register);
}
pub fn writeImplicitValue(writer: *Writer, value_bytes: []const u8) !void {
try writer.writeByte(OP.implicit_value);
try writer.writeUleb128(value_bytes.len);
try writer.writeAll(value_bytes);
}
};
}
// CFA 上下文中不允许某些操作码,参见 6.4.2。
fn isOpcodeValidInCFA(opcode: u8) bool {
return switch (opcode) {
OP.addrx,
OP.call2,
OP.call4,
OP.call_ref,
OP.const_type,
OP.constx,
OP.convert,
OP.deref_type,
OP.regval_type,
OP.reinterpret,
OP.push_object_address,
OP.call_frame_cfa,
=> false,
else => true,
};
}
fn isOpcodeRegisterLocation(opcode: u8) bool {
return switch (opcode) {
OP.reg0...OP.reg31, OP.regx => true,
else => false,
};
}
test "basics" {
const allocator = std.testing.allocator;
const options = Options{};
var stack_machine = StackMachine(options){};
defer stack_machine.deinit(allocator);
const b = Builder(options);
var program: std.Io.Writer.Allocating = .init(allocator);
defer program.deinit();
const writer = &program.writer;
// 字面量
{
const context = Context{};
for (0..32) |i| {
try b.writeLiteral(writer, @intCast(i));
}
_ = try stack_machine.run(program.written(), allocator, context, 0);
for (0..32) |i| {
const expected = 31 - i;
try testing.expectEqual(expected, stack_machine.stack.pop().?.generic);
}
}
// 常量
{
stack_machine.reset();
program.clearRetainingCapacity();
const input = [_]comptime_int{
1,
-1,
@as(usize, @truncate(0x0fff)),
@as(isize, @truncate(-0x0fff)),
@as(usize, @truncate(0x0fffffff)),
@as(isize, @truncate(-0x0fffffff)),
@as(usize, @truncate(0x0fffffffffffffff)),
@as(isize, @truncate(-0x0fffffffffffffff)),
@as(usize, @truncate(0x8000000)),
@as(isize, @truncate(-0x8000000)),
@as(usize, @truncate(0x12345678_12345678)),
@as(usize, @truncate(0xffffffff_ffffffff)),
@as(usize, @truncate(0xeeeeeeee_eeeeeeee)),
};
try b.writeConst(writer, u8, input[0]);
try b.writeConst(writer, i8, input[1]);
try b.writeConst(writer, u16, input[2]);
try b.writeConst(writer, i16, input[3]);
try b.writeConst(writer, u32, input[4]);
try b.writeConst(writer, i32, input[5]);
try b.writeConst(writer, u64, input[6]);
try b.writeConst(writer, i64, input[7]);
try b.writeConst(writer, u28, input[8]);
try b.writeConst(writer, i28, input[9]);
try b.writeAddr(writer, input[10]);
var mock_compile_unit: std.debug.Dwarf.CompileUnit = undefined;
mock_compile_unit.addr_base = 1;
var mock_debug_addr: std.Io.Writer.Allocating = .init(allocator);
defer mock_debug_addr.deinit();
try mock_debug_addr.writer.writeInt(u16, 0, native_endian);
try mock_debug_addr.writer.writeInt(usize, input[11], native_endian);
try mock_debug_addr.writer.writeInt(usize, input[12], native_endian);
const context: Context = .{
.compile_unit = &mock_compile_unit,
.debug_addr = mock_debug_addr.written(),
};
try b.writeConstx(writer, @as(usize, 1));
try b.writeAddrx(writer, @as(usize, 1 + @sizeOf(usize)));
const die_offset: usize = @truncate(0xaabbccdd);
const type_bytes: []const u8 = &.{ 1, 2, 3, 4 };
try b.writeConstType(writer, die_offset, type_bytes);
_ = try stack_machine.run(program.written(), allocator, context, 0);
const const_type = stack_machine.stack.pop().?.const_type;
try testing.expectEqual(die_offset, const_type.type_offset);
try testing.expectEqualSlices(u8, type_bytes, const_type.value_bytes);
const expected = .{
.{ usize, input[12], usize },
.{ usize, input[11], usize },
.{ usize, input[10], usize },
.{ isize, input[9], isize },
.{ usize, input[8], usize },
.{ isize, input[7], isize },
.{ usize, input[6], usize },
.{ isize, input[5], isize },
.{ usize, input[4], usize },
.{ isize, input[3], isize },
.{ usize, input[2], usize },
.{ isize, input[1], isize },
.{ usize, input[0], usize },
};
inline for (expected) |e| {
try testing.expectEqual(@as(e[0], e[1]), @as(e[2], @bitCast(stack_machine.stack.pop().?.generic)));
}
}
// 寄存器值
if (std.debug.cpu_context.Native != noreturn) {
stack_machine.reset();
program.clearRetainingCapacity();
var cpu_context: std.debug.cpu_context.Native = undefined;
const context = Context{
.cpu_context = &cpu_context,
};
const reg_bytes = try cpu_context.dwarfRegisterBytes(0);
// TODO: 实现 fbreg 后测试:模拟 DIE,并将 compile_unit.frame_base 指向它
mem.writeInt(std.debug.cpu_context.Native.Gpr, reg_bytes[0..@sizeOf(std.debug.cpu_context.Native.Gpr)], 0xee, native_endian);
(try regNative(&cpu_context, fp_reg_num)).* = 1;
(try regNative(&cpu_context, ip_reg_num)).* = 2;
try b.writeBreg(writer, fp_reg_num, @as(usize, 100));
try b.writeBregx(writer, ip_reg_num, @as(usize, 200));
try b.writeRegvalType(writer, @as(u8, 0), @as(usize, 300));
_ = try stack_machine.run(program.written(), allocator, context, 0);
const regval_type = stack_machine.stack.pop().?.regval_type;
try testing.expectEqual(@as(usize, 300), regval_type.type_offset);
try testing.expectEqual(@as(u8, @sizeOf(usize)), regval_type.type_size);
try testing.expectEqual(@as(usize, 0xee), regval_type.value);
try testing.expectEqual(@as(usize, 202), stack_machine.stack.pop().?.generic);
try testing.expectEqual(@as(usize, 101), stack_machine.stack.pop().?.generic);
}
// 栈操作
{
var context = Context{};
stack_machine.reset();
program.clearRetainingCapacity();
try b.writeConst(writer, u8, 1);
try b.writeOpcode(writer, OP.dup);
_ = try stack_machine.run(program.written(), allocator, context, null);
try testing.expectEqual(@as(usize, 1), stack_machine.stack.pop().?.generic);
try testing.expectEqual(@as(usize, 1), stack_machine.stack.pop().?.generic);
stack_machine.reset();
program.clearRetainingCapacity();
try b.writeConst(writer, u8, 1);
try b.writeOpcode(writer, OP.drop);
_ = try stack_machine.run(program.written(), allocator, context, null);
try testing.expect(stack_machine.stack.pop() == null);
stack_machine.reset();
program.clearRetainingCapacity();
try b.writeConst(writer, u8, 4);
try b.writeConst(writer, u8, 5);
try b.writeConst(writer, u8, 6);
try b.writePick(writer, 2);
_ = try stack_machine.run(program.written(), allocator, context, null);
try testing.expectEqual(@as(usize, 4), stack_machine.stack.pop().?.generic);
stack_machine.reset();
program.clearRetainingCapacity();
try b.writeConst(writer, u8, 4);
try b.writeConst(writer, u8, 5);
try b.writeConst(writer, u8, 6);
try b.writeOpcode(writer, OP.over);
_ = try stack_machine.run(program.written(), allocator, context, null);
try testing.expectEqual(@as(usize, 5), stack_machine.stack.pop().?.generic);
stack_machine.reset();
program.clearRetainingCapacity();
try b.writeConst(writer, u8, 5);
try b.writeConst(writer, u8, 6);
try b.writeOpcode(writer, OP.swap);
_ = try stack_machine.run(program.written(), allocator, context, null);
try testing.expectEqual(@as(usize, 5), stack_machine.stack.pop().?.generic);
try testing.expectEqual(@as(usize, 6), stack_machine.stack.pop().?.generic);
stack_machine.reset();
program.clearRetainingCapacity();
try b.writeConst(writer, u8, 4);
try b.writeConst(writer, u8, 5);
try b.writeConst(writer, u8, 6);
try b.writeOpcode(writer, OP.rot);
_ = try stack_machine.run(program.written(), allocator, context, null);
try testing.expectEqual(@as(usize, 5), stack_machine.stack.pop().?.generic);
try testing.expectEqual(@as(usize, 4), stack_machine.stack.pop().?.generic);
try testing.expectEqual(@as(usize, 6), stack_machine.stack.pop().?.generic);
const deref_target: usize = @truncate(0xffeeffee_ffeeffee);
stack_machine.reset();
program.clearRetainingCapacity();
try b.writeAddr(writer, @intFromPtr(&deref_target));
try b.writeOpcode(writer, OP.deref);
_ = try stack_machine.run(program.written(), allocator, context, null);
try testing.expectEqual(deref_target, stack_machine.stack.pop().?.generic);
stack_machine.reset();
program.clearRetainingCapacity();
try b.writeLiteral(writer, 0);
try b.writeAddr(writer, @intFromPtr(&deref_target));
try b.writeOpcode(writer, OP.xderef);
_ = try stack_machine.run(program.written(), allocator, context, null);
try testing.expectEqual(deref_target, stack_machine.stack.pop().?.generic);
stack_machine.reset();
program.clearRetainingCapacity();
try b.writeAddr(writer, @intFromPtr(&deref_target));
try b.writeDerefSize(writer, 1);
_ = try stack_machine.run(program.written(), allocator, context, null);
try testing.expectEqual(@as(usize, @as(*const u8, @ptrCast(&deref_target)).*), stack_machine.stack.pop().?.generic);
stack_machine.reset();
program.clearRetainingCapacity();
try b.writeLiteral(writer, 0);
try b.writeAddr(writer, @intFromPtr(&deref_target));
try b.writeXDerefSize(writer, 1);
_ = try stack_machine.run(program.written(), allocator, context, null);
try testing.expectEqual(@as(usize, @as(*const u8, @ptrCast(&deref_target)).*), stack_machine.stack.pop().?.generic);
const type_offset: usize = @truncate(0xaabbaabb_aabbaabb);
stack_machine.reset();
program.clearRetainingCapacity();
try b.writeAddr(writer, @intFromPtr(&deref_target));
try b.writeDerefType(writer, 1, type_offset);
_ = try stack_machine.run(program.written(), allocator, context, null);
const deref_type = stack_machine.stack.pop().?.regval_type;
try testing.expectEqual(type_offset, deref_type.type_offset);
try testing.expectEqual(@as(u8, 1), deref_type.type_size);
try testing.expectEqual(@as(usize, @as(*const u8, @ptrCast(&deref_target)).*), deref_type.value);
stack_machine.reset();
program.clearRetainingCapacity();
try b.writeLiteral(writer, 0);
try b.writeAddr(writer, @intFromPtr(&deref_target));
try b.writeXDerefType(writer, 1, type_offset);
_ = try stack_machine.run(program.written(), allocator, context, null);
const xderef_type = stack_machine.stack.pop().?.regval_type;
try testing.expectEqual(type_offset, xderef_type.type_offset);
try testing.expectEqual(@as(u8, 1), xderef_type.type_size);
try testing.expectEqual(@as(usize, @as(*const u8, @ptrCast(&deref_target)).*), xderef_type.value);
context.object_address = &deref_target;
stack_machine.reset();
program.clearRetainingCapacity();
try b.writeOpcode(writer, OP.push_object_address);
_ = try stack_machine.run(program.written(), allocator, context, null);
try testing.expectEqual(@as(usize, @intFromPtr(context.object_address.?)), stack_machine.stack.pop().?.generic);
// TODO: 测试 OP.form_tls_address
context.cfa = @truncate(0xccddccdd_ccddccdd);
stack_machine.reset();
program.clearRetainingCapacity();
try b.writeOpcode(writer, OP.call_frame_cfa);
_ = try stack_machine.run(program.written(), allocator, context, null);
try testing.expectEqual(context.cfa.?, stack_machine.stack.pop().?.generic);
}
// 算术与逻辑运算
{
const context = Context{};
stack_machine.reset();
program.clearRetainingCapacity();
try b.writeConst(writer, i16, -4096);
try b.writeOpcode(writer, OP.abs);
_ = try stack_machine.run(program.written(), allocator, context, null);
try testing.expectEqual(@as(usize, 4096), stack_machine.stack.pop().?.generic);
stack_machine.reset();
program.clearRetainingCapacity();
try b.writeConst(writer, u16, 0xff0f);
try b.writeConst(writer, u16, 0xf0ff);
try b.writeOpcode(writer, OP.@"and");
_ = try stack_machine.run(program.written(), allocator, context, null);
try testing.expectEqual(@as(usize, 0xf00f), stack_machine.stack.pop().?.generic);
stack_machine.reset();
program.clearRetainingCapacity();
try b.writeConst(writer, i16, -404);
try b.writeConst(writer, i16, 100);
try b.writeOpcode(writer, OP.div);
_ = try stack_machine.run(program.written(), allocator, context, null);
try testing.expectEqual(@as(isize, -404 / 100), @as(isize, @bitCast(stack_machine.stack.pop().?.generic)));
stack_machine.reset();
program.clearRetainingCapacity();
try b.writeConst(writer, u16, 200);
try b.writeConst(writer, u16, 50);
try b.writeOpcode(writer, OP.minus);
_ = try stack_machine.run(program.written(), allocator, context, null);
try testing.expectEqual(@as(usize, 150), stack_machine.stack.pop().?.generic);
stack_machine.reset();
program.clearRetainingCapacity();
try b.writeConst(writer, u16, 123);
try b.writeConst(writer, u16, 100);
try b.writeOpcode(writer, OP.mod);
_ = try stack_machine.run(program.written(), allocator, context, null);
try testing.expectEqual(@as(usize, 23), stack_machine.stack.pop().?.generic);
stack_machine.reset();
program.clearRetainingCapacity();
try b.writeConst(writer, u16, 0xff);
try b.writeConst(writer, u16, 0xee);
try b.writeOpcode(writer, OP.mul);
_ = try stack_machine.run(program.written(), allocator, context, null);
try testing.expectEqual(@as(usize, 0xed12), stack_machine.stack.pop().?.generic);
stack_machine.reset();
program.clearRetainingCapacity();
try b.writeConst(writer, u16, 5);
try b.writeOpcode(writer, OP.neg);
try b.writeConst(writer, i16, -6);
try b.writeOpcode(writer, OP.neg);
_ = try stack_machine.run(program.written(), allocator, context, null);
try testing.expectEqual(@as(usize, 6), stack_machine.stack.pop().?.generic);
try testing.expectEqual(@as(isize, -5), @as(isize, @bitCast(stack_machine.stack.pop().?.generic)));
stack_machine.reset();
program.clearRetainingCapacity();
try b.writeConst(writer, u16, 0xff0f);
try b.writeOpcode(writer, OP.not);
_ = try stack_machine.run(program.written(), allocator, context, null);
try testing.expectEqual(~@as(usize, 0xff0f), stack_machine.stack.pop().?.generic);
stack_machine.reset();
program.clearRetainingCapacity();
try b.writeConst(writer, u16, 0xff0f);
try b.writeConst(writer, u16, 0xf0ff);
try b.writeOpcode(writer, OP.@"or");
_ = try stack_machine.run(program.written(), allocator, context, null);
try testing.expectEqual(@as(usize, 0xffff), stack_machine.stack.pop().?.generic);
stack_machine.reset();
program.clearRetainingCapacity();
try b.writeConst(writer, i16, 402);
try b.writeConst(writer, i16, 100);
try b.writeOpcode(writer, OP.plus);
_ = try stack_machine.run(program.written(), allocator, context, null);
try testing.expectEqual(@as(usize, 502), stack_machine.stack.pop().?.generic);
stack_machine.reset();
program.clearRetainingCapacity();
try b.writeConst(writer, u16, 4096);
try b.writePlusUconst(writer, @as(usize, 8192));
_ = try stack_machine.run(program.written(), allocator, context, null);
try testing.expectEqual(@as(usize, 4096 + 8192), stack_machine.stack.pop().?.generic);
stack_machine.reset();
program.clearRetainingCapacity();
try b.writeConst(writer, u16, 0xfff);
try b.writeConst(writer, u16, 1);
try b.writeOpcode(writer, OP.shl);
_ = try stack_machine.run(program.written(), allocator, context, null);
try testing.expectEqual(@as(usize, 0xfff << 1), stack_machine.stack.pop().?.generic);
stack_machine.reset();
program.clearRetainingCapacity();
try b.writeConst(writer, u16, 0xfff);
try b.writeConst(writer, u16, 1);
try b.writeOpcode(writer, OP.shr);
_ = try stack_machine.run(program.written(), allocator, context, null);
try testing.expectEqual(@as(usize, 0xfff >> 1), stack_machine.stack.pop().?.generic);
stack_machine.reset();
program.clearRetainingCapacity();
try b.writeConst(writer, u16, 0xfff);
try b.writeConst(writer, u16, 1);
try b.writeOpcode(writer, OP.shr);
_ = try stack_machine.run(program.written(), allocator, context, null);
try testing.expectEqual(@as(usize, @bitCast(@as(isize, 0xfff) >> 1)), stack_machine.stack.pop().?.generic);
stack_machine.reset();
program.clearRetainingCapacity();
try b.writeConst(writer, u16, 0xf0ff);
try b.writeConst(writer, u16, 0xff0f);
try b.writeOpcode(writer, OP.xor);
_ = try stack_machine.run(program.written(), allocator, context, null);
try testing.expectEqual(@as(usize, 0x0ff0), stack_machine.stack.pop().?.generic);
}
// 控制流操作
{
const context = Context{};
const expected = .{
.{ OP.le, 1, 1, 0 },
.{ OP.ge, 1, 0, 1 },
.{ OP.eq, 1, 0, 0 },
.{ OP.lt, 0, 1, 0 },
.{ OP.gt, 0, 0, 1 },
.{ OP.ne, 0, 1, 1 },
};
inline for (expected) |e| {
stack_machine.reset();
program.clearRetainingCapacity();
try b.writeConst(writer, u16, 0);
try b.writeConst(writer, u16, 0);
try b.writeOpcode(writer, e[0]);
try b.writeConst(writer, u16, 0);
try b.writeConst(writer, u16, 1);
try b.writeOpcode(writer, e[0]);
try b.writeConst(writer, u16, 1);
try b.writeConst(writer, u16, 0);
try b.writeOpcode(writer, e[0]);
_ = try stack_machine.run(program.written(), allocator, context, null);
try testing.expectEqual(@as(usize, e[3]), stack_machine.stack.pop().?.generic);
try testing.expectEqual(@as(usize, e[2]), stack_machine.stack.pop().?.generic);
try testing.expectEqual(@as(usize, e[1]), stack_machine.stack.pop().?.generic);
}
stack_machine.reset();
program.clearRetainingCapacity();
try b.writeLiteral(writer, 2);
try b.writeSkip(writer, 1);
try b.writeLiteral(writer, 3);
_ = try stack_machine.run(program.written(), allocator, context, null);
try testing.expectEqual(@as(usize, 2), stack_machine.stack.pop().?.generic);
stack_machine.reset();
program.clearRetainingCapacity();
try b.writeLiteral(writer, 2);
try b.writeBra(writer, 1);
try b.writeLiteral(writer, 3);
try b.writeLiteral(writer, 0);
try b.writeBra(writer, 1);
try b.writeLiteral(writer, 4);
try b.writeLiteral(writer, 5);
_ = try stack_machine.run(program.written(), allocator, context, null);
try testing.expectEqual(@as(usize, 5), stack_machine.stack.pop().?.generic);
try testing.expectEqual(@as(usize, 4), stack_machine.stack.pop().?.generic);
try testing.expect(stack_machine.stack.pop() == null);
// TODO: 实现后测试 call2、call4、call_ref。
}
// 类型转换
{
const context = Context{};
stack_machine.reset();
program.clearRetainingCapacity();
// TODO: 实现后测试带类型的 OP.convert
const value: usize = @truncate(0xffeeffee_ffeeffee);
var value_bytes: [options.addr_size]u8 = undefined;
mem.writeInt(usize, &value_bytes, value, native_endian);
// 转换为泛型类型
stack_machine.reset();
program.clearRetainingCapacity();
try b.writeConstType(writer, @as(usize, 0), &value_bytes);
try b.writeConvert(writer, @as(usize, 0));
_ = try stack_machine.run(program.written(), allocator, context, null);
try testing.expectEqual(value, stack_machine.stack.pop().?.generic);
// 重新解释为泛型类型
stack_machine.reset();
program.clearRetainingCapacity();
try b.writeConstType(writer, @as(usize, 0), &value_bytes);
try b.writeReinterpret(writer, @as(usize, 0));
_ = try stack_machine.run(program.written(), allocator, context, null);
try testing.expectEqual(value, stack_machine.stack.pop().?.generic);
// 重新解释为新类型
const die_offset: usize = 0xffee;
stack_machine.reset();
program.clearRetainingCapacity();
try b.writeConstType(writer, @as(usize, 0), &value_bytes);
try b.writeReinterpret(writer, die_offset);
_ = try stack_machine.run(program.written(), allocator, context, null);
const const_type = stack_machine.stack.pop().?.const_type;
try testing.expectEqual(die_offset, const_type.type_offset);
stack_machine.reset();
program.clearRetainingCapacity();
try b.writeLiteral(writer, 0);
try b.writeReinterpret(writer, die_offset);
_ = try stack_machine.run(program.written(), allocator, context, null);
const regval_type = stack_machine.stack.pop().?.regval_type;
try testing.expectEqual(die_offset, regval_type.type_offset);
}
// 特殊操作
{
var context = Context{};
stack_machine.reset();
program.clearRetainingCapacity();
try b.writeOpcode(writer, OP.nop);
_ = try stack_machine.run(program.written(), allocator, context, null);
try testing.expect(stack_machine.stack.pop() == null);
// 子表达式
{
var sub_program: std.Io.Writer.Allocating = .init(allocator);
defer sub_program.deinit();
const sub_writer = &sub_program.writer;
try b.writeLiteral(sub_writer, 3);
stack_machine.reset();
program.clearRetainingCapacity();
try b.writeEntryValue(writer, sub_program.written());
_ = try stack_machine.run(program.written(), allocator, context, null);
try testing.expectEqual(@as(usize, 3), stack_machine.stack.pop().?.generic);
}
// 寄存器位置描述
var cpu_context: std.debug.cpu_context.Native = undefined;
context = .{ .cpu_context = &cpu_context };
const reg_bytes = try cpu_context.dwarfRegisterBytes(0);
mem.writeInt(std.debug.cpu_context.Native.Gpr, reg_bytes[0..@sizeOf(std.debug.cpu_context.Native.Gpr)], 0xee, native_endian);
var sub_program: std.Io.Writer.Allocating = .init(allocator);
defer sub_program.deinit();
const sub_writer = &sub_program.writer;
try b.writeReg(sub_writer, 0);
stack_machine.reset();
program.clearRetainingCapacity();
try b.writeEntryValue(writer, sub_program.written());
_ = try stack_machine.run(program.written(), allocator, context, null);
try testing.expectEqual(@as(usize, 0xee), stack_machine.stack.pop().?.generic);
}
}