Re: Global versus Stack variables

Hi,


>As John said, it depends on your language and your compiler. But in
>C-like languages on modern CPU's (with modern compilers), local
>variables tend to be register allocated (unless their address is
>taken) where global variables are memory allocated. This means that
>access to gobal variables usually require a memory reference, though a
>function can sometimes make a temporary copy in a register and use
>this for several accesses. It must write back before returning,
>calling another function or accessing a variable that might be aliased
>with the global variable.


I feel that accessing both local and global variables requires some memory
access, but it again depends on the architecture and complier.


Kindly consider the following code


#include "stdio.h"


int i = 10;


int main() {
                i = i + 75;
                return i;
}


Now consider the assembly corresponding to it (Turbo compiler)


__DATA segment word public 'DATA'
_i label word
                dw 10
_DATA ends
_TEXT segment byte public 'CODE'
; ?debug L 5
_main proc near
; ?debug L 6
                mov ax,word ptr DGROUP:_i #<---- Here we can see that some memory
access to data segment is made initially
                add ax,75
                mov word ptr DGROUP:_i,ax
; ?debug L 7
                mov ax,word ptr DGROUP:_i
                jmp short @1
@1:
; ?debug L 8
                ret
_main endp
_TEXT ends


Similarly consider following code snippet


#include "stdio.h"


int main() {
                int i = 10;
                i = i + 75;
                return i;
}


Consider the assembly corresponding to it (Turbo compiler)


_TEXT segment byte public 'CODE
; ?debug L 3
_main proc near
              push si#<--- Here we directly allocate the register to the
corresponding local (i).
; ?debug L 4
              mov si,10
; ?debug L 5
              mov ax,si
              add ax,75
              mov si,ax
; ?debug L 6
              mov ax,si
              jmp short @1
@1:
; ?debug L 7
              pop si
              ret
_main endp
_TEXT ends


But when the number of locals are more for eg. Consider the following code
snippet


#include "stdio.h"


int main() {
                int i = 10,j=6,k=6,l=5
                i = i + j + k + l;
                return i;
}


Consider its assembly


_TEXT segment byte public 'CODE'
; ?debug L 3
_main proc near
                push bp
                mov bp,sp
                sub sp,4
                push si
                push di
; ?debug L 4
                mov si,10 #<--- i and j are allocated registers
                mov di,6
                mov word ptr [bp-4],6 #<----- k and l are accessed from stack.
                mov word ptr [bp-2],5
; ?debug L 5
                mov ax,si
                add ax,di
                add ax,word ptr [bp-4]
                add ax,word ptr [bp-2]
                mov si,ax
; ?debug L 6
                mov ax,si
                jmp short @1
@1:
; ?debug L 7
                pop di
                pop si
                mov sp,bp
                pop bp
                ret
_main endp
_TEXT ends




Thus if the architecture does not have large number of GPRs (general purpose
registers)
then the locals are assigned the correct offset in the activation record and
when the activation record is pushed onto the stack then access to these
locals are made by using the base (frame pointer) + offset mechanism thus
memory access is made.




Thanks and Best Regards,
 
Jatin Bhateja
Subject Matter Expert

Return to the comp.compilers page.
Search the comp.compilers archives again.