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