diff --git a/sim/src/image.rs b/sim/src/image.rs
index 3024b1c..e563653 100644
--- a/sim/src/image.rs
+++ b/sim/src/image.rs
@@ -16,7 +16,7 @@
     },
 };
 
-use simflash::{Flash, SimFlash, SimFlashMap};
+use simflash::{Flash, SimFlash, SimMultiFlash};
 use mcuboot_sys::{c, AreaDesc, FlashId};
 use crate::{
     ALL_DEVICES,
@@ -30,16 +30,16 @@
 /// the flash simulator(s) and the information about the slots.
 #[derive(Clone)]
 pub struct ImagesBuilder {
-    flashmap: SimFlashMap,
+    flash: SimMultiFlash,
     areadesc: AreaDesc,
     slots: [SlotInfo; 2],
 }
 
 /// Images represents the state of a simulation for a given set of images.
-/// The flashmap holds the state of the simulated flash, whereas primaries
+/// The flash holds the state of the simulated flash, whereas primaries
 /// and upgrades hold the expected contents of these images.
 pub struct Images {
-    flashmap: SimFlashMap,
+    flash: SimMultiFlash,
     areadesc: AreaDesc,
     slots: [SlotInfo; 2],
     primaries: ImageData,
@@ -57,7 +57,7 @@
 
 impl ImagesBuilder {
     pub fn new(device: DeviceName, align: u8, erased_val: u8) -> Self {
-        let (flashmap, areadesc) = Self::make_device(device, align, erased_val);
+        let (flash, areadesc) = Self::make_device(device, align, erased_val);
 
         let (slot0_base, slot0_len, slot0_dev_id) = areadesc.find(FlashId::Image0);
         let (slot1_base, slot1_len, slot1_dev_id) = areadesc.find(FlashId::Image1);
@@ -82,7 +82,7 @@
         };
 
         ImagesBuilder {
-            flashmap: flashmap,
+            flash: flash,
             areadesc: areadesc,
             slots: [slot0, slot1],
         }
@@ -103,11 +103,11 @@
 
     /// Construct an `Images` that doesn't expect an upgrade to happen.
     pub fn make_no_upgrade_image(self) -> Images {
-        let mut flashmap = self.flashmap;
-        let primaries = install_image(&mut flashmap, &self.slots, 0, 32784, false);
-        let upgrades = install_image(&mut flashmap, &self.slots, 1, 41928, false);
+        let mut flash = self.flash;
+        let primaries = install_image(&mut flash, &self.slots, 0, 32784, false);
+        let upgrades = install_image(&mut flash, &self.slots, 1, 41928, false);
         Images {
-            flashmap: flashmap,
+            flash: flash,
             areadesc: self.areadesc,
             slots: self.slots,
             primaries: primaries,
@@ -119,7 +119,7 @@
     /// Construct an `Images` for normal testing.
     pub fn make_image(self) -> Images {
         let mut images = self.make_no_upgrade_image();
-        mark_upgrade(&mut images.flashmap, &images.slots[1]);
+        mark_upgrade(&mut images.flash, &images.slots[1]);
 
         // upgrades without fails, counts number of flash operations
         let total_count = match images.run_basic_upgrade() {
@@ -134,11 +134,11 @@
     }
 
     pub fn make_bad_secondary_slot_image(self) -> Images {
-        let mut bad_flashmap = self.flashmap;
-        let primaries = install_image(&mut bad_flashmap, &self.slots, 0, 32784, false);
-        let upgrades = install_image(&mut bad_flashmap, &self.slots, 1, 41928, true);
+        let mut bad_flash = self.flash;
+        let primaries = install_image(&mut bad_flash, &self.slots, 0, 32784, false);
+        let upgrades = install_image(&mut bad_flash, &self.slots, 1, 41928, true);
         Images {
-            flashmap: bad_flashmap,
+            flash: bad_flash,
             areadesc: self.areadesc,
             slots: self.slots,
             primaries: primaries,
@@ -148,90 +148,90 @@
     }
 
     /// Build the Flash and area descriptor for a given device.
-    pub fn make_device(device: DeviceName, align: u8, erased_val: u8) -> (SimFlashMap, AreaDesc) {
+    pub fn make_device(device: DeviceName, align: u8, erased_val: u8) -> (SimMultiFlash, AreaDesc) {
         match device {
             DeviceName::Stm32f4 => {
                 // STM style flash.  Large sectors, with a large scratch area.
-                let flash = SimFlash::new(vec![16 * 1024, 16 * 1024, 16 * 1024, 16 * 1024,
-                                          64 * 1024,
-                                          128 * 1024, 128 * 1024, 128 * 1024],
-                                          align as usize, erased_val);
+                let dev = SimFlash::new(vec![16 * 1024, 16 * 1024, 16 * 1024, 16 * 1024,
+                                        64 * 1024,
+                                        128 * 1024, 128 * 1024, 128 * 1024],
+                                        align as usize, erased_val);
                 let dev_id = 0;
                 let mut areadesc = AreaDesc::new();
-                areadesc.add_flash_sectors(dev_id, &flash);
+                areadesc.add_flash_sectors(dev_id, &dev);
                 areadesc.add_image(0x020000, 0x020000, FlashId::Image0, dev_id);
                 areadesc.add_image(0x040000, 0x020000, FlashId::Image1, dev_id);
                 areadesc.add_image(0x060000, 0x020000, FlashId::ImageScratch, dev_id);
 
-                let mut flashmap = SimFlashMap::new();
-                flashmap.insert(dev_id, flash);
-                (flashmap, areadesc)
+                let mut flash = SimMultiFlash::new();
+                flash.insert(dev_id, dev);
+                (flash, areadesc)
             }
             DeviceName::K64f => {
                 // NXP style flash.  Small sectors, one small sector for scratch.
-                let flash = SimFlash::new(vec![4096; 128], align as usize, erased_val);
+                let dev = SimFlash::new(vec![4096; 128], align as usize, erased_val);
 
                 let dev_id = 0;
                 let mut areadesc = AreaDesc::new();
-                areadesc.add_flash_sectors(dev_id, &flash);
+                areadesc.add_flash_sectors(dev_id, &dev);
                 areadesc.add_image(0x020000, 0x020000, FlashId::Image0, dev_id);
                 areadesc.add_image(0x040000, 0x020000, FlashId::Image1, dev_id);
                 areadesc.add_image(0x060000, 0x001000, FlashId::ImageScratch, dev_id);
 
-                let mut flashmap = SimFlashMap::new();
-                flashmap.insert(dev_id, flash);
-                (flashmap, areadesc)
+                let mut flash = SimMultiFlash::new();
+                flash.insert(dev_id, dev);
+                (flash, areadesc)
             }
             DeviceName::K64fBig => {
                 // Simulating an STM style flash on top of an NXP style flash.  Underlying flash device
                 // uses small sectors, but we tell the bootloader they are large.
-                let flash = SimFlash::new(vec![4096; 128], align as usize, erased_val);
+                let dev = SimFlash::new(vec![4096; 128], align as usize, erased_val);
 
                 let dev_id = 0;
                 let mut areadesc = AreaDesc::new();
-                areadesc.add_flash_sectors(dev_id, &flash);
+                areadesc.add_flash_sectors(dev_id, &dev);
                 areadesc.add_simple_image(0x020000, 0x020000, FlashId::Image0, dev_id);
                 areadesc.add_simple_image(0x040000, 0x020000, FlashId::Image1, dev_id);
                 areadesc.add_simple_image(0x060000, 0x020000, FlashId::ImageScratch, dev_id);
 
-                let mut flashmap = SimFlashMap::new();
-                flashmap.insert(dev_id, flash);
-                (flashmap, areadesc)
+                let mut flash = SimMultiFlash::new();
+                flash.insert(dev_id, dev);
+                (flash, areadesc)
             }
             DeviceName::Nrf52840 => {
                 // Simulating the flash on the nrf52840 with partitions set up so that the scratch size
                 // does not divide into the image size.
-                let flash = SimFlash::new(vec![4096; 128], align as usize, erased_val);
+                let dev = SimFlash::new(vec![4096; 128], align as usize, erased_val);
 
                 let dev_id = 0;
                 let mut areadesc = AreaDesc::new();
-                areadesc.add_flash_sectors(dev_id, &flash);
+                areadesc.add_flash_sectors(dev_id, &dev);
                 areadesc.add_image(0x008000, 0x034000, FlashId::Image0, dev_id);
                 areadesc.add_image(0x03c000, 0x034000, FlashId::Image1, dev_id);
                 areadesc.add_image(0x070000, 0x00d000, FlashId::ImageScratch, dev_id);
 
-                let mut flashmap = SimFlashMap::new();
-                flashmap.insert(dev_id, flash);
-                (flashmap, areadesc)
+                let mut flash = SimMultiFlash::new();
+                flash.insert(dev_id, dev);
+                (flash, areadesc)
             }
             DeviceName::Nrf52840SpiFlash => {
                 // Simulate nrf52840 with external SPI flash. The external SPI flash
                 // has a larger sector size so for now store scratch on that flash.
-                let flash0 = SimFlash::new(vec![4096; 128], align as usize, erased_val);
-                let flash1 = SimFlash::new(vec![8192; 64], align as usize, erased_val);
+                let dev0 = SimFlash::new(vec![4096; 128], align as usize, erased_val);
+                let dev1 = SimFlash::new(vec![8192; 64], align as usize, erased_val);
 
                 let mut areadesc = AreaDesc::new();
-                areadesc.add_flash_sectors(0, &flash0);
-                areadesc.add_flash_sectors(1, &flash1);
+                areadesc.add_flash_sectors(0, &dev0);
+                areadesc.add_flash_sectors(1, &dev1);
 
                 areadesc.add_image(0x008000, 0x068000, FlashId::Image0, 0);
                 areadesc.add_image(0x000000, 0x068000, FlashId::Image1, 1);
                 areadesc.add_image(0x068000, 0x018000, FlashId::ImageScratch, 1);
 
-                let mut flashmap = SimFlashMap::new();
-                flashmap.insert(0, flash0);
-                flashmap.insert(1, flash1);
-                (flashmap, areadesc)
+                let mut flash = SimMultiFlash::new();
+                flash.insert(0, dev0);
+                flash.insert(1, dev1);
+                (flash, areadesc)
             }
         }
     }
@@ -243,10 +243,10 @@
     /// Returns the number of flash operations which can later be used to
     /// inject failures at chosen steps.
     pub fn run_basic_upgrade(&self) -> Result<i32, ()> {
-        let (flashmap, total_count) = try_upgrade(&self.flashmap, &self, None);
+        let (flash, total_count) = try_upgrade(&self.flash, &self, None);
         info!("Total flash operation count={}", total_count);
 
-        if !verify_image(&flashmap, &self.slots, 0, &self.upgrades) {
+        if !verify_image(&flash, &self.slots, 0, &self.upgrades) {
             warn!("Image mismatch after first boot");
             Err(())
         } else {
@@ -265,8 +265,8 @@
         if Caps::SwapUpgrade.present() {
             for count in 2 .. 5 {
                 info!("Try revert: {}", count);
-                let flashmap = try_revert(&self.flashmap, &self.areadesc, count);
-                if !verify_image(&flashmap, &self.slots, 0, &self.primaries) {
+                let flash = try_revert(&self.flash, &self.areadesc, count);
+                if !verify_image(&flash, &self.slots, 0, &self.primaries) {
                     error!("Revert failure on count {}", count);
                     fails += 1;
                 }
@@ -283,27 +283,27 @@
         // Let's try an image halfway through.
         for i in 1 .. total_flash_ops {
             info!("Try interruption at {}", i);
-            let (flashmap, count) = try_upgrade(&self.flashmap, &self, Some(i));
+            let (flash, count) = try_upgrade(&self.flash, &self, Some(i));
             info!("Second boot, count={}", count);
-            if !verify_image(&flashmap, &self.slots, 0, &self.upgrades) {
+            if !verify_image(&flash, &self.slots, 0, &self.upgrades) {
                 warn!("FAIL at step {} of {}", i, total_flash_ops);
                 fails += 1;
             }
 
-            if !verify_trailer(&flashmap, &self.slots, 0, BOOT_MAGIC_GOOD,
+            if !verify_trailer(&flash, &self.slots, 0, BOOT_MAGIC_GOOD,
                                BOOT_FLAG_SET, BOOT_FLAG_SET) {
                 warn!("Mismatched trailer for the primary slot");
                 fails += 1;
             }
 
-            if !verify_trailer(&flashmap, &self.slots, 1, BOOT_MAGIC_UNSET,
+            if !verify_trailer(&flash, &self.slots, 1, BOOT_MAGIC_UNSET,
                                BOOT_FLAG_UNSET, BOOT_FLAG_UNSET) {
                 warn!("Mismatched trailer for the secondary slot");
                 fails += 1;
             }
 
             if Caps::SwapUpgrade.present() {
-                if !verify_image(&flashmap, &self.slots, 1, &self.primaries) {
+                if !verify_image(&flash, &self.slots, 1, &self.primaries) {
                     warn!("Secondary slot FAIL at step {} of {}",
                           i, total_flash_ops);
                     fails += 1;
@@ -326,14 +326,14 @@
     pub fn run_perm_with_random_fails(&self, total_fails: usize) -> bool {
         let mut fails = 0;
         let total_flash_ops = self.total_count.unwrap();
-        let (flashmap, total_counts) = try_random_fails(&self.flashmap, &self,
+        let (flash, total_counts) = try_random_fails(&self.flash, &self,
                                                         total_flash_ops, total_fails);
         info!("Random interruptions at reset points={:?}", total_counts);
 
-        let primary_slot_ok = verify_image(&flashmap, &self.slots,
+        let primary_slot_ok = verify_image(&flash, &self.slots,
                                            0, &self.upgrades);
         let secondary_slot_ok = if Caps::SwapUpgrade.present() {
-            verify_image(&flashmap, &self.slots, 1, &self.primaries)
+            verify_image(&flash, &self.slots, 1, &self.primaries)
         } else {
             true
         };
@@ -344,12 +344,12 @@
                    if secondary_slot_ok { "ok" } else { "fail" });
             fails += 1;
         }
-        if !verify_trailer(&flashmap, &self.slots, 0, BOOT_MAGIC_GOOD,
+        if !verify_trailer(&flash, &self.slots, 0, BOOT_MAGIC_GOOD,
                            BOOT_FLAG_SET, BOOT_FLAG_SET) {
             error!("Mismatched trailer for the primary slot");
             fails += 1;
         }
-        if !verify_trailer(&flashmap, &self.slots, 1, BOOT_MAGIC_UNSET,
+        if !verify_trailer(&flash, &self.slots, 1, BOOT_MAGIC_UNSET,
                            BOOT_FLAG_UNSET, BOOT_FLAG_UNSET) {
             error!("Mismatched trailer for the secondary slot");
             fails += 1;
@@ -372,7 +372,7 @@
         if Caps::SwapUpgrade.present() {
             for i in 1 .. (self.total_count.unwrap() - 1) {
                 info!("Try interruption at {}", i);
-                if try_revert_with_fail_at(&self.flashmap, &self, i) {
+                if try_revert_with_fail_at(&self.flash, &self, i) {
                     error!("Revert failed at interruption {}", i);
                     fails += 1;
                 }
@@ -387,13 +387,13 @@
             return false;
         }
 
-        let mut flashmap = self.flashmap.clone();
+        let mut flash = self.flash.clone();
         let mut fails = 0;
 
         info!("Try norevert");
 
         // First do a normal upgrade...
-        let (result, _) = c::boot_go(&mut flashmap, &self.areadesc, None, false);
+        let (result, _) = c::boot_go(&mut flash, &self.areadesc, None, false);
         if result != 0 {
             warn!("Failed first boot");
             fails += 1;
@@ -402,16 +402,16 @@
         //FIXME: copy_done is written by boot_go, is it ok if no copy
         //       was ever done?
 
-        if !verify_image(&flashmap, &self.slots, 0, &self.upgrades) {
+        if !verify_image(&flash, &self.slots, 0, &self.upgrades) {
             warn!("Primary slot image verification FAIL");
             fails += 1;
         }
-        if !verify_trailer(&flashmap, &self.slots, 0, BOOT_MAGIC_GOOD,
+        if !verify_trailer(&flash, &self.slots, 0, BOOT_MAGIC_GOOD,
                            BOOT_FLAG_UNSET, BOOT_FLAG_SET) {
             warn!("Mismatched trailer for the primary slot");
             fails += 1;
         }
-        if !verify_trailer(&flashmap, &self.slots, 1, BOOT_MAGIC_UNSET,
+        if !verify_trailer(&flash, &self.slots, 1, BOOT_MAGIC_UNSET,
                            BOOT_FLAG_UNSET, BOOT_FLAG_UNSET) {
             warn!("Mismatched trailer for the secondary slot");
             fails += 1;
@@ -419,26 +419,26 @@
 
         // Marks image in the primary slot as permanent,
         // no revert should happen...
-        mark_permanent_upgrade(&mut flashmap, &self.slots[0]);
+        mark_permanent_upgrade(&mut flash, &self.slots[0]);
 
-        if !verify_trailer(&flashmap, &self.slots, 0, BOOT_MAGIC_GOOD,
+        if !verify_trailer(&flash, &self.slots, 0, BOOT_MAGIC_GOOD,
                            BOOT_FLAG_SET, BOOT_FLAG_SET) {
             warn!("Mismatched trailer for the primary slot");
             fails += 1;
         }
 
-        let (result, _) = c::boot_go(&mut flashmap, &self.areadesc, None, false);
+        let (result, _) = c::boot_go(&mut flash, &self.areadesc, None, false);
         if result != 0 {
             warn!("Failed second boot");
             fails += 1;
         }
 
-        if !verify_trailer(&flashmap, &self.slots, 0, BOOT_MAGIC_GOOD,
+        if !verify_trailer(&flash, &self.slots, 0, BOOT_MAGIC_GOOD,
                            BOOT_FLAG_SET, BOOT_FLAG_SET) {
             warn!("Mismatched trailer for the primary slot");
             fails += 1;
         }
-        if !verify_image(&flashmap, &self.slots, 0, &self.upgrades) {
+        if !verify_image(&flash, &self.slots, 0, &self.upgrades) {
             warn!("Failed image verification");
             fails += 1;
         }
@@ -454,39 +454,39 @@
     // image_ok set while there is no image on the secondary slot, so no revert
     // should ever happen...
     pub fn run_norevert_newimage(&self) -> bool {
-        let mut flashmap = self.flashmap.clone();
+        let mut flash = self.flash.clone();
         let mut fails = 0;
 
         info!("Try non-revert on imgtool generated image");
 
-        mark_upgrade(&mut flashmap, &self.slots[0]);
+        mark_upgrade(&mut flash, &self.slots[0]);
 
         // This simulates writing an image created by imgtool to
         // the primary slot
-        if !verify_trailer(&flashmap, &self.slots, 0, BOOT_MAGIC_GOOD,
+        if !verify_trailer(&flash, &self.slots, 0, BOOT_MAGIC_GOOD,
                            BOOT_FLAG_UNSET, BOOT_FLAG_UNSET) {
             warn!("Mismatched trailer for the primary slot");
             fails += 1;
         }
 
         // Run the bootloader...
-        let (result, _) = c::boot_go(&mut flashmap, &self.areadesc, None, false);
+        let (result, _) = c::boot_go(&mut flash, &self.areadesc, None, false);
         if result != 0 {
             warn!("Failed first boot");
             fails += 1;
         }
 
         // State should not have changed
-        if !verify_image(&flashmap, &self.slots, 0, &self.primaries) {
+        if !verify_image(&flash, &self.slots, 0, &self.primaries) {
             warn!("Failed image verification");
             fails += 1;
         }
-        if !verify_trailer(&flashmap, &self.slots, 0, BOOT_MAGIC_GOOD,
+        if !verify_trailer(&flash, &self.slots, 0, BOOT_MAGIC_GOOD,
                            BOOT_FLAG_UNSET, BOOT_FLAG_UNSET) {
             warn!("Mismatched trailer for the primary slot");
             fails += 1;
         }
-        if !verify_trailer(&flashmap, &self.slots, 1, BOOT_MAGIC_UNSET,
+        if !verify_trailer(&flash, &self.slots, 1, BOOT_MAGIC_UNSET,
                            BOOT_FLAG_UNSET, BOOT_FLAG_UNSET) {
             warn!("Mismatched trailer for the secondary slot");
             fails += 1;
@@ -503,34 +503,34 @@
     // image_ok set while there is no image on the secondary slot, so no revert
     // should ever happen...
     pub fn run_signfail_upgrade(&self) -> bool {
-        let mut flashmap = self.flashmap.clone();
+        let mut flash = self.flash.clone();
         let mut fails = 0;
 
         info!("Try upgrade image with bad signature");
 
-        mark_upgrade(&mut flashmap, &self.slots[0]);
-        mark_permanent_upgrade(&mut flashmap, &self.slots[0]);
-        mark_upgrade(&mut flashmap, &self.slots[1]);
+        mark_upgrade(&mut flash, &self.slots[0]);
+        mark_permanent_upgrade(&mut flash, &self.slots[0]);
+        mark_upgrade(&mut flash, &self.slots[1]);
 
-        if !verify_trailer(&flashmap, &self.slots, 0, BOOT_MAGIC_GOOD,
+        if !verify_trailer(&flash, &self.slots, 0, BOOT_MAGIC_GOOD,
                            BOOT_FLAG_SET, BOOT_FLAG_UNSET) {
             warn!("Mismatched trailer for the primary slot");
             fails += 1;
         }
 
         // Run the bootloader...
-        let (result, _) = c::boot_go(&mut flashmap, &self.areadesc, None, false);
+        let (result, _) = c::boot_go(&mut flash, &self.areadesc, None, false);
         if result != 0 {
             warn!("Failed first boot");
             fails += 1;
         }
 
         // State should not have changed
-        if !verify_image(&flashmap, &self.slots, 0, &self.primaries) {
+        if !verify_image(&flash, &self.slots, 0, &self.primaries) {
             warn!("Failed image verification");
             fails += 1;
         }
-        if !verify_trailer(&flashmap, &self.slots, 0, BOOT_MAGIC_GOOD,
+        if !verify_trailer(&flash, &self.slots, 0, BOOT_MAGIC_GOOD,
                            BOOT_FLAG_SET, BOOT_FLAG_UNSET) {
             warn!("Mismatched trailer for the primary slot");
             fails += 1;
@@ -566,15 +566,15 @@
             return false;
         }
 
-        let mut flashmap = self.flashmap.clone();
+        let mut flash = self.flash.clone();
         let mut fails = 0;
 
         info!("Try swap with status fails");
 
-        mark_permanent_upgrade(&mut flashmap, &self.slots[1]);
-        self.mark_bad_status_with_rate(&mut flashmap, 0, 1.0);
+        mark_permanent_upgrade(&mut flash, &self.slots[1]);
+        self.mark_bad_status_with_rate(&mut flash, 0, 1.0);
 
-        let (result, asserts) = c::boot_go(&mut flashmap, &self.areadesc, None, true);
+        let (result, asserts) = c::boot_go(&mut flash, &self.areadesc, None, true);
         if result != 0 {
             warn!("Failed!");
             fails += 1;
@@ -587,20 +587,20 @@
             fails += 1;
         }
 
-        if !verify_trailer(&flashmap, &self.slots, 0, BOOT_MAGIC_GOOD,
+        if !verify_trailer(&flash, &self.slots, 0, BOOT_MAGIC_GOOD,
                            BOOT_FLAG_SET, BOOT_FLAG_SET) {
             warn!("Mismatched trailer for the primary slot");
             fails += 1;
         }
 
-        if !verify_image(&flashmap, &self.slots, 0, &self.upgrades) {
+        if !verify_image(&flash, &self.slots, 0, &self.upgrades) {
             warn!("Failed image verification");
             fails += 1;
         }
 
         info!("validate primary slot enabled; \
                re-run of boot_go should just work");
-        let (result, _) = c::boot_go(&mut flashmap, &self.areadesc, None, false);
+        let (result, _) = c::boot_go(&mut flash, &self.areadesc, None, false);
         if result != 0 {
             warn!("Failed!");
             fails += 1;
@@ -621,7 +621,7 @@
             false
         } else if Caps::ValidatePrimarySlot.present() {
 
-            let mut flashmap = self.flashmap.clone();
+            let mut flash = self.flash.clone();
             let mut fails = 0;
             let mut count = self.total_count.unwrap() / 2;
 
@@ -629,20 +629,20 @@
 
             info!("Try interrupted swap with status fails");
 
-            mark_permanent_upgrade(&mut flashmap, &self.slots[1]);
-            self.mark_bad_status_with_rate(&mut flashmap, 0, 0.5);
+            mark_permanent_upgrade(&mut flash, &self.slots[1]);
+            self.mark_bad_status_with_rate(&mut flash, 0, 0.5);
 
             // Should not fail, writing to bad regions does not assert
-            let (_, asserts) = c::boot_go(&mut flashmap, &self.areadesc, Some(&mut count), true);
+            let (_, asserts) = c::boot_go(&mut flash, &self.areadesc, Some(&mut count), true);
             if asserts != 0 {
                 warn!("At least one assert() was called");
                 fails += 1;
             }
 
-            self.reset_bad_status(&mut flashmap, 0);
+            self.reset_bad_status(&mut flash, 0);
 
             info!("Resuming an interrupted swap operation");
-            let (_, asserts) = c::boot_go(&mut flashmap, &self.areadesc, None, true);
+            let (_, asserts) = c::boot_go(&mut flash, &self.areadesc, None, true);
 
             // This might throw no asserts, for large sector devices, where
             // a single failure writing is indistinguishable from no failure,
@@ -660,16 +660,16 @@
 
             fails > 0
         } else {
-            let mut flashmap = self.flashmap.clone();
+            let mut flash = self.flash.clone();
             let mut fails = 0;
 
             info!("Try interrupted swap with status fails");
 
-            mark_permanent_upgrade(&mut flashmap, &self.slots[1]);
-            self.mark_bad_status_with_rate(&mut flashmap, 0, 1.0);
+            mark_permanent_upgrade(&mut flash, &self.slots[1]);
+            self.mark_bad_status_with_rate(&mut flash, 0, 1.0);
 
             // This is expected to fail while writing to bad regions...
-            let (_, asserts) = c::boot_go(&mut flashmap, &self.areadesc, None, true);
+            let (_, asserts) = c::boot_go(&mut flash, &self.areadesc, None, true);
             if asserts == 0 {
                 warn!("No assert() detected");
                 fails += 1;
@@ -680,51 +680,51 @@
     }
 
     /// Adds a new flash area that fails statistically
-    fn mark_bad_status_with_rate(&self, flashmap: &mut SimFlashMap, slot: usize,
+    fn mark_bad_status_with_rate(&self, flash: &mut SimMultiFlash, slot: usize,
                                  rate: f32) {
         if Caps::OverwriteUpgrade.present() {
             return;
         }
 
         let dev_id = &self.slots[slot].dev_id;
-        let flash = flashmap.get_mut(&dev_id).unwrap();
-        let align = flash.align();
+        let dev = flash.get_mut(&dev_id).unwrap();
+        let align = dev.align();
         let off = &self.slots[0].base_off;
         let len = &self.slots[0].len;
         let status_off = off + len - self.trailer_sz(align);
 
         // Mark the status area as a bad area
-        let _ = flash.add_bad_region(status_off, self.status_sz(align), rate);
+        let _ = dev.add_bad_region(status_off, self.status_sz(align), rate);
     }
 
-    fn reset_bad_status(&self, flashmap: &mut SimFlashMap, slot: usize) {
+    fn reset_bad_status(&self, flash: &mut SimMultiFlash, slot: usize) {
         if !Caps::ValidatePrimarySlot.present() {
             return;
         }
 
         let dev_id = &self.slots[slot].dev_id;
-        let flash = flashmap.get_mut(&dev_id).unwrap();
-        flash.reset_bad_regions();
+        let dev = flash.get_mut(&dev_id).unwrap();
+        dev.reset_bad_regions();
 
         // Disabling write verification the only assert triggered by
         // boot_go should be checking for integrity of status bytes.
-        flash.set_verify_writes(false);
+        dev.set_verify_writes(false);
     }
 
 }
 
 /// Test a boot, optionally stopping after 'n' flash options.  Returns a count
 /// of the number of flash operations done total.
-fn try_upgrade(flashmap: &SimFlashMap, images: &Images,
-               stop: Option<i32>) -> (SimFlashMap, i32) {
+fn try_upgrade(flash: &SimMultiFlash, images: &Images,
+               stop: Option<i32>) -> (SimMultiFlash, i32) {
     // Clone the flash to have a new copy.
-    let mut flashmap = flashmap.clone();
+    let mut flash = flash.clone();
 
-    mark_permanent_upgrade(&mut flashmap, &images.slots[1]);
+    mark_permanent_upgrade(&mut flash, &images.slots[1]);
 
     let mut counter = stop.unwrap_or(0);
 
-    let (first_interrupted, count) = match c::boot_go(&mut flashmap, &images.areadesc, Some(&mut counter), false) {
+    let (first_interrupted, count) = match c::boot_go(&mut flash, &images.areadesc, Some(&mut counter), false) {
         (-0x13579, _) => (true, stop.unwrap()),
         (0, _) => (false, -counter),
         (x, _) => panic!("Unknown return: {}", x),
@@ -733,94 +733,94 @@
     counter = 0;
     if first_interrupted {
         // fl.dump();
-        match c::boot_go(&mut flashmap, &images.areadesc, Some(&mut counter), false) {
+        match c::boot_go(&mut flash, &images.areadesc, Some(&mut counter), false) {
             (-0x13579, _) => panic!("Shouldn't stop again"),
             (0, _) => (),
             (x, _) => panic!("Unknown return: {}", x),
         }
     }
 
-    (flashmap, count - counter)
+    (flash, count - counter)
 }
 
-fn try_revert(flashmap: &SimFlashMap, areadesc: &AreaDesc, count: usize) -> SimFlashMap {
-    let mut flashmap = flashmap.clone();
+fn try_revert(flash: &SimMultiFlash, areadesc: &AreaDesc, count: usize) -> SimMultiFlash {
+    let mut flash = flash.clone();
 
     // fl.write_file("image0.bin").unwrap();
     for i in 0 .. count {
         info!("Running boot pass {}", i + 1);
-        assert_eq!(c::boot_go(&mut flashmap, &areadesc, None, false), (0, 0));
+        assert_eq!(c::boot_go(&mut flash, &areadesc, None, false), (0, 0));
     }
-    flashmap
+    flash
 }
 
-fn try_revert_with_fail_at(flashmap: &SimFlashMap, images: &Images,
+fn try_revert_with_fail_at(flash: &SimMultiFlash, images: &Images,
                            stop: i32) -> bool {
-    let mut flashmap = flashmap.clone();
+    let mut flash = flash.clone();
     let mut fails = 0;
 
     let mut counter = stop;
-    let (x, _) = c::boot_go(&mut flashmap, &images.areadesc, Some(&mut counter), false);
+    let (x, _) = c::boot_go(&mut flash, &images.areadesc, Some(&mut counter), false);
     if x != -0x13579 {
         warn!("Should have stopped at interruption point");
         fails += 1;
     }
 
-    if !verify_trailer(&flashmap, &images.slots, 0, None, None, BOOT_FLAG_UNSET) {
+    if !verify_trailer(&flash, &images.slots, 0, None, None, BOOT_FLAG_UNSET) {
         warn!("copy_done should be unset");
         fails += 1;
     }
 
-    let (x, _) = c::boot_go(&mut flashmap, &images.areadesc, None, false);
+    let (x, _) = c::boot_go(&mut flash, &images.areadesc, None, false);
     if x != 0 {
         warn!("Should have finished upgrade");
         fails += 1;
     }
 
-    if !verify_image(&flashmap, &images.slots, 0, &images.upgrades) {
+    if !verify_image(&flash, &images.slots, 0, &images.upgrades) {
         warn!("Image in the primary slot before revert is invalid at stop={}",
               stop);
         fails += 1;
     }
-    if !verify_image(&flashmap, &images.slots, 1, &images.primaries) {
+    if !verify_image(&flash, &images.slots, 1, &images.primaries) {
         warn!("Image in the secondary slot before revert is invalid at stop={}",
               stop);
         fails += 1;
     }
-    if !verify_trailer(&flashmap, &images.slots, 0, BOOT_MAGIC_GOOD,
+    if !verify_trailer(&flash, &images.slots, 0, BOOT_MAGIC_GOOD,
                        BOOT_FLAG_UNSET, BOOT_FLAG_SET) {
         warn!("Mismatched trailer for the primary slot before revert");
         fails += 1;
     }
-    if !verify_trailer(&flashmap, &images.slots, 1, BOOT_MAGIC_UNSET,
+    if !verify_trailer(&flash, &images.slots, 1, BOOT_MAGIC_UNSET,
                        BOOT_FLAG_UNSET, BOOT_FLAG_UNSET) {
         warn!("Mismatched trailer for the secondary slot before revert");
         fails += 1;
     }
 
     // Do Revert
-    let (x, _) = c::boot_go(&mut flashmap, &images.areadesc, None, false);
+    let (x, _) = c::boot_go(&mut flash, &images.areadesc, None, false);
     if x != 0 {
         warn!("Should have finished a revert");
         fails += 1;
     }
 
-    if !verify_image(&flashmap, &images.slots, 0, &images.primaries) {
+    if !verify_image(&flash, &images.slots, 0, &images.primaries) {
         warn!("Image in the primary slot after revert is invalid at stop={}",
               stop);
         fails += 1;
     }
-    if !verify_image(&flashmap, &images.slots, 1, &images.upgrades) {
+    if !verify_image(&flash, &images.slots, 1, &images.upgrades) {
         warn!("Image in the secondary slot after revert is invalid at stop={}",
               stop);
         fails += 1;
     }
-    if !verify_trailer(&flashmap, &images.slots, 0, BOOT_MAGIC_GOOD,
+    if !verify_trailer(&flash, &images.slots, 0, BOOT_MAGIC_GOOD,
                        BOOT_FLAG_SET, BOOT_FLAG_SET) {
         warn!("Mismatched trailer for the secondary slot after revert");
         fails += 1;
     }
-    if !verify_trailer(&flashmap, &images.slots, 1, BOOT_MAGIC_UNSET,
+    if !verify_trailer(&flash, &images.slots, 1, BOOT_MAGIC_UNSET,
                        BOOT_FLAG_UNSET, BOOT_FLAG_UNSET) {
         warn!("Mismatched trailer for the secondary slot after revert");
         fails += 1;
@@ -829,11 +829,11 @@
     fails > 0
 }
 
-fn try_random_fails(flashmap: &SimFlashMap, images: &Images,
-                    total_ops: i32,  count: usize) -> (SimFlashMap, Vec<i32>) {
-    let mut flashmap = flashmap.clone();
+fn try_random_fails(flash: &SimMultiFlash, images: &Images,
+                    total_ops: i32,  count: usize) -> (SimMultiFlash, Vec<i32>) {
+    let mut flash = flash.clone();
 
-    mark_permanent_upgrade(&mut flashmap, &images.slots[1]);
+    mark_permanent_upgrade(&mut flash, &images.slots[1]);
 
     let mut rng = rand::thread_rng();
     let mut resets = vec![0i32; count];
@@ -842,7 +842,7 @@
         let ops = Range::new(1, remaining_ops / 2);
         let reset_counter = ops.ind_sample(&mut rng);
         let mut counter = reset_counter;
-        match c::boot_go(&mut flashmap, &images.areadesc, Some(&mut counter), false) {
+        match c::boot_go(&mut flash, &images.areadesc, Some(&mut counter), false) {
             (0, _) | (-0x13579, _) => (),
             (x, _) => panic!("Unknown return: {}", x),
         }
@@ -850,13 +850,13 @@
         resets[i] = reset_counter;
     }
 
-    match c::boot_go(&mut flashmap, &images.areadesc, None, false) {
+    match c::boot_go(&mut flash, &images.areadesc, None, false) {
         (-0x13579, _) => panic!("Should not be have been interrupted!"),
         (0, _) => (),
         (x, _) => panic!("Unknown return: {}", x),
     }
 
-    (flashmap, resets)
+    (flash, resets)
 }
 
 /// Show the flash layout.
@@ -872,7 +872,7 @@
 
 /// Install a "program" into the given image.  This fakes the image header, or at least all of the
 /// fields used by the given code.  Returns a copy of the image that was written.
-fn install_image(flashmap: &mut SimFlashMap, slots: &[SlotInfo], slot: usize, len: usize,
+fn install_image(flash: &mut SimMultiFlash, slots: &[SlotInfo], slot: usize, len: usize,
                  bad_sig: bool) -> ImageData {
     let offset = slots[slot].base_off;
     let slot_len = slots[slot].len;
@@ -955,28 +955,28 @@
     // un-encrypted. In the secondary slot the image is written un-encrypted,
     // and if encryption is requested, it follows an erase + flash encrypted.
 
-    let flash = flashmap.get_mut(&dev_id).unwrap();
+    let dev = flash.get_mut(&dev_id).unwrap();
 
     if slot == 0 {
         let enc_copy: Option<Vec<u8>>;
 
         if is_encrypted {
-            flash.write(offset, &encbuf).unwrap();
+            dev.write(offset, &encbuf).unwrap();
 
             let mut enc = vec![0u8; encbuf.len()];
-            flash.read(offset, &mut enc).unwrap();
+            dev.read(offset, &mut enc).unwrap();
 
             enc_copy = Some(enc);
 
-            flash.erase(offset, slot_len).unwrap();
+            dev.erase(offset, slot_len).unwrap();
         } else {
             enc_copy = None;
         }
 
-        flash.write(offset, &buf).unwrap();
+        dev.write(offset, &buf).unwrap();
 
         let mut copy = vec![0u8; buf.len()];
-        flash.read(offset, &mut copy).unwrap();
+        dev.read(offset, &mut copy).unwrap();
 
         ImageData {
             plain: copy,
@@ -984,20 +984,20 @@
         }
     } else {
 
-        flash.write(offset, &buf).unwrap();
+        dev.write(offset, &buf).unwrap();
 
         let mut copy = vec![0u8; buf.len()];
-        flash.read(offset, &mut copy).unwrap();
+        dev.read(offset, &mut copy).unwrap();
 
         let enc_copy: Option<Vec<u8>>;
 
         if is_encrypted {
-            flash.erase(offset, slot_len).unwrap();
+            dev.erase(offset, slot_len).unwrap();
 
-            flash.write(offset, &encbuf).unwrap();
+            dev.write(offset, &encbuf).unwrap();
 
             let mut enc = vec![0u8; encbuf.len()];
-            flash.read(offset, &mut enc).unwrap();
+            dev.read(offset, &mut enc).unwrap();
 
             enc_copy = Some(enc);
         } else {
@@ -1057,7 +1057,7 @@
 }
 
 /// Verify that given image is present in the flash at the given offset.
-fn verify_image(flashmap: &SimFlashMap, slots: &[SlotInfo], slot: usize,
+fn verify_image(flash: &SimMultiFlash, slots: &[SlotInfo], slot: usize,
                 images: &ImageData) -> bool {
     let image = images.find(slot);
     let buf = image.as_slice();
@@ -1065,8 +1065,8 @@
 
     let mut copy = vec![0u8; buf.len()];
     let offset = slots[slot].base_off;
-    let flash = flashmap.get(&dev_id).unwrap();
-    flash.read(offset, &mut copy).unwrap();
+    let dev = flash.get(&dev_id).unwrap();
+    dev.read(offset, &mut copy).unwrap();
 
     if buf != &copy[..] {
         for i in 0 .. buf.len() {
@@ -1082,7 +1082,7 @@
     }
 }
 
-fn verify_trailer(flashmap: &SimFlashMap, slots: &[SlotInfo], slot: usize,
+fn verify_trailer(flash: &SimMultiFlash, slots: &[SlotInfo], slot: usize,
                   magic: Option<u8>, image_ok: Option<u8>,
                   copy_done: Option<u8>) -> bool {
     if Caps::OverwriteUpgrade.present() {
@@ -1094,9 +1094,9 @@
     let mut copy = vec![0u8; c::boot_magic_sz() + c::boot_max_align() * 2];
     let mut failed = false;
 
-    let flash = flashmap.get(&dev_id).unwrap();
-    let erased_val = flash.erased_val();
-    flash.read(offset, &mut copy).unwrap();
+    let dev = flash.get(&dev_id).unwrap();
+    let erased_val = dev.erased_val();
+    dev.read(offset, &mut copy).unwrap();
 
     failed |= match magic {
         Some(v) => {
@@ -1189,21 +1189,21 @@
 const BOOT_FLAG_UNSET: Option<u8> = Some(3);
 
 /// Write out the magic so that the loader tries doing an upgrade.
-pub fn mark_upgrade(flashmap: &mut SimFlashMap, slot: &SlotInfo) {
-    let flash = flashmap.get_mut(&slot.dev_id).unwrap();
+pub fn mark_upgrade(flash: &mut SimMultiFlash, slot: &SlotInfo) {
+    let dev = flash.get_mut(&slot.dev_id).unwrap();
     let offset = slot.trailer_off + c::boot_max_align() * 2;
-    flash.write(offset, MAGIC.unwrap()).unwrap();
+    dev.write(offset, MAGIC.unwrap()).unwrap();
 }
 
 /// Writes the image_ok flag which, guess what, tells the bootloader
 /// the this image is ok (not a test, and no revert is to be performed).
-fn mark_permanent_upgrade(flashmap: &mut SimFlashMap, slot: &SlotInfo) {
-    let flash = flashmap.get_mut(&slot.dev_id).unwrap();
-    let mut ok = [flash.erased_val(); 8];
+fn mark_permanent_upgrade(flash: &mut SimMultiFlash, slot: &SlotInfo) {
+    let dev = flash.get_mut(&slot.dev_id).unwrap();
+    let mut ok = [dev.erased_val(); 8];
     ok[0] = 1u8;
     let off = slot.trailer_off + c::boot_max_align();
-    let align = flash.align();
-    flash.write(off, &ok[..align]).unwrap();
+    let align = dev.align();
+    dev.write(off, &ok[..align]).unwrap();
 }
 
 // Drop some pseudo-random gibberish onto the data.