authorgravatar for mlugg@mlugg.co.ukMatthew Lugg <mlugg@mlugg.co.uk> 2024-03-07 19:23:05+00:00
committergravatar for mlugg@mlugg.co.ukMatthew Lugg <mlugg@mlugg.co.uk> 2024-03-08 08:02:45+00:00
loga7f6e738122e7f1a5d2e502ee121700883fa3818
treea6919def9cdbf694d4b54a74bc4a4b1aaa21bab8
parentf4bf061d8a8023ec2188f3ffdc861317da56fd44
signaturelock-open Commit is signed but in an unrecognized format.

std.os.windows: eliminate usage of `usingnamespace`

Some of the structs I shuffled around might be better namespaced under CONTEXT, I'm not sure. However, for now, this approach preserves backwards compatibility. Eliminates one more usage of `usingnamespace` from the standard library. 3 remain.

1 files changed, 278 insertions(+), 268 deletions(-)

lib/std/os/windows.zig+278-268
......@@ -3796,290 +3796,300 @@ pub const EXCEPTION_RECORD = extern struct {
37963796 ExceptionInformation: [15]usize,
37973797};
37983798
3799pub usingnamespace switch (native_arch) {
3800 .x86 => struct {
3801 pub const FLOATING_SAVE_AREA = extern struct {
3802 ControlWord: DWORD,
3803 StatusWord: DWORD,
3804 TagWord: DWORD,
3805 ErrorOffset: DWORD,
3806 ErrorSelector: DWORD,
3807 DataOffset: DWORD,
3808 DataSelector: DWORD,
3809 RegisterArea: [80]BYTE,
3810 Cr0NpxState: DWORD,
3811 };
3799pub const FLOATING_SAVE_AREA = switch (native_arch) {
3800 .x86 => extern struct {
3801 ControlWord: DWORD,
3802 StatusWord: DWORD,
3803 TagWord: DWORD,
3804 ErrorOffset: DWORD,
3805 ErrorSelector: DWORD,
3806 DataOffset: DWORD,
3807 DataSelector: DWORD,
3808 RegisterArea: [80]BYTE,
3809 Cr0NpxState: DWORD,
3810 },
3811 else => @compileError("FLOATING_SAVE_AREA only defined on x86"),
3812};
38123813
3813 pub const CONTEXT = extern struct {
3814 ContextFlags: DWORD,
3815 Dr0: DWORD,
3816 Dr1: DWORD,
3817 Dr2: DWORD,
3818 Dr3: DWORD,
3819 Dr6: DWORD,
3820 Dr7: DWORD,
3821 FloatSave: FLOATING_SAVE_AREA,
3822 SegGs: DWORD,
3823 SegFs: DWORD,
3824 SegEs: DWORD,
3825 SegDs: DWORD,
3826 Edi: DWORD,
3827 Esi: DWORD,
3828 Ebx: DWORD,
3829 Edx: DWORD,
3830 Ecx: DWORD,
3831 Eax: DWORD,
3832 Ebp: DWORD,
3833 Eip: DWORD,
3834 SegCs: DWORD,
3835 EFlags: DWORD,
3836 Esp: DWORD,
3837 SegSs: DWORD,
3838 ExtendedRegisters: [512]BYTE,
3839
3840 pub fn getRegs(ctx: *const CONTEXT) struct { bp: usize, ip: usize } {
3841 return .{ .bp = ctx.Ebp, .ip = ctx.Eip };
3842 }
3843 };
3814pub const M128A = switch (native_arch) {
3815 .x86_64 => extern struct {
3816 Low: ULONGLONG,
3817 High: LONGLONG,
3818 },
3819 else => @compileError("M128A only defined on x86_64"),
3820};
3821
3822pub const XMM_SAVE_AREA32 = switch (native_arch) {
3823 .x86_64 => extern struct {
3824 ControlWord: WORD,
3825 StatusWord: WORD,
3826 TagWord: BYTE,
3827 Reserved1: BYTE,
3828 ErrorOpcode: WORD,
3829 ErrorOffset: DWORD,
3830 ErrorSelector: WORD,
3831 Reserved2: WORD,
3832 DataOffset: DWORD,
3833 DataSelector: WORD,
3834 Reserved3: WORD,
3835 MxCsr: DWORD,
3836 MxCsr_Mask: DWORD,
3837 FloatRegisters: [8]M128A,
3838 XmmRegisters: [16]M128A,
3839 Reserved4: [96]BYTE,
38443840 },
3845 .x86_64 => struct {
3846 pub const M128A = extern struct {
3841 else => @compileError("XMM_SAVE_AREA32 only defined on x86_64"),
3842};
3843
3844pub const NEON128 = switch (native_arch) {
3845 .aarch64 => extern union {
3846 DUMMYSTRUCTNAME: extern struct {
38473847 Low: ULONGLONG,
38483848 High: LONGLONG,
3849 };
3850
3851 pub const XMM_SAVE_AREA32 = extern struct {
3852 ControlWord: WORD,
3853 StatusWord: WORD,
3854 TagWord: BYTE,
3855 Reserved1: BYTE,
3856 ErrorOpcode: WORD,
3857 ErrorOffset: DWORD,
3858 ErrorSelector: WORD,
3859 Reserved2: WORD,
3860 DataOffset: DWORD,
3861 DataSelector: WORD,
3862 Reserved3: WORD,
3863 MxCsr: DWORD,
3864 MxCsr_Mask: DWORD,
3865 FloatRegisters: [8]M128A,
3866 XmmRegisters: [16]M128A,
3867 Reserved4: [96]BYTE,
3868 };
3869
3870 pub const CONTEXT = extern struct {
3871 P1Home: DWORD64 align(16),
3872 P2Home: DWORD64,
3873 P3Home: DWORD64,
3874 P4Home: DWORD64,
3875 P5Home: DWORD64,
3876 P6Home: DWORD64,
3877 ContextFlags: DWORD,
3878 MxCsr: DWORD,
3879 SegCs: WORD,
3880 SegDs: WORD,
3881 SegEs: WORD,
3882 SegFs: WORD,
3883 SegGs: WORD,
3884 SegSs: WORD,
3885 EFlags: DWORD,
3886 Dr0: DWORD64,
3887 Dr1: DWORD64,
3888 Dr2: DWORD64,
3889 Dr3: DWORD64,
3890 Dr6: DWORD64,
3891 Dr7: DWORD64,
3892 Rax: DWORD64,
3893 Rcx: DWORD64,
3894 Rdx: DWORD64,
3895 Rbx: DWORD64,
3896 Rsp: DWORD64,
3897 Rbp: DWORD64,
3898 Rsi: DWORD64,
3899 Rdi: DWORD64,
3900 R8: DWORD64,
3901 R9: DWORD64,
3902 R10: DWORD64,
3903 R11: DWORD64,
3904 R12: DWORD64,
3905 R13: DWORD64,
3906 R14: DWORD64,
3907 R15: DWORD64,
3908 Rip: DWORD64,
3909 DUMMYUNIONNAME: extern union {
3910 FltSave: XMM_SAVE_AREA32,
3911 FloatSave: XMM_SAVE_AREA32,
3912 DUMMYSTRUCTNAME: extern struct {
3913 Header: [2]M128A,
3914 Legacy: [8]M128A,
3915 Xmm0: M128A,
3916 Xmm1: M128A,
3917 Xmm2: M128A,
3918 Xmm3: M128A,
3919 Xmm4: M128A,
3920 Xmm5: M128A,
3921 Xmm6: M128A,
3922 Xmm7: M128A,
3923 Xmm8: M128A,
3924 Xmm9: M128A,
3925 Xmm10: M128A,
3926 Xmm11: M128A,
3927 Xmm12: M128A,
3928 Xmm13: M128A,
3929 Xmm14: M128A,
3930 Xmm15: M128A,
3931 },
3849 },
3850 D: [2]f64,
3851 S: [4]f32,
3852 H: [8]WORD,
3853 B: [16]BYTE,
3854 },
3855 else => @compileError("NEON128 only defined on aarch64"),
3856};
3857
3858pub const CONTEXT = switch (native_arch) {
3859 .x86 => extern struct {
3860 ContextFlags: DWORD,
3861 Dr0: DWORD,
3862 Dr1: DWORD,
3863 Dr2: DWORD,
3864 Dr3: DWORD,
3865 Dr6: DWORD,
3866 Dr7: DWORD,
3867 FloatSave: FLOATING_SAVE_AREA,
3868 SegGs: DWORD,
3869 SegFs: DWORD,
3870 SegEs: DWORD,
3871 SegDs: DWORD,
3872 Edi: DWORD,
3873 Esi: DWORD,
3874 Ebx: DWORD,
3875 Edx: DWORD,
3876 Ecx: DWORD,
3877 Eax: DWORD,
3878 Ebp: DWORD,
3879 Eip: DWORD,
3880 SegCs: DWORD,
3881 EFlags: DWORD,
3882 Esp: DWORD,
3883 SegSs: DWORD,
3884 ExtendedRegisters: [512]BYTE,
3885
3886 pub fn getRegs(ctx: *const CONTEXT) struct { bp: usize, ip: usize } {
3887 return .{ .bp = ctx.Ebp, .ip = ctx.Eip };
3888 }
3889 },
3890 .x86_64 => extern struct {
3891 P1Home: DWORD64 align(16),
3892 P2Home: DWORD64,
3893 P3Home: DWORD64,
3894 P4Home: DWORD64,
3895 P5Home: DWORD64,
3896 P6Home: DWORD64,
3897 ContextFlags: DWORD,
3898 MxCsr: DWORD,
3899 SegCs: WORD,
3900 SegDs: WORD,
3901 SegEs: WORD,
3902 SegFs: WORD,
3903 SegGs: WORD,
3904 SegSs: WORD,
3905 EFlags: DWORD,
3906 Dr0: DWORD64,
3907 Dr1: DWORD64,
3908 Dr2: DWORD64,
3909 Dr3: DWORD64,
3910 Dr6: DWORD64,
3911 Dr7: DWORD64,
3912 Rax: DWORD64,
3913 Rcx: DWORD64,
3914 Rdx: DWORD64,
3915 Rbx: DWORD64,
3916 Rsp: DWORD64,
3917 Rbp: DWORD64,
3918 Rsi: DWORD64,
3919 Rdi: DWORD64,
3920 R8: DWORD64,
3921 R9: DWORD64,
3922 R10: DWORD64,
3923 R11: DWORD64,
3924 R12: DWORD64,
3925 R13: DWORD64,
3926 R14: DWORD64,
3927 R15: DWORD64,
3928 Rip: DWORD64,
3929 DUMMYUNIONNAME: extern union {
3930 FltSave: XMM_SAVE_AREA32,
3931 FloatSave: XMM_SAVE_AREA32,
3932 DUMMYSTRUCTNAME: extern struct {
3933 Header: [2]M128A,
3934 Legacy: [8]M128A,
3935 Xmm0: M128A,
3936 Xmm1: M128A,
3937 Xmm2: M128A,
3938 Xmm3: M128A,
3939 Xmm4: M128A,
3940 Xmm5: M128A,
3941 Xmm6: M128A,
3942 Xmm7: M128A,
3943 Xmm8: M128A,
3944 Xmm9: M128A,
3945 Xmm10: M128A,
3946 Xmm11: M128A,
3947 Xmm12: M128A,
3948 Xmm13: M128A,
3949 Xmm14: M128A,
3950 Xmm15: M128A,
39323951 },
3933 VectorRegister: [26]M128A,
3934 VectorControl: DWORD64,
3935 DebugControl: DWORD64,
3936 LastBranchToRip: DWORD64,
3937 LastBranchFromRip: DWORD64,
3938 LastExceptionToRip: DWORD64,
3939 LastExceptionFromRip: DWORD64,
3940
3941 pub fn getRegs(ctx: *const CONTEXT) struct { bp: usize, ip: usize, sp: usize } {
3942 return .{ .bp = ctx.Rbp, .ip = ctx.Rip, .sp = ctx.Rsp };
3943 }
3944
3945 pub fn setIp(ctx: *CONTEXT, ip: usize) void {
3946 ctx.Rip = ip;
3947 }
3948
3949 pub fn setSp(ctx: *CONTEXT, sp: usize) void {
3950 ctx.Rsp = sp;
3951 }
3952 };
3952 },
3953 VectorRegister: [26]M128A,
3954 VectorControl: DWORD64,
3955 DebugControl: DWORD64,
3956 LastBranchToRip: DWORD64,
3957 LastBranchFromRip: DWORD64,
3958 LastExceptionToRip: DWORD64,
3959 LastExceptionFromRip: DWORD64,
3960
3961 pub fn getRegs(ctx: *const CONTEXT) struct { bp: usize, ip: usize, sp: usize } {
3962 return .{ .bp = ctx.Rbp, .ip = ctx.Rip, .sp = ctx.Rsp };
3963 }
39533964
3954 pub const RUNTIME_FUNCTION = extern struct {
3955 BeginAddress: DWORD,
3956 EndAddress: DWORD,
3957 UnwindData: DWORD,
3958 };
3965 pub fn setIp(ctx: *CONTEXT, ip: usize) void {
3966 ctx.Rip = ip;
3967 }
39593968
3960 pub const KNONVOLATILE_CONTEXT_POINTERS = extern struct {
3961 FloatingContext: [16]?*M128A,
3962 IntegerContext: [16]?*ULONG64,
3963 };
3969 pub fn setSp(ctx: *CONTEXT, sp: usize) void {
3970 ctx.Rsp = sp;
3971 }
39643972 },
3965 .aarch64 => struct {
3966 pub const NEON128 = extern union {
3973 .aarch64 => extern struct {
3974 ContextFlags: ULONG align(16),
3975 Cpsr: ULONG,
3976 DUMMYUNIONNAME: extern union {
39673977 DUMMYSTRUCTNAME: extern struct {
3968 Low: ULONGLONG,
3969 High: LONGLONG,
3970 },
3971 D: [2]f64,
3972 S: [4]f32,
3973 H: [8]WORD,
3974 B: [16]BYTE,
3975 };
3976
3977 pub const CONTEXT = extern struct {
3978 ContextFlags: ULONG align(16),
3979 Cpsr: ULONG,
3980 DUMMYUNIONNAME: extern union {
3981 DUMMYSTRUCTNAME: extern struct {
3982 X0: DWORD64,
3983 X1: DWORD64,
3984 X2: DWORD64,
3985 X3: DWORD64,
3986 X4: DWORD64,
3987 X5: DWORD64,
3988 X6: DWORD64,
3989 X7: DWORD64,
3990 X8: DWORD64,
3991 X9: DWORD64,
3992 X10: DWORD64,
3993 X11: DWORD64,
3994 X12: DWORD64,
3995 X13: DWORD64,
3996 X14: DWORD64,
3997 X15: DWORD64,
3998 X16: DWORD64,
3999 X17: DWORD64,
4000 X18: DWORD64,
4001 X19: DWORD64,
4002 X20: DWORD64,
4003 X21: DWORD64,
4004 X22: DWORD64,
4005 X23: DWORD64,
4006 X24: DWORD64,
4007 X25: DWORD64,
4008 X26: DWORD64,
4009 X27: DWORD64,
4010 X28: DWORD64,
4011 Fp: DWORD64,
4012 Lr: DWORD64,
4013 },
4014 X: [31]DWORD64,
3978 X0: DWORD64,
3979 X1: DWORD64,
3980 X2: DWORD64,
3981 X3: DWORD64,
3982 X4: DWORD64,
3983 X5: DWORD64,
3984 X6: DWORD64,
3985 X7: DWORD64,
3986 X8: DWORD64,
3987 X9: DWORD64,
3988 X10: DWORD64,
3989 X11: DWORD64,
3990 X12: DWORD64,
3991 X13: DWORD64,
3992 X14: DWORD64,
3993 X15: DWORD64,
3994 X16: DWORD64,
3995 X17: DWORD64,
3996 X18: DWORD64,
3997 X19: DWORD64,
3998 X20: DWORD64,
3999 X21: DWORD64,
4000 X22: DWORD64,
4001 X23: DWORD64,
4002 X24: DWORD64,
4003 X25: DWORD64,
4004 X26: DWORD64,
4005 X27: DWORD64,
4006 X28: DWORD64,
4007 Fp: DWORD64,
4008 Lr: DWORD64,
40154009 },
4016 Sp: DWORD64,
4017 Pc: DWORD64,
4018 V: [32]NEON128,
4019 Fpcr: DWORD,
4020 Fpsr: DWORD,
4021 Bcr: [8]DWORD,
4022 Bvr: [8]DWORD64,
4023 Wcr: [2]DWORD,
4024 Wvr: [2]DWORD64,
4025
4026 pub fn getRegs(ctx: *const CONTEXT) struct { bp: usize, ip: usize, sp: usize } {
4027 return .{
4028 .bp = ctx.DUMMYUNIONNAME.DUMMYSTRUCTNAME.Fp,
4029 .ip = ctx.Pc,
4030 .sp = ctx.Sp,
4031 };
4032 }
4010 X: [31]DWORD64,
4011 },
4012 Sp: DWORD64,
4013 Pc: DWORD64,
4014 V: [32]NEON128,
4015 Fpcr: DWORD,
4016 Fpsr: DWORD,
4017 Bcr: [8]DWORD,
4018 Bvr: [8]DWORD64,
4019 Wcr: [2]DWORD,
4020 Wvr: [2]DWORD64,
4021
4022 pub fn getRegs(ctx: *const CONTEXT) struct { bp: usize, ip: usize, sp: usize } {
4023 return .{
4024 .bp = ctx.DUMMYUNIONNAME.DUMMYSTRUCTNAME.Fp,
4025 .ip = ctx.Pc,
4026 .sp = ctx.Sp,
4027 };
4028 }
40334029
4034 pub fn setIp(ctx: *CONTEXT, ip: usize) void {
4035 ctx.Pc = ip;
4036 }
4030 pub fn setIp(ctx: *CONTEXT, ip: usize) void {
4031 ctx.Pc = ip;
4032 }
40374033
4038 pub fn setSp(ctx: *CONTEXT, sp: usize) void {
4039 ctx.Sp = sp;
4040 }
4041 };
4034 pub fn setSp(ctx: *CONTEXT, sp: usize) void {
4035 ctx.Sp = sp;
4036 }
4037 },
4038 else => @compileError("CONTEXT is not defined for this architecture"),
4039};
40424040
4043 pub const RUNTIME_FUNCTION = extern struct {
4044 BeginAddress: DWORD,
4045 DUMMYUNIONNAME: extern union {
4046 UnwindData: DWORD,
4047 DUMMYSTRUCTNAME: packed struct {
4048 Flag: u2,
4049 FunctionLength: u11,
4050 RegF: u3,
4051 RegI: u4,
4052 H: u1,
4053 CR: u2,
4054 FrameSize: u9,
4055 },
4041pub const RUNTIME_FUNCTION = switch (native_arch) {
4042 .x86_64 => extern struct {
4043 BeginAddress: DWORD,
4044 EndAddress: DWORD,
4045 UnwindData: DWORD,
4046 },
4047 .aarch64 => extern struct {
4048 BeginAddress: DWORD,
4049 DUMMYUNIONNAME: extern union {
4050 UnwindData: DWORD,
4051 DUMMYSTRUCTNAME: packed struct {
4052 Flag: u2,
4053 FunctionLength: u11,
4054 RegF: u3,
4055 RegI: u4,
4056 H: u1,
4057 CR: u2,
4058 FrameSize: u9,
40564059 },
4057 };
4060 },
4061 },
4062 else => @compileError("RUNTIME_FUNCTION is not defined for this architecture"),
4063};
40584064
4059 pub const KNONVOLATILE_CONTEXT_POINTERS = extern struct {
4060 X19: ?*DWORD64,
4061 X20: ?*DWORD64,
4062 X21: ?*DWORD64,
4063 X22: ?*DWORD64,
4064 X23: ?*DWORD64,
4065 X24: ?*DWORD64,
4066 X25: ?*DWORD64,
4067 X26: ?*DWORD64,
4068 X27: ?*DWORD64,
4069 X28: ?*DWORD64,
4070 Fp: ?*DWORD64,
4071 Lr: ?*DWORD64,
4072 D8: ?*DWORD64,
4073 D9: ?*DWORD64,
4074 D10: ?*DWORD64,
4075 D11: ?*DWORD64,
4076 D12: ?*DWORD64,
4077 D13: ?*DWORD64,
4078 D14: ?*DWORD64,
4079 D15: ?*DWORD64,
4080 };
4065pub const KNONVOLATILE_CONTEXT_POINTERS = switch (native_arch) {
4066 .x86_64 => extern struct {
4067 FloatingContext: [16]?*M128A,
4068 IntegerContext: [16]?*ULONG64,
4069 },
4070 .aarch64 => extern struct {
4071 X19: ?*DWORD64,
4072 X20: ?*DWORD64,
4073 X21: ?*DWORD64,
4074 X22: ?*DWORD64,
4075 X23: ?*DWORD64,
4076 X24: ?*DWORD64,
4077 X25: ?*DWORD64,
4078 X26: ?*DWORD64,
4079 X27: ?*DWORD64,
4080 X28: ?*DWORD64,
4081 Fp: ?*DWORD64,
4082 Lr: ?*DWORD64,
4083 D8: ?*DWORD64,
4084 D9: ?*DWORD64,
4085 D10: ?*DWORD64,
4086 D11: ?*DWORD64,
4087 D12: ?*DWORD64,
4088 D13: ?*DWORD64,
4089 D14: ?*DWORD64,
4090 D15: ?*DWORD64,
40814091 },
4082 else => struct {},
4092 else => @compileError("KNONVOLATILE_CONTEXT_POINTERS is not defined for this architecture"),
40834093};
40844094
40854095pub const EXCEPTION_POINTERS = extern struct {