Mercurial > emacs
view src/alloca.s @ 20279:69a6030e443a
(kill-region): Detect read-only text
by getting an error trying to delete it.
Handle the cases where we can, and can't, get the killed text
from the undo list with much the same code.
author | Karl Heuer <kwzh@gnu.org> |
---|---|
date | Wed, 19 Nov 1997 21:36:56 +0000 |
parents | 6e7bb4bd5010 |
children | 23a1cea22d13 |
line wrap: on
line source
/* `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 */