Fix windows

Author: Marcondiro

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "libipt"
-version = "0.2.0-rc.1"
+version = "0.2.0-rc.2"
 authors = ["sum_catnip <catnip@catnip.fyi>", "Marcondiro"]
 edition = "2021"
 license = "MIT"

src/block/block.rs

@@ -92,7 +92,7 @@ impl Block {
 
     /// The execution mode for all instructions in this block.
     pub fn mode(&self) -> ExecModeType {
-        ExecModeType::try_from(self.0.mode).unwrap()
+        ExecModeType::try_from(self.0.mode as u32).unwrap()
     }
 
     /// The instruction class for the last instruction in this block.
@@ -101,7 +101,7 @@ impl Block {
     /// class is not available. The block decoder may choose to not provide
     /// the instruction class in some cases for performance reasons.
     pub fn class(&self) -> Class {
-        Class::try_from(self.0.iclass).unwrap()
+        Class::try_from(self.0.iclass as u32).unwrap()
     }
 
     /// The number of instructions in this block.

src/config/cpu.rs

@@ -1,10 +1,7 @@
-use libipt_sys::{
-    pt_cpu,
-    pt_cpu_vendor_pcv_intel,
-    pt_cpu_vendor_pcv_unknown,
-    pt_errata,
-    pt_cpu_errata,
-};
+// Certain casts are required only on Windows. Inform Clippy to ignore them.
+#![allow(clippy::unnecessary_cast)]
+
+use libipt_sys::{pt_cpu, pt_cpu_vendor_pcv_intel, pt_cpu_vendor_pcv_unknown, pt_errata, pt_cpu_errata, pt_cpu_vendor};
 
 use bitflags::bitflags;
 
@@ -43,8 +40,8 @@ mod test {
 bitflags! {
     /// i suppose this is relevant when/if amd finally gets intelpt support?
     pub struct CpuVendor: u32 {
-        const INTEL = pt_cpu_vendor_pcv_intel;
-        const UNKNOWN = pt_cpu_vendor_pcv_unknown;
+        const INTEL = pt_cpu_vendor_pcv_intel as u32;
+        const UNKNOWN = pt_cpu_vendor_pcv_unknown as u32;
     }
 }
 
@@ -53,7 +50,7 @@ bitflags! {
 pub struct Cpu (pub(super) pt_cpu);
 impl Cpu {
     pub fn new(vendor: CpuVendor, family: u16, model: u8, stepping: u8) -> Self {
-        Cpu(pt_cpu{ vendor: vendor.bits(), family, model, stepping })
+        Cpu(pt_cpu{ vendor: vendor.bits() as pt_cpu_vendor, family, model, stepping })
     }
 
     /// A shortcut for creating an intel Cpu instance

src/event/exec_mode.rs

@@ -1,3 +1,6 @@
+// Certain casts are required only on Windows. Inform Clippy to ignore them.
+#![allow(clippy::unnecessary_cast)]
+
 use std::convert::TryFrom;
 use libipt_sys::{
     pt_event__bindgen_ty_1__bindgen_ty_8,
@@ -39,10 +42,10 @@ mod test {
 #[derive(Clone, Copy, TryFromPrimitive, Debug, PartialEq)]
 #[repr(u32)]
 pub enum ExecModeType {
-    Bit16 = pt_exec_mode_ptem_16bit,
-    Bit32 = pt_exec_mode_ptem_32bit,
-    Bit64 = pt_exec_mode_ptem_64bit,
-    Unknown = pt_exec_mode_ptem_unknown
+    Bit16 = pt_exec_mode_ptem_16bit as u32,
+    Bit32 = pt_exec_mode_ptem_32bit as u32,
+    Bit64 = pt_exec_mode_ptem_64bit as u32,
+    Unknown = pt_exec_mode_ptem_unknown as u32
 }
 
 /// An execution mode change
@@ -52,5 +55,5 @@ impl ExecMode {
     /// The address at which the event is effective
     pub fn ip(self) -> u64 { self.0.ip }
     /// The execution mode
-    pub fn mode(self) -> ExecModeType { ExecModeType::try_from(self.0.mode).unwrap() }
+    pub fn mode(self) -> ExecModeType { ExecModeType::try_from(self.0.mode as u32).unwrap() }
 }

src/flags.rs

@@ -1,3 +1,6 @@
+// Certain casts are required only on Windows. Inform Clippy to ignore them.
+#![allow(clippy::unnecessary_cast)]
+
 use libipt_sys::{
     pt_status_flag_pts_eos,
     pt_status_flag_pts_event_pending,
@@ -9,11 +12,11 @@ bitflags! {
     /// Status flags for various IntelPT actions
     pub struct Status: u32 {
         /// There is no more trace data available.
-        const EOS = pt_status_flag_pts_eos;
+        const EOS = pt_status_flag_pts_eos as u32;
         /// There is an event pending.
-        const EVENT_PENDING = pt_status_flag_pts_event_pending;
+        const EVENT_PENDING = pt_status_flag_pts_event_pending as u32;
         /// The address has been suppressed.
-        const IP_SUPRESSED  = pt_status_flag_pts_ip_suppressed;
+        const IP_SUPRESSED  = pt_status_flag_pts_ip_suppressed as u32;
     }
 }
 

src/insn/class.rs

@@ -1,3 +1,6 @@
+// Certain casts are required only on Windows. Inform Clippy to ignore them.
+#![allow(clippy::unnecessary_cast)]
+
 use num_enum::TryFromPrimitive;
 use libipt_sys::{
     pt_insn_class_ptic_call,
@@ -20,26 +23,26 @@ use libipt_sys::{
 #[repr(u32)]
 pub enum Class {
     /// The instruction is a near (function) call.
-    Call = pt_insn_class_ptic_call,
+    Call = pt_insn_class_ptic_call as u32,
     /// The instruction is a near conditional jump.
-    CondJump = pt_insn_class_ptic_cond_jump,
+    CondJump = pt_insn_class_ptic_cond_jump as u32,
     /// The instruction could not be classified.
-    Error = pt_insn_class_ptic_error,
+    Error = pt_insn_class_ptic_error as u32,
     /// The instruction is a call-like far transfer.
     /// E.g. SYSCALL, SYSENTER, or FAR CALL.
-    FarCall = pt_insn_class_ptic_far_call,
+    FarCall = pt_insn_class_ptic_far_call as u32,
     /// The instruction is a jump-like far transfer.
     /// E.g. FAR JMP.
-    FarJump = pt_insn_class_ptic_far_jump,
+    FarJump = pt_insn_class_ptic_far_jump as u32,
     /// The instruction is a return-like far transfer.
     /// E.g. SYSRET, SYSEXIT, IRET, or FAR RET.
-    FarReturn = pt_insn_class_ptic_far_return,
+    FarReturn = pt_insn_class_ptic_far_return as u32,
     /// The instruction is a near unconditional jump.
-    Jump = pt_insn_class_ptic_jump,
+    Jump = pt_insn_class_ptic_jump as u32,
     /// The instruction is something not listed below.
-    Other = pt_insn_class_ptic_other,
+    Other = pt_insn_class_ptic_other as u32,
     /// The instruction is a PTWRITE.
-    Ptwrite = pt_insn_class_ptic_ptwrite,
+    Ptwrite = pt_insn_class_ptic_ptwrite as u32,
     /// The instruction is a near (function) return.
-    Return = pt_insn_class_ptic_return
+    Return = pt_insn_class_ptic_return as u32,
 }

src/insn/insn.rs

@@ -1,3 +1,6 @@
+// Certain casts are required only on Windows. Inform Clippy to ignore them.
+#![allow(clippy::unnecessary_cast)]
+
 use crate::event::ExecModeType;
 use super::Class;
 
@@ -50,14 +53,14 @@ impl Insn {
 
     /// The execution mode.
     pub fn mode(self) -> ExecModeType {
-        ExecModeType::try_from(self.0.mode)
+        ExecModeType::try_from(self.0.mode as u32)
             .expect(concat!("unmatched ExecModeType enum value, ",
                 "this is a bug in either libipt or the bindings"))
     }
 
     /// A coarse classification.
     pub fn class(self) -> Class {
-        Class::try_from(self.0.iclass)
+        Class::try_from(self.0.iclass as u32)
             .expect(concat!("unmatched Class enum value, ",
                 "this is a bug in either libipt or the bindings"))
     }

src/packet/ip.rs

@@ -1,3 +1,6 @@
+// Certain casts are required only on Windows. Inform Clippy to ignore them.
+#![allow(clippy::unnecessary_cast)]
+
 use std::convert::TryFrom;
 use num_enum::{TryFromPrimitive, IntoPrimitive};
 use libipt_sys::{
@@ -6,35 +9,36 @@ use libipt_sys::{
     pt_packet_type_ppt_fup,
     pt_packet_type_ppt_tip_pge,
     pt_packet_type_ppt_tip_pgd,
+    pt_ip_compression,
     pt_ip_compression_pt_ipc_full,
     pt_ip_compression_pt_ipc_sext_48,
     pt_ip_compression_pt_ipc_suppressed,
     pt_ip_compression_pt_ipc_update_16,
     pt_ip_compression_pt_ipc_update_32,
-    pt_ip_compression_pt_ipc_update_48
+    pt_ip_compression_pt_ipc_update_48,
 };
 
 /// The IP compression
 #[derive(Clone, Copy, Debug, TryFromPrimitive, IntoPrimitive)]
 #[repr(u32)]
 pub enum Compression {
     /// No payload. The IP has been suppressed
-    Suppressed = pt_ip_compression_pt_ipc_suppressed,
+    Suppressed = pt_ip_compression_pt_ipc_suppressed as u32,
 
     /// Payload: 16 bits. Update last IP
-    Update16   = pt_ip_compression_pt_ipc_update_16,
+    Update16   = pt_ip_compression_pt_ipc_update_16 as u32,
 
     /// Payload: 32 bits. Update last IP
-    Update32   = pt_ip_compression_pt_ipc_update_32,
+    Update32   = pt_ip_compression_pt_ipc_update_32 as u32,
 
     /// Payload: 48 bits. Sign extend to full address
-    Sext48     = pt_ip_compression_pt_ipc_sext_48,
+    Sext48     = pt_ip_compression_pt_ipc_sext_48 as u32,
 
     /// Payload: 48 bits. Update last IP
-    Update48   = pt_ip_compression_pt_ipc_update_48,
+    Update48   = pt_ip_compression_pt_ipc_update_48 as u32,
 
     /// Payload: 64 bits. Full address
-    Full       = pt_ip_compression_pt_ipc_full
+    Full       = pt_ip_compression_pt_ipc_full as u32,
 }
 
 /// A packet with IP payload.
@@ -44,7 +48,7 @@ pub struct Tip (pt_packet_ip);
 impl Tip {
     #[inline]
     pub fn new(tip: u64, compression: Compression) -> Self {
-        Tip (pt_packet_ip { ip: tip, ipc: compression.into() })
+        Tip (pt_packet_ip { ip: tip, ipc: u32::from(compression) as pt_ip_compression })
     }
 
     /// Zero-extended payload ip
@@ -59,13 +63,13 @@ impl Tip {
     pub fn compression(self) -> Compression {
         // if this tryfrom panics, there is a bug
         // in either libipt or this crate.
-        Compression::try_from(self.0.ipc).unwrap()
+        Compression::try_from(self.0.ipc as u32).unwrap()
     }
 
     /// IP compression
     #[inline]
     pub fn set_compression(&mut self, compression: Compression) {
-        self.0.ipc = compression.into()
+        self.0.ipc = u32::from(compression) as pt_ip_compression
     }
 }
 
@@ -76,7 +80,7 @@ pub struct Fup (pt_packet_ip);
 impl Fup {
     #[inline]
     pub fn new(fup: u64, compression: Compression) -> Self {
-        Fup (pt_packet_ip { ip: fup, ipc: compression.into() })
+        Fup (pt_packet_ip { ip: fup, ipc: u32::from(compression) as pt_ip_compression })
     }
 
     /// Zero-extended payload ip
@@ -91,13 +95,13 @@ impl Fup {
     pub fn compression(self) -> Compression {
         // if this tryfrom panics, there is a bug
         // in either libipt or this crate.
-        Compression::try_from(self.0.ipc).unwrap()
+        Compression::try_from(self.0.ipc as u32).unwrap()
     }
 
     /// IP compression
     #[inline]
     pub fn set_compression(&mut self, compression: Compression) {
-        self.0.ipc = compression.into()
+        self.0.ipc = u32::from(compression) as pt_ip_compression;
     }
 }
 
@@ -108,7 +112,7 @@ pub struct TipPge (pt_packet_ip);
 impl TipPge {
     #[inline]
     pub fn new(tippge: u64, compression: Compression) -> Self {
-        TipPge (pt_packet_ip { ip: tippge, ipc: compression.into() })
+        TipPge (pt_packet_ip { ip: tippge, ipc: u32::from(compression) as pt_ip_compression })
     }
 
     /// Zero-extended payload ip
@@ -123,13 +127,13 @@ impl TipPge {
     pub fn compression(self) -> Compression {
         // if this tryfrom panics, there is a bug
         // in either libipt or this crate.
-        Compression::try_from(self.0.ipc).unwrap()
+        Compression::try_from(self.0.ipc as u32).unwrap()
     }
 
     /// IP compression
     #[inline]
     pub fn set_compression(&mut self, compression: Compression) {
-        self.0.ipc = compression.into()
+        self.0.ipc = u32::from(compression) as pt_ip_compression
     }
 }
 
@@ -140,7 +144,7 @@ pub struct TipPgd (pt_packet_ip);
 impl TipPgd {
     #[inline]
     pub fn new(tippgd: u64, compression: Compression) -> Self {
-        TipPgd (pt_packet_ip { ip: tippgd, ipc: compression.into() })
+        TipPgd (pt_packet_ip { ip: tippgd, ipc: u32::from(compression) as pt_ip_compression })
     }
 
     /// Zero-extended payload ip
@@ -155,13 +159,13 @@ impl TipPgd {
     pub fn compression(self) -> Compression {
         // if this tryfrom panics, there is a bug
         // in either libipt or this crate.
-        Compression::try_from(self.0.ipc).unwrap()
+        Compression::try_from(self.0.ipc as u32).unwrap()
     }
 
     /// IP compression
     #[inline]
     pub fn set_compression(&mut self, compression: Compression) {
-        self.0.ipc = compression.into()
+        self.0.ipc = u32::from(compression) as pt_ip_compression
     }
 }