# pyOCD debugger # Copyright (c) 2016-2019 Arm Limited # Copyright (c) 2021 Chris Reed # SPDX-License-Identifier: Apache-2.0 # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from os import stat_result import pytest import copy import collections.abc from pathlib import Path from pyocd.core.memory_map import ( MemoryType, check_range, MemoryRange, MemoryRegion, MemoryMap, FlashRegion, RomRegion, RamRegion, DeviceRegion, DefaultFlashWeights ) DATA_PATH = Path(__file__).resolve().parents[1] / "data" FLM_PATH = DATA_PATH / "packs" / "nrf53xx_application.flm" @pytest.fixture(scope='function') def flash(): return FlashRegion(start=0, length=1*1024, blocksize=0x100, name='flash', is_boot_memory=True) @pytest.fixture(scope='function') def flash_with_flm(): return FlashRegion(start=0, length=1*1024, blocksize=0x100, name='flash', is_boot_memory=True, flm=FLM_PATH) @pytest.fixture(scope='function') def rom(): return RomRegion(start=0x1c000000, length=16*1024, name='rom') @pytest.fixture(scope='function') def ram1(): return RamRegion(start=0x20000000, length=1*1024, name='ram', is_default=False) @pytest.fixture(scope='function') def ram2(): return RamRegion(start=0x20000400, length=1*1024, name='ram2', is_cacheable=False) @pytest.fixture(scope='function') def ram_alias(): return RamRegion(start=0x30000400, length=1*1024, name='ram2_alias', alias='ram2', is_cacheable=False) @pytest.fixture(scope='function') def memmap(flash, rom, ram1, ram2): return MemoryMap(flash, rom, ram1, ram2) @pytest.fixture(scope='function') def memmap2(flash, rom, ram1, ram2, ram_alias): return MemoryMap(flash, rom, ram1, ram2, ram_alias) class TestCheckRange: def test_1(self): assert check_range(0, end=0x1ff) == (0, 0x1ff) def test_2(self): assert check_range(0, length=0x200) == (0, 0x1ff) def test_3(self): with pytest.raises(AssertionError): check_range(None, end=100) def test_4(self): with pytest.raises(AssertionError): check_range(0x100, end=None) def test_5(self): with pytest.raises(AssertionError): check_range(0x100, length=None) class TestRange: def test_empty_range_1(self): range = MemoryRange(start=0x1000, length=0) assert range.start == 0x1000 assert range.end == 0xfff assert range.length == 0 def test_empty_range_2(self): range = MemoryRange(start=0x1000, end=0xfff) assert range.start == 0x1000 assert range.end == 0xfff assert range.length == 0 def test_eq(self): assert MemoryRange(0, length=1000) == MemoryRange(0, length=1000) def test_lt(self): assert MemoryRange(0, length=1000) < MemoryRange(1000, length=1000) def test_gt(self): assert MemoryRange(1000, length=1000) > MemoryRange(0, length=1000) def test_sort(self, ram1, ram2, flash, rom): regionList = [ram2, rom, flash, ram1] sortedRegionList = sorted(regionList) assert sortedRegionList == [flash, rom, ram1, ram2] def test_inplace_sort(self, ram1, ram2, flash, rom): regionList = [ram2, rom, flash, ram1] regionList.sort() assert regionList == [flash, rom, ram1, ram2] def test_split_addr_empty(self, flash): assert list(flash.iter_split_by_address([])) == [MemoryRange(0, 1023)] def test_split_addr_1(self, flash): assert list(flash.iter_split_by_address([500])) == [MemoryRange(0, 499), MemoryRange(500, 1023)] def test_split_addr_2(self, flash): assert list(flash.iter_split_by_address([500, 900])) == \ [MemoryRange(0, 499), MemoryRange(500, 899), MemoryRange(900, 1023)] def test_split_addr_2_start(self, flash): assert list(flash.iter_split_by_address([0, 900])) == [MemoryRange(0, 899), MemoryRange(900, 1023)] def test_split_addr_2_end(self, flash): assert list(flash.iter_split_by_address([700, 1023])) == \ [MemoryRange(0, 699), MemoryRange(700, 1022), MemoryRange(1023, 1023)] def test_split_addr_1_out_of_bounds(self, flash): assert list(flash.iter_split_by_address([722, 72742])) == \ [MemoryRange(0, 721), MemoryRange(722, 1023)] def test_split_range(self, flash): assert list(flash.iter_split_by_range(MemoryRange(500, 699))) == \ [MemoryRange(0, 499), MemoryRange(500, 699), MemoryRange(700, 1023)] def test_split_range_out_of_bounds(self, flash): assert list(flash.iter_split_by_range(MemoryRange(9000, length=10))) == [MemoryRange(0, 1023)] def test_split_range_start(self, flash): assert list(flash.iter_split_by_range(MemoryRange(0, length=128))) == \ [MemoryRange(0, 127), MemoryRange(128, 1023)] def test_split_range_start_overlap(self): assert list(MemoryRange(1024, 2047).iter_split_by_range(MemoryRange(768, 1199))) == \ [MemoryRange(1024, 1199), MemoryRange(1200, 2047)] def test_split_range_end(self, flash): assert list(flash.iter_split_by_range(MemoryRange(768, 1023))) == \ [MemoryRange(0, 767), MemoryRange(768, 1023)] def test_split_range_end_overlap(self): assert list(MemoryRange(1024, 2047).iter_split_by_range(MemoryRange(2000, length=8000))) == \ [MemoryRange(1024, 1999), MemoryRange(2000, 2047)] class TestHash: def test_range_neq(self): a = MemoryRange(0, 0x1000) b = MemoryRange(10, 20) assert hash(a) != hash(b) def test_range_eq(self): a = MemoryRange(0, 0x1000) b = MemoryRange(0, 0x1000) assert hash(a) == hash(b) def test_range_w_region_neq(self, ram1, rom): a = MemoryRange(0, 0x1000, region=ram1) b = MemoryRange(0x5000, length=200, region=rom) assert hash(a) != hash(b) a = MemoryRange(0, 0x1000, region=ram1) b = MemoryRange(0, 0x1000, region=rom) assert hash(a) != hash(b) def test_range_eq_with_names(self, ram1): a = MemoryRange(0, 0x1000, region=ram1) b = MemoryRange(0, 0x1000, region=ram1) assert hash(a) == hash(b) # MemoryRegion test cases. class TestMemoryRegion: def test_empty_region_1(self): with pytest.raises(AssertionError): rgn = MemoryRegion(start=0x1000, length=0) def test_empty_region_2(self): with pytest.raises(AssertionError): rgn = MemoryRegion(start=0x1000, end=0xfff) def test_default_name(self): rgn = RamRegion(start=0x1000, end=0x1fff) assert rgn.name == 'ram' rgn = RomRegion(start=0x1000, end=0x1fff) assert rgn.name == 'rom' rgn = FlashRegion(start=0x1000, end=0x1fff, blocksize=256) assert rgn.name == 'flash' rgn = DeviceRegion(start=0x1000, end=0x1fff) assert rgn.name == 'device' def test_block_sector_size(self): rgn = FlashRegion(start=0x1000, end=0x1fff, blocksize=256) assert rgn.blocksize == 256 assert rgn.sector_size == 256 rgn = FlashRegion(start=0x1000, end=0x1fff, sector_size=256) assert rgn.blocksize == 256 assert rgn.sector_size == 256 def test_flash_attrs(self, flash): assert flash.type == MemoryType.FLASH assert flash.start == 0 assert flash.end == 0x3ff assert flash.length == 0x400 assert flash.blocksize == 0x100 assert flash.page_size == 0x100 assert flash.phrase_size == 0x100 assert flash.erase_all_weight == DefaultFlashWeights.ERASE_ALL_WEIGHT assert flash.erase_sector_weight == DefaultFlashWeights.ERASE_SECTOR_WEIGHT assert flash.program_page_weight == DefaultFlashWeights.PROGRAM_PAGE_WEIGHT assert flash.name == 'flash' assert flash.is_flash assert not flash.is_ram assert not flash.is_rom assert flash.is_boot_memory assert flash.is_cacheable assert flash.is_powered_on_boot assert flash.is_readable assert not flash.is_writable assert flash.is_executable def test_custom_flash_attrs(self): flash = FlashRegion(start=0x01000000, length=4*1024, blocksize=0x800, name='myflash', is_boot_memory=False, page_size=256, phrase_size=4, erase_all_weight=1.2, erase_sector_weight=0.1, program_page_weight=0.25) assert flash.type == MemoryType.FLASH assert flash.start == 0x01000000 assert flash.end == 0x01000fff assert flash.length == 0x1000 assert flash.blocksize == 0x800 assert flash.page_size == 256 assert flash.phrase_size == 4 assert flash.erase_all_weight == 1.2 assert flash.erase_sector_weight == 0.1 assert flash.program_page_weight == 0.25 assert flash.name == 'myflash' assert flash.is_flash assert not flash.is_ram assert not flash.is_rom assert not flash.is_boot_memory assert flash.is_cacheable assert flash.is_powered_on_boot assert flash.is_readable assert not flash.is_writable assert flash.is_executable def test_rom_attrs(self, rom): assert rom.type == MemoryType.ROM assert rom.start == 0x1c000000 assert rom.end == 0x1c003fff assert rom.length == 0x4000 with pytest.raises(AttributeError): rom.blocksize assert rom.name == 'rom' assert not rom.is_flash assert not rom.is_ram assert rom.is_rom assert not rom.is_boot_memory assert rom.is_cacheable assert rom.is_powered_on_boot assert rom.is_readable assert not rom.is_writable assert rom.is_executable def test_ram1_attrs(self, ram1): assert ram1.type == MemoryType.RAM assert ram1.start == 0x20000000 assert ram1.end == 0x200003ff assert ram1.length == 0x400 with pytest.raises(AttributeError): ram1.blocksize assert ram1.name == 'ram' assert not ram1.is_flash assert ram1.is_ram assert not ram1.is_rom assert not ram1.is_boot_memory assert ram1.is_cacheable assert ram1.is_powered_on_boot assert ram1.is_readable assert ram1.is_writable assert ram1.is_executable def test_ram2_attrs(self, ram2): assert ram2.type == MemoryType.RAM assert ram2.start == 0x20000400 assert ram2.end == 0x200007ff assert ram2.length == 0x400 with pytest.raises(AttributeError): ram2.blocksize assert ram2.name == 'ram2' assert not ram2.is_flash assert ram2.is_ram assert not ram2.is_rom assert not ram2.is_boot_memory assert not ram2.is_cacheable assert ram2.is_powered_on_boot assert ram2.is_readable assert ram2.is_writable assert ram2.is_executable def test_flash_range(self, flash): assert flash.contains_address(0) assert flash.contains_address(0x3ff) assert not flash.contains_address(0x400) assert flash.contains_range(0, length=0x400) assert flash.contains_range(0, end=0x3ff) assert flash.contains_range(0x100, length=0x100) assert not flash.contains_range(0x300, end=0x720) assert flash.intersects_range(0, length=0x100) assert flash.intersects_range(0x300, end=0x720) def test_intersects(self, ram1): assert not ram1.intersects_range(0, length=10) assert not ram1.intersects_range(0xf0000000, end=0xffffffff) assert ram1.intersects_range(0x100000, end=0x20000010) assert ram1.intersects_range(0x20000010, end=0x30000000) assert ram1.intersects_range(0x20000040, length=0x1000) assert ram1.intersects_range(0x20000020, end=0x20000030) assert ram1.intersects_range(0x20000020, length=0x10) assert ram1.intersects_range(0x1fff0000, end=0x20001000) assert ram1.intersects_range(0x1ffff000, length=0x40000) def test_copy_ram(self, ram1): ramcpy = copy.copy(ram1) assert ramcpy.type == ram1.type assert ramcpy.start == ram1.start assert ramcpy.end == ram1.end assert ramcpy.length == ram1.length assert ramcpy.name == ram1.name assert ramcpy == ram1 def test_copy_flash(self, flash): flashcpy = copy.copy(flash) assert flashcpy == flash def test_copy_flash_with_flm(self, flash_with_flm): flashcpy = copy.copy(flash_with_flm) assert flashcpy == flash_with_flm def test_copy_flash_with_assigned_flm(self, flash): flash.flm = FLM_PATH flashcpy = copy.copy(flash) assert flashcpy == flash def test_clone_with_changes(self, flash, ram1): flashcpy = flash.clone_with_changes(name='another flash') assert flashcpy.name == 'another flash' assert flashcpy.start == flash.start assert flashcpy.length == flash.length acopy = ram1.clone_with_changes(start=0x30000000, is_cacheable=False) assert acopy.name == 'ram' assert acopy.start == 0x30000000 assert acopy.length == ram1.length assert acopy.end == 0x30000000 + ram1.length - 1 def test_eq(self, flash, ram1): assert flash != ram1 a = RamRegion(name='a', start=0x1000, length=0x2000) b = RamRegion(name='a', start=0x1000, length=0x2000) assert a == b def test_set_attr(self, flash): flash.is_boot_memory = True # MemoryMap test cases. class TestMemoryMap: def test_empty_map(self): memmap = MemoryMap() assert memmap.region_count == 0 assert memmap.regions == [] assert memmap.get_boot_memory() is None assert memmap.get_region_for_address(0x1000) is None assert not memmap.is_valid_address(0x2000) assert memmap.get_contained_regions(0, end=0xffffffff) == [] assert memmap.get_intersecting_regions(0, end=0xffffffff) == [] def test_regions(self, memmap): rgns = memmap.regions # Count assert len(rgns) == 4 assert memmap.region_count == 4 # Sorted order assert rgns[0].start < rgns[1].start and rgns[1].start < rgns[2].start and rgns[2].start < rgns[3].start def test_boot_mem(self, memmap): bootmem = memmap.get_boot_memory() assert bootmem is not None assert bootmem.name == 'flash' assert bootmem.start == 0 assert bootmem.end == 0x3ff assert bootmem.is_boot_memory == True def test_rgn_for_addr(self, memmap): assert memmap.get_region_for_address(0).name == 'flash' assert memmap.get_region_for_address(0x20000000).name == 'ram' assert memmap.get_region_for_address(0x20000500).name == 'ram2' def test_valid(self, memmap): assert memmap.is_valid_address(0) assert memmap.is_valid_address(0x200) assert memmap.is_valid_address(0x3ff) assert not memmap.is_valid_address(0x400) assert not memmap.is_valid_address(0x1bffffff) assert memmap.is_valid_address(0x1c000000) assert not memmap.is_valid_address(0x1fffffff) assert memmap.is_valid_address(0x20000000) assert memmap.is_valid_address(0x20000001) assert memmap.is_valid_address(0x200003ff) assert memmap.is_valid_address(0x20000400) assert memmap.is_valid_address(0x200007ff) assert not memmap.is_valid_address(0x20000800) def test_contained_1(self, memmap): rgns = memmap.get_contained_regions(0, 0x100) assert len(rgns) == 0 def test_contained_2(self, memmap): rgns = memmap.get_contained_regions(0x20000000, 0x20000600) assert len(rgns) == 1 def test_intersect_1(self, memmap): rgns = memmap.get_intersecting_regions(0, 0x100) assert len(rgns) == 1 def test_intersect_2(self, memmap): rgns = memmap.get_intersecting_regions(0x20000200, end=0x20000700) assert len(rgns) == 2 def test_x(self): ramrgn = RamRegion(name='core0 ram', start=0x1fffa000, length=0x18000) assert ramrgn.contains_range(0x1fffc9f8, end=0x1fffc9fc) assert ramrgn.intersects_range(0x1fffc9f8, end=0x1fffc9fc) dualMap = MemoryMap( FlashRegion(name='flash', start=0, length=0x80000, blocksize=0x800, is_boot_memory=True), RomRegion(name='core1 imem alias', start=0x1d200000, length=0x40000), ramrgn, RomRegion(name='core1 imem', start=0x2d200000, length=0x40000), RamRegion(name='core1 dmem', start=0x2d300000, length=0x8000), RamRegion(name='usb ram', start=0x40100000, length=0x800) ) rgns = dualMap.get_intersecting_regions(0x1fffc9f8, end=0x1fffc9fc) assert len(rgns) > 0 def test_get_type_iter(self, memmap, flash, rom, ram1, ram2): assert list(memmap.iter_matching_regions(type=MemoryType.FLASH)) == [flash] assert list(memmap.iter_matching_regions(type=MemoryType.ROM)) == [rom] assert list(memmap.iter_matching_regions(type=MemoryType.RAM)) == [ram1, ram2] def test_match_iter(self, memmap, flash, ram1, ram2, ram_alias): assert list(memmap.iter_matching_regions(blocksize=0x100)) == [flash] assert list(memmap.iter_matching_regions(start=0x20000000)) == [ram1] def test_first_match(self, memmap, flash, ram2): assert memmap.get_first_matching_region(blocksize=0x100) == flash assert memmap.get_first_matching_region(length=1024, is_cacheable=False) == ram2 def test_alias(self, memmap2, ram2, ram_alias): assert ram_alias.alias is ram2 def test_get_default(self, memmap, flash, ram2): assert memmap.get_default_region_of_type(MemoryType.FLASH) == flash assert memmap.get_default_region_of_type(MemoryType.RAM) == ram2 def test_index_by_num(self, memmap, flash, ram2): assert memmap[0] == flash assert memmap[3] == ram2 def test_index_by_name(self, memmap, rom, ram2): assert memmap['rom'] == rom assert memmap['ram2'] == ram2 def test_clone(self, memmap): mapcpy = memmap.clone() assert id(mapcpy) != id(memmap) assert id(mapcpy.get_first_matching_region(type=MemoryType.RAM)) != \ id(memmap.get_first_matching_region(type=MemoryType.RAM)) assert mapcpy == memmap def test_contains_int(self, memmap): assert 0x200 in memmap assert 0x20000100 in memmap assert 0x20000614 in memmap assert 0x1c000040 in memmap assert 0x80000000 not in memmap assert 0xffffffff not in memmap def test_contains_name(self, memmap): assert 'rom' in memmap assert 'flash' in memmap assert 'funky' not in memmap assert '' not in memmap def test_contains_region(self, memmap, flash): assert flash in memmap def test_len(self, memmap): assert len(memmap) == 4 def test_iter(self, memmap): assert [r.name for r in memmap] == ['flash', 'rom', 'ram', 'ram2'] def test_reversed(self, memmap): assert [r.name for r in reversed(memmap)] == ['ram2', 'ram', 'rom', 'flash'] def test_abc(self): assert isinstance(MemoryMap(), collections.abc.Sequence) def test_name_uniquing(self, memmap): memmap.add_region(RomRegion(0x01000000, length=0x8000, name="rom")) assert memmap.get_first_matching_region(name="rom_1").start == 0x01000000 def test_multiple_unnamed_regions(self): map = MemoryMap(RomRegion(0x01000000, length=0x8000), RamRegion(0x20000000, length=0x8000)) assert len(map) == 2