Electrical Engineering Stack Exchange is a question and answer site for electronics and electrical engineering professionals, students, and enthusiasts. It only takes a minute to sign up.
Sign up to join this community
Most of the ARM Cortex-M core based MCUs have Harvard architecture (except for Cortex-M0 and M0+.)
The thing I do not understand is that why we see only one memory address space. For example, in tge STM32F4 we see only a unified memory address space:
If ARM Cortex-M based MCUs have Harvard architecture (in most cases,) why do we not see two separate memory address spaces - one for data and one for code instructions - instead of one?
When you pick a STM32F4 chip at random and look at the datasheet, in section 2.2 we see a block diagram of the chip.
We see that the CPU has three (!) buses - labeled I-BUS, D-BUS and S-BUS. All of them go to the "AHB bus matrix" and the D-BUS also goes to some "CCM data RAM".
I searched for "Cortex-M4 S-bus" and found this page from ARM describing the buses which describes the difference between the buses: For addresses lower than 0x20000000, the D-Bus is used for data access and the I-Bus is used for instruction accesses. For addresses 0x20000000 or higher, the S-Bus is used for both instruction and data accesses.
So the processor acts as a Harvard architecture below 0x20000000 and von Neumann above that.
However, if we go back to the chip datasheet, in section 2.2.7 (after the page break) we see a diagram of the AHB bus matrix which interconnects the different buses to different memory components on the chip. We see that the I-Bus and D-Bus have access to the same memory components: Flash memory (via ACCEL), SRAM1, and FSMC Static MemCtl. So by taking a Harvard architecture and then connecting the I and D buses to the same memory, we turn it into what may as well be called a von Neumann architecture. We can assume that each memory region has the same address on all buses where it can be accessed, because otherwise the datasheet would say otherwise. It's convenient that each piece of memory only has one address. It would be possible to connect the processor so that the instruction at 0x00000000 is different from the data at 0x00000000, but the designers of the STM32F405xx did not do that.
There is a slight difference: the "data CCM" memory cannot be used for instructions as it's only attached to the D-bus. Your memory map does not show "data CCM" below 0x20000000 so I guess on your chip this difference does not exist. However there may be other differences between the I-bus and D-bus.
The ARM Cortex parts are advertised as "Harvard Architecture", but they're really modified Harvard architecture.
Specifically, they use separate data and instruction caches, and (if I recall correctly) some memory areas are restricted from being used as instruction memory. But the entire memory space is available as data, even while at least some of it is available as instructions.
Most machines today that call themselves "Harvard Architecture" don't have fully separate memory spaces, and are thus some form of modified Harvard.
Many programs need the ability to use hard-coded constants within them. For example, to perform an operation like "x=12345" (in just about any common language), one needs a means of getting the number 12345 into a register. There are at least four approaches by which this may be accomplished:
Some architectures like older versions of the PIC have instructions which are larger than the largest immediate value one might want to load, and thus allow any desired values to be included as part of the instruction without needing any means to treat the code space as data.
Some architectures like MIPS and some newer ARM variants have instructions that can load half of a register, and which can be used along with a following "OR immediate" to load the other half, again without needing any means to treat the code space as data.
Some architectures like older versions of the ARM include an instruction to fetch an arbitrary value from an address which is near the currently-executing code. While the ARM has facilities to express some numbers as immediate constants, code which needs to use larger values would be expected to have the required numbers placed in code space near the code that needs them, so they can be fetched with the "load nearby value" instruction. This approach requires the ability to treat code and data space interchangeably.
It would be possible for an architecture to use constants stored at some read-only or pre-initialized area of the data space. This approach would not require the ability to treat code and data space interchangeably, but if applied to a microcontroller might require having a hard-wired partition between code and data storage (e.g. 12K of code and 4K of data). I don't know of any current designs that use such an approach, but would not be surprised if some early computers did this. If an instruction set included an instruction to load a value from a designated one of the first 1024 locations, a compiler and linker could arrange things so that if two compilation units both needed the value 0x08675309, it would only need to be stored once within that table. Architectures which expect constants to be stored near code blocks may be able to accommodate a larger total number of different constants, but would require that constants which are used by different functions be duplicated in every function where they are used.
While most of these approaches would work just fine with unrelated code and data address spaces, the ARM was designed approach #3 which requires the ability to place and load arbitrary constants at addresses which are located among the addressed where code will be placed and executed.
