LCOV - code coverage report
Current view: top level - src/pe - load_configuration.rs (source / functions) Coverage Total Hit
Test: lief.lcov Lines: 43.5 % 1135 494
Test Date: 2024-10-27:00:00:00 Functions: 20.1 % 657 132

            Line data    Source code
       1              : use std::marker::PhantomData;
       2              : use crate::common::FromFFI;
       3              : use crate::pe::code_integrity::CodeIntegrity;
       4              : use lief_ffi as ffi;
       5              : 
       6           40 : #[derive(Debug)]
       7              : pub enum LoadConfiguration<'a> {
       8              :     Base(Base<'a>),
       9              :     V0(LoadConfigV0<'a>),
      10              :     V1(LoadConfigV1<'a>),
      11              :     V2(LoadConfigV2<'a>),
      12              :     V3(LoadConfigV3<'a>),
      13              :     V4(LoadConfigV4<'a>),
      14              :     V5(LoadConfigV5<'a>),
      15              :     V6(LoadConfigV6<'a>),
      16              :     V7(LoadConfigV7<'a>),
      17              :     V8(LoadConfigV8<'a>),
      18              :     V9(LoadConfigV9<'a>),
      19              :     V10(LoadConfigV10<'a>),
      20              :     V11(LoadConfigV11<'a>),
      21              : }
      22              : 
      23              : 
      24              : impl<'a> FromFFI<ffi::PE_LoadConfiguration> for LoadConfiguration<'a> {
      25           40 :     fn from_ffi(ffi_entry: cxx::UniquePtr<ffi::PE_LoadConfiguration>) -> Self {
      26           40 :         unsafe {
      27           40 :             let config_ref = ffi_entry.as_ref().unwrap();
      28           40 : 
      29           40 :             if ffi::PE_LoadConfigurationV0::classof(config_ref) {
      30            0 :                 let raw = {
      31            0 :                     type From = cxx::UniquePtr<ffi::PE_LoadConfiguration>;
      32            0 :                     type To = cxx::UniquePtr<ffi::PE_LoadConfigurationV0>;
      33            0 :                     std::mem::transmute::<From, To>(ffi_entry)
      34            0 :                 };
      35            0 :                 LoadConfiguration::V0(LoadConfigV0::from_ffi(raw))
      36           40 :             } else if ffi::PE_LoadConfigurationV1::classof(config_ref) {
      37            0 :                 let raw = {
      38            0 :                     type From = cxx::UniquePtr<ffi::PE_LoadConfiguration>;
      39            0 :                     type To = cxx::UniquePtr<ffi::PE_LoadConfigurationV1>;
      40            0 :                     std::mem::transmute::<From, To>(ffi_entry)
      41            0 :                 };
      42            0 :                 LoadConfiguration::V1(LoadConfigV1::from_ffi(raw))
      43           40 :             } else if ffi::PE_LoadConfigurationV2::classof(config_ref) {
      44            0 :                 let raw = {
      45            0 :                     type From = cxx::UniquePtr<ffi::PE_LoadConfiguration>;
      46            0 :                     type To = cxx::UniquePtr<ffi::PE_LoadConfigurationV2>;
      47            0 :                     std::mem::transmute::<From, To>(ffi_entry)
      48            0 :                 };
      49            0 :                 LoadConfiguration::V2(LoadConfigV2::from_ffi(raw))
      50           40 :             } else if ffi::PE_LoadConfigurationV3::classof(config_ref) {
      51            0 :                 let raw = {
      52            0 :                     type From = cxx::UniquePtr<ffi::PE_LoadConfiguration>;
      53            0 :                     type To = cxx::UniquePtr<ffi::PE_LoadConfigurationV3>;
      54            0 :                     std::mem::transmute::<From, To>(ffi_entry)
      55            0 :                 };
      56            0 :                 LoadConfiguration::V3(LoadConfigV3::from_ffi(raw))
      57           40 :             } else if ffi::PE_LoadConfigurationV4::classof(config_ref) {
      58            0 :                 let raw = {
      59            0 :                     type From = cxx::UniquePtr<ffi::PE_LoadConfiguration>;
      60            0 :                     type To = cxx::UniquePtr<ffi::PE_LoadConfigurationV4>;
      61            0 :                     std::mem::transmute::<From, To>(ffi_entry)
      62            0 :                 };
      63            0 :                 LoadConfiguration::V4(LoadConfigV4::from_ffi(raw))
      64           40 :             } else if ffi::PE_LoadConfigurationV5::classof(config_ref) {
      65            0 :                 let raw = {
      66            0 :                     type From = cxx::UniquePtr<ffi::PE_LoadConfiguration>;
      67            0 :                     type To = cxx::UniquePtr<ffi::PE_LoadConfigurationV5>;
      68            0 :                     std::mem::transmute::<From, To>(ffi_entry)
      69            0 :                 };
      70            0 :                 LoadConfiguration::V5(LoadConfigV5::from_ffi(raw))
      71           40 :             } else if ffi::PE_LoadConfigurationV6::classof(config_ref) {
      72            0 :                 let raw = {
      73            0 :                     type From = cxx::UniquePtr<ffi::PE_LoadConfiguration>;
      74            0 :                     type To = cxx::UniquePtr<ffi::PE_LoadConfigurationV6>;
      75            0 :                     std::mem::transmute::<From, To>(ffi_entry)
      76            0 :                 };
      77            0 :                 LoadConfiguration::V6(LoadConfigV6::from_ffi(raw))
      78           40 :             } else if ffi::PE_LoadConfigurationV7::classof(config_ref) {
      79            8 :                 let raw = {
      80            8 :                     type From = cxx::UniquePtr<ffi::PE_LoadConfiguration>;
      81            8 :                     type To = cxx::UniquePtr<ffi::PE_LoadConfigurationV7>;
      82            8 :                     std::mem::transmute::<From, To>(ffi_entry)
      83            8 :                 };
      84            8 :                 LoadConfiguration::V7(LoadConfigV7::from_ffi(raw))
      85           32 :             } else if ffi::PE_LoadConfigurationV8::classof(config_ref) {
      86            0 :                 let raw = {
      87            0 :                     type From = cxx::UniquePtr<ffi::PE_LoadConfiguration>;
      88            0 :                     type To = cxx::UniquePtr<ffi::PE_LoadConfigurationV8>;
      89            0 :                     std::mem::transmute::<From, To>(ffi_entry)
      90            0 :                 };
      91            0 :                 LoadConfiguration::V8(LoadConfigV8::from_ffi(raw))
      92           32 :             } else if ffi::PE_LoadConfigurationV9::classof(config_ref) {
      93            0 :                 let raw = {
      94            0 :                     type From = cxx::UniquePtr<ffi::PE_LoadConfiguration>;
      95            0 :                     type To = cxx::UniquePtr<ffi::PE_LoadConfigurationV9>;
      96            0 :                     std::mem::transmute::<From, To>(ffi_entry)
      97            0 :                 };
      98            0 :                 LoadConfiguration::V9(LoadConfigV9::from_ffi(raw))
      99           32 :             } else if ffi::PE_LoadConfigurationV10::classof(config_ref) {
     100            0 :                 let raw = {
     101            0 :                     type From = cxx::UniquePtr<ffi::PE_LoadConfiguration>;
     102            0 :                     type To = cxx::UniquePtr<ffi::PE_LoadConfigurationV10>;
     103            0 :                     std::mem::transmute::<From, To>(ffi_entry)
     104            0 :                 };
     105            0 :                 LoadConfiguration::V10(LoadConfigV10::from_ffi(raw))
     106           32 :             } else if ffi::PE_LoadConfigurationV11::classof(config_ref) {
     107           32 :                 let raw = {
     108           32 :                     type From = cxx::UniquePtr<ffi::PE_LoadConfiguration>;
     109           32 :                     type To = cxx::UniquePtr<ffi::PE_LoadConfigurationV11>;
     110           32 :                     std::mem::transmute::<From, To>(ffi_entry)
     111           32 :                 };
     112           32 :                 LoadConfiguration::V11(LoadConfigV11::from_ffi(raw))
     113              :             } else {
     114            0 :                 LoadConfiguration::Base(Base::from_ffi(ffi_entry))
     115              :             }
     116              :         }
     117           40 :     }
     118              : }
     119              : 
     120              : pub struct Base<'a> {
     121              :     ptr: cxx::UniquePtr<ffi::PE_LoadConfiguration>,
     122              :     _owner: PhantomData<&'a ffi::PE_Binary>,
     123              : }
     124              : 
     125              : impl std::fmt::Debug for Base<'_> {
     126            0 :     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
     127            0 :         let base = self as &dyn AsBase;
     128            0 :         f.write_str(format!("{base:?}").as_str())
     129            0 :     }
     130              : }
     131              : 
     132              : impl std::fmt::Debug for &dyn AsBase {
     133           40 :     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
     134           40 :         f.debug_struct("Base")
     135           40 :             .field("characteristics", &self.characteristics())
     136           40 :             .field("timedatestamp", &self.timedatestamp())
     137           40 :             .field("major_version", &self.major_version())
     138           40 :             .field("minor_version", &self.minor_version())
     139           40 :             .field("global_flags_clear", &self.global_flags_clear())
     140           40 :             .field("global_flags_set", &self.global_flags_set())
     141           40 :             .field("critical_section_default_timeout", &self.critical_section_default_timeout())
     142           40 :             .field("decommit_free_block_threshold", &self.decommit_free_block_threshold())
     143           40 :             .field("decommit_total_free_threshold", &self.decommit_total_free_threshold())
     144           40 :             .field("lock_prefix_table", &self.lock_prefix_table())
     145           40 :             .field("maximum_allocation_size", &self.maximum_allocation_size())
     146           40 :             .field("virtual_memory_threshold", &self.virtual_memory_threshold())
     147           40 :             .field("process_affinity_mask", &self.process_affinity_mask())
     148           40 :             .field("process_heap_flags", &self.process_heap_flags())
     149           40 :             .field("csd_version", &self.csd_version())
     150           40 :             .field("reserved1", &self.reserved1())
     151           40 :             .field("dependent_load_flags", &self.dependent_load_flags())
     152           40 :             .field("editlist", &self.editlist())
     153           40 :             .field("security_cookie", &self.security_cookie())
     154           40 :             .finish()
     155           40 :     }
     156              : }
     157              : 
     158              : impl<'a> FromFFI<ffi::PE_LoadConfiguration> for Base<'a> {
     159            0 :     fn from_ffi(ptr: cxx::UniquePtr<ffi::PE_LoadConfiguration>) -> Self {
     160            0 :         Self {
     161            0 :             ptr,
     162            0 :             _owner: PhantomData,
     163            0 :         }
     164            0 :     }
     165              : }
     166              : 
     167              : pub trait AsBase {
     168              :     #[doc(hidden)]
     169              :     fn as_base(&self) -> &ffi::PE_LoadConfiguration;
     170              : 
     171            5 :     fn characteristics(&self) -> u32 {
     172            5 :         self.as_base().characteristics()
     173            5 :     }
     174              : 
     175            0 :     fn size(&self) -> u32 {
     176            0 :         self.as_base().size()
     177            0 :     }
     178              : 
     179            5 :     fn timedatestamp(&self) -> u32 {
     180            5 :         self.as_base().timedatestamp()
     181            5 :     }
     182              : 
     183            5 :     fn major_version(&self) -> u32 {
     184            5 :         self.as_base().major_version()
     185            5 :     }
     186              : 
     187            5 :     fn minor_version(&self) -> u32 {
     188            5 :         self.as_base().minor_version()
     189            5 :     }
     190              : 
     191            5 :     fn global_flags_clear(&self) -> u32 {
     192            5 :         self.as_base().global_flags_clear()
     193            5 :     }
     194              : 
     195            5 :     fn global_flags_set(&self) -> u32 {
     196            5 :         self.as_base().global_flags_set()
     197            5 :     }
     198              : 
     199            5 :     fn critical_section_default_timeout(&self) -> u32 {
     200            5 :         self.as_base().critical_section_default_timeout()
     201            5 :     }
     202              : 
     203            5 :     fn decommit_free_block_threshold(&self) -> u64 {
     204            5 :         self.as_base().decommit_free_block_threshold()
     205            5 :     }
     206              : 
     207            5 :     fn decommit_total_free_threshold(&self) -> u64 {
     208            5 :         self.as_base().decommit_total_free_threshold()
     209            5 :     }
     210              : 
     211            5 :     fn lock_prefix_table(&self) -> u64 {
     212            5 :         self.as_base().lock_prefix_table()
     213            5 :     }
     214              : 
     215            5 :     fn maximum_allocation_size(&self) -> u64 {
     216            5 :         self.as_base().maximum_allocation_size()
     217            5 :     }
     218              : 
     219            5 :     fn virtual_memory_threshold(&self) -> u64 {
     220            5 :         self.as_base().virtual_memory_threshold()
     221            5 :     }
     222              : 
     223            5 :     fn process_affinity_mask(&self) -> u64 {
     224            5 :         self.as_base().process_affinity_mask()
     225            5 :     }
     226              : 
     227            5 :     fn process_heap_flags(&self) -> u32 {
     228            5 :         self.as_base().process_heap_flags()
     229            5 :     }
     230              : 
     231            5 :     fn csd_version(&self) -> u16 {
     232            5 :         self.as_base().csd_version()
     233            5 :     }
     234              : 
     235            5 :     fn reserved1(&self) -> u16 {
     236            5 :         self.as_base().reserved1()
     237            5 :     }
     238              : 
     239            5 :     fn dependent_load_flags(&self) -> u16 {
     240            5 :         self.as_base().dependent_load_flags()
     241            5 :     }
     242              : 
     243            5 :     fn editlist(&self) -> u32 {
     244            5 :         self.as_base().editlist()
     245            5 :     }
     246              : 
     247            5 :     fn security_cookie(&self) -> u64 {
     248            5 :         self.as_base().security_cookie()
     249            5 :     }
     250              : }
     251              : 
     252              : impl AsBase for Base<'_> {
     253            0 :     fn as_base(&self) -> &ffi::PE_LoadConfiguration {
     254            0 :         self.ptr.as_ref().unwrap()
     255            0 :     }
     256              : }
     257              : 
     258              : pub struct LoadConfigV0<'a> {
     259              :     ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV0>,
     260              :     _owner: PhantomData<&'a ffi::PE_Binary>,
     261              : }
     262              : 
     263              : impl std::fmt::Debug for LoadConfigV0<'_> {
     264            0 :     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
     265            0 :         let base = self as &dyn AsLoadConfigV0;
     266            0 :         f.write_str(format!("{base:?}").as_str())
     267            0 :     }
     268              : }
     269              : 
     270              : impl std::fmt::Debug for &dyn AsLoadConfigV0 {
     271           40 :     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
     272           40 :         f.debug_struct("LoadConfigV0")
     273           40 :             .field("se_handler_table", &self.se_handler_table())
     274           40 :             .field("se_handler_count", &self.se_handler_count())
     275           40 :             .finish()
     276           40 :     }
     277              : }
     278              : 
     279              : impl<'a> FromFFI<ffi::PE_LoadConfigurationV0> for LoadConfigV0<'a> {
     280            0 :     fn from_ffi(ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV0>) -> Self {
     281            0 :         Self {
     282            0 :             ptr,
     283            0 :             _owner: PhantomData,
     284            0 :         }
     285            0 :     }
     286              : }
     287              : 
     288              : pub trait AsLoadConfigV0 {
     289              :     #[doc(hidden)]
     290              :     fn as_v0(&self) -> &ffi::PE_LoadConfigurationV0;
     291              : 
     292            5 :     fn se_handler_table(&self) -> u64 {
     293            5 :         self.as_v0().se_handler_table()
     294            5 :     }
     295              : 
     296            5 :     fn se_handler_count(&self) -> u64 {
     297            5 :         self.as_v0().se_handler_count()
     298            5 :     }
     299              : }
     300              : 
     301              : impl AsBase for LoadConfigV0<'_> {
     302            0 :     fn as_base(&self) -> &ffi::PE_LoadConfiguration {
     303            0 :         self.ptr.as_ref().unwrap().as_ref()
     304            0 :     }
     305              : }
     306              : 
     307              : impl AsLoadConfigV0 for LoadConfigV0<'_> {
     308            0 :     fn as_v0(&self) -> &ffi::PE_LoadConfigurationV0 {
     309            0 :         self.ptr.as_ref().unwrap()
     310            0 :     }
     311              : }
     312              : 
     313              : pub struct LoadConfigV1<'a> {
     314              :     ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV1>,
     315              :     _owner: PhantomData<&'a ffi::PE_Binary>,
     316              : }
     317              : 
     318              : impl<'a> FromFFI<ffi::PE_LoadConfigurationV1> for LoadConfigV1<'a> {
     319            0 :     fn from_ffi(ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV1>) -> Self {
     320            0 :         Self {
     321            0 :             ptr,
     322            0 :             _owner: PhantomData,
     323            0 :         }
     324            0 :     }
     325              : }
     326              : 
     327              : impl std::fmt::Debug for LoadConfigV1<'_> {
     328            0 :     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
     329            0 :         let base = self as &dyn AsLoadConfigV1;
     330            0 :         f.write_str(format!("{base:?}").as_str())
     331            0 :     }
     332              : }
     333              : 
     334              : impl std::fmt::Debug for &dyn AsLoadConfigV1 {
     335           40 :     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
     336           40 :         f.debug_struct("LoadConfigV1")
     337           40 :             .field("guard_cf_check_function_pointer", &self.guard_cf_check_function_pointer())
     338           40 :             .field("guard_cf_dispatch_function_pointer", &self.guard_cf_dispatch_function_pointer())
     339           40 :             .field("guard_cf_function_table", &self.guard_cf_function_table())
     340           40 :             .field("guard_cf_function_count", &self.guard_cf_function_count())
     341           40 :             .field("guard_flags", &self.guard_flags())
     342           40 :             .finish()
     343           40 :     }
     344              : }
     345              : 
     346              : pub trait AsLoadConfigV1 {
     347              :     #[doc(hidden)]
     348              :     fn as_v1(&self) -> &ffi::PE_LoadConfigurationV1;
     349              : 
     350            5 :     fn guard_cf_check_function_pointer(&self) -> u64 {
     351            5 :         self.as_v1().guard_cf_check_function_pointer()
     352            5 :     }
     353              : 
     354            5 :     fn guard_cf_dispatch_function_pointer(&self) -> u64 {
     355            5 :         self.as_v1().guard_cf_dispatch_function_pointer()
     356            5 :     }
     357              : 
     358            5 :     fn guard_cf_function_table(&self) -> u64 {
     359            5 :         self.as_v1().guard_cf_function_table()
     360            5 :     }
     361              : 
     362            5 :     fn guard_cf_function_count(&self) -> u64 {
     363            5 :         self.as_v1().guard_cf_function_count()
     364            5 :     }
     365              : 
     366            5 :     fn guard_flags(&self) -> u32 {
     367            5 :         self.as_v1().guard_flags()
     368            5 :     }
     369              : }
     370              : 
     371              : impl AsBase for LoadConfigV1<'_> {
     372            0 :     fn as_base(&self) -> &ffi::PE_LoadConfiguration {
     373            0 :         self.ptr.as_ref().unwrap().as_ref().as_ref()
     374            0 :     }
     375              : }
     376              : 
     377              : impl AsLoadConfigV0 for LoadConfigV1<'_> {
     378            0 :     fn as_v0(&self) -> &ffi::PE_LoadConfigurationV0 {
     379            0 :         self.ptr.as_ref().unwrap().as_ref()
     380            0 :     }
     381              : }
     382              : 
     383              : impl AsLoadConfigV1 for LoadConfigV1<'_> {
     384            0 :     fn as_v1(&self) -> &ffi::PE_LoadConfigurationV1 {
     385            0 :         self.ptr.as_ref().unwrap()
     386            0 :     }
     387              : }
     388              : 
     389              : pub struct LoadConfigV2<'a> {
     390              :     ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV2>,
     391              :     _owner: PhantomData<&'a ffi::PE_Binary>,
     392              : }
     393              : 
     394              : 
     395              : impl std::fmt::Debug for LoadConfigV2<'_> {
     396            0 :     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
     397            0 :         let base = self as &dyn AsLoadConfigV2;
     398            0 :         f.write_str(format!("{base:?}").as_str())
     399            0 :     }
     400              : }
     401              : 
     402              : impl std::fmt::Debug for &dyn AsLoadConfigV2 {
     403           40 :     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
     404           40 :         f.debug_struct("LoadConfigV2")
     405           40 :             .field("code_integrity", &self.code_integrity())
     406           40 :             .finish()
     407           40 :     }
     408              : }
     409              : 
     410              : 
     411              : impl<'a> FromFFI<ffi::PE_LoadConfigurationV2> for LoadConfigV2<'a> {
     412            0 :     fn from_ffi(ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV2>) -> Self {
     413            0 :         Self {
     414            0 :             ptr,
     415            0 :             _owner: PhantomData,
     416            0 :         }
     417            0 :     }
     418              : }
     419              : 
     420              : 
     421              : pub trait AsLoadConfigV2 {
     422              :     #[doc(hidden)]
     423              :     fn as_v2(&self) -> &ffi::PE_LoadConfigurationV2;
     424              : 
     425            5 :     fn code_integrity(&self) -> CodeIntegrity {
     426            5 :         CodeIntegrity::from_ffi(self.as_v2().code_integrity())
     427            5 :     }
     428              : }
     429              : 
     430              : impl AsBase for LoadConfigV2<'_> {
     431            0 :     fn as_base(&self) -> &ffi::PE_LoadConfiguration {
     432            0 :         self.ptr.as_ref().unwrap().as_ref().as_ref().as_ref()
     433            0 :     }
     434              : }
     435              : 
     436              : impl AsLoadConfigV0 for LoadConfigV2<'_> {
     437            0 :     fn as_v0(&self) -> &ffi::PE_LoadConfigurationV0 {
     438            0 :         self.ptr.as_ref().unwrap().as_ref().as_ref()
     439            0 :     }
     440              : }
     441              : 
     442              : impl AsLoadConfigV1 for LoadConfigV2<'_> {
     443            0 :     fn as_v1(&self) -> &ffi::PE_LoadConfigurationV1 {
     444            0 :         self.ptr.as_ref().unwrap().as_ref()
     445            0 :     }
     446              : }
     447              : 
     448              : impl AsLoadConfigV2 for LoadConfigV2<'_> {
     449            0 :     fn as_v2(&self) -> &ffi::PE_LoadConfigurationV2 {
     450            0 :         self.ptr.as_ref().unwrap()
     451            0 :     }
     452              : }
     453              : 
     454              : pub struct LoadConfigV3<'a> {
     455              :     ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV3>,
     456              :     _owner: PhantomData<&'a ffi::PE_Binary>,
     457              : }
     458              : 
     459              : impl std::fmt::Debug for LoadConfigV3<'_> {
     460            0 :     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
     461            0 :         let base = self as &dyn AsLoadConfigV3;
     462            0 :         f.write_str(format!("{base:?}").as_str())
     463            0 :     }
     464              : }
     465              : 
     466              : 
     467              : impl std::fmt::Debug for &dyn AsLoadConfigV3 {
     468           40 :     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
     469           40 :         f.debug_struct("LoadConfigV3")
     470           40 :             .field("guard_address_taken_iat_entry_table", &self.guard_address_taken_iat_entry_table())
     471           40 :             .field("guard_address_taken_iat_entry_count", &self.guard_address_taken_iat_entry_count())
     472           40 :             .field("guard_long_jump_target_table", &self.guard_long_jump_target_table())
     473           40 :             .field("guard_long_jump_target_count", &self.guard_long_jump_target_count())
     474           40 :             .finish()
     475           40 :     }
     476              : }
     477              : 
     478              : 
     479              : impl<'a> FromFFI<ffi::PE_LoadConfigurationV3> for LoadConfigV3<'a> {
     480            0 :     fn from_ffi(ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV3>) -> Self {
     481            0 :         Self {
     482            0 :             ptr,
     483            0 :             _owner: PhantomData,
     484            0 :         }
     485            0 :     }
     486              : }
     487              : 
     488              : 
     489              : pub trait AsLoadConfigV3 {
     490              :     #[doc(hidden)]
     491              :     fn as_v3(&self) -> &ffi::PE_LoadConfigurationV3;
     492              : 
     493            5 :     fn guard_address_taken_iat_entry_table(&self) -> u64 {
     494            5 :         self.as_v3().guard_address_taken_iat_entry_table()
     495            5 :     }
     496              : 
     497            5 :     fn guard_address_taken_iat_entry_count(&self) -> u64 {
     498            5 :         self.as_v3().guard_address_taken_iat_entry_count()
     499            5 :     }
     500              : 
     501            5 :     fn guard_long_jump_target_table(&self) -> u64 {
     502            5 :         self.as_v3().guard_long_jump_target_table()
     503            5 :     }
     504              : 
     505            5 :     fn guard_long_jump_target_count(&self) -> u64 {
     506            5 :         self.as_v3().guard_long_jump_target_count()
     507            5 :     }
     508              : }
     509              : 
     510              : impl AsBase for LoadConfigV3<'_> {
     511            0 :     fn as_base(&self) -> &ffi::PE_LoadConfiguration {
     512            0 :         self.ptr
     513            0 :             .as_ref()
     514            0 :             .unwrap()
     515            0 :             .as_ref()
     516            0 :             .as_ref()
     517            0 :             .as_ref()
     518            0 :             .as_ref()
     519            0 :     }
     520              : }
     521              : 
     522              : impl AsLoadConfigV0 for LoadConfigV3<'_> {
     523            0 :     fn as_v0(&self) -> &ffi::PE_LoadConfigurationV0 {
     524            0 :         self.ptr.as_ref().unwrap().as_ref().as_ref().as_ref()
     525            0 :     }
     526              : }
     527              : 
     528              : impl AsLoadConfigV1 for LoadConfigV3<'_> {
     529            0 :     fn as_v1(&self) -> &ffi::PE_LoadConfigurationV1 {
     530            0 :         self.ptr.as_ref().unwrap().as_ref().as_ref()
     531            0 :     }
     532              : }
     533              : 
     534              : impl AsLoadConfigV2 for LoadConfigV3<'_> {
     535            0 :     fn as_v2(&self) -> &ffi::PE_LoadConfigurationV2 {
     536            0 :         self.ptr.as_ref().unwrap().as_ref()
     537            0 :     }
     538              : }
     539              : 
     540              : impl AsLoadConfigV3 for LoadConfigV3<'_> {
     541            0 :     fn as_v3(&self) -> &ffi::PE_LoadConfigurationV3 {
     542            0 :         self.ptr.as_ref().unwrap()
     543            0 :     }
     544              : }
     545              : 
     546              : pub struct LoadConfigV4<'a> {
     547              :     ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV4>,
     548              :     _owner: PhantomData<&'a ffi::PE_Binary>,
     549              : }
     550              : 
     551              : impl std::fmt::Debug for LoadConfigV4<'_> {
     552            0 :     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
     553            0 :         let base = self as &dyn AsLoadConfigV4;
     554            0 :         f.write_str(format!("{base:?}").as_str())
     555            0 :     }
     556              : }
     557              : 
     558              : 
     559              : impl std::fmt::Debug for &dyn AsLoadConfigV4 {
     560           40 :     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
     561           40 :         f.debug_struct("LoadConfigV4")
     562           40 :             .field("dynamic_value_reloc_table", &self.dynamic_value_reloc_table())
     563           40 :             .field("hybrid_metadata_pointer", &self.hybrid_metadata_pointer())
     564           40 :             .finish()
     565           40 :     }
     566              : }
     567              : 
     568              : 
     569              : impl<'a> FromFFI<ffi::PE_LoadConfigurationV4> for LoadConfigV4<'a> {
     570            0 :     fn from_ffi(ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV4>) -> Self {
     571            0 :         Self {
     572            0 :             ptr,
     573            0 :             _owner: PhantomData,
     574            0 :         }
     575            0 :     }
     576              : }
     577              : 
     578              : pub trait AsLoadConfigV4 {
     579              :     #[doc(hidden)]
     580              :     fn as_v4(&self) -> &ffi::PE_LoadConfigurationV4;
     581              : 
     582            5 :     fn dynamic_value_reloc_table(&self) -> u64 {
     583            5 :         self.as_v4().dynamic_value_reloc_table()
     584            5 :     }
     585              : 
     586            5 :     fn hybrid_metadata_pointer(&self) -> u64 {
     587            5 :         self.as_v4().hybrid_metadata_pointer()
     588            5 :     }
     589              : }
     590              : 
     591              : impl AsBase for LoadConfigV4<'_> {
     592            0 :     fn as_base(&self) -> &ffi::PE_LoadConfiguration {
     593            0 :         self.ptr
     594            0 :             .as_ref()
     595            0 :             .unwrap()
     596            0 :             .as_ref()
     597            0 :             .as_ref()
     598            0 :             .as_ref()
     599            0 :             .as_ref()
     600            0 :             .as_ref()
     601            0 :     }
     602              : }
     603              : 
     604              : impl AsLoadConfigV0 for LoadConfigV4<'_> {
     605            0 :     fn as_v0(&self) -> &ffi::PE_LoadConfigurationV0 {
     606            0 :         self.ptr
     607            0 :             .as_ref()
     608            0 :             .unwrap()
     609            0 :             .as_ref()
     610            0 :             .as_ref()
     611            0 :             .as_ref()
     612            0 :             .as_ref()
     613            0 :     }
     614              : }
     615              : 
     616              : impl AsLoadConfigV1 for LoadConfigV4<'_> {
     617            0 :     fn as_v1(&self) -> &ffi::PE_LoadConfigurationV1 {
     618            0 :         self.ptr.as_ref().unwrap().as_ref().as_ref().as_ref()
     619            0 :     }
     620              : }
     621              : 
     622              : impl AsLoadConfigV2 for LoadConfigV4<'_> {
     623            0 :     fn as_v2(&self) -> &ffi::PE_LoadConfigurationV2 {
     624            0 :         self.ptr.as_ref().unwrap().as_ref().as_ref()
     625            0 :     }
     626              : }
     627              : 
     628              : impl AsLoadConfigV3 for LoadConfigV4<'_> {
     629            0 :     fn as_v3(&self) -> &ffi::PE_LoadConfigurationV3 {
     630            0 :         self.ptr.as_ref().unwrap().as_ref()
     631            0 :     }
     632              : }
     633              : 
     634              : impl AsLoadConfigV4 for LoadConfigV4<'_> {
     635            0 :     fn as_v4(&self) -> &ffi::PE_LoadConfigurationV4 {
     636            0 :         self.ptr.as_ref().unwrap()
     637            0 :     }
     638              : }
     639              : 
     640              : pub struct LoadConfigV5<'a> {
     641              :     ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV5>,
     642              :     _owner: PhantomData<&'a ffi::PE_Binary>,
     643              : }
     644              : 
     645              : impl std::fmt::Debug for LoadConfigV5<'_> {
     646            0 :     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
     647            0 :         let base = self as &dyn AsLoadConfigV5;
     648            0 :         f.write_str(format!("{base:?}").as_str())
     649            0 :     }
     650              : }
     651              : 
     652              : 
     653              : impl std::fmt::Debug for &dyn AsLoadConfigV5 {
     654           40 :     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
     655           40 :         f.debug_struct("LoadConfigV5")
     656           40 :             .field("guard_rf_failure_routine", &self.guard_rf_failure_routine())
     657           40 :             .field("guard_rf_failure_routine_function_pointer", &self.guard_rf_failure_routine_function_pointer())
     658           40 :             .field("dynamic_value_reloctable_offset", &self.dynamic_value_reloctable_offset())
     659           40 :             .field("dynamic_value_reloctable_section", &self.dynamic_value_reloctable_section())
     660           40 :             .field("reserved2", &self.reserved2())
     661           40 :             .finish()
     662           40 :     }
     663              : }
     664              : 
     665              : impl<'a> FromFFI<ffi::PE_LoadConfigurationV5> for LoadConfigV5<'a> {
     666            0 :     fn from_ffi(ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV5>) -> Self {
     667            0 :         Self {
     668            0 :             ptr,
     669            0 :             _owner: PhantomData,
     670            0 :         }
     671            0 :     }
     672              : }
     673              : 
     674              : pub trait AsLoadConfigV5 {
     675              :     #[doc(hidden)]
     676              :     fn as_v5(&self) -> &ffi::PE_LoadConfigurationV5;
     677              : 
     678            5 :     fn guard_rf_failure_routine(&self) -> u64 {
     679            5 :         self.as_v5().guard_rf_failure_routine()
     680            5 :     }
     681              : 
     682            5 :     fn guard_rf_failure_routine_function_pointer(&self) -> u64 {
     683            5 :         self.as_v5().guard_rf_failure_routine_function_pointer()
     684            5 :     }
     685              : 
     686            5 :     fn dynamic_value_reloctable_offset(&self) -> u32 {
     687            5 :         self.as_v5().dynamic_value_reloctable_offset()
     688            5 :     }
     689              : 
     690            5 :     fn dynamic_value_reloctable_section(&self) -> u16 {
     691            5 :         self.as_v5().dynamic_value_reloctable_section()
     692            5 :     }
     693              : 
     694            5 :     fn reserved2(&self) -> u16 {
     695            5 :         self.as_v5().reserved2()
     696            5 :     }
     697              : }
     698              : 
     699              : impl AsBase for LoadConfigV5<'_> {
     700            0 :     fn as_base(&self) -> &ffi::PE_LoadConfiguration {
     701            0 :         self.ptr
     702            0 :             .as_ref()
     703            0 :             .unwrap()
     704            0 :             .as_ref()
     705            0 :             .as_ref()
     706            0 :             .as_ref()
     707            0 :             .as_ref()
     708            0 :             .as_ref()
     709            0 :             .as_ref()
     710            0 :     }
     711              : }
     712              : 
     713              : impl AsLoadConfigV0 for LoadConfigV5<'_> {
     714            0 :     fn as_v0(&self) -> &ffi::PE_LoadConfigurationV0 {
     715            0 :         self.ptr
     716            0 :             .as_ref()
     717            0 :             .unwrap()
     718            0 :             .as_ref()
     719            0 :             .as_ref()
     720            0 :             .as_ref()
     721            0 :             .as_ref()
     722            0 :             .as_ref()
     723            0 :     }
     724              : }
     725              : 
     726              : impl AsLoadConfigV1 for LoadConfigV5<'_> {
     727            0 :     fn as_v1(&self) -> &ffi::PE_LoadConfigurationV1 {
     728            0 :         self.ptr
     729            0 :             .as_ref()
     730            0 :             .unwrap()
     731            0 :             .as_ref()
     732            0 :             .as_ref()
     733            0 :             .as_ref()
     734            0 :             .as_ref()
     735            0 :     }
     736              : }
     737              : 
     738              : impl AsLoadConfigV2 for LoadConfigV5<'_> {
     739            0 :     fn as_v2(&self) -> &ffi::PE_LoadConfigurationV2 {
     740            0 :         self.ptr.as_ref().unwrap().as_ref().as_ref().as_ref()
     741            0 :     }
     742              : }
     743              : 
     744              : impl AsLoadConfigV3 for LoadConfigV5<'_> {
     745            0 :     fn as_v3(&self) -> &ffi::PE_LoadConfigurationV3 {
     746            0 :         self.ptr.as_ref().unwrap().as_ref().as_ref()
     747            0 :     }
     748              : }
     749              : 
     750              : impl AsLoadConfigV4 for LoadConfigV5<'_> {
     751            0 :     fn as_v4(&self) -> &ffi::PE_LoadConfigurationV4 {
     752            0 :         self.ptr.as_ref().unwrap().as_ref()
     753            0 :     }
     754              : }
     755              : 
     756              : impl AsLoadConfigV5 for LoadConfigV5<'_> {
     757            0 :     fn as_v5(&self) -> &ffi::PE_LoadConfigurationV5 {
     758            0 :         self.ptr.as_ref().unwrap()
     759            0 :     }
     760              : }
     761              : 
     762              : pub struct LoadConfigV6<'a> {
     763              :     ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV6>,
     764              :     _owner: PhantomData<&'a ffi::PE_Binary>,
     765              : }
     766              : 
     767              : impl std::fmt::Debug for LoadConfigV6<'_> {
     768            0 :     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
     769            0 :         let base = self as &dyn AsLoadConfigV6;
     770            0 :         f.write_str(format!("{base:?}").as_str())
     771            0 :     }
     772              : }
     773              : 
     774              : 
     775              : impl std::fmt::Debug for &dyn AsLoadConfigV6 {
     776           40 :     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
     777           40 :         f.debug_struct("LoadConfigV6")
     778           40 :             .field("guard_rf_verify_stackpointer_function_pointer", &self.guard_rf_verify_stackpointer_function_pointer())
     779           40 :             .field("hotpatch_table_offset", &self.hotpatch_table_offset())
     780           40 :             .finish()
     781           40 :     }
     782              : }
     783              : 
     784              : impl<'a> FromFFI<ffi::PE_LoadConfigurationV6> for LoadConfigV6<'a> {
     785            0 :     fn from_ffi(ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV6>) -> Self {
     786            0 :         Self {
     787            0 :             ptr,
     788            0 :             _owner: PhantomData,
     789            0 :         }
     790            0 :     }
     791              : }
     792              : 
     793              : pub trait AsLoadConfigV6 {
     794              :     #[doc(hidden)]
     795              :     fn as_v6(&self) -> &ffi::PE_LoadConfigurationV6;
     796              : 
     797            5 :     fn guard_rf_verify_stackpointer_function_pointer(&self) -> u64 {
     798            5 :         self.as_v6().guard_rf_verify_stackpointer_function_pointer()
     799            5 :     }
     800              : 
     801            5 :     fn hotpatch_table_offset(&self) -> u32 {
     802            5 :         self.as_v6().hotpatch_table_offset()
     803            5 :     }
     804              : }
     805              : 
     806              : impl AsBase for LoadConfigV6<'_> {
     807            0 :     fn as_base(&self) -> &ffi::PE_LoadConfiguration {
     808            0 :         self.ptr
     809            0 :             .as_ref()
     810            0 :             .unwrap()
     811            0 :             .as_ref()
     812            0 :             .as_ref()
     813            0 :             .as_ref()
     814            0 :             .as_ref()
     815            0 :             .as_ref()
     816            0 :             .as_ref()
     817            0 :             .as_ref()
     818            0 :     }
     819              : }
     820              : 
     821              : impl AsLoadConfigV0 for LoadConfigV6<'_> {
     822            0 :     fn as_v0(&self) -> &ffi::PE_LoadConfigurationV0 {
     823            0 :         self.ptr
     824            0 :             .as_ref()
     825            0 :             .unwrap()
     826            0 :             .as_ref()
     827            0 :             .as_ref()
     828            0 :             .as_ref()
     829            0 :             .as_ref()
     830            0 :             .as_ref()
     831            0 :             .as_ref()
     832            0 :     }
     833              : }
     834              : 
     835              : impl AsLoadConfigV1 for LoadConfigV6<'_> {
     836            0 :     fn as_v1(&self) -> &ffi::PE_LoadConfigurationV1 {
     837            0 :         self.ptr
     838            0 :             .as_ref()
     839            0 :             .unwrap()
     840            0 :             .as_ref()
     841            0 :             .as_ref()
     842            0 :             .as_ref()
     843            0 :             .as_ref()
     844            0 :             .as_ref()
     845            0 :     }
     846              : }
     847              : 
     848              : impl AsLoadConfigV2 for LoadConfigV6<'_> {
     849            0 :     fn as_v2(&self) -> &ffi::PE_LoadConfigurationV2 {
     850            0 :         self.ptr
     851            0 :             .as_ref()
     852            0 :             .unwrap()
     853            0 :             .as_ref()
     854            0 :             .as_ref()
     855            0 :             .as_ref()
     856            0 :             .as_ref()
     857            0 :     }
     858              : }
     859              : 
     860              : impl AsLoadConfigV3 for LoadConfigV6<'_> {
     861            0 :     fn as_v3(&self) -> &ffi::PE_LoadConfigurationV3 {
     862            0 :         self.ptr.as_ref().unwrap().as_ref().as_ref().as_ref()
     863            0 :     }
     864              : }
     865              : 
     866              : impl AsLoadConfigV4 for LoadConfigV6<'_> {
     867            0 :     fn as_v4(&self) -> &ffi::PE_LoadConfigurationV4 {
     868            0 :         self.ptr.as_ref().unwrap().as_ref().as_ref()
     869            0 :     }
     870              : }
     871              : 
     872              : impl AsLoadConfigV5 for LoadConfigV6<'_> {
     873            0 :     fn as_v5(&self) -> &ffi::PE_LoadConfigurationV5 {
     874            0 :         self.ptr.as_ref().unwrap().as_ref()
     875            0 :     }
     876              : }
     877              : 
     878              : impl AsLoadConfigV6 for LoadConfigV6<'_> {
     879            0 :     fn as_v6(&self) -> &ffi::PE_LoadConfigurationV6 {
     880            0 :         self.ptr.as_ref().unwrap()
     881            0 :     }
     882              : }
     883              : 
     884              : pub struct LoadConfigV7<'a> {
     885              :     ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV7>,
     886              :     _owner: PhantomData<&'a ffi::PE_Binary>,
     887              : }
     888              : 
     889              : 
     890              : impl std::fmt::Debug for LoadConfigV7<'_> {
     891           16 :     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
     892           16 :         let base = self as &dyn AsLoadConfigV7;
     893           16 :         f.write_str(format!("{base:?}").as_str())
     894           16 :     }
     895              : }
     896              : 
     897              : 
     898              : impl std::fmt::Debug for &dyn AsLoadConfigV7 {
     899           48 :     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
     900           48 :         f.debug_struct("LoadConfigV7")
     901           48 :             .field("reserved3", &self.reserved3())
     902           48 :             .field("addressof_unicode_string", &self.addressof_unicode_string())
     903           48 :             .finish()
     904           48 :     }
     905              : }
     906              : 
     907              : impl<'a> FromFFI<ffi::PE_LoadConfigurationV7> for LoadConfigV7<'a> {
     908            8 :     fn from_ffi(ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV7>) -> Self {
     909            8 :         Self {
     910            8 :             ptr,
     911            8 :             _owner: PhantomData,
     912            8 :         }
     913            8 :     }
     914              : }
     915              : 
     916              : pub trait AsLoadConfigV7 {
     917              :     #[doc(hidden)]
     918              :     fn as_v7(&self) -> &ffi::PE_LoadConfigurationV7;
     919              : 
     920           20 :     fn reserved3(&self) -> u32 {
     921           20 :         self.as_v7().reserved3()
     922           20 :     }
     923              : 
     924           20 :     fn addressof_unicode_string(&self) -> u64 {
     925           20 :         self.as_v7().addressof_unicode_string()
     926           20 :     }
     927              : }
     928              : 
     929              : impl AsBase for LoadConfigV7<'_> {
     930          152 :     fn as_base(&self) -> &ffi::PE_LoadConfiguration {
     931          152 :         self.ptr
     932          152 :             .as_ref()
     933          152 :             .unwrap()
     934          152 :             .as_ref()
     935          152 :             .as_ref()
     936          152 :             .as_ref()
     937          152 :             .as_ref()
     938          152 :             .as_ref()
     939          152 :             .as_ref()
     940          152 :             .as_ref()
     941          152 :             .as_ref()
     942          152 :     }
     943              : }
     944              : 
     945              : impl AsLoadConfigV0 for LoadConfigV7<'_> {
     946           16 :     fn as_v0(&self) -> &ffi::PE_LoadConfigurationV0 {
     947           16 :         self.ptr
     948           16 :             .as_ref()
     949           16 :             .unwrap()
     950           16 :             .as_ref()
     951           16 :             .as_ref()
     952           16 :             .as_ref()
     953           16 :             .as_ref()
     954           16 :             .as_ref()
     955           16 :             .as_ref()
     956           16 :             .as_ref()
     957           16 :     }
     958              : }
     959              : 
     960              : impl AsLoadConfigV1 for LoadConfigV7<'_> {
     961           40 :     fn as_v1(&self) -> &ffi::PE_LoadConfigurationV1 {
     962           40 :         self.ptr
     963           40 :             .as_ref()
     964           40 :             .unwrap()
     965           40 :             .as_ref()
     966           40 :             .as_ref()
     967           40 :             .as_ref()
     968           40 :             .as_ref()
     969           40 :             .as_ref()
     970           40 :             .as_ref()
     971           40 :     }
     972              : }
     973              : 
     974              : impl AsLoadConfigV2 for LoadConfigV7<'_> {
     975            8 :     fn as_v2(&self) -> &ffi::PE_LoadConfigurationV2 {
     976            8 :         self.ptr
     977            8 :             .as_ref()
     978            8 :             .unwrap()
     979            8 :             .as_ref()
     980            8 :             .as_ref()
     981            8 :             .as_ref()
     982            8 :             .as_ref()
     983            8 :             .as_ref()
     984            8 :     }
     985              : }
     986              : 
     987              : impl AsLoadConfigV3 for LoadConfigV7<'_> {
     988           32 :     fn as_v3(&self) -> &ffi::PE_LoadConfigurationV3 {
     989           32 :         self.ptr
     990           32 :             .as_ref()
     991           32 :             .unwrap()
     992           32 :             .as_ref()
     993           32 :             .as_ref()
     994           32 :             .as_ref()
     995           32 :             .as_ref()
     996           32 :     }
     997              : }
     998              : 
     999              : impl AsLoadConfigV4 for LoadConfigV7<'_> {
    1000           16 :     fn as_v4(&self) -> &ffi::PE_LoadConfigurationV4 {
    1001           16 :         self.ptr.as_ref().unwrap().as_ref().as_ref().as_ref()
    1002           16 :     }
    1003              : }
    1004              : 
    1005              : impl AsLoadConfigV5 for LoadConfigV7<'_> {
    1006           40 :     fn as_v5(&self) -> &ffi::PE_LoadConfigurationV5 {
    1007           40 :         self.ptr.as_ref().unwrap().as_ref().as_ref()
    1008           40 :     }
    1009              : }
    1010              : 
    1011              : impl AsLoadConfigV6 for LoadConfigV7<'_> {
    1012           16 :     fn as_v6(&self) -> &ffi::PE_LoadConfigurationV6 {
    1013           16 :         self.ptr.as_ref().unwrap().as_ref()
    1014           16 :     }
    1015              : }
    1016              : 
    1017              : impl AsLoadConfigV7 for LoadConfigV7<'_> {
    1018           32 :     fn as_v7(&self) -> &ffi::PE_LoadConfigurationV7 {
    1019           32 :         self.ptr.as_ref().unwrap()
    1020           32 :     }
    1021              : }
    1022              : 
    1023              : pub struct LoadConfigV8<'a> {
    1024              :     ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV8>,
    1025              :     _owner: PhantomData<&'a ffi::PE_Binary>,
    1026              : }
    1027              : 
    1028              : 
    1029              : impl std::fmt::Debug for LoadConfigV8<'_> {
    1030            0 :     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    1031            0 :         let base = self as &dyn AsLoadConfigV8;
    1032            0 :         f.write_str(format!("{base:?}").as_str())
    1033            0 :     }
    1034              : }
    1035              : 
    1036              : 
    1037              : impl std::fmt::Debug for &dyn AsLoadConfigV8 {
    1038           32 :     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    1039           32 :         f.debug_struct("LoadConfigV8")
    1040           32 :             .field("volatile_metadata_pointer", &self.volatile_metadata_pointer())
    1041           32 :             .finish()
    1042           32 :     }
    1043              : }
    1044              : 
    1045              : 
    1046              : impl<'a> FromFFI<ffi::PE_LoadConfigurationV8> for LoadConfigV8<'a> {
    1047            0 :     fn from_ffi(ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV8>) -> Self {
    1048            0 :         Self {
    1049            0 :             ptr,
    1050            0 :             _owner: PhantomData,
    1051            0 :         }
    1052            0 :     }
    1053              : }
    1054              : 
    1055              : pub trait AsLoadConfigV8 {
    1056              :     #[doc(hidden)]
    1057              :     fn as_v8(&self) -> &ffi::PE_LoadConfigurationV8;
    1058              : 
    1059            4 :     fn volatile_metadata_pointer(&self) -> u64 {
    1060            4 :         self.as_v8().volatile_metadata_pointer()
    1061            4 :     }
    1062              : }
    1063              : 
    1064              : impl AsBase for LoadConfigV8<'_> {
    1065            0 :     fn as_base(&self) -> &ffi::PE_LoadConfiguration {
    1066            0 :         self.ptr
    1067            0 :             .as_ref()
    1068            0 :             .unwrap()
    1069            0 :             .as_ref()
    1070            0 :             .as_ref()
    1071            0 :             .as_ref()
    1072            0 :             .as_ref()
    1073            0 :             .as_ref()
    1074            0 :             .as_ref()
    1075            0 :             .as_ref()
    1076            0 :             .as_ref()
    1077            0 :             .as_ref()
    1078            0 :     }
    1079              : }
    1080              : 
    1081              : impl AsLoadConfigV0 for LoadConfigV8<'_> {
    1082            0 :     fn as_v0(&self) -> &ffi::PE_LoadConfigurationV0 {
    1083            0 :         self.ptr
    1084            0 :             .as_ref()
    1085            0 :             .unwrap()
    1086            0 :             .as_ref()
    1087            0 :             .as_ref()
    1088            0 :             .as_ref()
    1089            0 :             .as_ref()
    1090            0 :             .as_ref()
    1091            0 :             .as_ref()
    1092            0 :             .as_ref()
    1093            0 :             .as_ref()
    1094            0 :     }
    1095              : }
    1096              : 
    1097              : impl AsLoadConfigV1 for LoadConfigV8<'_> {
    1098            0 :     fn as_v1(&self) -> &ffi::PE_LoadConfigurationV1 {
    1099            0 :         self.ptr
    1100            0 :             .as_ref()
    1101            0 :             .unwrap()
    1102            0 :             .as_ref()
    1103            0 :             .as_ref()
    1104            0 :             .as_ref()
    1105            0 :             .as_ref()
    1106            0 :             .as_ref()
    1107            0 :             .as_ref()
    1108            0 :             .as_ref()
    1109            0 :     }
    1110              : }
    1111              : 
    1112              : impl AsLoadConfigV2 for LoadConfigV8<'_> {
    1113            0 :     fn as_v2(&self) -> &ffi::PE_LoadConfigurationV2 {
    1114            0 :         self.ptr
    1115            0 :             .as_ref()
    1116            0 :             .unwrap()
    1117            0 :             .as_ref()
    1118            0 :             .as_ref()
    1119            0 :             .as_ref()
    1120            0 :             .as_ref()
    1121            0 :             .as_ref()
    1122            0 :             .as_ref()
    1123            0 :     }
    1124              : }
    1125              : 
    1126              : impl AsLoadConfigV3 for LoadConfigV8<'_> {
    1127            0 :     fn as_v3(&self) -> &ffi::PE_LoadConfigurationV3 {
    1128            0 :         self.ptr
    1129            0 :             .as_ref()
    1130            0 :             .unwrap()
    1131            0 :             .as_ref()
    1132            0 :             .as_ref()
    1133            0 :             .as_ref()
    1134            0 :             .as_ref()
    1135            0 :             .as_ref()
    1136            0 :     }
    1137              : }
    1138              : 
    1139              : impl AsLoadConfigV4 for LoadConfigV8<'_> {
    1140            0 :     fn as_v4(&self) -> &ffi::PE_LoadConfigurationV4 {
    1141            0 :         self.ptr
    1142            0 :             .as_ref()
    1143            0 :             .unwrap()
    1144            0 :             .as_ref()
    1145            0 :             .as_ref()
    1146            0 :             .as_ref()
    1147            0 :             .as_ref()
    1148            0 :     }
    1149              : }
    1150              : 
    1151              : impl AsLoadConfigV5 for LoadConfigV8<'_> {
    1152            0 :     fn as_v5(&self) -> &ffi::PE_LoadConfigurationV5 {
    1153            0 :         self.ptr.as_ref().unwrap().as_ref().as_ref().as_ref()
    1154            0 :     }
    1155              : }
    1156              : 
    1157              : impl AsLoadConfigV6 for LoadConfigV8<'_> {
    1158            0 :     fn as_v6(&self) -> &ffi::PE_LoadConfigurationV6 {
    1159            0 :         self.ptr.as_ref().unwrap().as_ref().as_ref()
    1160            0 :     }
    1161              : }
    1162              : 
    1163              : impl AsLoadConfigV7 for LoadConfigV8<'_> {
    1164            0 :     fn as_v7(&self) -> &ffi::PE_LoadConfigurationV7 {
    1165            0 :         self.ptr.as_ref().unwrap().as_ref()
    1166            0 :     }
    1167              : }
    1168              : 
    1169              : impl AsLoadConfigV8 for LoadConfigV8<'_> {
    1170            0 :     fn as_v8(&self) -> &ffi::PE_LoadConfigurationV8 {
    1171            0 :         self.ptr.as_ref().unwrap()
    1172            0 :     }
    1173              : }
    1174              : 
    1175              : pub struct LoadConfigV9<'a> {
    1176              :     ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV9>,
    1177              :     _owner: PhantomData<&'a ffi::PE_Binary>,
    1178              : }
    1179              : 
    1180              : impl std::fmt::Debug for LoadConfigV9<'_> {
    1181            0 :     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    1182            0 :         let base = self as &dyn AsLoadConfigV9;
    1183            0 :         f.write_str(format!("{base:?}").as_str())
    1184            0 :     }
    1185              : }
    1186              : 
    1187              : 
    1188              : impl std::fmt::Debug for &dyn AsLoadConfigV9 {
    1189           32 :     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    1190           32 :         f.debug_struct("LoadConfigV9")
    1191           32 :             .field("guard_eh_continuation_table", &self.guard_eh_continuation_table())
    1192           32 :             .field("guard_eh_continuation_count", &self.guard_eh_continuation_count())
    1193           32 :             .finish()
    1194           32 :     }
    1195              : }
    1196              : 
    1197              : 
    1198              : impl<'a> FromFFI<ffi::PE_LoadConfigurationV9> for LoadConfigV9<'a> {
    1199            0 :     fn from_ffi(ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV9>) -> Self {
    1200            0 :         Self {
    1201            0 :             ptr,
    1202            0 :             _owner: PhantomData,
    1203            0 :         }
    1204            0 :     }
    1205              : }
    1206              : 
    1207              : pub trait AsLoadConfigV9 {
    1208              :     #[doc(hidden)]
    1209              :     fn as_v9(&self) -> &ffi::PE_LoadConfigurationV9;
    1210              : 
    1211            4 :     fn guard_eh_continuation_table(&self) -> u64 {
    1212            4 :         self.as_v9().guard_eh_continuation_table()
    1213            4 :     }
    1214              : 
    1215            4 :     fn guard_eh_continuation_count(&self) -> u64 {
    1216            4 :         self.as_v9().guard_eh_continuation_count()
    1217            4 :     }
    1218              : }
    1219              : 
    1220              : impl AsBase for LoadConfigV9<'_> {
    1221            0 :     fn as_base(&self) -> &ffi::PE_LoadConfiguration {
    1222            0 :         self.ptr
    1223            0 :             .as_ref()
    1224            0 :             .unwrap()
    1225            0 :             .as_ref()
    1226            0 :             .as_ref()
    1227            0 :             .as_ref()
    1228            0 :             .as_ref()
    1229            0 :             .as_ref()
    1230            0 :             .as_ref()
    1231            0 :             .as_ref()
    1232            0 :             .as_ref()
    1233            0 :             .as_ref()
    1234            0 :             .as_ref()
    1235            0 :     }
    1236              : }
    1237              : 
    1238              : impl AsLoadConfigV0 for LoadConfigV9<'_> {
    1239            0 :     fn as_v0(&self) -> &ffi::PE_LoadConfigurationV0 {
    1240            0 :         self.ptr
    1241            0 :             .as_ref()
    1242            0 :             .unwrap()
    1243            0 :             .as_ref()
    1244            0 :             .as_ref()
    1245            0 :             .as_ref()
    1246            0 :             .as_ref()
    1247            0 :             .as_ref()
    1248            0 :             .as_ref()
    1249            0 :             .as_ref()
    1250            0 :             .as_ref()
    1251            0 :             .as_ref()
    1252            0 :     }
    1253              : }
    1254              : 
    1255              : impl AsLoadConfigV1 for LoadConfigV9<'_> {
    1256            0 :     fn as_v1(&self) -> &ffi::PE_LoadConfigurationV1 {
    1257            0 :         self.ptr
    1258            0 :             .as_ref()
    1259            0 :             .unwrap()
    1260            0 :             .as_ref()
    1261            0 :             .as_ref()
    1262            0 :             .as_ref()
    1263            0 :             .as_ref()
    1264            0 :             .as_ref()
    1265            0 :             .as_ref()
    1266            0 :             .as_ref()
    1267            0 :             .as_ref()
    1268            0 :     }
    1269              : }
    1270              : 
    1271              : impl AsLoadConfigV2 for LoadConfigV9<'_> {
    1272            0 :     fn as_v2(&self) -> &ffi::PE_LoadConfigurationV2 {
    1273            0 :         self.ptr
    1274            0 :             .as_ref()
    1275            0 :             .unwrap()
    1276            0 :             .as_ref()
    1277            0 :             .as_ref()
    1278            0 :             .as_ref()
    1279            0 :             .as_ref()
    1280            0 :             .as_ref()
    1281            0 :             .as_ref()
    1282            0 :             .as_ref()
    1283            0 :     }
    1284              : }
    1285              : 
    1286              : impl AsLoadConfigV3 for LoadConfigV9<'_> {
    1287            0 :     fn as_v3(&self) -> &ffi::PE_LoadConfigurationV3 {
    1288            0 :         self.ptr
    1289            0 :             .as_ref()
    1290            0 :             .unwrap()
    1291            0 :             .as_ref()
    1292            0 :             .as_ref()
    1293            0 :             .as_ref()
    1294            0 :             .as_ref()
    1295            0 :             .as_ref()
    1296            0 :             .as_ref()
    1297            0 :     }
    1298              : }
    1299              : 
    1300              : impl AsLoadConfigV4 for LoadConfigV9<'_> {
    1301            0 :     fn as_v4(&self) -> &ffi::PE_LoadConfigurationV4 {
    1302            0 :         self.ptr
    1303            0 :             .as_ref()
    1304            0 :             .unwrap()
    1305            0 :             .as_ref()
    1306            0 :             .as_ref()
    1307            0 :             .as_ref()
    1308            0 :             .as_ref()
    1309            0 :             .as_ref()
    1310            0 :     }
    1311              : }
    1312              : 
    1313              : impl AsLoadConfigV5 for LoadConfigV9<'_> {
    1314            0 :     fn as_v5(&self) -> &ffi::PE_LoadConfigurationV5 {
    1315            0 :         self.ptr
    1316            0 :             .as_ref()
    1317            0 :             .unwrap()
    1318            0 :             .as_ref()
    1319            0 :             .as_ref()
    1320            0 :             .as_ref()
    1321            0 :             .as_ref()
    1322            0 :     }
    1323              : }
    1324              : 
    1325              : impl AsLoadConfigV6 for LoadConfigV9<'_> {
    1326            0 :     fn as_v6(&self) -> &ffi::PE_LoadConfigurationV6 {
    1327            0 :         self.ptr.as_ref().unwrap().as_ref().as_ref().as_ref()
    1328            0 :     }
    1329              : }
    1330              : 
    1331              : impl AsLoadConfigV7 for LoadConfigV9<'_> {
    1332            0 :     fn as_v7(&self) -> &ffi::PE_LoadConfigurationV7 {
    1333            0 :         self.ptr.as_ref().unwrap().as_ref().as_ref()
    1334            0 :     }
    1335              : }
    1336              : 
    1337              : impl AsLoadConfigV8 for LoadConfigV9<'_> {
    1338            0 :     fn as_v8(&self) -> &ffi::PE_LoadConfigurationV8 {
    1339            0 :         self.ptr.as_ref().unwrap().as_ref()
    1340            0 :     }
    1341              : }
    1342              : 
    1343              : impl AsLoadConfigV9 for LoadConfigV9<'_> {
    1344            0 :     fn as_v9(&self) -> &ffi::PE_LoadConfigurationV9 {
    1345            0 :         self.ptr.as_ref().unwrap()
    1346            0 :     }
    1347              : }
    1348              : 
    1349              : pub struct LoadConfigV10<'a> {
    1350              :     ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV10>,
    1351              :     _owner: PhantomData<&'a ffi::PE_Binary>,
    1352              : }
    1353              : 
    1354              : impl std::fmt::Debug for LoadConfigV10<'_> {
    1355            0 :     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    1356            0 :         let base = self as &dyn AsLoadConfigV10;
    1357            0 :         f.write_str(format!("{base:?}").as_str())
    1358            0 :     }
    1359              : }
    1360              : 
    1361              : impl std::fmt::Debug for &dyn AsLoadConfigV10 {
    1362           32 :     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    1363           32 :         f.debug_struct("LoadConfigV10")
    1364           32 :             .field("guard_xfg_check_function_pointer", &self.guard_xfg_check_function_pointer())
    1365           32 :             .field("guard_xfg_dispatch_function_pointer", &self.guard_xfg_dispatch_function_pointer())
    1366           32 :             .field("guard_xfg_table_dispatch_function_pointer", &self.guard_xfg_table_dispatch_function_pointer())
    1367           32 :             .finish()
    1368           32 :     }
    1369              : }
    1370              : 
    1371              : 
    1372              : impl<'a> FromFFI<ffi::PE_LoadConfigurationV10> for LoadConfigV10<'a> {
    1373            0 :     fn from_ffi(ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV10>) -> Self {
    1374            0 :         Self {
    1375            0 :             ptr,
    1376            0 :             _owner: PhantomData,
    1377            0 :         }
    1378            0 :     }
    1379              : }
    1380              : 
    1381              : pub trait AsLoadConfigV10 {
    1382              :     #[doc(hidden)]
    1383              :     fn as_v10(&self) -> &ffi::PE_LoadConfigurationV10;
    1384              : 
    1385            4 :     fn guard_xfg_check_function_pointer(&self) -> u64 {
    1386            4 :         self.as_v10().guard_xfg_check_function_pointer()
    1387            4 :     }
    1388              : 
    1389            4 :     fn guard_xfg_dispatch_function_pointer(&self) -> u64 {
    1390            4 :         self.as_v10().guard_xfg_dispatch_function_pointer()
    1391            4 :     }
    1392              : 
    1393            4 :     fn guard_xfg_table_dispatch_function_pointer(&self) -> u64 {
    1394            4 :         self.as_v10().guard_xfg_table_dispatch_function_pointer()
    1395            4 :     }
    1396              : }
    1397              : 
    1398              : impl AsBase for LoadConfigV10<'_> {
    1399            0 :     fn as_base(&self) -> &ffi::PE_LoadConfiguration {
    1400            0 :         self.ptr
    1401            0 :             .as_ref()
    1402            0 :             .unwrap()
    1403            0 :             .as_ref()
    1404            0 :             .as_ref()
    1405            0 :             .as_ref()
    1406            0 :             .as_ref()
    1407            0 :             .as_ref()
    1408            0 :             .as_ref()
    1409            0 :             .as_ref()
    1410            0 :             .as_ref()
    1411            0 :             .as_ref()
    1412            0 :             .as_ref()
    1413            0 :             .as_ref()
    1414            0 :     }
    1415              : }
    1416              : 
    1417              : impl AsLoadConfigV0 for LoadConfigV10<'_> {
    1418            0 :     fn as_v0(&self) -> &ffi::PE_LoadConfigurationV0 {
    1419            0 :         self.ptr
    1420            0 :             .as_ref()
    1421            0 :             .unwrap()
    1422            0 :             .as_ref()
    1423            0 :             .as_ref()
    1424            0 :             .as_ref()
    1425            0 :             .as_ref()
    1426            0 :             .as_ref()
    1427            0 :             .as_ref()
    1428            0 :             .as_ref()
    1429            0 :             .as_ref()
    1430            0 :             .as_ref()
    1431            0 :             .as_ref()
    1432            0 :     }
    1433              : }
    1434              : 
    1435              : impl AsLoadConfigV1 for LoadConfigV10<'_> {
    1436            0 :     fn as_v1(&self) -> &ffi::PE_LoadConfigurationV1 {
    1437            0 :         self.ptr
    1438            0 :             .as_ref()
    1439            0 :             .unwrap()
    1440            0 :             .as_ref()
    1441            0 :             .as_ref()
    1442            0 :             .as_ref()
    1443            0 :             .as_ref()
    1444            0 :             .as_ref()
    1445            0 :             .as_ref()
    1446            0 :             .as_ref()
    1447            0 :             .as_ref()
    1448            0 :             .as_ref()
    1449            0 :     }
    1450              : }
    1451              : 
    1452              : impl AsLoadConfigV2 for LoadConfigV10<'_> {
    1453            0 :     fn as_v2(&self) -> &ffi::PE_LoadConfigurationV2 {
    1454            0 :         self.ptr
    1455            0 :             .as_ref()
    1456            0 :             .unwrap()
    1457            0 :             .as_ref()
    1458            0 :             .as_ref()
    1459            0 :             .as_ref()
    1460            0 :             .as_ref()
    1461            0 :             .as_ref()
    1462            0 :             .as_ref()
    1463            0 :             .as_ref()
    1464            0 :             .as_ref()
    1465            0 :     }
    1466              : }
    1467              : 
    1468              : impl AsLoadConfigV3 for LoadConfigV10<'_> {
    1469            0 :     fn as_v3(&self) -> &ffi::PE_LoadConfigurationV3 {
    1470            0 :         self.ptr
    1471            0 :             .as_ref()
    1472            0 :             .unwrap()
    1473            0 :             .as_ref()
    1474            0 :             .as_ref()
    1475            0 :             .as_ref()
    1476            0 :             .as_ref()
    1477            0 :             .as_ref()
    1478            0 :             .as_ref()
    1479            0 :             .as_ref()
    1480            0 :     }
    1481              : }
    1482              : 
    1483              : impl AsLoadConfigV4 for LoadConfigV10<'_> {
    1484            0 :     fn as_v4(&self) -> &ffi::PE_LoadConfigurationV4 {
    1485            0 :         self.ptr
    1486            0 :             .as_ref()
    1487            0 :             .unwrap()
    1488            0 :             .as_ref()
    1489            0 :             .as_ref()
    1490            0 :             .as_ref()
    1491            0 :             .as_ref()
    1492            0 :             .as_ref()
    1493            0 :             .as_ref()
    1494            0 :     }
    1495              : }
    1496              : 
    1497              : impl AsLoadConfigV5 for LoadConfigV10<'_> {
    1498            0 :     fn as_v5(&self) -> &ffi::PE_LoadConfigurationV5 {
    1499            0 :         self.ptr
    1500            0 :             .as_ref()
    1501            0 :             .unwrap()
    1502            0 :             .as_ref()
    1503            0 :             .as_ref()
    1504            0 :             .as_ref()
    1505            0 :             .as_ref()
    1506            0 :             .as_ref()
    1507            0 :     }
    1508              : }
    1509              : 
    1510              : impl AsLoadConfigV6 for LoadConfigV10<'_> {
    1511            0 :     fn as_v6(&self) -> &ffi::PE_LoadConfigurationV6 {
    1512            0 :         self.ptr
    1513            0 :             .as_ref()
    1514            0 :             .unwrap()
    1515            0 :             .as_ref()
    1516            0 :             .as_ref()
    1517            0 :             .as_ref()
    1518            0 :             .as_ref()
    1519            0 :     }
    1520              : }
    1521              : 
    1522              : impl AsLoadConfigV7 for LoadConfigV10<'_> {
    1523            0 :     fn as_v7(&self) -> &ffi::PE_LoadConfigurationV7 {
    1524            0 :         self.ptr.as_ref().unwrap().as_ref().as_ref().as_ref()
    1525            0 :     }
    1526              : }
    1527              : 
    1528              : impl AsLoadConfigV8 for LoadConfigV10<'_> {
    1529            0 :     fn as_v8(&self) -> &ffi::PE_LoadConfigurationV8 {
    1530            0 :         self.ptr.as_ref().unwrap().as_ref().as_ref()
    1531            0 :     }
    1532              : }
    1533              : 
    1534              : impl AsLoadConfigV9 for LoadConfigV10<'_> {
    1535            0 :     fn as_v9(&self) -> &ffi::PE_LoadConfigurationV9 {
    1536            0 :         self.ptr.as_ref().unwrap().as_ref()
    1537            0 :     }
    1538              : }
    1539              : 
    1540              : impl AsLoadConfigV10 for LoadConfigV10<'_> {
    1541            0 :     fn as_v10(&self) -> &ffi::PE_LoadConfigurationV10 {
    1542            0 :         self.ptr.as_ref().unwrap()
    1543            0 :     }
    1544              : }
    1545              : 
    1546              : pub struct LoadConfigV11<'a> {
    1547              :     ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV11>,
    1548              :     _owner: PhantomData<&'a ffi::PE_Binary>,
    1549              : }
    1550              : 
    1551              : impl std::fmt::Debug for LoadConfigV11<'_> {
    1552           64 :     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    1553           64 :         let base = self as &dyn AsLoadConfigV11;
    1554           64 :         f.write_str(format!("{base:?}").as_str())
    1555           64 :     }
    1556              : }
    1557              : 
    1558              : impl std::fmt::Debug for &dyn AsLoadConfigV11 {
    1559           64 :     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    1560           64 :         f.debug_struct("LoadConfigV11")
    1561           64 :             .field("cast_guard_os_determined_failure_mode", &self.cast_guard_os_determined_failure_mode())
    1562           64 :             .finish()
    1563           64 :     }
    1564              : }
    1565              : 
    1566              : impl<'a> FromFFI<ffi::PE_LoadConfigurationV11> for LoadConfigV11<'a> {
    1567           32 :     fn from_ffi(ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV11>) -> Self {
    1568           32 :         Self {
    1569           32 :             ptr,
    1570           32 :             _owner: PhantomData,
    1571           32 :         }
    1572           32 :     }
    1573              : }
    1574              : 
    1575              : pub trait AsLoadConfigV11 {
    1576              :     #[doc(hidden)]
    1577              :     fn as_v11(&self) -> &ffi::PE_LoadConfigurationV11;
    1578              : 
    1579           64 :     fn cast_guard_os_determined_failure_mode(&self) -> u64 {
    1580           64 :         self.as_v11().cast_guard_os_determined_failure_mode()
    1581           64 :     }
    1582              : }
    1583              : 
    1584              : impl AsBase for LoadConfigV11<'_> {
    1585          608 :     fn as_base(&self) -> &ffi::PE_LoadConfiguration {
    1586          608 :         self.ptr
    1587          608 :             .as_ref()
    1588          608 :             .unwrap()
    1589          608 :             .as_ref()
    1590          608 :             .as_ref()
    1591          608 :             .as_ref()
    1592          608 :             .as_ref()
    1593          608 :             .as_ref()
    1594          608 :             .as_ref()
    1595          608 :             .as_ref()
    1596          608 :             .as_ref()
    1597          608 :             .as_ref()
    1598          608 :             .as_ref()
    1599          608 :             .as_ref()
    1600          608 :             .as_ref()
    1601          608 :     }
    1602              : }
    1603              : 
    1604              : impl AsLoadConfigV0 for LoadConfigV11<'_> {
    1605           64 :     fn as_v0(&self) -> &ffi::PE_LoadConfigurationV0 {
    1606           64 :         self.ptr
    1607           64 :             .as_ref()
    1608           64 :             .unwrap()
    1609           64 :             .as_ref()
    1610           64 :             .as_ref()
    1611           64 :             .as_ref()
    1612           64 :             .as_ref()
    1613           64 :             .as_ref()
    1614           64 :             .as_ref()
    1615           64 :             .as_ref()
    1616           64 :             .as_ref()
    1617           64 :             .as_ref()
    1618           64 :             .as_ref()
    1619           64 :             .as_ref()
    1620           64 :     }
    1621              : }
    1622              : 
    1623              : impl AsLoadConfigV1 for LoadConfigV11<'_> {
    1624          160 :     fn as_v1(&self) -> &ffi::PE_LoadConfigurationV1 {
    1625          160 :         self.ptr
    1626          160 :             .as_ref()
    1627          160 :             .unwrap()
    1628          160 :             .as_ref()
    1629          160 :             .as_ref()
    1630          160 :             .as_ref()
    1631          160 :             .as_ref()
    1632          160 :             .as_ref()
    1633          160 :             .as_ref()
    1634          160 :             .as_ref()
    1635          160 :             .as_ref()
    1636          160 :             .as_ref()
    1637          160 :             .as_ref()
    1638          160 :     }
    1639              : }
    1640              : 
    1641              : impl AsLoadConfigV2 for LoadConfigV11<'_> {
    1642           32 :     fn as_v2(&self) -> &ffi::PE_LoadConfigurationV2 {
    1643           32 :         self.ptr
    1644           32 :             .as_ref()
    1645           32 :             .unwrap()
    1646           32 :             .as_ref()
    1647           32 :             .as_ref()
    1648           32 :             .as_ref()
    1649           32 :             .as_ref()
    1650           32 :             .as_ref()
    1651           32 :             .as_ref()
    1652           32 :             .as_ref()
    1653           32 :             .as_ref()
    1654           32 :             .as_ref()
    1655           32 :     }
    1656              : }
    1657              : 
    1658              : impl AsLoadConfigV3 for LoadConfigV11<'_> {
    1659          128 :     fn as_v3(&self) -> &ffi::PE_LoadConfigurationV3 {
    1660          128 :         self.ptr
    1661          128 :             .as_ref()
    1662          128 :             .unwrap()
    1663          128 :             .as_ref()
    1664          128 :             .as_ref()
    1665          128 :             .as_ref()
    1666          128 :             .as_ref()
    1667          128 :             .as_ref()
    1668          128 :             .as_ref()
    1669          128 :             .as_ref()
    1670          128 :             .as_ref()
    1671          128 :     }
    1672              : }
    1673              : 
    1674              : impl AsLoadConfigV4 for LoadConfigV11<'_> {
    1675           64 :     fn as_v4(&self) -> &ffi::PE_LoadConfigurationV4 {
    1676           64 :         self.ptr
    1677           64 :             .as_ref()
    1678           64 :             .unwrap()
    1679           64 :             .as_ref()
    1680           64 :             .as_ref()
    1681           64 :             .as_ref()
    1682           64 :             .as_ref()
    1683           64 :             .as_ref()
    1684           64 :             .as_ref()
    1685           64 :             .as_ref()
    1686           64 :     }
    1687              : }
    1688              : 
    1689              : impl AsLoadConfigV5 for LoadConfigV11<'_> {
    1690          160 :     fn as_v5(&self) -> &ffi::PE_LoadConfigurationV5 {
    1691          160 :         self.ptr
    1692          160 :             .as_ref()
    1693          160 :             .unwrap()
    1694          160 :             .as_ref()
    1695          160 :             .as_ref()
    1696          160 :             .as_ref()
    1697          160 :             .as_ref()
    1698          160 :             .as_ref()
    1699          160 :             .as_ref()
    1700          160 :     }
    1701              : }
    1702              : 
    1703              : impl AsLoadConfigV6 for LoadConfigV11<'_> {
    1704           64 :     fn as_v6(&self) -> &ffi::PE_LoadConfigurationV6 {
    1705           64 :         self.ptr
    1706           64 :             .as_ref()
    1707           64 :             .unwrap()
    1708           64 :             .as_ref()
    1709           64 :             .as_ref()
    1710           64 :             .as_ref()
    1711           64 :             .as_ref()
    1712           64 :             .as_ref()
    1713           64 :     }
    1714              : }
    1715              : 
    1716              : impl AsLoadConfigV7 for LoadConfigV11<'_> {
    1717           64 :     fn as_v7(&self) -> &ffi::PE_LoadConfigurationV7 {
    1718           64 :         self.ptr
    1719           64 :             .as_ref()
    1720           64 :             .unwrap()
    1721           64 :             .as_ref()
    1722           64 :             .as_ref()
    1723           64 :             .as_ref()
    1724           64 :             .as_ref()
    1725           64 :     }
    1726              : }
    1727              : 
    1728              : impl AsLoadConfigV8 for LoadConfigV11<'_> {
    1729           32 :     fn as_v8(&self) -> &ffi::PE_LoadConfigurationV8 {
    1730           32 :         self.ptr.as_ref().unwrap().as_ref().as_ref().as_ref()
    1731           32 :     }
    1732              : }
    1733              : 
    1734              : impl AsLoadConfigV9 for LoadConfigV11<'_> {
    1735           64 :     fn as_v9(&self) -> &ffi::PE_LoadConfigurationV9 {
    1736           64 :         self.ptr.as_ref().unwrap().as_ref().as_ref()
    1737           64 :     }
    1738              : }
    1739              : 
    1740              : impl AsLoadConfigV10 for LoadConfigV11<'_> {
    1741           96 :     fn as_v10(&self) -> &ffi::PE_LoadConfigurationV10 {
    1742           96 :         self.ptr.as_ref().unwrap().as_ref()
    1743           96 :     }
    1744              : }
    1745              : 
    1746              : impl AsLoadConfigV11 for LoadConfigV11<'_> {
    1747           64 :     fn as_v11(&self) -> &ffi::PE_LoadConfigurationV11 {
    1748           64 :         self.ptr.as_ref().unwrap()
    1749           64 :     }
    1750              : }
        

Generated by: LCOV version 2.1-1