When do memory addresses get assigned?

Question

Consider the following CPU instruction which takes the memory at address 16777386 (decimal) and stores it in Register 1:

Move &0x010000AA, R1

Traditionally programs are translated to assembly (machine code) at compile time. (Let's ignore more complex modern systems like jitting).

However, if this address allocation is completed statically at compile time, how does the OS ensure that two processes do not use the same memory? (eg if you ran the same compiled program twice concurrently).

Question:

How, and when, does a program get its memory addresses assigned?

Virtual Memory:

I understand most (if not all) modern systems use Memory Management Units in hardware to allow for the use of virtual memory. The first few octets of an address space being used to reference which page. This would allow for memory protection if each process used different pages. However, if this is how memory protection is enforced, the original question still persists, only this time with how page numbers are assigned?

EDIT:

CPU:

One possibility is the CPU can handle memory protection by enforcing that a process id be assigned by the OS before executing memory based instructions. However, this is only speculation, and requires support in hardware by the CPU architecture, something I'm not sure RISC ISAs would be designed to do.

Answer 1

With virtual memory each process has separate address space, so 0x010000AA in one process will refer to different value than in another process.

Address spaces are implemented with kernel-controlled page tables that processor uses to translate virtual page addresses to physical ones. Having two processes using the same address page number is not an issue, since the processes have separate page tables and physical memory mapped can be different.

Usually executable code and global variables will be mapped statically, stack will be mapped at random address (some exploits are more difficult that way) and dynamic allocation routines will use syscalls to map more pages.

Answer 2

(ignoring the Unix fork) The initial state of a processes memory is set up by the executable loader. The linker defines the initial memory state and the loader creates it. That state usually includes memory to static data, executable code, writeable data, and the stack.

In most systems a process can modify the address space by adding pages (possibly removing them as well).

[Ignoring system addresses] In virtual (logical) memory systems each process has an address space starting at zero (usually the first page is not mapped). The address space is divided into pages. The operating system maps (and remaps) logical pages to physical pages.

Address 0x010000AA in one process is then a difference physical memory address in each process.