home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c082_122 / 2.ddi / CLIBSRC3.ZIP / ALLOCA.ASM < prev    next >
Encoding:
Assembly Source File  |  1992-06-10  |  5.4 KB  |  161 lines
  1. ;[]-----------------------------------------------------------------[]
  2. ;|      ALLOCA.ASM -- Allocate temporary stack space                 |
  3. ;[]-----------------------------------------------------------------[]
  4.  
  5. ;
  6. ;       C/C++ Run Time Library - Version 5.0
  7. ; 
  8. ;       Copyright (c) 1991, 1992 by Borland International
  9. ;       All Rights Reserved.
  10. ; 
  11.  
  12.         INCLUDE RULES.ASI
  13.  
  14. ;       Segments Definitions
  15.  
  16. Header@
  17.  
  18. ;----------------------------------------------------------------------
  19. ; In large data models, the stack is in its own segment.  The stack
  20. ; starts at SS:__stklen and grows down to SS:0.
  21. ;
  22. ; In small data models, the stack is in the DGROUP, and grows down
  23. ; to meet the heap.  The end of the heap is marked by ___brklvl.
  24. ;----------------------------------------------------------------------
  25.  
  26. ifdef _WINDOWS
  27. pStackTop equ   0Ah             ; SS:[0A] contains addr of top of stack
  28. else
  29.   if LDATA eq false
  30. ExtSym@         __brklvl, WORD, __CDECL__
  31.   endif
  32. endif
  33.  
  34. ; REGSTACK contains the number of bytes taken up in the stack
  35. ; by registers saved in the normal function prologue.  This includes
  36. ; space for SI and DI, plus DS in huge model.
  37.  
  38. ifdef __HUGE__
  39. REGSTACK   equ     6
  40. else
  41. REGSTACK   equ     4
  42. endif
  43.  
  44. ;----------------------------------------------------------------------
  45. ; Name          alloca - allocate temporary stack memory
  46. ;
  47. ; Usage         void *alloca(size_t size);
  48. ;
  49. ; Prototype in  malloc.h
  50. ;
  51. ; Description   Alloca allocates size bytes on the stack; the allocated
  52. ;               space is automatically freed up when the calling function
  53. ;               exits.
  54. ;
  55. ;               Because alloca modifies the stack pointer, do not place calls
  56. ;               to alloca in an expression that is an argument to a function.
  57. ;
  58. ;               If the calling function does not contain any references
  59. ;               to local variables in the stack, the stack will not
  60. ;               be restored correctly when the function exits, resulting
  61. ;               in a program crash.  To ensure that the stack is restored
  62. ;               correctly, use the following code in the calling function:
  63. ;
  64. ;                       char *p;
  65. ;                       char dummy[1];
  66. ;
  67. ;                       dummy[0] = 0;
  68. ;                       ...
  69. ;                       p = alloca(nbytes);
  70. ;
  71. ; Return value  Returns a pointer to the allocated stack area on success.
  72. ;               If the stack cannot be extended, a NULL pointer is returned.
  73. ;               The returned pointer should never be passed to free().
  74. ;
  75. ; Note          Compatible with Microsoft C and UNIX.  Not recommended.
  76. ;               Use malloc() instead.
  77. ;----------------------------------------------------------------------
  78.  
  79. Code_seg@
  80.  
  81. PubProc@ alloca, __CDECL__
  82.  
  83.         pop     bx              ; pop return address (offset)
  84. if LPROG
  85.         pop     es              ; pop return address (segment)
  86. endif
  87.         pop     ax              ; pop size parameter
  88.         add     ax,1            ; round size up to even number of bytes
  89.         and     ax,not 1
  90.         neg     ax              ; negate size
  91.         add     ax,sp           ; add current stack pointer
  92.  
  93. ; Put into cx the value sp would attain after adding the space
  94. ; for pushing the return address and size parameter, and copies
  95. ; of the register variables saved in the caller's stack.  Compare
  96. ; this value with the stack base to guard against stack overflow.
  97.  
  98.         mov     cx,ax           ; add some extra to ensure there's room for
  99.         sub     cx,REGSTACK+cPtrSize+2   ; ret address, size, and regs
  100.         cmp     cx,sp           ; would new SP wrap around?
  101.         ja      bad
  102. ifdef _WINDOWS
  103.         cmp     ss:pStackTop,cx ; would new SP go below top of stack?
  104.         ja      bad
  105. else
  106.     if LDATA eq false
  107.         cmp     __brklvl@,cx    ; would new SP fall in the near heap?
  108.         ja      bad
  109.     endif
  110. endif
  111.         mov     cx,bp           ; save BP in CX
  112.         mov     bp,sp           ; get a copy of SP into BP for later use
  113.  
  114. ; The current stack looks like this, from high to low address:
  115. ;       SI saved by caller (assumed to be present)
  116. ;       DI saved by caller (assumed to be present)
  117. ; BP -> DS saved by caller (present only in huge model)
  118. ;       ... empty space ...
  119. ; AX -> new stack area
  120. ;
  121. ; Before we can return, we need to push on the new stack area the registers
  122. ; saved by caller in the old stack area.  We need to copy at least 2 stack words
  123. ; (for SI and DI), plus one more in huge model (DS).  We can't tell if SI
  124. ; and DI were really saved, so we assume that they were and allocate extra
  125. ; space for them.
  126.  
  127.         mov     sp,ax           ; set up new SP
  128. ifdef __HUGE__
  129.         push    [bp+4]
  130. endif
  131.         push    [bp+2]
  132.         push    [bp+0]
  133. if LDATA
  134.         mov     dx,ss           ; return high word of stack address in DX
  135. endif
  136.         mov     bp,cx           ; restore caller's BP
  137. return:
  138.         sub     sp,2            ; caller will add 2 to SP after we return
  139. if LPROG
  140.         push    es              ; can't "jmp es:bx", so push es:bx,
  141.         push    bx              ;  then do a far return
  142.         retf
  143. else
  144.         jmp     bx              ; return
  145. endif
  146.  
  147. ; Come here if there isn't enough stack space.  Return a null pointer.
  148.  
  149. bad:
  150.         xor     ax,ax           ; return NULL pointer
  151. if LDATA
  152.         mov     dx,ax
  153. endif
  154.         jmp     return
  155.  
  156. EndProc@ alloca, __CDECL__
  157.  
  158. Code_EndS@
  159.  
  160.         end
  161.