7

As far as i know, an assembly program is devided to two- 1)the code 2)the data. Now, when we code, say on c\c++, the code is loaded to the memory and then the CPU starts execute the code, one instruction by one, as an assembly program. My questions are: 1. where is the c code stored? I mean, when I'm running a program in Visual Studio, is the code loaded to one of them- Heap,Stack..? 2. So the memory is virtually divided to Stack,Heap and Date segment, but when the CPU executes the program, as an assembly program, are they all 1 assembly program with the same data area or they are formed in to,lets say 2 or 3 assebmly program thats jumps from one to another?

** Let me add this question, maybe it will clarify my intention: When I'm launching a C program, the code (machine instructions) is loaded to the memory. So, this is one assembly program. But how does the memory division take place? I mean, how des the different memory sections such as Stack, Data segment, etc. modify the assembly program?

trincot
  • 317,000
  • 35
  • 244
  • 286
izac89
  • 3,790
  • 7
  • 30
  • 46

2 Answers2

8

From wikipedia:

The PC architecture supports a few basic read-write memory regions in a program namely: Stack, Data and Code. The heap is another region of address space available to a program, from which memory can be dynamically allocated or freed by the operating system in response to system calls such as malloc and free.

I recommend you to read the full article

There is also this question on SO: How are the different segments like heap, stack, text related to the physical memory?

Also, these articles may be worth reading. Especially the last one:

To answer your questions:

1. where is the c code stored?

In the code segment.

2. So the memory is virtually divided to Stack, Heap and Date segment,

In real mode, yes. In protected mode… depends. To simplify extremely: program memory is mapped to physical memory. Each program lives in its own address space.

I recommend these articles if you want to know more:

3. but when the CPU executes the program, as an assembly program, are they all 1 assembly program with the same data area or they are formed in to,lets say 2 or 3 assebmly program thats jumps from one to another?

No. There are no jumps. Processor registers are pointing towards the next instruction to be executed. Others are pointing towards the stack, etc.

Community
  • 1
  • 1
Jean
  • 7,623
  • 6
  • 43
  • 58
  • Thanks but It's not exactly what I'm asking. – izac89 Apr 03 '13 at 16:47
  • @user2162550 Is the update useful to you? If no, what additional information are you seeking? To understand the basics, best is to keep to the memory mapping in real mode. Things are way more simple. – Jean Apr 03 '13 at 16:49
  • "No. There are no jumps. Processor registers are pointing towards the next instruction to be executed. Others are pointing towards the stack, etc." if there are other registers pointing to stack,etc. as you say, so there are different assembly programs, and the CPU is indeed jumps from one to another, isn't it correct? – izac89 Apr 03 '13 at 18:12
  • 1
    @user2162550 There is no jump. Assuming x86 CPU: from the CPU point of view, there are instructions to be executed. The CPU has registers to point towards the next instruction to be executed (IP), registers to point towards the stack (BP, SP). The CPU uses these registers to get the flow of instruction and to put informations on the stack at each *call* or *return* instructions. Please, see [this article](http://en.wikipedia.org/wiki/X86_assembly_language) especially the parts called **Registers** and **Segmented addressing**. Which CPU are you interested in? x86? ARM? PPC? etc… – Jean Apr 03 '13 at 20:27
  • 1
    Also, on some CPUs, the memory model used is that of segment:offset. But that's just a way of dealing with memory. The CPU doesn't actually jump from the stack to the code segment to the stack again. It loads instructions pointed by its instruction pointer from their memory location, adds data to the stack (pointed by other registers) when requires (for a call, when you push registers, etc.) or removes them (pop, etc…). A jump occurs when the CPU encounters specific instructions (jump family or call family). – Jean Apr 03 '13 at 20:36
7

The segments or sections are contiguous divisions in object and executable files, much like chapters in a book. The stack and bss sections do not exist in the file but are created at runtime.

The point of the sections is mostly to divide the program into areas that the operating system can protect in different ways. In order to arrange for that, the sections must start on page boundaries and be contiguous in memory.

The basic ("important") sections are...

text or code - the OS will write-protect this section, and since it's immutable, it can also share it between multiple processes or threads running the same executable

data - the OS will map this r/w and won't directly1 share it

bss - this section consists of zero-initialized data.

stack - typically separated from the program, it generally grows downward from higher addresses

The last two sections aren't in the executable file because they don't need any intiialization.

If you are asking about how they are implemented, well, the assembler and linker create a table-of-contents and write out the sections in binary like chapters in a book. The OS then reads them separately and puts them in different sections of the address space.

The specifics and the terminology are different between Unix-like systems and Windows, but the principles are the same.

1. Yeah yeah, copy-on-write allows for sharing data too, kind of.
DigitalRoss
  • 143,651
  • 25
  • 248
  • 329