Thread: How do we know the memory arrangement using in microprocessors? Top-Bottom,Bottom-Top

Hi folks,

This question is a little deep into memory management of microprocessor.

How do we know the memory arrangement using in microprocessors? Top-Bottom or Bottom-Top?
For example, the "Top-Bottom" is arranging memory resource from higher address to lower address.

If we have no hardware knowledge of microprocessors, how can we know the arrangement of microprocessors?

I have idea which is declearing an array and check the addresses of array elements because the allocation of array elements is sequential. And, then, we know how memory resource is arranged.

BUT, is there any other way to find out?

Code:

// My complier is gcc v4.1.1

#include <stdio.h>

int main (void)
{
    char var[10];
    int i;
    for ( i = 0; i < 10; i++)
        printf("addr = %X\n", &var[i]);
    
    return 0;
}

// Bottom-Top arrangement:
// Result:
$ ./addr
addr = BF9CEF66
addr = BF9CEF67
addr = BF9CEF68
addr = BF9CEF69
addr = BF9CEF6A
addr = BF9CEF6B
addr = BF9CEF6C
addr = BF9CEF6D
addr = BF9CEF6E
addr = BF9CEF6F
$

Sorry, it's not about how to print the addresses. Thank you.

How to find out the memory arrangement in microprocessors or in its MMU using only software techniques?

Cuthbert

Sorry, my way is meaningless. The address of array elements is always increased along indexes.
Maybe different dynamic objects can reflect the real order of memory allocation. I guass.

Cuthbert

Originally Posted by cuthbert

Hi folks,

This question is a little deep into memory management of microprocessor.

How do we know the memory arrangement using in microprocessors? Top-Bottom or Bottom-Top?
For example, the "Top-Bottom" is arranging memory resource from higher address to lower address.

If we have no hardware knowledge of microprocessors, how can we know the arrangement of microprocessors?

I have idea which is declearing an array and check the addresses of array elements because the allocation of array elements is sequential. And, then, we know how memory resource is arranged.

BUT, is there any other way to find out?

Code:

// My complier is gcc v4.1.1

#include <stdio.h>

int main (void)
{
    char var[10];
    int i;
    for ( i = 0; i < 10; i++)
        printf("addr = %X\n", &var[i]);
    
    return 0;
}

// Bottom-Top arrangement:
// Result:
$ ./addr
addr = BF9CEF66
addr = BF9CEF67
addr = BF9CEF68
addr = BF9CEF69
addr = BF9CEF6A
addr = BF9CEF6B
addr = BF9CEF6C
addr = BF9CEF6D
addr = BF9CEF6E
addr = BF9CEF6F
$

If you know the processor you can get the manual which describes the instruction set and how the processor works, so you can see what a 'push' statement does, for example for an intel chip:-
ftp://download.intel.com/design/Pent...s/25366520.pdf
"When an item is pushed onto the stack, the processor decrements the ESP register, then writes the item at the new top of stack."
However what happens depends on how the compiler is actually written, although there may be 'standard' ways of writing compilers, not everyone sticks to the standards!!
Anyway it seems like your data was created on the heap, which I think is normal a bottom to top 'thing'. (By the way if you are in a chat room and if someone asks you if you are a top or bottom it's probably a good time to leave )
Anyway, it depends upon what you mean to a certain extent, for example, you might think
from your experiment that in the following code that the address of var2[0] would be higher
than var[9]

Code:

char var[10];
char var2[10];

However in the following code:-

Code:

int main (void)
{
    char var[10];
    char var2[10];
    int i;
    for ( i = 0; i < 10; i++)
        printf("addr = %X\n", &var[i]);
		
     for ( i = 0; i < 10; i++)
        printf("addr = %X\n", &var2[i]);
    
    return 0;
}

However it is not (well not on my setup anyway) as the results show:-
===========
addr = 8FF42
addr = 8FF43
addr = 8FF44
addr = 8FF45
addr = 8FF46
addr = 8FF47
addr = 8FF48
addr = 8FF49
addr = 8FF4A
addr = 8FF4B
addr = 8FF38
addr = 8FF39
addr = 8FF3A
addr = 8FF3B
addr = 8FF3C
addr = 8FF3D
addr = 8FF3E
addr = 8FF3F
addr = 8FF40
addr = 8FF41
===========

So it seems they are created on the stack, but prehaps not as I expected!!

I remember at one time in work we had a program which was 'ported' to several different machines (processors), it failed to run on one (a RISC machine, I believe) because it managed it's memory 'upside down' which cause a minor bug to overwrite a critical piece of data, rather
then the non-critical data it overwrote on the other machines. However if you code is bug free you don't have to worry to much about such things!!
So...you probably need to know how the processor and the compiler works to be sure!

Unless you are coding in asm or directly using EBP and ESP in C code, which you shouldn't be, I don't see why this entire thread has any relevance.

Your compiler will handle the stack and I wouldn't recommend fiddling with it unless you have good reason to - which most people don't when they do.

I think it's like owning a car. Some people just want to drive it. Some people want to know what's under the hood. To be honest, that's a very peculiar quote coming from you Bubba

This thread makes no sense and at the very least does not belong on this particular board b/c it has nothing to do with C and everything to do with CPU and architecture. Maybe that's why it struck me as irrelevant barring the fact that there is no way to tell unless you read the processor's manual.

But for the heck of it the Intel tech ref will tell you all you need to know about AMD/Intel CPUs. AFAI remember they can grow either way. I do believe the FPU stack grows down. But I could be wrong since it's been ages since I've messed with it.