[bpt/emacs.git] / src / 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 program is free software; you can redistribute it and/or modify it
   under the terms of the GNU General Public License as published by the
   Free Software Foundation; either version 2, or (at your option) any
   later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License along
   with this program; if not, write to the Free Software Foundation, Inc.,
   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */

/* 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
#ifdef emacs
#include <config.h>
#else
#include "config.h"
#endif

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

#ifndef hp9000s300
#ifndef m68k
#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 /* 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 address
	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
#ifdef m68k			/* 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 registers 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 SVR3V7 . 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 allocation.
	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 */

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