vmcs_intel_x64_32bit_read_only_data_fields.h
Go to the documentation of this file.
1 //
2 // Bareflank Hypervisor
3 //
4 // Copyright (C) 2015 Assured Information Security, Inc.
5 // Author: Rian Quinn <quinnr@ainfosec.com>
6 // Author: Brendan Kerrigan <kerriganb@ainfosec.com>
7 // Author: Connor Davis <davisc@ainfosec.com>
8 //
9 // This library is free software; you can redistribute it and/or
10 // modify it under the terms of the GNU Lesser General Public
11 // License as published by the Free Software Foundation; either
12 // version 2.1 of the License, or (at your option) any later version.
13 //
14 // This library is distributed in the hope that it will be useful,
15 // but WITHOUT ANY WARRANTY; without even the implied warranty of
16 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 // Lesser General Public License for more details.
18 //
19 // You should have received a copy of the GNU Lesser General Public
20 // License along with this library; if not, write to the Free Software
21 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 
23 #ifndef VMCS_INTEL_X64_32BIT_READ_ONLY_DATA_FIELDS_H
24 #define VMCS_INTEL_X64_32BIT_READ_ONLY_DATA_FIELDS_H
25 
26 #include <bitmanip.h>
27 #include <vmcs/vmcs_intel_x64.h>
28 
35 
36 // *INDENT-OFF*
37 
38 namespace intel_x64
39 {
40 namespace vmcs
41 {
42 
43 namespace vm_instruction_error
44 {
45  constexpr const auto addr = 0x0000000000004400UL;
46  constexpr const auto name = "vm_instruction_error";
47 
48  inline auto exists() noexcept
49  { return true; }
50 
51  inline auto get()
52  { return get_vmcs_field(addr, name, exists()); }
53 
54  inline auto get_if_exists(bool verbose = false) noexcept
55  { return get_vmcs_field_if_exists(addr, name, verbose, exists()); }
56 
57  template<class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
59  {
60  switch (error)
61  {
62  case 1U:
63  return "VMCALL executed in VMX root operation";
64 
65  case 2U:
66  return "VMCLEAR with invalid physical address";
67 
68  case 3U:
69  return "VMCLEAR with VMXON pointer";
70 
71  case 4U:
72  return "VMLAUNCH with non-clear VMCS";
73 
74  case 5U:
75  return "VMRESUME with non-launched VMCS";
76 
77  case 6U:
78  return "VMRESUME after VMXOFF (VMXOFF AND VMXON between VMLAUNCH and VMRESUME)";
79 
80  case 7U:
81  return "VM entry with invalid control field(s)";
82 
83  case 8U:
84  return "VM entry with invalid host-state field(s)";
85 
86  case 9U:
87  return "VMPTRLD with invalid physical address";
88 
89  case 10U:
90  return "VMPTRLD with VMXON pointer";
91 
92  case 11U:
93  return "VMPTRLD with incorrect VMCS revision identifier";
94 
95  case 12U:
96  return "VMREAD/VMWRITE from/to unsupported VMCS component";
97 
98  case 13U:
99  return "VMWRITE to read-only VMCS component";
100 
101  case 15U:
102  return "VMXON executed in VMX root operation";
103 
104  case 16U:
105  return "VM entry with invalid executive-VMCS pointer";
106 
107  case 17U:
108  return "VM entry with non-launched executive VMCS";
109 
110  case 18U:
111  return "VM entry with executive-VMCS pointer not VMXON pointer "
112  "(when attempting to deactivate the dual-monitor treatment of SMIs and SMM)";
113 
114  case 19U:
115  return "VMCALL with non-clear VMCS (when attempting to activate"
116  " the dual-monitor treatment of SMIs and SMM)";
117 
118  case 20U:
119  return "VMCALL with invalid VM-exit control fields";
120 
121  case 22U:
122  return "VMCALL with incorrect MSEG revision identifier (when attempting "
123  "to activate the dual-monitor treatment of SMIs and SMM)";
124 
125  case 23U:
126  return "VMXOFF under dual-monitor treatment of SMIs and SMM";
127 
128  case 24U:
129  return "VMCALL with invalid SMM-monitor features (when attempting to "
130  "activate the dual-monitor treatment of SMIs and SMM)";
131 
132  case 25U:
133  return "VM entry with invalid VM-execution control fields in executive"
134  " VMCS (when attempting to return from SMM)";
135 
136  case 26U:
137  return "VM entry with events blocked by MOV SS";
138 
139  case 28U:
140  return "Invalid operand to INVEPT/INVVPID";
141 
142  default:
143  return "Unknown VM-instruction error";
144  }
145  }
146 
147  template<class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
149  {
150  if (!exists)
151  throw std::logic_error("vm_instruction_error() failed: vm_instruction_error field doesn't exist");
152 
154  }
155 
156  template<class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
157  auto vm_instruction_error_description_if_exists(T error, bool verbose, bool exists)
158  {
159  if (!exists && verbose)
160  bfwarning << "vm_instruction_error() failed: vm_instruction_error field doesn't exist" << '\n';
161 
162  if (exists)
164 
165  return "";
166  }
167 
168  inline auto description()
169  { return vm_instruction_error_description(get_vmcs_field(addr, name, exists()), exists()); }
170 
171  inline auto description_if_exists(bool verbose = false) noexcept
172  {
173  auto&& field = get_vmcs_field_if_exists(addr, name, verbose, exists());
174  return vm_instruction_error_description_if_exists(field, verbose, exists());
175  }
176 }
177 
178 namespace exit_reason
179 {
180  constexpr const auto addr = 0x0000000000004402UL;
181  constexpr const auto name = "exit_reason";
182 
183  inline auto exists() noexcept
184  { return true; }
185 
186  inline auto get()
187  { return get_vmcs_field(addr, name, exists()); }
188 
189  inline auto get_if_exists(bool verbose = false) noexcept
190  { return get_vmcs_field_if_exists(addr, name, verbose, exists()); }
191 
192  namespace basic_exit_reason
193  {
194  constexpr const auto mask = 0x000000000000FFFFUL;
195  constexpr const auto from = 0;
196  constexpr const auto name = "basic_exit_reason";
197 
198  constexpr const auto exception_or_non_maskable_interrupt = 0U;
199  constexpr const auto external_interrupt = 1U;
200  constexpr const auto triple_fault = 2U;
201  constexpr const auto init_signal = 3U;
202  constexpr const auto sipi = 4U;
203  constexpr const auto smi = 5U;
204  constexpr const auto other_smi = 6U;
205  constexpr const auto interrupt_window = 7U;
206  constexpr const auto nmi_window = 8U;
207  constexpr const auto task_switch = 9U;
208  constexpr const auto cpuid = 10U;
209  constexpr const auto getsec = 11U;
210  constexpr const auto hlt = 12U;
211  constexpr const auto invd = 13U;
212  constexpr const auto invlpg = 14U;
213  constexpr const auto rdpmc = 15U;
214  constexpr const auto rdtsc = 16U;
215  constexpr const auto rsm = 17U;
216  constexpr const auto vmcall = 18U;
217  constexpr const auto vmclear = 19U;
218  constexpr const auto vmlaunch = 20U;
219  constexpr const auto vmptrld = 21U;
220  constexpr const auto vmptrst = 22U;
221  constexpr const auto vmread = 23U;
222  constexpr const auto vmresume = 24U;
223  constexpr const auto vmwrite = 25U;
224  constexpr const auto vmxoff = 26U;
225  constexpr const auto vmxon = 27U;
226  constexpr const auto control_register_accesses = 28U;
227  constexpr const auto mov_dr = 29U;
228  constexpr const auto io_instruction = 30U;
229  constexpr const auto rdmsr = 31U;
230  constexpr const auto wrmsr = 32U;
231  constexpr const auto vm_entry_failure_invalid_guest_state = 33U;
232  constexpr const auto vm_entry_failure_msr_loading = 34U;
233  constexpr const auto mwait = 36U;
234  constexpr const auto monitor_trap_flag = 37U;
235  constexpr const auto monitor = 39U;
236  constexpr const auto pause = 40U;
237  constexpr const auto vm_entry_failure_machine_check_event = 41U;
238  constexpr const auto tpr_below_threshold = 43U;
239  constexpr const auto apic_access = 44U;
240  constexpr const auto virtualized_eoi = 45U;
241  constexpr const auto access_to_gdtr_or_idtr = 46U;
242  constexpr const auto access_to_ldtr_or_tr = 47U;
243  constexpr const auto ept_violation = 48U;
244  constexpr const auto ept_misconfiguration = 49U;
245  constexpr const auto invept = 50U;
246  constexpr const auto rdtscp = 51U;
247  constexpr const auto vmx_preemption_timer_expired = 52U;
248  constexpr const auto invvpid = 53U;
249  constexpr const auto wbinvd = 54U;
250  constexpr const auto xsetbv = 55U;
251  constexpr const auto apic_write = 56U;
252  constexpr const auto rdrand = 57U;
253  constexpr const auto invpcid = 58U;
254  constexpr const auto vmfunc = 59U;
255  constexpr const auto rdseed = 61U;
256  constexpr const auto xsaves = 63U;
257  constexpr const auto xrstors = 64U;
258 
259  inline auto get()
260  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
261 
262  inline auto get_if_exists(bool verbose = false) noexcept
263  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
264 
265  template<class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
267  {
268  switch (reason)
269  {
271  return "exception_or_non_maskable_interrupt";
272 
273  case external_interrupt:
274  return "external_interrupt";
275 
276  case triple_fault:
277  return "triple_fault";
278 
279  case init_signal:
280  return "init_signal";
281 
282  case sipi:
283  return "sipi";
284 
285  case smi:
286  return "smi";
287 
288  case other_smi:
289  return "other_smi";
290 
291  case interrupt_window:
292  return "interrupt_window";
293 
294  case nmi_window:
295  return "nmi_window";
296 
297  case task_switch:
298  return "task_switch";
299 
300  case cpuid:
301  return "cpuid";
302 
303  case getsec:
304  return "getsec";
305 
306  case hlt:
307  return "hlt";
308 
309  case invd:
310  return "invd";
311 
312  case invlpg:
313  return "invlpg";
314 
315  case rdpmc:
316  return "rdpmc";
317 
318  case rdtsc:
319  return "rdtsc";
320 
321  case rsm:
322  return "rsm";
323 
324  case vmcall:
325  return "vmcall";
326 
327  case vmclear:
328  return "vmclear";
329 
330  case vmlaunch:
331  return "vmlaunch";
332 
333  case vmptrld:
334  return "vmptrld";
335 
336  case vmptrst:
337  return "vmptrst";
338 
339  case vmread:
340  return "vmread";
341 
342  case vmresume:
343  return "vmresume";
344 
345  case vmwrite:
346  return "vmwrite";
347 
348  case vmxoff:
349  return "vmxoff";
350 
351  case vmxon:
352  return "vmxon";
353 
355  return "control_register_accesses";
356 
357  case mov_dr:
358  return "mov_dr";
359 
360  case io_instruction:
361  return "io_instruction";
362 
363  case rdmsr:
364  return "rdmsr";
365 
366  case wrmsr:
367  return "wrmsr";
368 
370  return "vm_entry_failure_invalid_guest_state";
371 
373  return "vm_entry_failure_msr_loading";
374 
375  case mwait:
376  return "mwait";
377 
378  case monitor_trap_flag:
379  return "monitor_trap_flag";
380 
381  case monitor:
382  return "monitor";
383 
384  case pause:
385  return "pause";
386 
388  return "vm_entry_failure_machine_check_event";
389 
390  case tpr_below_threshold:
391  return "tpr_below_threshold";
392 
393  case apic_access:
394  return "apic_access";
395 
396  case virtualized_eoi:
397  return "virtualized_eoi";
398 
400  return "access_to_gdtr_or_idtr";
401 
403  return "access_to_ldtr_or_tr";
404 
405  case ept_violation:
406  return "ept_violation";
407 
409  return "ept_misconfiguration";
410 
411  case invept:
412  return "invept";
413 
414  case rdtscp:
415  return "rdtscp";
416 
418  return "vmx_preemption_timer_expired";
419 
420  case invvpid:
421  return "invvpid";
422 
423  case wbinvd:
424  return "wbinvd";
425 
426  case xsetbv:
427  return "xsetbv";
428 
429  case apic_write:
430  return "apic_write";
431 
432  case rdrand:
433  return "rdrand";
434 
435  case invpcid:
436  return "invpcid";
437 
438  case vmfunc:
439  return "vmfunc";
440 
441  case rdseed:
442  return "rdseed";
443 
444  case xsaves:
445  return "xsaves";
446 
447  case xrstors:
448  return "xrstors";
449 
450  default:
451  return "unknown";
452  };
453  }
454 
455  template<class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
457  {
458  if (!exists)
459  throw std::logic_error("basic_exit_reason_description failed: exit_reason field doesn't exist");
460 
461  return __basic_exit_reason_description(reason);
462  }
463 
464  template<class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
465  auto basic_exit_reason_description_if_exists(T reason, bool verbose, bool exists)
466  {
467  if (!exists && verbose)
468  bfwarning << "basic_exit_reason_description_if_exists failed: exit_reason field doesn't exist" << '\n';
469 
470  if (exists)
471  return __basic_exit_reason_description(reason);
472 
473  return "";
474  }
475 
476  inline auto description()
477  {
478  auto&& field = get_bits(get_vmcs_field(addr, name, exists()), mask) >> from;
479  return basic_exit_reason_description(field, exists());
480  }
481 
482  inline auto description_if_exists(bool verbose = false) noexcept
483  {
484  auto&& field = get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from;
485  return basic_exit_reason_description_if_exists(field, verbose, exists());
486  }
487  }
488 
489  namespace reserved
490  {
491  constexpr const auto mask = 0x0000000047FF0000UL;
492  constexpr const auto from = 0;
493  constexpr const auto name = "reserved";
494 
495  inline auto get()
496  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
497 
498  inline auto get_if_exists(bool verbose = false) noexcept
499  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
500  }
501 
502  namespace vm_exit_incident_to_enclave_mode
503  {
504  constexpr const auto mask = 0x0000000008000000UL;
505  constexpr const auto from = 27;
506  constexpr const auto name = "vm_exit_incident_to_enclave_mode";
507 
508  inline auto is_enabled()
509  { return is_bit_set(get_vmcs_field(addr, name, exists()), from); }
510 
511  inline auto is_enabled_if_exists(bool verbose = false)
512  { return is_bit_set(get_vmcs_field_if_exists(addr, name, verbose, exists()), from); }
513 
514  inline auto is_disabled()
515  { return is_bit_cleared(get_vmcs_field(addr, name, exists()), from); }
516 
517  inline auto is_disabled_if_exists(bool verbose = false)
518  { return is_bit_cleared(get_vmcs_field_if_exists(addr, name, verbose, exists()), from); }
519  }
520 
521  namespace pending_mtf_vm_exit
522  {
523  constexpr const auto mask = 0x0000000010000000UL;
524  constexpr const auto from = 28;
525  constexpr const auto name = "pending_mtf_vm_exit";
526 
527  inline auto is_enabled()
528  { return is_bit_set(get_vmcs_field(addr, name, exists()), from); }
529 
530  inline auto is_enabled_if_exists(bool verbose = false)
531  { return is_bit_set(get_vmcs_field_if_exists(addr, name, verbose, exists()), from); }
532 
533  inline auto is_disabled()
534  { return is_bit_cleared(get_vmcs_field(addr, name, exists()), from); }
535 
536  inline auto is_disabled_if_exists(bool verbose = false)
537  { return is_bit_cleared(get_vmcs_field_if_exists(addr, name, verbose, exists()), from); }
538  }
539 
540  namespace vm_exit_from_vmx_root_operation
541  {
542  constexpr const auto mask = 0x0000000020000000UL;
543  constexpr const auto from = 29;
544  constexpr const auto name = "vm_exit_from_vmx_root_operation";
545 
546  inline auto is_enabled()
547  { return is_bit_set(get_vmcs_field(addr, name, exists()), from); }
548 
549  inline auto is_enabled_if_exists(bool verbose = false)
550  { return is_bit_set(get_vmcs_field_if_exists(addr, name, verbose, exists()), from); }
551 
552  inline auto is_disabled()
553  { return is_bit_cleared(get_vmcs_field(addr, name, exists()), from); }
554 
555  inline auto is_disabled_if_exists(bool verbose = false)
556  { return is_bit_cleared(get_vmcs_field_if_exists(addr, name, verbose, exists()), from); }
557  }
558 
559  namespace vm_entry_failure
560  {
561  constexpr const auto mask = 0x0000000080000000UL;
562  constexpr const auto from = 31;
563  constexpr const auto name = "vm_entry_failure";
564 
565  inline auto is_enabled()
566  { return is_bit_set(get_vmcs_field(addr, name, exists()), from); }
567 
568  inline auto is_enabled_if_exists(bool verbose = false)
569  { return is_bit_set(get_vmcs_field_if_exists(addr, name, verbose, exists()), from); }
570 
571  inline auto is_disabled()
572  { return is_bit_cleared(get_vmcs_field(addr, name, exists()), from); }
573 
574  inline auto is_disabled_if_exists(bool verbose = false)
575  { return is_bit_cleared(get_vmcs_field_if_exists(addr, name, verbose, exists()), from); }
576  }
577 }
578 
579 namespace vm_exit_interruption_information
580 {
581  constexpr const auto addr = 0x0000000000004404UL;
582  constexpr const auto name = "vm_exit_interruption_information";
583 
584  inline auto exists() noexcept
585  { return true; }
586 
587  inline auto get()
588  { return get_vmcs_field(addr, name, exists()); }
589 
590  inline auto get_if_exists(bool verbose = false) noexcept
591  { return get_vmcs_field_if_exists(addr, name, verbose, exists()); }
592 
593  namespace vector
594  {
595  constexpr const auto mask = 0x000000FFUL;
596  constexpr const auto from = 0;
597  constexpr const auto name = "vector";
598 
599  inline auto get()
600  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
601 
602  inline auto get_if_exists(bool verbose = false) noexcept
603  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
604  }
605 
606  namespace interruption_type
607  {
608  constexpr const auto mask = 0x00000700UL;
609  constexpr const auto from = 8;
610  constexpr const auto name = "interruption_type";
611 
612  constexpr const auto external_interrupt = 0UL;
613  constexpr const auto non_maskable_interrupt = 2UL;
614  constexpr const auto hardware_exception = 3UL;
615  constexpr const auto software_exception = 6UL;
616 
617  inline auto get()
618  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
619 
620  inline auto get_if_exists(bool verbose = false) noexcept
621  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
622  }
623 
624  namespace error_code_valid
625  {
626  constexpr const auto mask = 0x00000800UL;
627  constexpr const auto from = 11;
628  constexpr const auto name = "deliver_error_code_bit";
629 
630  inline auto is_enabled()
631  { return is_bit_set(get_vmcs_field(addr, name, exists()), from); }
632 
633  inline auto is_enabled_if_exists(bool verbose = false) noexcept
634  { return is_bit_set(get_vmcs_field_if_exists(addr, name, verbose, exists()), from); }
635 
636  inline auto is_disabled()
637  { return is_bit_cleared(get_vmcs_field(addr, name, exists()), from); }
638 
639  inline auto is_disabled_if_exists(bool verbose = false) noexcept
640  { return is_bit_cleared(get_vmcs_field_if_exists(addr, name, verbose, exists()), from); }
641  }
642 
643  namespace nmi_unblocking_due_to_iret
644  {
645  constexpr const auto mask = 0x00001000UL;
646  constexpr const auto from = 12;
647  constexpr const auto name = "nmi_unblocking_due_to_iret";
648 
649  inline auto is_enabled()
650  { return is_bit_set(get_vmcs_field(addr, name, exists()), from); }
651 
652  inline auto is_enabled_if_exists(bool verbose = false) noexcept
653  { return is_bit_set(get_vmcs_field_if_exists(addr, name, verbose, exists()), from); }
654 
655  inline auto is_disabled()
656  { return is_bit_cleared(get_vmcs_field(addr, name, exists()), from); }
657 
658  inline auto is_disabled_if_exists(bool verbose = false) noexcept
659  { return is_bit_cleared(get_vmcs_field_if_exists(addr, name, verbose, exists()), from); }
660  }
661 
662  namespace reserved
663  {
664  constexpr const auto mask = 0x7FFFE000UL;
665  constexpr const auto from = 0;
666  constexpr const auto name = "reserved";
667 
668  inline auto get()
669  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
670 
671  inline auto get_if_exists(bool verbose = false) noexcept
672  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
673  }
674 
675  namespace valid_bit
676  {
677  constexpr const auto mask = 0x80000000UL;
678  constexpr const auto from = 31;
679  constexpr const auto name = "valid_bit";
680 
681  inline auto is_enabled()
682  { return is_bit_set(get_vmcs_field(addr, name, exists()), from); }
683 
684  inline auto is_enabled_if_exists(bool verbose = false) noexcept
685  { return is_bit_set(get_vmcs_field_if_exists(addr, name, verbose, exists()), from); }
686 
687  inline auto is_disabled()
688  { return is_bit_cleared(get_vmcs_field(addr, name, exists()), from); }
689 
690  inline auto is_disabled_if_exists(bool verbose = false) noexcept
691  { return is_bit_cleared(get_vmcs_field_if_exists(addr, name, verbose, exists()), from); }
692  }
693 }
694 
695 namespace vm_exit_interruption_error_code
696 {
697  constexpr const auto addr = 0x0000000000004406UL;
698  constexpr const auto name = "vm_exit_interruption_error_code";
699 
700  inline auto exists() noexcept
701  { return true; }
702 
703  inline auto get()
704  { return get_vmcs_field(addr, name, exists()); }
705 
706  inline auto get_if_exists(bool verbose = false) noexcept
707  { return get_vmcs_field_if_exists(addr, name, verbose, exists()); }
708 }
709 
710 namespace idt_vectoring_information
711 {
712  constexpr const auto addr = 0x0000000000004408UL;
713  constexpr const auto name = "idt_vectoring_information_field";
714 
715  inline auto exists() noexcept
716  { return true; }
717 
718  inline auto get()
719  { return get_vmcs_field(addr, name, exists()); }
720 
721  inline auto get_if_exists(bool verbose = false) noexcept
722  { return get_vmcs_field_if_exists(addr, name, verbose, exists()); }
723 
724  namespace vector
725  {
726  constexpr const auto mask = 0x000000FFUL;
727  constexpr const auto from = 0;
728  constexpr const auto name = "vector";
729 
730  inline auto get()
731  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
732 
733  inline auto get_if_exists(bool verbose = false) noexcept
734  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
735  }
736 
737  namespace interruption_type
738  {
739  constexpr const auto mask = 0x00000700UL;
740  constexpr const auto from = 8;
741  constexpr const auto name = "interruption_type";
742 
743  constexpr const auto external_interrupt = 0UL;
744  constexpr const auto non_maskable_interrupt = 2UL;
745  constexpr const auto hardware_exception = 3UL;
746  constexpr const auto software_interrupt = 4UL;
747  constexpr const auto privileged_software_exception = 5UL;
748  constexpr const auto software_exception = 6UL;
749 
750  inline auto get()
751  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
752 
753  inline auto get_if_exists(bool verbose = false) noexcept
754  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
755  }
756 
757  namespace error_code_valid
758  {
759  constexpr const auto mask = 0x00000800UL;
760  constexpr const auto from = 11;
761  constexpr const auto name = "deliver_error_code_bit";
762 
763  inline auto is_enabled()
764  { return is_bit_set(get_vmcs_field(addr, name, exists()), from); }
765 
766  inline auto is_enabled_if_exists(bool verbose = false) noexcept
767  { return is_bit_set(get_vmcs_field_if_exists(addr, name, verbose, exists()), from); }
768 
769  inline auto is_disabled()
770  { return is_bit_cleared(get_vmcs_field(addr, name, exists()), from); }
771 
772  inline auto is_disabled_if_exists(bool verbose = false) noexcept
773  { return is_bit_cleared(get_vmcs_field_if_exists(addr, name, verbose, exists()), from); }
774  }
775 
776  namespace reserved
777  {
778  constexpr const auto mask = 0x7FFFE000UL;
779  constexpr const auto from = 0;
780  constexpr const auto name = "reserved";
781 
782  inline auto get()
783  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
784 
785  inline auto get_if_exists(bool verbose = false) noexcept
786  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
787  }
788 
789  namespace valid_bit
790  {
791  constexpr const auto mask = 0x80000000UL;
792  constexpr const auto from = 31;
793  constexpr const auto name = "valid_bit";
794 
795  inline auto is_enabled()
796  { return is_bit_set(get_vmcs_field(addr, name, exists()), from); }
797 
798  inline auto is_enabled_if_exists(bool verbose = false) noexcept
799  { return is_bit_set(get_vmcs_field_if_exists(addr, name, verbose, exists()), from); }
800 
801  inline auto is_disabled()
802  { return is_bit_cleared(get_vmcs_field(addr, name, exists()), from); }
803 
804  inline auto is_disabled_if_exists(bool verbose = false) noexcept
805  { return is_bit_cleared(get_vmcs_field_if_exists(addr, name, verbose, exists()), from); }
806  }
807 }
808 
809 namespace idt_vectoring_error_code
810 {
811  constexpr const auto addr = 0x000000000000440AUL;
812  constexpr const auto name = "idt_vectoring_error_code";
813 
814  inline auto exists() noexcept
815  { return true; }
816 
817  inline auto get()
818  { return get_vmcs_field(addr, name, exists()); }
819 
820  inline auto get_if_exists(bool verbose = false) noexcept
821  { return get_vmcs_field_if_exists(addr, name, verbose, exists()); }
822 }
823 
824 namespace vm_exit_instruction_length
825 {
826  constexpr const auto addr = 0x000000000000440CUL;
827  constexpr const auto name = "vm_exit_instruction_length";
828 
829  inline auto exists() noexcept
830  { return true; }
831 
832  inline auto get()
833  { return get_vmcs_field(addr, name, exists()); }
834 
835  inline auto get_if_exists(bool verbose = false) noexcept
836  { return get_vmcs_field_if_exists(addr, name, verbose, exists()); }
837 }
838 
839 namespace vm_exit_instruction_information
840 {
841  constexpr const auto addr = 0x000000000000440EUL;
842  constexpr const auto name = "vm_exit_instruction_information";
843 
844  inline auto exists() noexcept
845  { return true; }
846 
847  inline auto get()
848  { return get_vmcs_field(addr, name, exists()); }
849 
850  inline auto get_if_exists(bool verbose = false) noexcept
851  { return get_vmcs_field_if_exists(addr, name, verbose, exists()); }
852 
853  namespace ins
854  {
855  constexpr const auto name = "ins";
856 
857  inline auto get_name()
858  { return name; }
859 
860  inline auto get()
861  { return get_vmcs_field(addr, name, exists()); }
862 
863  inline auto get_if_exists(bool verbose = false) noexcept
864  { return get_vmcs_field_if_exists(addr, name, verbose, exists()); }
865 
866  namespace address_size
867  {
868  constexpr const auto mask = 0x0000000000000380UL;
869  constexpr const auto from = 7;
870  constexpr const auto name = "address_size";
871 
872  constexpr const auto _16bit = 0U;
873  constexpr const auto _32bit = 1U;
874  constexpr const auto _64bit = 2U;
875 
876  inline auto get()
877  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
878 
879  inline auto get_if_exists(bool verbose = false) noexcept
880  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
881  }
882  }
883 
884  namespace outs
885  {
886  constexpr const auto name = "outs";
887 
888  inline auto get_name()
889  { return name; }
890 
891  inline auto get()
892  { return get_vmcs_field(addr, name, exists()); }
893 
894  inline auto get_if_exists(bool verbose = false) noexcept
895  { return get_vmcs_field_if_exists(addr, name, verbose, exists()); }
896 
897  namespace address_size
898  {
899  constexpr const auto mask = 0x0000000000000380UL;
900  constexpr const auto from = 7;
901  constexpr const auto name = "address_size";
902 
903  constexpr const auto _16bit = 0U;
904  constexpr const auto _32bit = 1U;
905  constexpr const auto _64bit = 2U;
906 
907  inline auto get()
908  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
909 
910  inline auto get_if_exists(bool verbose = false) noexcept
911  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
912  }
913 
914  namespace segment_register
915  {
916  constexpr const auto mask = 0x0000000000038000UL;
917  constexpr const auto from = 15;
918  constexpr const auto name = "segment_register";
919 
920  constexpr const auto es = 0U;
921  constexpr const auto cs = 1U;
922  constexpr const auto ss = 2U;
923  constexpr const auto ds = 3U;
924  constexpr const auto fs = 4U;
925  constexpr const auto gs = 5U;
926 
927  inline auto get()
928  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
929 
930  inline auto get_if_exists(bool verbose = false) noexcept
931  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
932  }
933  }
934 
935  namespace invept
936  {
937  constexpr const auto name = "invept";
938 
939  inline auto get_name()
940  { return name; }
941 
942  inline auto get()
943  { return get_vmcs_field(addr, name, exists()); }
944 
945  inline auto get_if_exists(bool verbose = false) noexcept
946  { return get_vmcs_field_if_exists(addr, name, verbose, exists()); }
947 
948  namespace scaling
949  {
950  constexpr const auto mask = 0x0000000000000003UL;
951  constexpr const auto from = 0;
952  constexpr const auto name = "scaling";
953 
954  constexpr const auto no_scaling = 0U;
955  constexpr const auto scale_by_2 = 1U;
956  constexpr const auto scale_by_4 = 2U;
957  constexpr const auto scale_by_8 = 3U;
958 
959  inline auto get()
960  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
961 
962  inline auto get_if_exists(bool verbose = false) noexcept
963  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
964  }
965 
966  namespace address_size
967  {
968  constexpr const auto mask = 0x0000000000000380UL;
969  constexpr const auto from = 7;
970  constexpr const auto name = "address_size";
971 
972  constexpr const auto _16bit = 0U;
973  constexpr const auto _32bit = 1U;
974  constexpr const auto _64bit = 2U;
975 
976  inline auto get()
977  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
978 
979  inline auto get_if_exists(bool verbose = false) noexcept
980  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
981  }
982 
983  namespace segment_register
984  {
985  constexpr const auto mask = 0x0000000000038000UL;
986  constexpr const auto from = 15;
987  constexpr const auto name = "segment_register";
988 
989  constexpr const auto es = 0U;
990  constexpr const auto cs = 1U;
991  constexpr const auto ss = 2U;
992  constexpr const auto ds = 3U;
993  constexpr const auto fs = 4U;
994  constexpr const auto gs = 5U;
995 
996  inline auto get()
997  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
998 
999  inline auto get_if_exists(bool verbose = false) noexcept
1000  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1001  }
1002 
1003  namespace index_reg
1004  {
1005  constexpr const auto mask = 0x00000000003C0000UL;
1006  constexpr const auto from = 18;
1007  constexpr const auto name = "index_reg";
1008 
1009  constexpr const auto rax = 0U;
1010  constexpr const auto rcx = 1U;
1011  constexpr const auto rdx = 2U;
1012  constexpr const auto rbx = 3U;
1013  constexpr const auto rsp = 4U;
1014  constexpr const auto rbp = 5U;
1015  constexpr const auto rsi = 6U;
1016  constexpr const auto rdi = 7U;
1017  constexpr const auto r8 = 8U;
1018  constexpr const auto r9 = 9U;
1019  constexpr const auto r10 = 10U;
1020  constexpr const auto r11 = 11U;
1021  constexpr const auto r12 = 12U;
1022  constexpr const auto r13 = 13U;
1023  constexpr const auto r14 = 14U;
1024  constexpr const auto r15 = 15U;
1025 
1026  inline auto get()
1027  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1028 
1029  inline auto get_if_exists(bool verbose = false) noexcept
1030  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1031  }
1032 
1033  namespace index_reg_invalid
1034  {
1035  constexpr const auto mask = 0x0000000000400000UL;
1036  constexpr const auto from = 22;
1037  constexpr const auto name = "index_reg_invalid";
1038 
1039  constexpr const auto valid = 0U;
1040  constexpr const auto invalid = 1U;
1041 
1042  inline auto get()
1043  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1044 
1045  inline auto get_if_exists(bool verbose = false) noexcept
1046  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1047  }
1048 
1049  namespace base_reg
1050  {
1051  constexpr const auto mask = 0x0000000007800000UL;
1052  constexpr const auto from = 23;
1053  constexpr const auto name = "base_reg";
1054 
1055  constexpr const auto rax = 0U;
1056  constexpr const auto rcx = 1U;
1057  constexpr const auto rdx = 2U;
1058  constexpr const auto rbx = 3U;
1059  constexpr const auto rsp = 4U;
1060  constexpr const auto rbp = 5U;
1061  constexpr const auto rsi = 6U;
1062  constexpr const auto rdi = 7U;
1063  constexpr const auto r8 = 8U;
1064  constexpr const auto r9 = 9U;
1065  constexpr const auto r10 = 10U;
1066  constexpr const auto r11 = 11U;
1067  constexpr const auto r12 = 12U;
1068  constexpr const auto r13 = 13U;
1069  constexpr const auto r14 = 14U;
1070  constexpr const auto r15 = 15U;
1071 
1072  inline auto get()
1073  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1074 
1075  inline auto get_if_exists(bool verbose = false) noexcept
1076  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1077  }
1078 
1079  namespace base_reg_invalid
1080  {
1081  constexpr const auto mask = 0x0000000008000000UL;
1082  constexpr const auto from = 27;
1083  constexpr const auto name = "base_reg_invalid";
1084 
1085  constexpr const auto valid = 0U;
1086  constexpr const auto invalid = 1U;
1087 
1088  inline auto get()
1089  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1090 
1091  inline auto get_if_exists(bool verbose = false) noexcept
1092  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1093  }
1094 
1095  namespace reg2
1096  {
1097  constexpr const auto mask = 0x00000000F0000000UL;
1098  constexpr const auto from = 28;
1099  constexpr const auto name = "reg2";
1100 
1101  constexpr const auto rax = 0U;
1102  constexpr const auto rcx = 1U;
1103  constexpr const auto rdx = 2U;
1104  constexpr const auto rbx = 3U;
1105  constexpr const auto rsp = 4U;
1106  constexpr const auto rbp = 5U;
1107  constexpr const auto rsi = 6U;
1108  constexpr const auto rdi = 7U;
1109  constexpr const auto r8 = 8U;
1110  constexpr const auto r9 = 9U;
1111  constexpr const auto r10 = 10U;
1112  constexpr const auto r11 = 11U;
1113  constexpr const auto r12 = 12U;
1114  constexpr const auto r13 = 13U;
1115  constexpr const auto r14 = 14U;
1116  constexpr const auto r15 = 15U;
1117 
1118  inline auto get()
1119  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1120 
1121  inline auto get_if_exists(bool verbose = false) noexcept
1122  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1123  }
1124  }
1125 
1126  namespace invpcid
1127  {
1128  constexpr const auto name = "invpcid";
1129 
1130  inline auto get_name()
1131  { return name; }
1132 
1133  inline auto get()
1134  { return get_vmcs_field(addr, name, exists()); }
1135 
1136  inline auto get_if_exists(bool verbose = false) noexcept
1137  { return get_vmcs_field_if_exists(addr, name, verbose, exists()); }
1138 
1139  namespace scaling
1140  {
1141  constexpr const auto mask = 0x0000000000000003UL;
1142  constexpr const auto from = 0;
1143  constexpr const auto name = "scaling";
1144 
1145  constexpr const auto no_scaling = 0U;
1146  constexpr const auto scale_by_2 = 1U;
1147  constexpr const auto scale_by_4 = 2U;
1148  constexpr const auto scale_by_8 = 3U;
1149 
1150  inline auto get()
1151  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1152 
1153  inline auto get_if_exists(bool verbose = false) noexcept
1154  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1155  }
1156 
1157  namespace address_size
1158  {
1159  constexpr const auto mask = 0x0000000000000380UL;
1160  constexpr const auto from = 7;
1161  constexpr const auto name = "address_size";
1162 
1163  constexpr const auto _16bit = 0U;
1164  constexpr const auto _32bit = 1U;
1165  constexpr const auto _64bit = 2U;
1166 
1167  inline auto get()
1168  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1169 
1170  inline auto get_if_exists(bool verbose = false) noexcept
1171  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1172  }
1173 
1174  namespace segment_register
1175  {
1176  constexpr const auto mask = 0x0000000000038000UL;
1177  constexpr const auto from = 15;
1178  constexpr const auto name = "segment_register";
1179 
1180  constexpr const auto es = 0U;
1181  constexpr const auto cs = 1U;
1182  constexpr const auto ss = 2U;
1183  constexpr const auto ds = 3U;
1184  constexpr const auto fs = 4U;
1185  constexpr const auto gs = 5U;
1186 
1187  inline auto get()
1188  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1189 
1190  inline auto get_if_exists(bool verbose = false) noexcept
1191  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1192  }
1193 
1194  namespace index_reg
1195  {
1196  constexpr const auto mask = 0x00000000003C0000UL;
1197  constexpr const auto from = 18;
1198  constexpr const auto name = "index_reg";
1199 
1200  constexpr const auto rax = 0U;
1201  constexpr const auto rcx = 1U;
1202  constexpr const auto rdx = 2U;
1203  constexpr const auto rbx = 3U;
1204  constexpr const auto rsp = 4U;
1205  constexpr const auto rbp = 5U;
1206  constexpr const auto rsi = 6U;
1207  constexpr const auto rdi = 7U;
1208  constexpr const auto r8 = 8U;
1209  constexpr const auto r9 = 9U;
1210  constexpr const auto r10 = 10U;
1211  constexpr const auto r11 = 11U;
1212  constexpr const auto r12 = 12U;
1213  constexpr const auto r13 = 13U;
1214  constexpr const auto r14 = 14U;
1215  constexpr const auto r15 = 15U;
1216 
1217  inline auto get()
1218  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1219 
1220  inline auto get_if_exists(bool verbose = false) noexcept
1221  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1222  }
1223 
1224  namespace index_reg_invalid
1225  {
1226  constexpr const auto mask = 0x0000000000400000UL;
1227  constexpr const auto from = 22;
1228  constexpr const auto name = "index_reg_invalid";
1229 
1230  constexpr const auto valid = 0U;
1231  constexpr const auto invalid = 1U;
1232 
1233  inline auto get()
1234  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1235 
1236  inline auto get_if_exists(bool verbose = false) noexcept
1237  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1238  }
1239 
1240  namespace base_reg
1241  {
1242  constexpr const auto mask = 0x0000000007800000UL;
1243  constexpr const auto from = 23;
1244  constexpr const auto name = "base_reg";
1245 
1246  constexpr const auto rax = 0U;
1247  constexpr const auto rcx = 1U;
1248  constexpr const auto rdx = 2U;
1249  constexpr const auto rbx = 3U;
1250  constexpr const auto rsp = 4U;
1251  constexpr const auto rbp = 5U;
1252  constexpr const auto rsi = 6U;
1253  constexpr const auto rdi = 7U;
1254  constexpr const auto r8 = 8U;
1255  constexpr const auto r9 = 9U;
1256  constexpr const auto r10 = 10U;
1257  constexpr const auto r11 = 11U;
1258  constexpr const auto r12 = 12U;
1259  constexpr const auto r13 = 13U;
1260  constexpr const auto r14 = 14U;
1261  constexpr const auto r15 = 15U;
1262 
1263  inline auto get()
1264  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1265 
1266  inline auto get_if_exists(bool verbose = false) noexcept
1267  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1268  }
1269 
1270  namespace base_reg_invalid
1271  {
1272  constexpr const auto mask = 0x0000000008000000UL;
1273  constexpr const auto from = 27;
1274  constexpr const auto name = "base_reg_invalid";
1275 
1276  constexpr const auto valid = 0U;
1277  constexpr const auto invalid = 1U;
1278 
1279  inline auto get()
1280  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1281 
1282  inline auto get_if_exists(bool verbose = false) noexcept
1283  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1284  }
1285 
1286  namespace reg2
1287  {
1288  constexpr const auto mask = 0x00000000F0000000UL;
1289  constexpr const auto from = 28;
1290  constexpr const auto name = "reg2";
1291 
1292  constexpr const auto rax = 0U;
1293  constexpr const auto rcx = 1U;
1294  constexpr const auto rdx = 2U;
1295  constexpr const auto rbx = 3U;
1296  constexpr const auto rsp = 4U;
1297  constexpr const auto rbp = 5U;
1298  constexpr const auto rsi = 6U;
1299  constexpr const auto rdi = 7U;
1300  constexpr const auto r8 = 8U;
1301  constexpr const auto r9 = 9U;
1302  constexpr const auto r10 = 10U;
1303  constexpr const auto r11 = 11U;
1304  constexpr const auto r12 = 12U;
1305  constexpr const auto r13 = 13U;
1306  constexpr const auto r14 = 14U;
1307  constexpr const auto r15 = 15U;
1308 
1309  inline auto get()
1310  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1311 
1312  inline auto get_if_exists(bool verbose = false) noexcept
1313  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1314  }
1315  }
1316 
1317  namespace invvpid
1318  {
1319  constexpr const auto name = "invvpid";
1320 
1321  inline auto get_name()
1322  { return name; }
1323 
1324  inline auto get()
1325  { return get_vmcs_field(addr, name, exists()); }
1326 
1327  inline auto get_if_exists(bool verbose = false) noexcept
1328  { return get_vmcs_field_if_exists(addr, name, verbose, exists()); }
1329 
1330  namespace scaling
1331  {
1332  constexpr const auto mask = 0x0000000000000003UL;
1333  constexpr const auto from = 0;
1334  constexpr const auto name = "scaling";
1335 
1336  constexpr const auto no_scaling = 0U;
1337  constexpr const auto scale_by_2 = 1U;
1338  constexpr const auto scale_by_4 = 2U;
1339  constexpr const auto scale_by_8 = 3U;
1340 
1341  inline auto get()
1342  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1343 
1344  inline auto get_if_exists(bool verbose = false) noexcept
1345  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1346  }
1347 
1348  namespace address_size
1349  {
1350  constexpr const auto mask = 0x0000000000000380UL;
1351  constexpr const auto from = 7;
1352  constexpr const auto name = "address_size";
1353 
1354  constexpr const auto _16bit = 0U;
1355  constexpr const auto _32bit = 1U;
1356  constexpr const auto _64bit = 2U;
1357 
1358  inline auto get()
1359  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1360 
1361  inline auto get_if_exists(bool verbose = false) noexcept
1362  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1363  }
1364 
1365  namespace segment_register
1366  {
1367  constexpr const auto mask = 0x0000000000038000UL;
1368  constexpr const auto from = 15;
1369  constexpr const auto name = "segment_register";
1370 
1371  constexpr const auto es = 0U;
1372  constexpr const auto cs = 1U;
1373  constexpr const auto ss = 2U;
1374  constexpr const auto ds = 3U;
1375  constexpr const auto fs = 4U;
1376  constexpr const auto gs = 5U;
1377 
1378  inline auto get()
1379  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1380 
1381  inline auto get_if_exists(bool verbose = false) noexcept
1382  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1383  }
1384 
1385  namespace index_reg
1386  {
1387  constexpr const auto mask = 0x00000000003C0000UL;
1388  constexpr const auto from = 18;
1389  constexpr const auto name = "index_reg";
1390 
1391  constexpr const auto rax = 0U;
1392  constexpr const auto rcx = 1U;
1393  constexpr const auto rdx = 2U;
1394  constexpr const auto rbx = 3U;
1395  constexpr const auto rsp = 4U;
1396  constexpr const auto rbp = 5U;
1397  constexpr const auto rsi = 6U;
1398  constexpr const auto rdi = 7U;
1399  constexpr const auto r8 = 8U;
1400  constexpr const auto r9 = 9U;
1401  constexpr const auto r10 = 10U;
1402  constexpr const auto r11 = 11U;
1403  constexpr const auto r12 = 12U;
1404  constexpr const auto r13 = 13U;
1405  constexpr const auto r14 = 14U;
1406  constexpr const auto r15 = 15U;
1407 
1408  inline auto get()
1409  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1410 
1411  inline auto get_if_exists(bool verbose = false) noexcept
1412  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1413  }
1414 
1415  namespace index_reg_invalid
1416  {
1417  constexpr const auto mask = 0x0000000000400000UL;
1418  constexpr const auto from = 22;
1419  constexpr const auto name = "index_reg_invalid";
1420 
1421  constexpr const auto valid = 0U;
1422  constexpr const auto invalid = 1U;
1423 
1424  inline auto get()
1425  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1426 
1427  inline auto get_if_exists(bool verbose = false) noexcept
1428  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1429  }
1430 
1431  namespace base_reg
1432  {
1433  constexpr const auto mask = 0x0000000007800000UL;
1434  constexpr const auto from = 23;
1435  constexpr const auto name = "base_reg";
1436 
1437  constexpr const auto rax = 0U;
1438  constexpr const auto rcx = 1U;
1439  constexpr const auto rdx = 2U;
1440  constexpr const auto rbx = 3U;
1441  constexpr const auto rsp = 4U;
1442  constexpr const auto rbp = 5U;
1443  constexpr const auto rsi = 6U;
1444  constexpr const auto rdi = 7U;
1445  constexpr const auto r8 = 8U;
1446  constexpr const auto r9 = 9U;
1447  constexpr const auto r10 = 10U;
1448  constexpr const auto r11 = 11U;
1449  constexpr const auto r12 = 12U;
1450  constexpr const auto r13 = 13U;
1451  constexpr const auto r14 = 14U;
1452  constexpr const auto r15 = 15U;
1453 
1454  inline auto get()
1455  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1456 
1457  inline auto get_if_exists(bool verbose = false) noexcept
1458  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1459  }
1460 
1461  namespace base_reg_invalid
1462  {
1463  constexpr const auto mask = 0x0000000008000000UL;
1464  constexpr const auto from = 27;
1465  constexpr const auto name = "base_reg_invalid";
1466 
1467  constexpr const auto valid = 0U;
1468  constexpr const auto invalid = 1U;
1469 
1470  inline auto get()
1471  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1472 
1473  inline auto get_if_exists(bool verbose = false) noexcept
1474  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1475  }
1476 
1477  namespace reg2
1478  {
1479  constexpr const auto mask = 0x00000000F0000000UL;
1480  constexpr const auto from = 28;
1481  constexpr const auto name = "reg2";
1482 
1483  constexpr const auto rax = 0U;
1484  constexpr const auto rcx = 1U;
1485  constexpr const auto rdx = 2U;
1486  constexpr const auto rbx = 3U;
1487  constexpr const auto rsp = 4U;
1488  constexpr const auto rbp = 5U;
1489  constexpr const auto rsi = 6U;
1490  constexpr const auto rdi = 7U;
1491  constexpr const auto r8 = 8U;
1492  constexpr const auto r9 = 9U;
1493  constexpr const auto r10 = 10U;
1494  constexpr const auto r11 = 11U;
1495  constexpr const auto r12 = 12U;
1496  constexpr const auto r13 = 13U;
1497  constexpr const auto r14 = 14U;
1498  constexpr const auto r15 = 15U;
1499 
1500  inline auto get()
1501  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1502 
1503  inline auto get_if_exists(bool verbose = false) noexcept
1504  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1505  }
1506  }
1507 
1508  namespace lidt
1509  {
1510  constexpr const auto name = "lidt";
1511 
1512  inline auto get_name()
1513  { return name; }
1514 
1515  inline auto get()
1516  { return get_vmcs_field(addr, name, exists()); }
1517 
1518  inline auto get_if_exists(bool verbose = false) noexcept
1519  { return get_vmcs_field_if_exists(addr, name, verbose, exists()); }
1520 
1521  namespace scaling
1522  {
1523  constexpr const auto mask = 0x0000000000000003UL;
1524  constexpr const auto from = 0;
1525  constexpr const auto name = "scaling";
1526 
1527  constexpr const auto no_scaling = 0U;
1528  constexpr const auto scale_by_2 = 1U;
1529  constexpr const auto scale_by_4 = 2U;
1530  constexpr const auto scale_by_8 = 3U;
1531 
1532  inline auto get()
1533  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1534 
1535  inline auto get_if_exists(bool verbose = false) noexcept
1536  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1537  }
1538 
1539  namespace address_size
1540  {
1541  constexpr const auto mask = 0x0000000000000380UL;
1542  constexpr const auto from = 7;
1543  constexpr const auto name = "address_size";
1544 
1545  constexpr const auto _16bit = 0U;
1546  constexpr const auto _32bit = 1U;
1547  constexpr const auto _64bit = 2U;
1548 
1549  inline auto get()
1550  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1551 
1552  inline auto get_if_exists(bool verbose = false) noexcept
1553  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1554  }
1555 
1556  namespace operand_size
1557  {
1558  constexpr const auto mask = 0x0000000000000800UL;
1559  constexpr const auto from = 11;
1560  constexpr const auto name = "operand_size";
1561 
1562  constexpr const auto _16bit = 0U;
1563  constexpr const auto _32bit = 1U;
1564 
1565  inline auto get()
1566  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1567 
1568  inline auto get_if_exists(bool verbose = false) noexcept
1569  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1570  }
1571 
1572  namespace segment_register
1573  {
1574  constexpr const auto mask = 0x0000000000038000UL;
1575  constexpr const auto from = 15;
1576  constexpr const auto name = "segment_register";
1577 
1578  constexpr const auto es = 0U;
1579  constexpr const auto cs = 1U;
1580  constexpr const auto ss = 2U;
1581  constexpr const auto ds = 3U;
1582  constexpr const auto fs = 4U;
1583  constexpr const auto gs = 5U;
1584 
1585  inline auto get()
1586  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1587 
1588  inline auto get_if_exists(bool verbose = false) noexcept
1589  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1590  }
1591 
1592  namespace index_reg
1593  {
1594  constexpr const auto mask = 0x00000000003C0000UL;
1595  constexpr const auto from = 18;
1596  constexpr const auto name = "index_reg";
1597 
1598  constexpr const auto rax = 0U;
1599  constexpr const auto rcx = 1U;
1600  constexpr const auto rdx = 2U;
1601  constexpr const auto rbx = 3U;
1602  constexpr const auto rsp = 4U;
1603  constexpr const auto rbp = 5U;
1604  constexpr const auto rsi = 6U;
1605  constexpr const auto rdi = 7U;
1606  constexpr const auto r8 = 8U;
1607  constexpr const auto r9 = 9U;
1608  constexpr const auto r10 = 10U;
1609  constexpr const auto r11 = 11U;
1610  constexpr const auto r12 = 12U;
1611  constexpr const auto r13 = 13U;
1612  constexpr const auto r14 = 14U;
1613  constexpr const auto r15 = 15U;
1614 
1615  inline auto get()
1616  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1617 
1618  inline auto get_if_exists(bool verbose = false) noexcept
1619  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1620  }
1621 
1622  namespace index_reg_invalid
1623  {
1624  constexpr const auto mask = 0x0000000000400000UL;
1625  constexpr const auto from = 22;
1626  constexpr const auto name = "index_reg_invalid";
1627 
1628  constexpr const auto valid = 0U;
1629  constexpr const auto invalid = 1U;
1630 
1631  inline auto get()
1632  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1633 
1634  inline auto get_if_exists(bool verbose = false) noexcept
1635  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1636  }
1637 
1638  namespace base_reg
1639  {
1640  constexpr const auto mask = 0x0000000007800000UL;
1641  constexpr const auto from = 23;
1642  constexpr const auto name = "base_reg";
1643 
1644  constexpr const auto rax = 0U;
1645  constexpr const auto rcx = 1U;
1646  constexpr const auto rdx = 2U;
1647  constexpr const auto rbx = 3U;
1648  constexpr const auto rsp = 4U;
1649  constexpr const auto rbp = 5U;
1650  constexpr const auto rsi = 6U;
1651  constexpr const auto rdi = 7U;
1652  constexpr const auto r8 = 8U;
1653  constexpr const auto r9 = 9U;
1654  constexpr const auto r10 = 10U;
1655  constexpr const auto r11 = 11U;
1656  constexpr const auto r12 = 12U;
1657  constexpr const auto r13 = 13U;
1658  constexpr const auto r14 = 14U;
1659  constexpr const auto r15 = 15U;
1660 
1661  inline auto get()
1662  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1663 
1664  inline auto get_if_exists(bool verbose = false) noexcept
1665  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1666  }
1667 
1668  namespace base_reg_invalid
1669  {
1670  constexpr const auto mask = 0x0000000008000000UL;
1671  constexpr const auto from = 27;
1672  constexpr const auto name = "base_reg_invalid";
1673 
1674  constexpr const auto valid = 0U;
1675  constexpr const auto invalid = 1U;
1676 
1677  inline auto get()
1678  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1679 
1680  inline auto get_if_exists(bool verbose = false) noexcept
1681  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1682  }
1683 
1684  namespace instruction_identity
1685  {
1686  constexpr const auto mask = 0x0000000030000000UL;
1687  constexpr const auto from = 28;
1688  constexpr const auto name = "instruction_identity";
1689 
1690  constexpr const auto sgdt = 0U;
1691  constexpr const auto sidt = 1U;
1692  constexpr const auto lgdt = 2U;
1693  constexpr const auto lidt = 3U;
1694 
1695  inline auto get()
1696  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1697 
1698  inline auto get_if_exists(bool verbose = false) noexcept
1699  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1700  }
1701  }
1702 
1703  namespace lgdt
1704  {
1705  constexpr const auto name = "lgdt";
1706 
1707  inline auto get_name()
1708  { return name; }
1709 
1710  inline auto get()
1711  { return get_vmcs_field(addr, name, exists()); }
1712 
1713  inline auto get_if_exists(bool verbose = false) noexcept
1714  { return get_vmcs_field_if_exists(addr, name, verbose, exists()); }
1715 
1716  namespace scaling
1717  {
1718  constexpr const auto mask = 0x0000000000000003UL;
1719  constexpr const auto from = 0;
1720  constexpr const auto name = "scaling";
1721 
1722  constexpr const auto no_scaling = 0U;
1723  constexpr const auto scale_by_2 = 1U;
1724  constexpr const auto scale_by_4 = 2U;
1725  constexpr const auto scale_by_8 = 3U;
1726 
1727  inline auto get()
1728  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1729 
1730  inline auto get_if_exists(bool verbose = false) noexcept
1731  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1732  }
1733 
1734  namespace address_size
1735  {
1736  constexpr const auto mask = 0x0000000000000380UL;
1737  constexpr const auto from = 7;
1738  constexpr const auto name = "address_size";
1739 
1740  constexpr const auto _16bit = 0U;
1741  constexpr const auto _32bit = 1U;
1742  constexpr const auto _64bit = 2U;
1743 
1744  inline auto get()
1745  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1746 
1747  inline auto get_if_exists(bool verbose = false) noexcept
1748  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1749  }
1750 
1751  namespace operand_size
1752  {
1753  constexpr const auto mask = 0x0000000000000800UL;
1754  constexpr const auto from = 11;
1755  constexpr const auto name = "operand_size";
1756 
1757  constexpr const auto _16bit = 0U;
1758  constexpr const auto _32bit = 1U;
1759 
1760  inline auto get()
1761  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1762 
1763  inline auto get_if_exists(bool verbose = false) noexcept
1764  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1765  }
1766 
1767  namespace segment_register
1768  {
1769  constexpr const auto mask = 0x0000000000038000UL;
1770  constexpr const auto from = 15;
1771  constexpr const auto name = "segment_register";
1772 
1773  constexpr const auto es = 0U;
1774  constexpr const auto cs = 1U;
1775  constexpr const auto ss = 2U;
1776  constexpr const auto ds = 3U;
1777  constexpr const auto fs = 4U;
1778  constexpr const auto gs = 5U;
1779 
1780  inline auto get()
1781  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1782 
1783  inline auto get_if_exists(bool verbose = false) noexcept
1784  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1785  }
1786 
1787  namespace index_reg
1788  {
1789  constexpr const auto mask = 0x00000000003C0000UL;
1790  constexpr const auto from = 18;
1791  constexpr const auto name = "index_reg";
1792 
1793  constexpr const auto rax = 0U;
1794  constexpr const auto rcx = 1U;
1795  constexpr const auto rdx = 2U;
1796  constexpr const auto rbx = 3U;
1797  constexpr const auto rsp = 4U;
1798  constexpr const auto rbp = 5U;
1799  constexpr const auto rsi = 6U;
1800  constexpr const auto rdi = 7U;
1801  constexpr const auto r8 = 8U;
1802  constexpr const auto r9 = 9U;
1803  constexpr const auto r10 = 10U;
1804  constexpr const auto r11 = 11U;
1805  constexpr const auto r12 = 12U;
1806  constexpr const auto r13 = 13U;
1807  constexpr const auto r14 = 14U;
1808  constexpr const auto r15 = 15U;
1809 
1810  inline auto get()
1811  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1812 
1813  inline auto get_if_exists(bool verbose = false) noexcept
1814  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1815  }
1816 
1817  namespace index_reg_invalid
1818  {
1819  constexpr const auto mask = 0x0000000000400000UL;
1820  constexpr const auto from = 22;
1821  constexpr const auto name = "index_reg_invalid";
1822 
1823  constexpr const auto valid = 0U;
1824  constexpr const auto invalid = 1U;
1825 
1826  inline auto get()
1827  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1828 
1829  inline auto get_if_exists(bool verbose = false) noexcept
1830  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1831  }
1832 
1833  namespace base_reg
1834  {
1835  constexpr const auto mask = 0x0000000007800000UL;
1836  constexpr const auto from = 23;
1837  constexpr const auto name = "base_reg";
1838 
1839  constexpr const auto rax = 0U;
1840  constexpr const auto rcx = 1U;
1841  constexpr const auto rdx = 2U;
1842  constexpr const auto rbx = 3U;
1843  constexpr const auto rsp = 4U;
1844  constexpr const auto rbp = 5U;
1845  constexpr const auto rsi = 6U;
1846  constexpr const auto rdi = 7U;
1847  constexpr const auto r8 = 8U;
1848  constexpr const auto r9 = 9U;
1849  constexpr const auto r10 = 10U;
1850  constexpr const auto r11 = 11U;
1851  constexpr const auto r12 = 12U;
1852  constexpr const auto r13 = 13U;
1853  constexpr const auto r14 = 14U;
1854  constexpr const auto r15 = 15U;
1855 
1856  inline auto get()
1857  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1858 
1859  inline auto get_if_exists(bool verbose = false) noexcept
1860  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1861  }
1862 
1863  namespace base_reg_invalid
1864  {
1865  constexpr const auto mask = 0x0000000008000000UL;
1866  constexpr const auto from = 27;
1867  constexpr const auto name = "base_reg_invalid";
1868 
1869  constexpr const auto valid = 0U;
1870  constexpr const auto invalid = 1U;
1871 
1872  inline auto get()
1873  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1874 
1875  inline auto get_if_exists(bool verbose = false) noexcept
1876  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1877  }
1878 
1879  namespace instruction_identity
1880  {
1881  constexpr const auto mask = 0x0000000030000000UL;
1882  constexpr const auto from = 28;
1883  constexpr const auto name = "instruction_identity";
1884 
1885  constexpr const auto sgdt = 0U;
1886  constexpr const auto sidt = 1U;
1887  constexpr const auto lgdt = 2U;
1888  constexpr const auto lidt = 3U;
1889 
1890  inline auto get()
1891  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1892 
1893  inline auto get_if_exists(bool verbose = false) noexcept
1894  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1895  }
1896  }
1897 
1898  namespace sidt
1899  {
1900  constexpr const auto name = "sidt";
1901 
1902  inline auto get_name()
1903  { return name; }
1904 
1905  inline auto get()
1906  { return get_vmcs_field(addr, name, exists()); }
1907 
1908  inline auto get_if_exists(bool verbose = false) noexcept
1909  { return get_vmcs_field_if_exists(addr, name, verbose, exists()); }
1910 
1911  namespace scaling
1912  {
1913  constexpr const auto mask = 0x0000000000000003UL;
1914  constexpr const auto from = 0;
1915  constexpr const auto name = "scaling";
1916 
1917  constexpr const auto no_scaling = 0U;
1918  constexpr const auto scale_by_2 = 1U;
1919  constexpr const auto scale_by_4 = 2U;
1920  constexpr const auto scale_by_8 = 3U;
1921 
1922  inline auto get()
1923  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1924 
1925  inline auto get_if_exists(bool verbose = false) noexcept
1926  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1927  }
1928 
1929  namespace address_size
1930  {
1931  constexpr const auto mask = 0x0000000000000380UL;
1932  constexpr const auto from = 7;
1933  constexpr const auto name = "address_size";
1934 
1935  constexpr const auto _16bit = 0U;
1936  constexpr const auto _32bit = 1U;
1937  constexpr const auto _64bit = 2U;
1938 
1939  inline auto get()
1940  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1941 
1942  inline auto get_if_exists(bool verbose = false) noexcept
1943  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1944  }
1945 
1946  namespace operand_size
1947  {
1948  constexpr const auto mask = 0x0000000000000800UL;
1949  constexpr const auto from = 11;
1950  constexpr const auto name = "operand_size";
1951 
1952  constexpr const auto _16bit = 0U;
1953  constexpr const auto _32bit = 1U;
1954 
1955  inline auto get()
1956  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1957 
1958  inline auto get_if_exists(bool verbose = false) noexcept
1959  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1960  }
1961 
1962  namespace segment_register
1963  {
1964  constexpr const auto mask = 0x0000000000038000UL;
1965  constexpr const auto from = 15;
1966  constexpr const auto name = "segment_register";
1967 
1968  constexpr const auto es = 0U;
1969  constexpr const auto cs = 1U;
1970  constexpr const auto ss = 2U;
1971  constexpr const auto ds = 3U;
1972  constexpr const auto fs = 4U;
1973  constexpr const auto gs = 5U;
1974 
1975  inline auto get()
1976  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
1977 
1978  inline auto get_if_exists(bool verbose = false) noexcept
1979  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
1980  }
1981 
1982  namespace index_reg
1983  {
1984  constexpr const auto mask = 0x00000000003C0000UL;
1985  constexpr const auto from = 18;
1986  constexpr const auto name = "index_reg";
1987 
1988  constexpr const auto rax = 0U;
1989  constexpr const auto rcx = 1U;
1990  constexpr const auto rdx = 2U;
1991  constexpr const auto rbx = 3U;
1992  constexpr const auto rsp = 4U;
1993  constexpr const auto rbp = 5U;
1994  constexpr const auto rsi = 6U;
1995  constexpr const auto rdi = 7U;
1996  constexpr const auto r8 = 8U;
1997  constexpr const auto r9 = 9U;
1998  constexpr const auto r10 = 10U;
1999  constexpr const auto r11 = 11U;
2000  constexpr const auto r12 = 12U;
2001  constexpr const auto r13 = 13U;
2002  constexpr const auto r14 = 14U;
2003  constexpr const auto r15 = 15U;
2004 
2005  inline auto get()
2006  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2007 
2008  inline auto get_if_exists(bool verbose = false) noexcept
2009  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2010  }
2011 
2012  namespace index_reg_invalid
2013  {
2014  constexpr const auto mask = 0x0000000000400000UL;
2015  constexpr const auto from = 22;
2016  constexpr const auto name = "index_reg_invalid";
2017 
2018  constexpr const auto valid = 0U;
2019  constexpr const auto invalid = 1U;
2020 
2021  inline auto get()
2022  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2023 
2024  inline auto get_if_exists(bool verbose = false) noexcept
2025  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2026  }
2027 
2028  namespace base_reg
2029  {
2030  constexpr const auto mask = 0x0000000007800000UL;
2031  constexpr const auto from = 23;
2032  constexpr const auto name = "base_reg";
2033 
2034  constexpr const auto rax = 0U;
2035  constexpr const auto rcx = 1U;
2036  constexpr const auto rdx = 2U;
2037  constexpr const auto rbx = 3U;
2038  constexpr const auto rsp = 4U;
2039  constexpr const auto rbp = 5U;
2040  constexpr const auto rsi = 6U;
2041  constexpr const auto rdi = 7U;
2042  constexpr const auto r8 = 8U;
2043  constexpr const auto r9 = 9U;
2044  constexpr const auto r10 = 10U;
2045  constexpr const auto r11 = 11U;
2046  constexpr const auto r12 = 12U;
2047  constexpr const auto r13 = 13U;
2048  constexpr const auto r14 = 14U;
2049  constexpr const auto r15 = 15U;
2050 
2051  inline auto get()
2052  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2053 
2054  inline auto get_if_exists(bool verbose = false) noexcept
2055  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2056  }
2057 
2058  namespace base_reg_invalid
2059  {
2060  constexpr const auto mask = 0x0000000008000000UL;
2061  constexpr const auto from = 27;
2062  constexpr const auto name = "base_reg_invalid";
2063 
2064  constexpr const auto valid = 0U;
2065  constexpr const auto invalid = 1U;
2066 
2067  inline auto get()
2068  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2069 
2070  inline auto get_if_exists(bool verbose = false) noexcept
2071  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2072  }
2073 
2074  namespace instruction_identity
2075  {
2076  constexpr const auto mask = 0x0000000030000000UL;
2077  constexpr const auto from = 28;
2078  constexpr const auto name = "instruction_identity";
2079 
2080  constexpr const auto sgdt = 0U;
2081  constexpr const auto sidt = 1U;
2082  constexpr const auto lgdt = 2U;
2083  constexpr const auto lidt = 3U;
2084 
2085  inline auto get()
2086  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2087 
2088  inline auto get_if_exists(bool verbose = false) noexcept
2089  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2090  }
2091  }
2092 
2093  namespace sgdt
2094  {
2095  constexpr const auto name = "sgdt";
2096 
2097  inline auto get_name()
2098  { return name; }
2099 
2100  inline auto get()
2101  { return get_vmcs_field(addr, name, exists()); }
2102 
2103  inline auto get_if_exists(bool verbose = false) noexcept
2104  { return get_vmcs_field_if_exists(addr, name, verbose, exists()); }
2105 
2106  namespace scaling
2107  {
2108  constexpr const auto mask = 0x0000000000000003UL;
2109  constexpr const auto from = 0;
2110  constexpr const auto name = "scaling";
2111 
2112  constexpr const auto no_scaling = 0U;
2113  constexpr const auto scale_by_2 = 1U;
2114  constexpr const auto scale_by_4 = 2U;
2115  constexpr const auto scale_by_8 = 3U;
2116 
2117  inline auto get()
2118  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2119 
2120  inline auto get_if_exists(bool verbose = false) noexcept
2121  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2122  }
2123 
2124  namespace address_size
2125  {
2126  constexpr const auto mask = 0x0000000000000380UL;
2127  constexpr const auto from = 7;
2128  constexpr const auto name = "address_size";
2129 
2130  constexpr const auto _16bit = 0U;
2131  constexpr const auto _32bit = 1U;
2132  constexpr const auto _64bit = 2U;
2133 
2134  inline auto get()
2135  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2136 
2137  inline auto get_if_exists(bool verbose = false) noexcept
2138  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2139  }
2140 
2141  namespace operand_size
2142  {
2143  constexpr const auto mask = 0x0000000000000800UL;
2144  constexpr const auto from = 11;
2145  constexpr const auto name = "operand_size";
2146 
2147  constexpr const auto _16bit = 0U;
2148  constexpr const auto _32bit = 1U;
2149 
2150  inline auto get()
2151  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2152 
2153  inline auto get_if_exists(bool verbose = false) noexcept
2154  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2155  }
2156 
2157  namespace segment_register
2158  {
2159  constexpr const auto mask = 0x0000000000038000UL;
2160  constexpr const auto from = 15;
2161  constexpr const auto name = "segment_register";
2162 
2163  constexpr const auto es = 0U;
2164  constexpr const auto cs = 1U;
2165  constexpr const auto ss = 2U;
2166  constexpr const auto ds = 3U;
2167  constexpr const auto fs = 4U;
2168  constexpr const auto gs = 5U;
2169 
2170  inline auto get()
2171  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2172 
2173  inline auto get_if_exists(bool verbose = false) noexcept
2174  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2175  }
2176 
2177  namespace index_reg
2178  {
2179  constexpr const auto mask = 0x00000000003C0000UL;
2180  constexpr const auto from = 18;
2181  constexpr const auto name = "index_reg";
2182 
2183  constexpr const auto rax = 0U;
2184  constexpr const auto rcx = 1U;
2185  constexpr const auto rdx = 2U;
2186  constexpr const auto rbx = 3U;
2187  constexpr const auto rsp = 4U;
2188  constexpr const auto rbp = 5U;
2189  constexpr const auto rsi = 6U;
2190  constexpr const auto rdi = 7U;
2191  constexpr const auto r8 = 8U;
2192  constexpr const auto r9 = 9U;
2193  constexpr const auto r10 = 10U;
2194  constexpr const auto r11 = 11U;
2195  constexpr const auto r12 = 12U;
2196  constexpr const auto r13 = 13U;
2197  constexpr const auto r14 = 14U;
2198  constexpr const auto r15 = 15U;
2199 
2200  inline auto get()
2201  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2202 
2203  inline auto get_if_exists(bool verbose = false) noexcept
2204  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2205  }
2206 
2207  namespace index_reg_invalid
2208  {
2209  constexpr const auto mask = 0x0000000000400000UL;
2210  constexpr const auto from = 22;
2211  constexpr const auto name = "index_reg_invalid";
2212 
2213  constexpr const auto valid = 0U;
2214  constexpr const auto invalid = 1U;
2215 
2216  inline auto get()
2217  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2218 
2219  inline auto get_if_exists(bool verbose = false) noexcept
2220  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2221  }
2222 
2223  namespace base_reg
2224  {
2225  constexpr const auto mask = 0x0000000007800000UL;
2226  constexpr const auto from = 23;
2227  constexpr const auto name = "base_reg";
2228 
2229  constexpr const auto rax = 0U;
2230  constexpr const auto rcx = 1U;
2231  constexpr const auto rdx = 2U;
2232  constexpr const auto rbx = 3U;
2233  constexpr const auto rsp = 4U;
2234  constexpr const auto rbp = 5U;
2235  constexpr const auto rsi = 6U;
2236  constexpr const auto rdi = 7U;
2237  constexpr const auto r8 = 8U;
2238  constexpr const auto r9 = 9U;
2239  constexpr const auto r10 = 10U;
2240  constexpr const auto r11 = 11U;
2241  constexpr const auto r12 = 12U;
2242  constexpr const auto r13 = 13U;
2243  constexpr const auto r14 = 14U;
2244  constexpr const auto r15 = 15U;
2245 
2246  inline auto get()
2247  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2248 
2249  inline auto get_if_exists(bool verbose = false) noexcept
2250  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2251  }
2252 
2253  namespace base_reg_invalid
2254  {
2255  constexpr const auto mask = 0x0000000008000000UL;
2256  constexpr const auto from = 27;
2257  constexpr const auto name = "base_reg_invalid";
2258 
2259  constexpr const auto valid = 0U;
2260  constexpr const auto invalid = 1U;
2261 
2262  inline auto get()
2263  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2264 
2265  inline auto get_if_exists(bool verbose = false) noexcept
2266  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2267  }
2268 
2269  namespace instruction_identity
2270  {
2271  constexpr const auto mask = 0x0000000030000000UL;
2272  constexpr const auto from = 28;
2273  constexpr const auto name = "instruction_identity";
2274 
2275  constexpr const auto sgdt = 0U;
2276  constexpr const auto sidt = 1U;
2277  constexpr const auto lgdt = 2U;
2278  constexpr const auto lidt = 3U;
2279 
2280  inline auto get()
2281  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2282 
2283  inline auto get_if_exists(bool verbose = false) noexcept
2284  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2285  }
2286  }
2287 
2288  namespace lldt
2289  {
2290  constexpr const auto name = "lldt";
2291 
2292  inline auto get_name()
2293  { return name; }
2294 
2295  inline auto get()
2296  { return get_vmcs_field(addr, name, exists()); }
2297 
2298  inline auto get_if_exists(bool verbose = false) noexcept
2299  { return get_vmcs_field_if_exists(addr, name, verbose, exists()); }
2300 
2301  namespace scaling
2302  {
2303  constexpr const auto mask = 0x0000000000000003UL;
2304  constexpr const auto from = 0;
2305  constexpr const auto name = "scaling";
2306 
2307  constexpr const auto no_scaling = 0U;
2308  constexpr const auto scale_by_2 = 1U;
2309  constexpr const auto scale_by_4 = 2U;
2310  constexpr const auto scale_by_8 = 3U;
2311 
2312  inline auto get()
2313  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2314 
2315  inline auto get_if_exists(bool verbose = false) noexcept
2316  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2317  }
2318 
2319  namespace reg1
2320  {
2321  constexpr const auto mask = 0x0000000000000078UL;
2322  constexpr const auto from = 3;
2323  constexpr const auto name = "reg1";
2324 
2325  constexpr const auto rax = 0U;
2326  constexpr const auto rcx = 1U;
2327  constexpr const auto rdx = 2U;
2328  constexpr const auto rbx = 3U;
2329  constexpr const auto rsp = 4U;
2330  constexpr const auto rbp = 5U;
2331  constexpr const auto rsi = 6U;
2332  constexpr const auto rdi = 7U;
2333  constexpr const auto r8 = 8U;
2334  constexpr const auto r9 = 9U;
2335  constexpr const auto r10 = 10U;
2336  constexpr const auto r11 = 11U;
2337  constexpr const auto r12 = 12U;
2338  constexpr const auto r13 = 13U;
2339  constexpr const auto r14 = 14U;
2340  constexpr const auto r15 = 15U;
2341 
2342  inline auto get()
2343  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2344 
2345  inline auto get_if_exists(bool verbose = false) noexcept
2346  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2347  }
2348 
2349  namespace address_size
2350  {
2351  constexpr const auto mask = 0x0000000000000380UL;
2352  constexpr const auto from = 7;
2353  constexpr const auto name = "address_size";
2354 
2355  constexpr const auto _16bit = 0U;
2356  constexpr const auto _32bit = 1U;
2357  constexpr const auto _64bit = 2U;
2358 
2359  inline auto get()
2360  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2361 
2362  inline auto get_if_exists(bool verbose = false) noexcept
2363  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2364  }
2365 
2366  namespace mem_reg
2367  {
2368  constexpr const auto mask = 0x0000000000000400UL;
2369  constexpr const auto from = 10;
2370  constexpr const auto name = "mem/reg";
2371 
2372  constexpr const auto mem = 0U;
2373  constexpr const auto reg = 1U;
2374 
2375  inline auto get()
2376  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2377 
2378  inline auto get_if_exists(bool verbose = false) noexcept
2379  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2380  }
2381 
2382  namespace segment_register
2383  {
2384  constexpr const auto mask = 0x0000000000038000UL;
2385  constexpr const auto from = 15;
2386  constexpr const auto name = "segment_register";
2387 
2388  constexpr const auto es = 0U;
2389  constexpr const auto cs = 1U;
2390  constexpr const auto ss = 2U;
2391  constexpr const auto ds = 3U;
2392  constexpr const auto fs = 4U;
2393  constexpr const auto gs = 5U;
2394 
2395  inline auto get()
2396  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2397 
2398  inline auto get_if_exists(bool verbose = false) noexcept
2399  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2400  }
2401 
2402  namespace index_reg
2403  {
2404  constexpr const auto mask = 0x00000000003C0000UL;
2405  constexpr const auto from = 18;
2406  constexpr const auto name = "index_reg";
2407 
2408  constexpr const auto rax = 0U;
2409  constexpr const auto rcx = 1U;
2410  constexpr const auto rdx = 2U;
2411  constexpr const auto rbx = 3U;
2412  constexpr const auto rsp = 4U;
2413  constexpr const auto rbp = 5U;
2414  constexpr const auto rsi = 6U;
2415  constexpr const auto rdi = 7U;
2416  constexpr const auto r8 = 8U;
2417  constexpr const auto r9 = 9U;
2418  constexpr const auto r10 = 10U;
2419  constexpr const auto r11 = 11U;
2420  constexpr const auto r12 = 12U;
2421  constexpr const auto r13 = 13U;
2422  constexpr const auto r14 = 14U;
2423  constexpr const auto r15 = 15U;
2424 
2425  inline auto get()
2426  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2427 
2428  inline auto get_if_exists(bool verbose = false) noexcept
2429  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2430  }
2431 
2432  namespace index_reg_invalid
2433  {
2434  constexpr const auto mask = 0x0000000000400000UL;
2435  constexpr const auto from = 22;
2436  constexpr const auto name = "index_reg_invalid";
2437 
2438  constexpr const auto valid = 0U;
2439  constexpr const auto invalid = 1U;
2440 
2441  inline auto get()
2442  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2443 
2444  inline auto get_if_exists(bool verbose = false) noexcept
2445  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2446  }
2447 
2448  namespace base_reg
2449  {
2450  constexpr const auto mask = 0x0000000007800000UL;
2451  constexpr const auto from = 23;
2452  constexpr const auto name = "base_reg";
2453 
2454  constexpr const auto rax = 0U;
2455  constexpr const auto rcx = 1U;
2456  constexpr const auto rdx = 2U;
2457  constexpr const auto rbx = 3U;
2458  constexpr const auto rsp = 4U;
2459  constexpr const auto rbp = 5U;
2460  constexpr const auto rsi = 6U;
2461  constexpr const auto rdi = 7U;
2462  constexpr const auto r8 = 8U;
2463  constexpr const auto r9 = 9U;
2464  constexpr const auto r10 = 10U;
2465  constexpr const auto r11 = 11U;
2466  constexpr const auto r12 = 12U;
2467  constexpr const auto r13 = 13U;
2468  constexpr const auto r14 = 14U;
2469  constexpr const auto r15 = 15U;
2470 
2471  inline auto get()
2472  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2473 
2474  inline auto get_if_exists(bool verbose = false) noexcept
2475  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2476  }
2477 
2478  namespace base_reg_invalid
2479  {
2480  constexpr const auto mask = 0x0000000008000000UL;
2481  constexpr const auto from = 27;
2482  constexpr const auto name = "base_reg_invalid";
2483 
2484  constexpr const auto valid = 0U;
2485  constexpr const auto invalid = 1U;
2486 
2487  inline auto get()
2488  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2489 
2490  inline auto get_if_exists(bool verbose = false) noexcept
2491  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2492  }
2493 
2494  namespace instruction_identity
2495  {
2496  constexpr const auto mask = 0x0000000030000000UL;
2497  constexpr const auto from = 28;
2498  constexpr const auto name = "instruction_identity";
2499 
2500  constexpr const auto sldt = 0U;
2501  constexpr const auto str = 1U;
2502  constexpr const auto lldt = 2U;
2503  constexpr const auto ltr = 3U;
2504 
2505  inline auto get()
2506  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2507 
2508  inline auto get_if_exists(bool verbose = false) noexcept
2509  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2510  }
2511  }
2512 
2513  namespace ltr
2514  {
2515  constexpr const auto name = "ltr";
2516 
2517  inline auto get_name()
2518  { return name; }
2519 
2520  inline auto get()
2521  { return get_vmcs_field(addr, name, exists()); }
2522 
2523  inline auto get_if_exists(bool verbose = false) noexcept
2524  { return get_vmcs_field_if_exists(addr, name, verbose, exists()); }
2525 
2526  namespace scaling
2527  {
2528  constexpr const auto mask = 0x0000000000000003UL;
2529  constexpr const auto from = 0;
2530  constexpr const auto name = "scaling";
2531 
2532  constexpr const auto no_scaling = 0U;
2533  constexpr const auto scale_by_2 = 1U;
2534  constexpr const auto scale_by_4 = 2U;
2535  constexpr const auto scale_by_8 = 3U;
2536 
2537  inline auto get()
2538  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2539 
2540  inline auto get_if_exists(bool verbose = false) noexcept
2541  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2542  }
2543 
2544  namespace reg1
2545  {
2546  constexpr const auto mask = 0x0000000000000078UL;
2547  constexpr const auto from = 3;
2548  constexpr const auto name = "reg1";
2549 
2550  constexpr const auto rax = 0U;
2551  constexpr const auto rcx = 1U;
2552  constexpr const auto rdx = 2U;
2553  constexpr const auto rbx = 3U;
2554  constexpr const auto rsp = 4U;
2555  constexpr const auto rbp = 5U;
2556  constexpr const auto rsi = 6U;
2557  constexpr const auto rdi = 7U;
2558  constexpr const auto r8 = 8U;
2559  constexpr const auto r9 = 9U;
2560  constexpr const auto r10 = 10U;
2561  constexpr const auto r11 = 11U;
2562  constexpr const auto r12 = 12U;
2563  constexpr const auto r13 = 13U;
2564  constexpr const auto r14 = 14U;
2565  constexpr const auto r15 = 15U;
2566 
2567  inline auto get()
2568  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2569 
2570  inline auto get_if_exists(bool verbose = false) noexcept
2571  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2572  }
2573 
2574  namespace address_size
2575  {
2576  constexpr const auto mask = 0x0000000000000380UL;
2577  constexpr const auto from = 7;
2578  constexpr const auto name = "address_size";
2579 
2580  constexpr const auto _16bit = 0U;
2581  constexpr const auto _32bit = 1U;
2582  constexpr const auto _64bit = 2U;
2583 
2584  inline auto get()
2585  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2586 
2587  inline auto get_if_exists(bool verbose = false) noexcept
2588  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2589  }
2590 
2591  namespace mem_reg
2592  {
2593  constexpr const auto mask = 0x0000000000000400UL;
2594  constexpr const auto from = 10;
2595  constexpr const auto name = "mem/reg";
2596 
2597  constexpr const auto mem = 0U;
2598  constexpr const auto reg = 1U;
2599 
2600  inline auto get()
2601  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2602 
2603  inline auto get_if_exists(bool verbose = false) noexcept
2604  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2605  }
2606 
2607  namespace segment_register
2608  {
2609  constexpr const auto mask = 0x0000000000038000UL;
2610  constexpr const auto from = 15;
2611  constexpr const auto name = "segment_register";
2612 
2613  constexpr const auto es = 0U;
2614  constexpr const auto cs = 1U;
2615  constexpr const auto ss = 2U;
2616  constexpr const auto ds = 3U;
2617  constexpr const auto fs = 4U;
2618  constexpr const auto gs = 5U;
2619 
2620  inline auto get()
2621  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2622 
2623  inline auto get_if_exists(bool verbose = false) noexcept
2624  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2625  }
2626 
2627  namespace index_reg
2628  {
2629  constexpr const auto mask = 0x00000000003C0000UL;
2630  constexpr const auto from = 18;
2631  constexpr const auto name = "index_reg";
2632 
2633  constexpr const auto rax = 0U;
2634  constexpr const auto rcx = 1U;
2635  constexpr const auto rdx = 2U;
2636  constexpr const auto rbx = 3U;
2637  constexpr const auto rsp = 4U;
2638  constexpr const auto rbp = 5U;
2639  constexpr const auto rsi = 6U;
2640  constexpr const auto rdi = 7U;
2641  constexpr const auto r8 = 8U;
2642  constexpr const auto r9 = 9U;
2643  constexpr const auto r10 = 10U;
2644  constexpr const auto r11 = 11U;
2645  constexpr const auto r12 = 12U;
2646  constexpr const auto r13 = 13U;
2647  constexpr const auto r14 = 14U;
2648  constexpr const auto r15 = 15U;
2649 
2650  inline auto get()
2651  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2652 
2653  inline auto get_if_exists(bool verbose = false) noexcept
2654  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2655  }
2656 
2657  namespace index_reg_invalid
2658  {
2659  constexpr const auto mask = 0x0000000000400000UL;
2660  constexpr const auto from = 22;
2661  constexpr const auto name = "index_reg_invalid";
2662 
2663  constexpr const auto valid = 0U;
2664  constexpr const auto invalid = 1U;
2665 
2666  inline auto get()
2667  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2668 
2669  inline auto get_if_exists(bool verbose = false) noexcept
2670  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2671  }
2672 
2673  namespace base_reg
2674  {
2675  constexpr const auto mask = 0x0000000007800000UL;
2676  constexpr const auto from = 23;
2677  constexpr const auto name = "base_reg";
2678 
2679  constexpr const auto rax = 0U;
2680  constexpr const auto rcx = 1U;
2681  constexpr const auto rdx = 2U;
2682  constexpr const auto rbx = 3U;
2683  constexpr const auto rsp = 4U;
2684  constexpr const auto rbp = 5U;
2685  constexpr const auto rsi = 6U;
2686  constexpr const auto rdi = 7U;
2687  constexpr const auto r8 = 8U;
2688  constexpr const auto r9 = 9U;
2689  constexpr const auto r10 = 10U;
2690  constexpr const auto r11 = 11U;
2691  constexpr const auto r12 = 12U;
2692  constexpr const auto r13 = 13U;
2693  constexpr const auto r14 = 14U;
2694  constexpr const auto r15 = 15U;
2695 
2696  inline auto get()
2697  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2698 
2699  inline auto get_if_exists(bool verbose = false) noexcept
2700  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2701  }
2702 
2703  namespace base_reg_invalid
2704  {
2705  constexpr const auto mask = 0x0000000008000000UL;
2706  constexpr const auto from = 27;
2707  constexpr const auto name = "base_reg_invalid";
2708 
2709  constexpr const auto valid = 0U;
2710  constexpr const auto invalid = 1U;
2711 
2712  inline auto get()
2713  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2714 
2715  inline auto get_if_exists(bool verbose = false) noexcept
2716  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2717  }
2718 
2719  namespace instruction_identity
2720  {
2721  constexpr const auto mask = 0x0000000030000000UL;
2722  constexpr const auto from = 28;
2723  constexpr const auto name = "instruction_identity";
2724 
2725  constexpr const auto sldt = 0U;
2726  constexpr const auto str = 1U;
2727  constexpr const auto lldt = 2U;
2728  constexpr const auto ltr = 3U;
2729 
2730  inline auto get()
2731  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2732 
2733  inline auto get_if_exists(bool verbose = false) noexcept
2734  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2735  }
2736  }
2737 
2738  namespace sldt
2739  {
2740  constexpr const auto name = "sldt";
2741 
2742  inline auto get_name()
2743  { return name; }
2744 
2745  inline auto get()
2746  { return get_vmcs_field(addr, name, exists()); }
2747 
2748  inline auto get_if_exists(bool verbose = false) noexcept
2749  { return get_vmcs_field_if_exists(addr, name, verbose, exists()); }
2750 
2751  namespace scaling
2752  {
2753  constexpr const auto mask = 0x0000000000000003UL;
2754  constexpr const auto from = 0;
2755  constexpr const auto name = "scaling";
2756 
2757  constexpr const auto no_scaling = 0U;
2758  constexpr const auto scale_by_2 = 1U;
2759  constexpr const auto scale_by_4 = 2U;
2760  constexpr const auto scale_by_8 = 3U;
2761 
2762  inline auto get()
2763  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2764 
2765  inline auto get_if_exists(bool verbose = false) noexcept
2766  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2767  }
2768 
2769  namespace reg1
2770  {
2771  constexpr const auto mask = 0x0000000000000078UL;
2772  constexpr const auto from = 3;
2773  constexpr const auto name = "reg1";
2774 
2775  constexpr const auto rax = 0U;
2776  constexpr const auto rcx = 1U;
2777  constexpr const auto rdx = 2U;
2778  constexpr const auto rbx = 3U;
2779  constexpr const auto rsp = 4U;
2780  constexpr const auto rbp = 5U;
2781  constexpr const auto rsi = 6U;
2782  constexpr const auto rdi = 7U;
2783  constexpr const auto r8 = 8U;
2784  constexpr const auto r9 = 9U;
2785  constexpr const auto r10 = 10U;
2786  constexpr const auto r11 = 11U;
2787  constexpr const auto r12 = 12U;
2788  constexpr const auto r13 = 13U;
2789  constexpr const auto r14 = 14U;
2790  constexpr const auto r15 = 15U;
2791 
2792  inline auto get()
2793  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2794 
2795  inline auto get_if_exists(bool verbose = false) noexcept
2796  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2797  }
2798 
2799  namespace address_size
2800  {
2801  constexpr const auto mask = 0x0000000000000380UL;
2802  constexpr const auto from = 7;
2803  constexpr const auto name = "address_size";
2804 
2805  constexpr const auto _16bit = 0U;
2806  constexpr const auto _32bit = 1U;
2807  constexpr const auto _64bit = 2U;
2808 
2809  inline auto get()
2810  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2811 
2812  inline auto get_if_exists(bool verbose = false) noexcept
2813  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2814  }
2815 
2816  namespace mem_reg
2817  {
2818  constexpr const auto mask = 0x0000000000000400UL;
2819  constexpr const auto from = 10;
2820  constexpr const auto name = "mem/reg";
2821 
2822  constexpr const auto mem = 0U;
2823  constexpr const auto reg = 1U;
2824 
2825  inline auto get()
2826  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2827 
2828  inline auto get_if_exists(bool verbose = false) noexcept
2829  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2830  }
2831 
2832  namespace segment_register
2833  {
2834  constexpr const auto mask = 0x0000000000038000UL;
2835  constexpr const auto from = 15;
2836  constexpr const auto name = "segment_register";
2837 
2838  constexpr const auto es = 0U;
2839  constexpr const auto cs = 1U;
2840  constexpr const auto ss = 2U;
2841  constexpr const auto ds = 3U;
2842  constexpr const auto fs = 4U;
2843  constexpr const auto gs = 5U;
2844 
2845  inline auto get()
2846  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2847 
2848  inline auto get_if_exists(bool verbose = false) noexcept
2849  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2850  }
2851 
2852  namespace index_reg
2853  {
2854  constexpr const auto mask = 0x00000000003C0000UL;
2855  constexpr const auto from = 18;
2856  constexpr const auto name = "index_reg";
2857 
2858  constexpr const auto rax = 0U;
2859  constexpr const auto rcx = 1U;
2860  constexpr const auto rdx = 2U;
2861  constexpr const auto rbx = 3U;
2862  constexpr const auto rsp = 4U;
2863  constexpr const auto rbp = 5U;
2864  constexpr const auto rsi = 6U;
2865  constexpr const auto rdi = 7U;
2866  constexpr const auto r8 = 8U;
2867  constexpr const auto r9 = 9U;
2868  constexpr const auto r10 = 10U;
2869  constexpr const auto r11 = 11U;
2870  constexpr const auto r12 = 12U;
2871  constexpr const auto r13 = 13U;
2872  constexpr const auto r14 = 14U;
2873  constexpr const auto r15 = 15U;
2874 
2875  inline auto get()
2876  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2877 
2878  inline auto get_if_exists(bool verbose = false) noexcept
2879  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2880  }
2881 
2882  namespace index_reg_invalid
2883  {
2884  constexpr const auto mask = 0x0000000000400000UL;
2885  constexpr const auto from = 22;
2886  constexpr const auto name = "index_reg_invalid";
2887 
2888  constexpr const auto valid = 0U;
2889  constexpr const auto invalid = 1U;
2890 
2891  inline auto get()
2892  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2893 
2894  inline auto get_if_exists(bool verbose = false) noexcept
2895  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2896  }
2897 
2898  namespace base_reg
2899  {
2900  constexpr const auto mask = 0x0000000007800000UL;
2901  constexpr const auto from = 23;
2902  constexpr const auto name = "base_reg";
2903 
2904  constexpr const auto rax = 0U;
2905  constexpr const auto rcx = 1U;
2906  constexpr const auto rdx = 2U;
2907  constexpr const auto rbx = 3U;
2908  constexpr const auto rsp = 4U;
2909  constexpr const auto rbp = 5U;
2910  constexpr const auto rsi = 6U;
2911  constexpr const auto rdi = 7U;
2912  constexpr const auto r8 = 8U;
2913  constexpr const auto r9 = 9U;
2914  constexpr const auto r10 = 10U;
2915  constexpr const auto r11 = 11U;
2916  constexpr const auto r12 = 12U;
2917  constexpr const auto r13 = 13U;
2918  constexpr const auto r14 = 14U;
2919  constexpr const auto r15 = 15U;
2920 
2921  inline auto get()
2922  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2923 
2924  inline auto get_if_exists(bool verbose = false) noexcept
2925  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2926  }
2927 
2928  namespace base_reg_invalid
2929  {
2930  constexpr const auto mask = 0x0000000008000000UL;
2931  constexpr const auto from = 27;
2932  constexpr const auto name = "base_reg_invalid";
2933 
2934  constexpr const auto valid = 0U;
2935  constexpr const auto invalid = 1U;
2936 
2937  inline auto get()
2938  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2939 
2940  inline auto get_if_exists(bool verbose = false) noexcept
2941  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2942  }
2943 
2944  namespace instruction_identity
2945  {
2946  constexpr const auto mask = 0x0000000030000000UL;
2947  constexpr const auto from = 28;
2948  constexpr const auto name = "instruction_identity";
2949 
2950  constexpr const auto sldt = 0U;
2951  constexpr const auto str = 1U;
2952  constexpr const auto lldt = 2U;
2953  constexpr const auto ltr = 3U;
2954 
2955  inline auto get()
2956  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2957 
2958  inline auto get_if_exists(bool verbose = false) noexcept
2959  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2960  }
2961  }
2962 
2963  namespace str
2964  {
2965  constexpr const auto name = "str";
2966 
2967  inline auto get_name()
2968  { return name; }
2969 
2970  inline auto get()
2971  { return get_vmcs_field(addr, name, exists()); }
2972 
2973  inline auto get_if_exists(bool verbose = false) noexcept
2974  { return get_vmcs_field_if_exists(addr, name, verbose, exists()); }
2975 
2976  namespace scaling
2977  {
2978  constexpr const auto mask = 0x0000000000000003UL;
2979  constexpr const auto from = 0;
2980  constexpr const auto name = "scaling";
2981 
2982  constexpr const auto no_scaling = 0U;
2983  constexpr const auto scale_by_2 = 1U;
2984  constexpr const auto scale_by_4 = 2U;
2985  constexpr const auto scale_by_8 = 3U;
2986 
2987  inline auto get()
2988  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
2989 
2990  inline auto get_if_exists(bool verbose = false) noexcept
2991  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
2992  }
2993 
2994  namespace reg1
2995  {
2996  constexpr const auto mask = 0x0000000000000078UL;
2997  constexpr const auto from = 3;
2998  constexpr const auto name = "reg1";
2999 
3000  constexpr const auto rax = 0U;
3001  constexpr const auto rcx = 1U;
3002  constexpr const auto rdx = 2U;
3003  constexpr const auto rbx = 3U;
3004  constexpr const auto rsp = 4U;
3005  constexpr const auto rbp = 5U;
3006  constexpr const auto rsi = 6U;
3007  constexpr const auto rdi = 7U;
3008  constexpr const auto r8 = 8U;
3009  constexpr const auto r9 = 9U;
3010  constexpr const auto r10 = 10U;
3011  constexpr const auto r11 = 11U;
3012  constexpr const auto r12 = 12U;
3013  constexpr const auto r13 = 13U;
3014  constexpr const auto r14 = 14U;
3015  constexpr const auto r15 = 15U;
3016 
3017  inline auto get()
3018  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
3019 
3020  inline auto get_if_exists(bool verbose = false) noexcept
3021  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
3022  }
3023 
3024  namespace address_size
3025  {
3026  constexpr const auto mask = 0x0000000000000380UL;
3027  constexpr const auto from = 7;
3028  constexpr const auto name = "address_size";
3029 
3030  constexpr const auto _16bit = 0U;
3031  constexpr const auto _32bit = 1U;
3032  constexpr const auto _64bit = 2U;
3033 
3034  inline auto get()
3035  { return get_bits(get_vmcs_field(addr, name, exists()), mask) >> from; }
3036 
3037  inline auto get_if_exists(bool verbose = false) noexcept
3038  { return get_bits(get_vmcs_field_if_exists(addr, name, verbose, exists()), mask) >> from; }
3039  }
3040 
3041  namespace mem_reg
3042  {