1 /********************************************************
2 *
3 * Warning!
4 * This file was generated automatically.
5 * Please do not edit. Changes should be made in the
6 * appropriate *.tt file.
7 *
8 */
9 using System;
10 using System.Linq;
11 using System.Collections.Generic;
12 using Antmicro.Renode.Peripherals.CPU.Registers;
13 using Antmicro.Renode.Utilities.Binding;
14 using Antmicro.Renode.Exceptions;
15 
16 namespace Antmicro.Renode.Peripherals.CPU
17 {
18     public partial class X86
19     {
SetRegister(int register, RegisterValue value)20         public override void SetRegister(int register, RegisterValue value)
21         {
22             if(!mapping.TryGetValue((X86Registers)register, out var r))
23             {
24                 throw new RecoverableException($"Wrong register index: {register}");
25             }
26 
27             SetRegisterValue32(r.Index, checked((uint)value));
28         }
29 
GetRegister(int register)30         public override RegisterValue GetRegister(int register)
31         {
32             if(!mapping.TryGetValue((X86Registers)register, out var r))
33             {
34                 throw new RecoverableException($"Wrong register index: {register}");
35             }
36             return GetRegisterValue32(r.Index);
37         }
38 
GetRegisters()39         public override IEnumerable<CPURegister> GetRegisters()
40         {
41             return mapping.Values.OrderBy(x => x.Index);
42         }
43 
44         [Register]
45         public RegisterValue EAX
46         {
47             get
48             {
49                 return GetRegisterValue32((int)X86Registers.EAX);
50             }
51             set
52             {
53                 SetRegisterValue32((int)X86Registers.EAX, value);
54             }
55         }
56         [Register]
57         public RegisterValue ECX
58         {
59             get
60             {
61                 return GetRegisterValue32((int)X86Registers.ECX);
62             }
63             set
64             {
65                 SetRegisterValue32((int)X86Registers.ECX, value);
66             }
67         }
68         [Register]
69         public RegisterValue EDX
70         {
71             get
72             {
73                 return GetRegisterValue32((int)X86Registers.EDX);
74             }
75             set
76             {
77                 SetRegisterValue32((int)X86Registers.EDX, value);
78             }
79         }
80         [Register]
81         public RegisterValue EBX
82         {
83             get
84             {
85                 return GetRegisterValue32((int)X86Registers.EBX);
86             }
87             set
88             {
89                 SetRegisterValue32((int)X86Registers.EBX, value);
90             }
91         }
92         [Register]
93         public RegisterValue ESP
94         {
95             get
96             {
97                 return GetRegisterValue32((int)X86Registers.ESP);
98             }
99             set
100             {
101                 SetRegisterValue32((int)X86Registers.ESP, value);
102             }
103         }
104         [Register]
105         public RegisterValue EBP
106         {
107             get
108             {
109                 return GetRegisterValue32((int)X86Registers.EBP);
110             }
111             set
112             {
113                 SetRegisterValue32((int)X86Registers.EBP, value);
114             }
115         }
116         [Register]
117         public RegisterValue ESI
118         {
119             get
120             {
121                 return GetRegisterValue32((int)X86Registers.ESI);
122             }
123             set
124             {
125                 SetRegisterValue32((int)X86Registers.ESI, value);
126             }
127         }
128         [Register]
129         public RegisterValue EDI
130         {
131             get
132             {
133                 return GetRegisterValue32((int)X86Registers.EDI);
134             }
135             set
136             {
137                 SetRegisterValue32((int)X86Registers.EDI, value);
138             }
139         }
140         [Register]
141         public RegisterValue EIP
142         {
143             get
144             {
145                 return GetRegisterValue32((int)X86Registers.EIP);
146             }
147             set
148             {
149                 SetRegisterValue32((int)X86Registers.EIP, value);
150             }
151         }
152         [Register]
153         public RegisterValue EFLAGS
154         {
155             get
156             {
157                 return GetRegisterValue32((int)X86Registers.EFLAGS);
158             }
159             set
160             {
161                 SetRegisterValue32((int)X86Registers.EFLAGS, value);
162             }
163         }
164         [Register]
165         public RegisterValue CS
166         {
167             get
168             {
169                 return GetRegisterValue32((int)X86Registers.CS);
170             }
171             set
172             {
173                 SetRegisterValue32((int)X86Registers.CS, value);
174             }
175         }
176         [Register]
177         public RegisterValue SS
178         {
179             get
180             {
181                 return GetRegisterValue32((int)X86Registers.SS);
182             }
183             set
184             {
185                 SetRegisterValue32((int)X86Registers.SS, value);
186             }
187         }
188         [Register]
189         public RegisterValue DS
190         {
191             get
192             {
193                 return GetRegisterValue32((int)X86Registers.DS);
194             }
195             set
196             {
197                 SetRegisterValue32((int)X86Registers.DS, value);
198             }
199         }
200         [Register]
201         public RegisterValue ES
202         {
203             get
204             {
205                 return GetRegisterValue32((int)X86Registers.ES);
206             }
207             set
208             {
209                 SetRegisterValue32((int)X86Registers.ES, value);
210             }
211         }
212         [Register]
213         public RegisterValue FS
214         {
215             get
216             {
217                 return GetRegisterValue32((int)X86Registers.FS);
218             }
219             set
220             {
221                 SetRegisterValue32((int)X86Registers.FS, value);
222             }
223         }
224         [Register]
225         public RegisterValue GS
226         {
227             get
228             {
229                 return GetRegisterValue32((int)X86Registers.GS);
230             }
231             set
232             {
233                 SetRegisterValue32((int)X86Registers.GS, value);
234             }
235         }
236         [Register]
237         public RegisterValue CR0
238         {
239             get
240             {
241                 return GetRegisterValue32((int)X86Registers.CR0);
242             }
243             set
244             {
245                 SetRegisterValue32((int)X86Registers.CR0, value);
246             }
247         }
248         [Register]
249         public RegisterValue CR1
250         {
251             get
252             {
253                 return GetRegisterValue32((int)X86Registers.CR1);
254             }
255             set
256             {
257                 SetRegisterValue32((int)X86Registers.CR1, value);
258             }
259         }
260         [Register]
261         public RegisterValue CR2
262         {
263             get
264             {
265                 return GetRegisterValue32((int)X86Registers.CR2);
266             }
267             set
268             {
269                 SetRegisterValue32((int)X86Registers.CR2, value);
270             }
271         }
272         [Register]
273         public RegisterValue CR3
274         {
275             get
276             {
277                 return GetRegisterValue32((int)X86Registers.CR3);
278             }
279             set
280             {
281                 SetRegisterValue32((int)X86Registers.CR3, value);
282             }
283         }
284         [Register]
285         public RegisterValue CR4
286         {
287             get
288             {
289                 return GetRegisterValue32((int)X86Registers.CR4);
290             }
291             set
292             {
293                 SetRegisterValue32((int)X86Registers.CR4, value);
294             }
295         }
296         [Register]
297         public override RegisterValue PC
298         {
299             get
300             {
301                 return GetRegisterValue32((int)X86Registers.PC);
302             }
303             set
304             {
305                 SetRegisterValue32((int)X86Registers.PC, value);
306             }
307         }
308 
InitializeRegisters()309         protected override void InitializeRegisters()
310         {
311         }
312 
313         // 649:  Field '...' is never assigned to, and will always have its default value null
314         #pragma warning disable 649
315 
316         [Import(Name = "tlib_set_register_value_32")]
317         protected Action<int, uint> SetRegisterValue32;
318         [Import(Name = "tlib_get_register_value_32")]
319         protected Func<int, uint> GetRegisterValue32;
320 
321         #pragma warning restore 649
322 
323         private static readonly Dictionary<X86Registers, CPURegister> mapping = new Dictionary<X86Registers, CPURegister>
324         {
325             { X86Registers.EAX,  new CPURegister(0, 32, isGeneral: true, isReadonly: false, aliases: new [] { "EAX" }) },
326             { X86Registers.ECX,  new CPURegister(1, 32, isGeneral: true, isReadonly: false, aliases: new [] { "ECX" }) },
327             { X86Registers.EDX,  new CPURegister(2, 32, isGeneral: true, isReadonly: false, aliases: new [] { "EDX" }) },
328             { X86Registers.EBX,  new CPURegister(3, 32, isGeneral: true, isReadonly: false, aliases: new [] { "EBX" }) },
329             { X86Registers.ESP,  new CPURegister(4, 32, isGeneral: true, isReadonly: false, aliases: new [] { "ESP" }) },
330             { X86Registers.EBP,  new CPURegister(5, 32, isGeneral: true, isReadonly: false, aliases: new [] { "EBP" }) },
331             { X86Registers.ESI,  new CPURegister(6, 32, isGeneral: true, isReadonly: false, aliases: new [] { "ESI" }) },
332             { X86Registers.EDI,  new CPURegister(7, 32, isGeneral: true, isReadonly: false, aliases: new [] { "EDI" }) },
333             { X86Registers.EIP,  new CPURegister(8, 32, isGeneral: true, isReadonly: false, aliases: new [] { "EIP", "PC" }) },
334             { X86Registers.EFLAGS,  new CPURegister(9, 32, isGeneral: true, isReadonly: false, aliases: new [] { "EFLAGS" }) },
335             { X86Registers.CS,  new CPURegister(10, 32, isGeneral: true, isReadonly: false, aliases: new [] { "CS" }) },
336             { X86Registers.SS,  new CPURegister(11, 32, isGeneral: true, isReadonly: false, aliases: new [] { "SS" }) },
337             { X86Registers.DS,  new CPURegister(12, 32, isGeneral: true, isReadonly: false, aliases: new [] { "DS" }) },
338             { X86Registers.ES,  new CPURegister(13, 32, isGeneral: true, isReadonly: false, aliases: new [] { "ES" }) },
339             { X86Registers.FS,  new CPURegister(14, 32, isGeneral: true, isReadonly: false, aliases: new [] { "FS" }) },
340             { X86Registers.GS,  new CPURegister(15, 32, isGeneral: true, isReadonly: false, aliases: new [] { "GS" }) },
341             { X86Registers.CR0,  new CPURegister(16, 32, isGeneral: true, isReadonly: false, aliases: new [] { "CR0" }) },
342             { X86Registers.CR1,  new CPURegister(17, 32, isGeneral: true, isReadonly: false, aliases: new [] { "CR1" }) },
343             { X86Registers.CR2,  new CPURegister(18, 32, isGeneral: true, isReadonly: false, aliases: new [] { "CR2" }) },
344             { X86Registers.CR3,  new CPURegister(19, 32, isGeneral: true, isReadonly: false, aliases: new [] { "CR3" }) },
345             { X86Registers.CR4,  new CPURegister(20, 32, isGeneral: true, isReadonly: false, aliases: new [] { "CR4" }) },
346         };
347     }
348 
349     public enum X86Registers
350     {
351         EAX = 0,
352         ECX = 1,
353         EDX = 2,
354         EBX = 3,
355         ESP = 4,
356         EBP = 5,
357         ESI = 6,
358         EDI = 7,
359         EIP = 8,
360         EFLAGS = 9,
361         CS = 10,
362         SS = 11,
363         DS = 12,
364         ES = 13,
365         FS = 14,
366         GS = 15,
367         CR0 = 16,
368         CR1 = 17,
369         CR2 = 18,
370         CR3 = 19,
371         CR4 = 20,
372         PC = 8,
373     }
374 }
375