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