Make sure 32bit version compiles again.

Signed-off-by: Gerd Zellweger <mail@gerdzellweger.com>

7 files changed, 29 insertions, 15 deletions

diff --git a/src/bits32/eflags.rs b/src/bits32/eflags.rs
index d937d25..4daa917 100644
--- a/src/bits32/eflags.rs
+++ b/src/bits32/eflags.rs
@@ -1,6 +1,6 @@
 //! Processor state stored in the EFLAGS register.
 
-use super::PrivilegeLevel;
+use ::PrivilegeLevel;
 
 /// The EFLAGS register.
 bitflags! {
@@ -50,7 +50,7 @@ bitflags! {
     }
 }
 
-impl Flags {
+impl EFlags {
     /// Creates a new Flags entry. Ensures bit 1 is set.
     pub const fn new() -> EFlags {
         FLAGS_A1
@@ -62,12 +62,14 @@ impl Flags {
     }
 }
 
+#[cfg(target_arch="x86")]
 pub unsafe fn read() -> EFlags {
     let r: u32;
     asm!("pushfl; popl $0" : "=r"(r) :: "memory");
     EFlags::from_bits_truncate(r)
 }
 
+#[cfg(target_arch="x86")]
 pub unsafe fn set(val: EFlags) {
     asm!("pushl $0; popfl" :: "r"(val.bits()) : "memory" "flags");
 }
diff --git a/src/bits32/segmentation.rs b/src/bits32/segmentation.rs
index fe95141..6f0fec8 100644
--- a/src/bits32/segmentation.rs
+++ b/src/bits32/segmentation.rs
@@ -11,15 +11,16 @@ use bits32::task::*;
 /// to %cs. Instead we push the new segment selector
 /// and return value on the stack and use lretl
 /// to reload cs and continue at 1:.
+#[cfg(target_arch="x86")]
 pub unsafe fn set_cs(sel: SegmentSelector) {
     asm!("pushl $0; \
           pushl $$1f; \
           lretl; \
-          1:" :: "ri" (sel.bits() as usize) : "memory");
+          1:" :: "ri" (sel.bits() as u32) : "memory");
 }
 
 impl SegmentDescriptor {
-    pub fn new_memory(base: u32, limit: u32, ty: Type, accessed: bool, dpl: PrivilegeLevel) -> SegmentDescriptor {
+    pub fn new_memory32(base: u32, limit: u32, ty: Type, accessed: bool, dpl: PrivilegeLevel) -> SegmentDescriptor {
         let ty1 = descriptor::Type::SegmentDescriptor {
             ty: ty,
             accessed: accessed,
@@ -29,7 +30,7 @@ impl SegmentDescriptor {
         seg
     }
 
-    pub fn new_tss(tss: &TaskStateSegment, dpl: PrivilegeLevel) -> SegmentDescriptor {
+    pub fn new_tss32(tss: &TaskStateSegment, dpl: PrivilegeLevel) -> SegmentDescriptor {
         let tss_ptr = tss as *const TaskStateSegment;
         let ty1 = descriptor::Type::SystemDescriptor {
             size: true,
diff --git a/src/bits64/mod.rs b/src/bits64/mod.rs
index d72b732..6e2a1bd 100644
--- a/src/bits64/mod.rs
+++ b/src/bits64/mod.rs
@@ -21,4 +21,6 @@ pub mod paging;
 pub mod segmentation;
 pub mod task;
 pub mod syscall;
+
+#[cfg(target_arch="x86-64")]
 pub mod sgx;
diff --git a/src/bits64/paging.rs b/src/bits64/paging.rs
index 4ec8485..0fda00e 100644
--- a/src/bits64/paging.rs
+++ b/src/bits64/paging.rs
@@ -75,26 +75,26 @@ pub type PT = [PTEntry; 512];
 
 /// Given virtual address calculate corresponding entry in PML4.
 #[inline]
-pub fn pml4_index(addr: VAddr) -> usize {
-    (addr.as_usize() >> 39) & 0b111111111
+pub fn pml4_index(addr: VAddr) -> u64 {
+    (addr.as_u64() >> 39) & 0b111111111
 }
 
 /// Given virtual address calculate corresponding entry in PDPT.
 #[inline]
-pub fn pdpt_index(addr: VAddr) -> usize {
-    (addr.as_usize() >> 30) & 0b111111111
+pub fn pdpt_index(addr: VAddr) -> u64 {
+    (addr.as_u64() >> 30) & 0b111111111
 }
 
 /// Given virtual address calculate corresponding entry in PD.
 #[inline]
-pub fn pd_index(addr: VAddr) -> usize {
-    (addr.as_usize() >> 21) & 0b111111111
+pub fn pd_index(addr: VAddr) -> u64 {
+    (addr.as_u64() >> 21) & 0b111111111
 }
 
 /// Given virtual address calculate corresponding entry in PT.
 #[inline]
-pub fn pt_index(addr: VAddr) -> usize {
-    (addr.as_usize() >> 12) & 0b111111111
+pub fn pt_index(addr: VAddr) -> u64 {
+    (addr.as_u64() >> 12) & 0b111111111
 }
 
 /// PML4 Entry bits description.
diff --git a/src/bits64/rflags.rs b/src/bits64/rflags.rs
index 69e85ee..937d3d3 100644
--- a/src/bits64/rflags.rs
+++ b/src/bits64/rflags.rs
@@ -67,12 +67,14 @@ impl RFlags {
     }
 }
 
+#[cfg(target_arch="x86-64")]
 pub unsafe fn flags() -> RFlags {
     let r: u64;
     asm!("pushfq; popq $0" : "=r"(r) :: "memory");
     RFlags::from_bits_truncate(r)
 }
 
+#[cfg(target_arch="x86-64")]
 pub unsafe fn set(val: RFlags) {
     asm!("pushq $0; popfq" :: "r"(val.bits()) : "memory" "flags");
 }
diff --git a/src/bits64/segmentation.rs b/src/bits64/segmentation.rs
index 93ac2aa..4c440e9 100644
--- a/src/bits64/segmentation.rs
+++ b/src/bits64/segmentation.rs
@@ -10,6 +10,7 @@ use bits64::task::*;
 /// to %cs. Instead we push the new segment selector
 /// and return value on the stack and use lretq
 /// to reload cs and continue at 1:.
+#[cfg(target_arch="x86-64")]
 pub unsafe fn set_cs(sel: SegmentSelector) {
     asm!("pushq $0; \
           leaq  1f(%rip), %rax; \
@@ -33,7 +34,7 @@ impl SegmentBitness {
 }
 
 impl SegmentDescriptor {
-    pub fn new_memory(base: u32, limit: u32, ty: Type, accessed: bool, dpl: PrivilegeLevel, bitness: SegmentBitness) -> SegmentDescriptor {
+    pub fn new_memory64(base: u32, limit: u32, ty: Type, accessed: bool, dpl: PrivilegeLevel, bitness: SegmentBitness) -> SegmentDescriptor {
         let ty1 = descriptor::Type::SegmentDescriptor {
             ty: ty,
             accessed: accessed,
@@ -43,7 +44,7 @@ impl SegmentDescriptor {
         seg
     }
 
-    pub fn new_tss(tss: &TaskStateSegment, dpl: PrivilegeLevel) -> [SegmentDescriptor; 2] {
+    pub fn new_tss64(tss: &TaskStateSegment, dpl: PrivilegeLevel) -> [SegmentDescriptor; 2] {
         let tss_ptr = tss as *const TaskStateSegment;
         let ty1 = descriptor::Type::SystemDescriptor {
             size: true,
diff --git a/src/paging.rs b/src/paging.rs
index 41705a9..06c86aa 100644
--- a/src/paging.rs
+++ b/src/paging.rs
@@ -11,10 +11,16 @@ impl VAddr {
     pub const fn as_usize(&self) -> usize {
         self.0
     }
+
     /// Convert from `usize`
     pub const fn from_usize(v: usize) -> Self {
         VAddr(v)
     }
+
+    pub const fn as_u64(&self) -> u64 {
+        self.0 as u64
+    }
+
 }
 
 impl fmt::Binary for VAddr {