OSDev.org

VolTeK wrote:Question is, do you use the stack for variables in assembler? What calling convention do you use? Do you think its useless to, and why?

iansjack wrote:There should only be one copy of a true global variable (otherwise it wouldn't be global). An example would be currentProcess or nextFreePhysicalPage. All programs need to see the same version and value of this when they access it (via the kernel). These would be stored in fixed locations in kernel memory. Some may be more indirectly stored, as part of a linked list for example, but still not on the stack.

Local variables may have the same name, but different values, for different processes. Examples would be currentDirectory or nextFreeMemoryOnHeap. These could be stored in memory that is unique to the process; in a reasonably sophisticated OS processes won't be able to see the memory belonging to other processes. Alternatively, they may be stored as part of the process structure in the process table and only accessed via the kernel.

Some variables are global to a particular process, but may not exist in other processes; for example currentLineNumber in an editor. These are best stored in the private memory of the process. Several instances of the variable may exist at the same time in the system, but only one will exist for a particular process.

Variables stored on the stack are only really useful as variables local to a particular function. Else it becomes difficult to keep track of their position. Storage in a fixed memory location is not appropriate here because functions may be called recursively or, in a multi-threaded system, different instances of the function may be active at the same time. Thus there is a need to allow several instances of the same variable within a process.

VolTeK wrote:My system core is called by many programs running at once, since the variables i have now are global (physically part of the program) their content can be modified many times a second, by multiple programs calling just the one. There is many instances of the core function (open in every process that called it) but they all act off one piece of code, one set of variables but a stack for each program.

If the core function puts its variables on the stack, and there is multiple stacks (one per program) there is multiple versions of variables, off one set of code.

VolTeK wrote:Question is, do you use the stack for variables in assembler? What calling convention do you use? Do you think its useless to, and why?

VolTeK wrote:I don't give a $hit.

VolTeK wrote:I really don't know how much more straight forward i need to be with you kids.

For a while i had been playing with having my variables put onto the stack,

Since i'm multitasking in real mode, very soon ill need my core components to run on the stack since their values are in one place rather then one per program.

Question is, do you use the stack for variables in assembler? What calling convention do you use? Do you think its useless to, and why?

VolTeK wrote:Question is, do you use the stack for variables in assembler?

VolTeK wrote:What calling convention do you use?

;Add three 32-bit unsigned values
;
;Input
; eax = first value
; ebx = second value
; ecx = third value
;
;Output
; eax = status (0 = ok, 1 = overflowed)
; ebx = result
; All other registers unchanged

addThreeValues:
    add ebx,eax
    jc .overflowed
    add ebx,ecx
    jc .overflowed
    xor eax,eax
    ret

.overflowed:
    mov eax,1
    ret

;Add three 32-bit unsigned values
;
;Input
; eax = first value
; ecx = second value
; esi = third value
;
;Output
; carry = set if overflowed
; esi = result
;
;Trashed
; ecx

addThreeValues:
    add ecx,eax
    jc .done
    add esi,ecx
.done:
    ret

Tosi wrote:I never liked fastcall and parameter passing in registers.