![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to alloca.s CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / src|
Return to alloca.s CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / src |
1.1 root 1: /* `alloca' standard 4.2 subroutine for 68000's and 16000's and others.
2: Also has _setjmp and _longjmp for pyramids.
3: Copyright (C) 1985, 1986, 1988 Free Software Foundation, Inc.
4:
5: This file is part of GNU Emacs.
6:
7: GNU Emacs is distributed in the hope that it will be useful,
8: but WITHOUT ANY WARRANTY. No author or distributor
9: accepts responsibility to anyone for the consequences of using it
10: or for whether it serves any particular purpose or works at all,
11: unless he says so in writing. Refer to the GNU Emacs General Public
12: License for full details.
13:
14: Everyone is granted permission to copy, modify and redistribute
15: GNU Emacs, but only under the conditions described in the
16: GNU Emacs General Public License. A copy of this license is
17: supposed to have been given to you along with GNU Emacs so you
18: can know your rights and responsibilities. It should be in a
19: file named COPYING. Among other things, the copyright notice
20: and this notice must be preserved on all copies. */
21:
22:
23: /* Both 68000 systems I have run this on have had broken versions of alloca.
24: Also, I am told that non-berkeley systems do not have it at all.
25: So replace whatever system-provided alloca there may be
26: on all 68000 systems. */
27:
28: #define NOT_C_CODE
29: #include "config.h"
30:
31: #ifndef HAVE_ALLOCA /* define this to use system's alloca */
32:
33: #ifndef hp9000s300
34: #ifndef m68k
35: #ifndef m68000
36: #ifndef WICAT
37: #ifndef ns16000
38: #ifndef sequent
39: #ifndef pyramid
40: #ifndef ATT3B5
41: #ifndef XENIX
42: you
43: lose!!
44: #endif /* XENIX */
45: #endif /* ATT3B5 */
46: #endif /* pyramid */
47: #endif /* sequent */
48: #endif /* ns16000 */
49: #endif /* WICAT */
50: #endif /* m68000 */
51: #endif /* m68k */
52: #endif /* hp9000s300 */
53:
54:
55: #ifdef hp9000s300
56: #ifdef OLD_HP_ASSEMBLER
57: data
58: text
59: globl _alloca
60: _alloca
61: move.l (sp)+,a0 ; pop return addr from top of stack
62: move.l (sp)+,d0 ; pop size in bytes from top of stack
63: add.l #ROUND,d0 ; round size up to long word
64: and.l #MASK,d0 ; mask out lower two bits of size
65: sub.l d0,sp ; allocate by moving stack pointer
66: tst.b PROBE(sp) ; stack probe to allocate pages
67: move.l sp,d0 ; return pointer
68: add.l #-4,sp ; new top of stack
69: jmp (a0) ; not a normal return
70: MASK equ -4 ; Longword alignment
71: ROUND equ 3 ; ditto
72: PROBE equ -128 ; safety buffer for C compiler scratch
73: data
74: #else /* new hp assembler syntax */
75: /*
76: The new compiler does "move.m <registers> (%sp)" to save registers,
77: so we must copy the saved registers when we mung the sp.
78: The old compiler did "move.m <register> <offset>(%a6)", which
79: gave us no trouble
80: */
81: text
82: set PROBE,-128 # safety for C frame temporaries
83: set MAXREG,22 # d2-d7, a2-a5, fp2-fp7 may have been saved
84: global _alloca
85: _alloca:
86: mov.l (%sp)+,%a0 # return addess
87: mov.l (%sp)+,%d0 # number of bytes to allocate
88: mov.l %sp,%a1 # save old sp for register copy
89: mov.l %sp,%d1 # compute new sp
90: sub.l %d0,%d1 # space requested
91: and.l &-4,%d1 # round down to longword
92: sub.l &MAXREG*4,%d1 # space for saving registers
93: mov.l %d1,%sp # save new value of sp
94: tst.b PROBE(%sp) # create pages (sigh)
95: move.w &MAXREG-1,%d0
96: copy_regs_loop: /* save caller's saved registers */
97: mov.l (%a1)+,(%sp)+
98: dbra %d0,copy_regs_loop
99: mov.l %sp,%d0 # return value
100: mov.l %d1,%sp
101: add.l &-4,%sp # adjust tos
102: jmp (%a0) # rts
103: #endif /* new hp assembler */
104: #else
105: #ifdef m68k /* SGS assembler totally different */
106: file "alloca.s"
107: global alloca
108: alloca:
109: mov.l (%sp)+,%a1 # pop return addr from top of stack
110: mov.l (%sp)+,%d0 # pop size in bytes from top of stack
111: add.l &R%1,%d0 # round size up to long word
112: and.l &-4,%d0 # mask out lower two bits of size
113: sub.l %d0,%sp # allocate by moving stack pointer
114: tst.b P%1(%sp) # stack probe to allocate pages
115: mov.l %sp,%a0 # return pointer as pointer
116: mov.l %sp,%d0 # return pointer as int to avoid disaster
117: add.l &-4,%sp # new top of stack
118: jmp (%a1) # not a normal return
119: set S%1,64 # safety factor for C compiler scratch
120: set R%1,3+S%1 # add to size for rounding
121: set P%1,-132 # probe this far below current top of stack
122:
123: #else /* not m68k */
124:
125: #ifdef m68000
126:
127: #ifdef WICAT
128: /*
129: * Registers are saved after the corresponding link so we have to explicitly
130: * move them to the top of the stack where they are expected to be.
131: * Since we do not know how many registers were saved in the calling function
132: * we must assume the maximum possible (d2-d7,a2-a5). Hence, we end up
133: * wasting some space on the stack.
134: *
135: * The large probe (tst.b) attempts to make up for the fact that we have
136: * potentially used up the space that the caller probed for its own needs.
137: */
138: .procss m0
139: .config "68000 1"
140: .module _alloca
141: MAXREG: .const 10
142: .sect text
143: .global _alloca
144: _alloca:
145: move.l (sp)+,a1 ; pop return address
146: move.l (sp)+,d0 ; pop allocation size
147: move.l sp,d1 ; get current SP value
148: sub.l d0,d1 ; adjust to reflect required size...
149: sub.l #MAXREG*4,d1 ; ...and space needed for registers
150: and.l #-4,d1 ; backup to longword boundry
151: move.l sp,a0 ; save old SP value for register copy
152: move.l d1,sp ; set the new SP value
153: tst.b -4096(sp) ; grab an extra page (to cover caller)
154: move.l a2,d1 ; save callers register
155: move.l sp,a2
156: move.w #MAXREG-1,d0 ; # of longwords to copy
157: loop: move.l (a0)+,(a2)+ ; copy registers...
158: dbra d0,loop ; ...til there are no more
159: move.l a2,d0 ; end of register area is addr for new space
160: move.l d1,a2 ; restore saved a2.
161: addq.l #4,sp ; caller will increment sp by 4 after return.
162: move.l d0,a0 ; return value in both a0 and d0.
163: jmp (a1)
164: .end _alloca
165: #else
166:
167: /* Some systems want the _, some do not. Win with both kinds. */
168: .globl _alloca
169: _alloca:
170: .globl alloca
171: alloca:
172: movl sp@+,a0
173: movl a7,d0
174: subl sp@,d0
175: andl #~3,d0
176: movl d0,sp
177: tstb sp@(0) /* Make stack pages exist */
178: /* Needed on certain systems
179: that lack true demand paging */
180: addql #4,d0
181: jmp a0@
182:
183: #endif /* not WICAT */
184: #endif /* m68000 */
185: #endif /* not m68k */
186: #endif /* not hp9000s300 */
187:
188: #ifdef ns16000
189:
190: .text
191: .align 2
192: /* Some systems want the _, some do not. Win with both kinds. */
193: .globl _alloca
194: _alloca:
195: .globl alloca
196: alloca:
197:
198: /* Two different assembler syntaxes are used for the same code
199: on different systems. */
200:
201: #ifdef sequent
202: #define IM
203: #define REGISTER(x) x
204: #else
205: #define IM $
206: #define REGISTER(x) 0(x)
207: #endif
208:
209: /*
210: * The ns16000 is a little more difficult, need to copy regs.
211: * Also the code assumes direct linkage call sequence (no mod table crap).
212: * We have to copy registers, and therefore waste 32 bytes.
213: *
214: * Stack layout:
215: * new sp -> junk
216: * registers (copy)
217: * r0 -> new data
218: * | (orig retval)
219: * | (orig arg)
220: * old sp -> regs (orig)
221: * local data
222: * fp -> old fp
223: */
224:
225: movd tos,r1 /* pop return addr */
226: negd tos,r0 /* pop amount to allocate */
227: sprd sp,r2
228: addd r2,r0
229: bicb IM/**/3,r0 /* 4-byte align */
230: lprd sp,r0
231: adjspb IM/**/36 /* space for regs, +4 for caller to pop */
232: movmd 0(r2),4(sp),IM/**/4 /* copy regs */
233: movmd 0x10(r2),0x14(sp),IM/**/4
234: jump REGISTER(r1) /* funky return */
235: #endif /* ns16000 */
236:
237: #ifdef pyramid
238:
239: .globl _alloca
240:
241: _alloca: addw $3,pr0 # add 3 (dec) to first argument
242: bicw $3,pr0 # then clear its last 2 bits
243: subw pr0,sp # subtract from SP the val in PR0
244: andw $-32,sp # keep sp aligned on multiple of 32.
245: movw sp,pr0 # ret. current SP
246: ret
247:
248: #ifdef PYRAMID_OLD /* This isn't needed in system version 4. */
249: .globl __longjmp
250: .globl _longjmp
251: .globl __setjmp
252: .globl _setjmp
253:
254: __longjmp: jump _longjmp
255: __setjmp: jump _setjmp
256: #endif
257:
258: #endif /* pyramid */
259:
260: #ifdef ATT3B5
261:
262: .align 4
263: .globl alloca
264:
265: alloca:
266: movw %ap, %r8
267: subw2 $9*4, %r8
268: movw 0(%r8), %r1 /* pc */
269: movw 4(%r8), %fp
270: movw 8(%r8), %sp
271: addw2 %r0, %sp /* make room */
272: movw %sp, %r0 /* return value */
273: jmp (%r1) /* continue... */
274:
275: #endif /* ATT3B5 */
276:
277: #ifdef XENIX
278:
279: .386
280:
281: _TEXT segment dword use32 public 'CODE'
282: assume cs:_TEXT
283:
284: ;-------------------------------------------------------------------------
285:
286: public _alloca
287: _alloca proc near
288:
289: pop ecx ; return address
290: pop eax ; amount to alloc
291: add eax,3 ; round it to 32-bit boundary
292: and al,11111100B ;
293: mov edx,esp ; current sp in edx
294: sub edx,eax ; lower the stack
295: xchg esp,edx ; start of allocation in esp, old sp in edx
296: mov eax,esp ; return ptr to base in eax
297: push [edx+8] ; save poss. stored reg. values (esi,edi,ebx)
298: push [edx+4] ; on lowered stack
299: push [edx] ;
300: sub esp,4 ; allow for 'add esp, 4'
301: jmp ecx ; jump to return address
302:
303: _alloca endp
304:
305: _TEXT ends
306:
307: end
308:
309: #endif /* XENIX */
310:
311: #endif /* not HAVE_ALLOCA */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.