[unix-history] / usr / src / contrib / gawk-2.15.2 / alloca.s

/* `alloca' standard 4.2 subroutine for 68000's and 16000's and others.
   Also has _setjmp and _longjmp for pyramids.
   Copyright (C) 1985, 1986, 1988 Free Software Foundation, Inc.

This file is part of GNU Emacs.

GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY.  No author or distributor
accepts responsibility to anyone for the consequences of using it
or for whether it serves any particular purpose or works at all,
unless he says so in writing.  Refer to the GNU Emacs General Public
License for full details.

Everyone is granted permission to copy, modify and redistribute
GNU Emacs, but only under the conditions described in the
GNU Emacs General Public License.   A copy of this license is
supposed to have been given to you along with GNU Emacs so you
can know your rights and responsibilities.  It should be in a
file named COPYING.  Among other things, the copyright notice
and this notice must be preserved on all copies.  */


/* Both 68000 systems I have run this on have had broken versions of alloca.
   Also, I am told that non-berkeley systems do not have it at all.
   So replace whatever system-provided alloca there may be
   on all 68000 systems.  */

#define NOT_C_CODE
/* #include "config.h" */

#ifndef HAVE_ALLOCA  /* define this to use system's alloca */

#ifndef hp9000s300
#ifndef m68k
#ifndef mc68k
#ifndef m68000
#ifndef WICAT
#ifndef ns32000
#ifndef ns16000
#ifndef sequent
#ifndef pyramid
#ifndef ATT3B5
#ifndef XENIX
you
lose!!
#endif /* XENIX */
#endif /* ATT3B5 */
#endif /* pyramid */
#endif /* sequent */
#endif /* ns16000 */
#endif /* ns32000 */
#endif /* WICAT */
#endif /* m68000 */
#endif /* mc68k */
#endif /* m68k */
#endif /* hp9000s300 */


#ifdef hp9000s300
#ifdef OLD_HP_ASSEMBLER
	data
	text
	globl	_alloca
_alloca	
	move.l	(sp)+,a0	; pop return addr from top of stack
	move.l	(sp)+,d0	; pop size in bytes from top of stack
	add.l	#ROUND,d0	; round size up to long word
	and.l	#MASK,d0	; mask out lower two bits of size
	sub.l	d0,sp		; allocate by moving stack pointer
	tst.b	PROBE(sp)	; stack probe to allocate pages
	move.l	sp,d0		; return pointer
	add.l	#-4,sp		; new top of stack
	jmp	(a0)		; not a normal return
MASK	equ	-4		; Longword alignment
ROUND	equ	3		; ditto
PROBE	equ	-128		; safety buffer for C compiler scratch
	data
#else /* new hp assembler syntax */
/*
  The new compiler does "move.m <registers> (%sp)" to save registers,
    so we must copy the saved registers when we mung the sp.
  The old compiler did "move.m <register> <offset>(%a6)", which
    gave us no trouble
 */
	text
	set	PROBE,-128	# safety for C frame temporaries
	set	MAXREG,22	# d2-d7, a2-a5, fp2-fp7 may have been saved
	global	_alloca
_alloca:
	mov.l	(%sp)+,%a0	# return addess
	mov.l	(%sp)+,%d0	# number of bytes to allocate
	mov.l	%sp,%a1		# save old sp for register copy
	mov.l	%sp,%d1		# compute new sp
	sub.l	%d0,%d1		# space requested
	and.l	&-4,%d1		# round down to longword
	sub.l	&MAXREG*4,%d1	# space for saving registers
	mov.l	%d1,%sp		# save new value of sp
	tst.b	PROBE(%sp)	# create pages (sigh)
	mov.l	%a2,%d1		# save reg a2
	mov.l	%sp,%a2
	move.w	&MAXREG-1,%d0
copy_regs_loop:			/* save caller's saved registers */
	mov.l	(%a1)+,(%a2)+
	dbra	%d0,copy_regs_loop
	mov.l	%a2,%d0		# return value
	mov.l	%d1,%a2		# restore a2
	add.l	&-4,%sp		# adjust tos
	jmp	(%a0)		# rts
#endif /* new hp assembler */
#else
#if defined(m68k) || defined(mc68k)	/* SGS assembler totally different */
	file	"alloca.s"
	global	alloca
alloca:
#ifdef MOTOROLA_DELTA
/* slightly modified version of alloca to motorola sysV/68 pcc - based
   compiler. 
   this compiler saves used regfisters relative to %sp instead of %fp.
   alright, just make new copy of saved register set whenever we allocate
   new space from stack..
   this is true at last until SVR3V5.1 . bug has reported to Motorola. */
	set	MAXREG,10	# max no of registers to save (d2-d7, a2-a5)
        mov.l   (%sp)+,%a1	# pop return addr from top of stack
        mov.l   (%sp)+,%d0	# pop size in bytes from top of stack
	mov.l	%sp,%a0		# save stack pointer for register copy
        addq.l  &3,%d0		# round size up to long word
        andi.l  &-4,%d0		# mask out lower two bits of size
	mov.l	%sp,%d1		# compute new value of sp to d1
        sub.l	%d0,%d1		# pseudo-allocate by moving stack pointer
	sub.l	&MAXREG*4,%d1	# allocate more space for saved regs.
	mov.l	%d1,%sp		# actual alloaction.
	move.w	&MAXREG-1,%d0	# d0 counts saved regs.
	mov.l	%a2,%d1		# preserve a2.
	mov.l	%sp,%a2		# make pointer to new reg save area.
copy_regs_loop: 		# copy stuff from old save area.
	mov.l	(%a0)+,(%a2)+	# save saved register
	dbra	%d0,copy_regs_loop
        mov.l   %a2,%a0		# now a2 is start of allocated space.
	mov.l	%a2,%d0		# return it in both a0 and d0 to play safe.
	mov.l	%d1,%a2		# restore a2.
        subq.l  &4,%sp		# new top of stack
        jmp     (%a1)		# far below normal return
#else /* not MOTOROLA_DELTA */
	mov.l	(%sp)+,%a1	# pop return addr from top of stack
	mov.l	(%sp)+,%d0	# pop size in bytes from top of stack
	add.l	&R%1,%d0	# round size up to long word
	and.l	&-4,%d0		# mask out lower two bits of size
	sub.l	%d0,%sp		# allocate by moving stack pointer
	tst.b	P%1(%sp)	# stack probe to allocate pages
	mov.l	%sp,%a0		# return pointer as pointer
	mov.l	%sp,%d0		# return pointer as int to avoid disaster
	add.l	&-4,%sp		# new top of stack
	jmp	(%a1)		# not a normal return
	set	S%1,64		# safety factor for C compiler scratch
	set	R%1,3+S%1	# add to size for rounding
	set	P%1,-132	# probe this far below current top of stack
#endif /* not MOTOROLA_DELTA */

#else /* not m68k && not mc68k */

#ifdef m68000

#ifdef WICAT
/*
 * Registers are saved after the corresponding link so we have to explicitly
 * move them to the top of the stack where they are expected to be.
 * Since we do not know how many registers were saved in the calling function
 * we must assume the maximum possible (d2-d7,a2-a5).  Hence, we end up
 * wasting some space on the stack.
 *
 * The large probe (tst.b) attempts to make up for the fact that we have
 * potentially used up the space that the caller probed for its own needs.
 */
	.procss m0
	.config "68000 1"
	.module	_alloca
MAXREG:	.const	10
	.sect	text
	.global	_alloca
_alloca:
	move.l	(sp)+,a1	; pop return address
	move.l	(sp)+,d0	; pop allocation size
	move.l	sp,d1		; get current SP value
	sub.l	d0,d1		; adjust to reflect required size...
	sub.l	#MAXREG*4,d1	; ...and space needed for registers
	and.l	#-4,d1		; backup to longword boundry
	move.l	sp,a0		; save old SP value for register copy
	move.l	d1,sp		; set the new SP value
	tst.b	-4096(sp)	; grab an extra page (to cover caller)
	move.l	a2,d1		; save callers register
	move.l	sp,a2
	move.w	#MAXREG-1,d0	; # of longwords to copy
loop:	move.l	(a0)+,(a2)+	; copy registers...
	dbra	d0,loop		; ...til there are no more
	move.l	a2,d0		; end of register area is addr for new space
	move.l	d1,a2		; restore saved a2.
	addq.l	#4,sp		; caller will increment sp by 4 after return.
	move.l	d0,a0		; return value in both a0 and d0.
	jmp	(a1)
	.end	_alloca
#else

/* Some systems want the _, some do not.  Win with both kinds.  */
.globl	_alloca
_alloca:
.globl	alloca
alloca:
	movl	sp@+,a0
	movl	a7,d0
	subl	sp@,d0
	andl	#~3,d0
	movl	d0,sp
	tstb	sp@(0)		/* Make stack pages exist  */
				/* Needed on certain systems
				   that lack true demand paging */
	addql	#4,d0
	jmp	a0@

#endif /* not WICAT */
#endif /* m68000 */
#endif /* not m68k */
#endif /* not hp9000s300 */

#if defined (ns16000) || defined (ns32000)

	.text
	.align	2
/* Some systems want the _, some do not.  Win with both kinds.  */
.globl	_alloca
_alloca:
.globl	alloca
alloca:

/* Two different assembler syntaxes are used for the same code
	on different systems.  */

#ifdef sequent
#define IM
#define REGISTER(x) x
#else
#ifdef NS5   /* ns SysV assembler */
#define IM $
#define REGISTER(x) x
#else
#define IM $
#define REGISTER(x) 0(x)
#endif
#endif

/*
 * The ns16000 is a little more difficult, need to copy regs.
 * Also the code assumes direct linkage call sequence (no mod table crap).
 * We have to copy registers, and therefore waste 32 bytes.
 *
 * Stack layout:
 * new	sp ->	junk	
 *	 	registers (copy)
 *	r0 ->	new data		
 *		 | 	  (orig retval)
 *		 |	  (orig arg)
 * old  sp ->	regs	  (orig)
 *		local data
 *	fp ->	old fp
 */

	movd	tos,r1		/*  pop return addr */
	negd	tos,r0		/*  pop amount to allocate */
	sprd	sp,r2
	addd	r2,r0
	bicb	IM/**/3,r0	/*  4-byte align */
	lprd	sp,r0
	adjspb	IM/**/36	/*  space for regs, +4 for caller to pop */
	movmd	0(r2),4(sp),IM/**/4	/*  copy regs */
	movmd	0x10(r2),0x14(sp),IM/**/4
	jump	REGISTER(r1)	/* funky return */
#endif /* ns16000 or ns32000 */

#ifdef pyramid

.globl _alloca

_alloca: addw $3,pr0	# add 3 (dec) to first argument
	bicw $3,pr0	# then clear its last 2 bits
	subw pr0,sp	# subtract from SP the val in PR0
	andw $-32,sp	# keep sp aligned on multiple of 32.
	movw sp,pr0	# ret. current SP
	ret

#ifdef PYRAMID_OLD /* This isn't needed in system version 4.  */
.globl __longjmp
.globl _longjmp
.globl __setjmp
.globl _setjmp

__longjmp: jump _longjmp
__setjmp:  jump _setjmp
#endif

#endif /* pyramid */

#ifdef ATT3B5

	.align 4
	.globl alloca

alloca:
	movw %ap, %r8
	subw2 $9*4, %r8
	movw 0(%r8), %r1    /* pc */
	movw 4(%r8), %fp
	movw 8(%r8), %sp
	addw2 %r0, %sp /* make room */
	movw %sp, %r0 /* return value */
	jmp (%r1) /* continue... */

#endif /* ATT3B5 */

#ifdef XENIX

.386

_TEXT segment dword use32 public 'CODE'
assume   cs:_TEXT

;-------------------------------------------------------------------------

public _alloca
_alloca proc near

	pop	ecx		; return address
	pop	eax		; amount to alloc
	add	eax,3		; round it to 32-bit boundary
	and	al,11111100B	;
	mov	edx,esp		; current sp in edx
	sub	edx,eax		; lower the stack
	xchg	esp,edx		; start of allocation in esp, old sp in edx
	mov	eax,esp		; return ptr to base in eax
	push	[edx+8]		; save poss. stored reg. values (esi,edi,ebx)
	push	[edx+4]		;  on lowered stack
	push	[edx]		;
	sub	esp,4		; allow for 'add esp, 4'
	jmp	ecx		; jump to return address

_alloca endp

_TEXT	ends

end

#endif /* XENIX */

#endif /* not HAVE_ALLOCA */
Commit	Line	Data
46ad1067 C	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 mc68k
	36	#ifndef m68000
	37	#ifndef WICAT
	38	#ifndef ns32000
	39	#ifndef ns16000
	40	#ifndef sequent
	41	#ifndef pyramid
	42	#ifndef ATT3B5
	43	#ifndef XENIX
	44	you
	45	lose!!
	46	#endif /* XENIX */
	47	#endif /* ATT3B5 */
	48	#endif /* pyramid */
	49	#endif /* sequent */
	50	#endif /* ns16000 */
	51	#endif /* ns32000 */
	52	#endif /* WICAT */
	53	#endif /* m68000 */
	54	#endif /* mc68k */
	55	#endif /* m68k */
	56	#endif /* hp9000s300 */
	57
	58
	59	#ifdef hp9000s300
	60	#ifdef OLD_HP_ASSEMBLER
	61	data
	62	text
	63	globl _alloca
	64	_alloca
65	move.l (sp)+,a0 ; pop return addr from top of stack
66	move.l (sp)+,d0 ; pop size in bytes from top of stack
67	add.l #ROUND,d0 ; round size up to long word
68	and.l #MASK,d0 ; mask out lower two bits of size
69	sub.l d0,sp ; allocate by moving stack pointer
70	tst.b PROBE(sp) ; stack probe to allocate pages
71	move.l sp,d0 ; return pointer
72	add.l #-4,sp ; new top of stack
73	jmp (a0) ; not a normal return
74	MASK equ -4 ; Longword alignment
75	ROUND equ 3 ; ditto
76	PROBE equ -128 ; safety buffer for C compiler scratch
77	data
78	#else /* new hp assembler syntax */
79	/*
80	The new compiler does "move.m <registers> (%sp)" to save registers,
81	so we must copy the saved registers when we mung the sp.
82	The old compiler did "move.m <register> <offset>(%a6)", which
83	gave us no trouble
84	*/
85	text
86	set PROBE,-128 # safety for C frame temporaries
87	set MAXREG,22 # d2-d7, a2-a5, fp2-fp7 may have been saved
88	global _alloca
89	_alloca:
90	mov.l (%sp)+,%a0 # return addess
91	mov.l (%sp)+,%d0 # number of bytes to allocate
92	mov.l %sp,%a1 # save old sp for register copy
93	mov.l %sp,%d1 # compute new sp
94	sub.l %d0,%d1 # space requested
95	and.l &-4,%d1 # round down to longword
96	sub.l &MAXREG*4,%d1 # space for saving registers
97	mov.l %d1,%sp # save new value of sp
98	tst.b PROBE(%sp) # create pages (sigh)
99	mov.l %a2,%d1 # save reg a2
100	mov.l %sp,%a2
101	move.w &MAXREG-1,%d0
102	copy_regs_loop: /* save caller's saved registers */
103	mov.l (%a1)+,(%a2)+
104	dbra %d0,copy_regs_loop
105	mov.l %a2,%d0 # return value
106	mov.l %d1,%a2 # restore a2
107	add.l &-4,%sp # adjust tos
108	jmp (%a0) # rts
109	#endif /* new hp assembler */
110	#else
111	#if defined(m68k) \|\| defined(mc68k) /* SGS assembler totally different */
112	file "alloca.s"
113	global alloca
114	alloca:
115	#ifdef MOTOROLA_DELTA
116	/* slightly modified version of alloca to motorola sysV/68 pcc - based
117	compiler.
118	this compiler saves used regfisters relative to %sp instead of %fp.
119	alright, just make new copy of saved register set whenever we allocate
120	new space from stack..
121	this is true at last until SVR3V5.1 . bug has reported to Motorola. */
122	set MAXREG,10 # max no of registers to save (d2-d7, a2-a5)
123	mov.l (%sp)+,%a1 # pop return addr from top of stack
124	mov.l (%sp)+,%d0 # pop size in bytes from top of stack
125	mov.l %sp,%a0 # save stack pointer for register copy
126	addq.l &3,%d0 # round size up to long word
127	andi.l &-4,%d0 # mask out lower two bits of size
128	mov.l %sp,%d1 # compute new value of sp to d1
129	sub.l %d0,%d1 # pseudo-allocate by moving stack pointer
130	sub.l &MAXREG*4,%d1 # allocate more space for saved regs.
131	mov.l %d1,%sp # actual alloaction.
132	move.w &MAXREG-1,%d0 # d0 counts saved regs.
133	mov.l %a2,%d1 # preserve a2.
134	mov.l %sp,%a2 # make pointer to new reg save area.
135	copy_regs_loop: # copy stuff from old save area.
136	mov.l (%a0)+,(%a2)+ # save saved register
137	dbra %d0,copy_regs_loop
138	mov.l %a2,%a0 # now a2 is start of allocated space.
139	mov.l %a2,%d0 # return it in both a0 and d0 to play safe.
140	mov.l %d1,%a2 # restore a2.
141	subq.l &4,%sp # new top of stack
142	jmp (%a1) # far below normal return
143	#else /* not MOTOROLA_DELTA */
144	mov.l (%sp)+,%a1 # pop return addr from top of stack
145	mov.l (%sp)+,%d0 # pop size in bytes from top of stack
146	add.l &R%1,%d0 # round size up to long word
147	and.l &-4,%d0 # mask out lower two bits of size
148	sub.l %d0,%sp # allocate by moving stack pointer
149	tst.b P%1(%sp) # stack probe to allocate pages
150	mov.l %sp,%a0 # return pointer as pointer
151	mov.l %sp,%d0 # return pointer as int to avoid disaster
152	add.l &-4,%sp # new top of stack
153	jmp (%a1) # not a normal return
154	set S%1,64 # safety factor for C compiler scratch
155	set R%1,3+S%1 # add to size for rounding
156	set P%1,-132 # probe this far below current top of stack
157	#endif /* not MOTOROLA_DELTA */
158
159	#else /* not m68k && not mc68k */
160
161	#ifdef m68000
162
163	#ifdef WICAT
164	/*
165	* Registers are saved after the corresponding link so we have to explicitly
166	* move them to the top of the stack where they are expected to be.
167	* Since we do not know how many registers were saved in the calling function
168	* we must assume the maximum possible (d2-d7,a2-a5). Hence, we end up
169	* wasting some space on the stack.
170	*
171	* The large probe (tst.b) attempts to make up for the fact that we have
172	* potentially used up the space that the caller probed for its own needs.
173	*/
174	.procss m0
175	.config "68000 1"
176	.module _alloca
177	MAXREG: .const 10
178	.sect text
179	.global _alloca
180	_alloca:
181	move.l (sp)+,a1 ; pop return address
182	move.l (sp)+,d0 ; pop allocation size
183	move.l sp,d1 ; get current SP value
184	sub.l d0,d1 ; adjust to reflect required size...
185	sub.l #MAXREG*4,d1 ; ...and space needed for registers
186	and.l #-4,d1 ; backup to longword boundry
187	move.l sp,a0 ; save old SP value for register copy
188	move.l d1,sp ; set the new SP value
189	tst.b -4096(sp) ; grab an extra page (to cover caller)
190	move.l a2,d1 ; save callers register
191	move.l sp,a2
192	move.w #MAXREG-1,d0 ; # of longwords to copy
193	loop: move.l (a0)+,(a2)+ ; copy registers...
194	dbra d0,loop ; ...til there are no more
195	move.l a2,d0 ; end of register area is addr for new space
196	move.l d1,a2 ; restore saved a2.
197	addq.l #4,sp ; caller will increment sp by 4 after return.
198	move.l d0,a0 ; return value in both a0 and d0.
199	jmp (a1)
200	.end _alloca
201	#else
202
203	/* Some systems want the _, some do not. Win with both kinds. */
204	.globl _alloca
205	_alloca:
206	.globl alloca
207	alloca:
208	movl sp@+,a0
209	movl a7,d0
210	subl sp@,d0
211	andl #~3,d0
212	movl d0,sp
213	tstb sp@(0) /* Make stack pages exist */
214	/* Needed on certain systems
215	that lack true demand paging */
216	addql #4,d0
217	jmp a0@
218
219	#endif /* not WICAT */
220	#endif /* m68000 */
221	#endif /* not m68k */
222	#endif /* not hp9000s300 */
223
224	#if defined (ns16000) \|\| defined (ns32000)
225
226	.text
227	.align 2
228	/* Some systems want the _, some do not. Win with both kinds. */
229	.globl _alloca
230	_alloca:
231	.globl alloca
232	alloca:
233
234	/* Two different assembler syntaxes are used for the same code
235	on different systems. */
236
237	#ifdef sequent
238	#define IM
239	#define REGISTER(x) x
240	#else
241	#ifdef NS5 /* ns SysV assembler */
242	#define IM $
243	#define REGISTER(x) x
244	#else
245	#define IM $
246	#define REGISTER(x) 0(x)
247	#endif
248	#endif
249
250	/*
251	* The ns16000 is a little more difficult, need to copy regs.
252	* Also the code assumes direct linkage call sequence (no mod table crap).
253	* We have to copy registers, and therefore waste 32 bytes.
254	*
255	* Stack layout:
256	* new sp -> junk
257	* registers (copy)
258	* r0 -> new data
259	* \| (orig retval)
260	* \| (orig arg)
261	* old sp -> regs (orig)
262	* local data
263	* fp -> old fp
264	*/
265
266	movd tos,r1 /* pop return addr */
267	negd tos,r0 /* pop amount to allocate */
268	sprd sp,r2
269	addd r2,r0
270	bicb IM/*/3,r0 / 4-byte align */
271	lprd sp,r0
272	adjspb IM/*/36 / space for regs, +4 for caller to pop */
273	movmd 0(r2),4(sp),IM/*/4 / copy regs */
274	movmd 0x10(r2),0x14(sp),IM/**/4
275	jump REGISTER(r1) /* funky return */
276	#endif /* ns16000 or ns32000 */
277
278	#ifdef pyramid
279
280	.globl _alloca
281
282	_alloca: addw $3,pr0 # add 3 (dec) to first argument
283	bicw $3,pr0 # then clear its last 2 bits
284	subw pr0,sp # subtract from SP the val in PR0
285	andw $-32,sp # keep sp aligned on multiple of 32.
286	movw sp,pr0 # ret. current SP
287	ret
288
289	#ifdef PYRAMID_OLD /* This isn't needed in system version 4. */
290	.globl __longjmp
291	.globl _longjmp
292	.globl __setjmp
293	.globl _setjmp
294
295	__longjmp: jump _longjmp
296	__setjmp: jump _setjmp
297	#endif
298
299	#endif /* pyramid */
300
301	#ifdef ATT3B5
302
303	.align 4
304	.globl alloca
305
306	alloca:
307	movw %ap, %r8
308	subw2 $9*4, %r8
309	movw 0(%r8), %r1 /* pc */
310	movw 4(%r8), %fp
311	movw 8(%r8), %sp
312	addw2 %r0, %sp /* make room */
313	movw %sp, %r0 /* return value */
314	jmp (%r1) /* continue... */
315
316	#endif /* ATT3B5 */
317
318	#ifdef XENIX
319
320	.386
321
322	_TEXT segment dword use32 public 'CODE'
323	assume cs:_TEXT
324
325	;-------------------------------------------------------------------------
326
327	public _alloca
328	_alloca proc near
329
330	pop ecx ; return address
331	pop eax ; amount to alloc
332	add eax,3 ; round it to 32-bit boundary
333	and al,11111100B ;
334	mov edx,esp ; current sp in edx
335	sub edx,eax ; lower the stack
336	xchg esp,edx ; start of allocation in esp, old sp in edx
337	mov eax,esp ; return ptr to base in eax
338	push [edx+8] ; save poss. stored reg. values (esi,edi,ebx)
339	push [edx+4] ; on lowered stack
340	push [edx] ;
341	sub esp,4 ; allow for 'add esp, 4'
342	jmp ecx ; jump to return address
343
344	_alloca endp
345
346	_TEXT ends
347
348	end
349
350	#endif /* XENIX */
351
352	#endif /* not HAVE_ALLOCA */