![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tmps.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ucb / pascal / src|
Return to tmps.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ucb / pascal / src |
1.1 ! root 1: /* ! 2: * Copyright (c) 1980 Regents of the University of California. ! 3: * All rights reserved. The Berkeley software License Agreement ! 4: * specifies the terms and conditions for redistribution. ! 5: */ ! 6: ! 7: #ifndef lint ! 8: static char sccsid[] = "@(#)tmps.c 5.1 (Berkeley) 6/5/85"; ! 9: #endif not lint ! 10: ! 11: #include "whoami.h" ! 12: #include "0.h" ! 13: #include "objfmt.h" ! 14: #ifdef PC ! 15: # include "pc.h" ! 16: #endif PC ! 17: #include "align.h" ! 18: #include "tmps.h" ! 19: ! 20: /* ! 21: * This routine defines the register allocation strategy ! 22: * All temporaries are allocated here, and this routines decides ! 23: * where they are to be put. ! 24: */ ! 25: #ifdef PC ! 26: /* ! 27: * register temporaries ! 28: * - are allocated from highreg towards lowreg. ! 29: * - are of size regsize. ! 30: * - register numbers from the various register types are mapped to ! 31: * integer register numbers using the offsets. (cf. pcc/mac2defs) ! 32: * ! 33: * stack temporaries ! 34: * - are allocated on a downward growing stack. ! 35: */ ! 36: ! 37: #ifdef vax ! 38: /* ! 39: * first pass register declaration constants ! 40: */ ! 41: struct regtype { ! 42: long lowreg; ! 43: long highreg; ! 44: long regsize; ! 45: } regtypes[NUMREGTYPES] = { ! 46: { 6, 11, 4 }, /* r6..r11 */ ! 47: }; ! 48: #endif vax ! 49: ! 50: #ifdef mc68000 ! 51: /* ! 52: * first pass register declaration constants ! 53: */ ! 54: struct regtype { ! 55: long lowreg; ! 56: long highreg; ! 57: long regsize; ! 58: } regtypes[NUMREGTYPES] = { ! 59: { 2, 7, 4 }, /* d2..d7 */ ! 60: { 2, 5, 4 }, /* a2..a5 */ ! 61: }; ! 62: #endif mc68000 ! 63: #endif PC ! 64: ! 65: tmpinit(cbn) ! 66: int cbn; ! 67: { ! 68: struct om *sizesp = &sizes[cbn]; ! 69: # ifdef PC ! 70: int i; ! 71: # endif PC ! 72: ! 73: sizesp->om_max = -DPOFF1; ! 74: sizesp->curtmps.om_off = -DPOFF1; ! 75: # ifdef PC ! 76: for (i = 0; i < NUMREGTYPES; i++) { ! 77: sizesp->low_water[i] = regtypes[i].highreg + 1; ! 78: sizesp->curtmps.next_avail[i] = regtypes[i].highreg; ! 79: } ! 80: # endif PC ! 81: } ! 82: ! 83: /* ! 84: * allocate runtime temporary variables ! 85: */ ! 86: /*ARGSUSED*/ ! 87: struct nl * ! 88: tmpalloc(size, type, mode) ! 89: long size; ! 90: struct nl *type; ! 91: int mode; ! 92: { ! 93: register struct om *op = &sizes[ cbn ]; ! 94: register int offset; ! 95: register struct nl *nlp; ! 96: long alignment; ! 97: ! 98: # ifdef PC ! 99: # ifdef vax ! 100: if ( mode == REGOK ! 101: && size == regtypes[REG_GENERAL].regsize ! 102: && op->curtmps.next_avail[REG_GENERAL] ! 103: >= regtypes[REG_GENERAL].lowreg) { ! 104: offset = op->curtmps.next_avail[REG_GENERAL]--; ! 105: if (offset < op->low_water[REG_GENERAL]) { ! 106: op->low_water[REG_GENERAL] = offset; ! 107: } ! 108: nlp = defnl( (char *) 0 , VAR , type , offset ); ! 109: nlp -> extra_flags = NLOCAL | NREGVAR; ! 110: putlbracket(ftnno, op); ! 111: return nlp; ! 112: } ! 113: # endif vax ! 114: # ifdef mc68000 ! 115: if ( mode == REGOK ! 116: && type != nl + TPTR ! 117: && size == regtypes[REG_DATA].regsize ! 118: && op->curtmps.next_avail[REG_DATA] ! 119: >= regtypes[REG_DATA].lowreg) { ! 120: offset = op->curtmps.next_avail[REG_DATA]--; ! 121: if (offset < op->low_water[REG_DATA]) { ! 122: op->low_water[REG_DATA] = offset; ! 123: } ! 124: nlp = defnl(0, VAR, type, offset + DATA_REG_OFFSET ); ! 125: nlp -> extra_flags = NLOCAL | NREGVAR; ! 126: putlbracket(ftnno, op); ! 127: return nlp; ! 128: } ! 129: if ( mode == REGOK ! 130: && type == nl + TPTR ! 131: && size == regtypes[REG_ADDR].regsize ! 132: && op->curtmps.next_avail[REG_ADDR] ! 133: >= regtypes[REG_ADDR].lowreg) { ! 134: offset = op->curtmps.next_avail[REG_ADDR]--; ! 135: if (offset < op->low_water[REG_ADDR]) { ! 136: op->low_water[REG_ADDR] = offset; ! 137: } ! 138: nlp = defnl(0, VAR, type, offset + ADDR_REG_OFFSET ); ! 139: nlp -> extra_flags = NLOCAL | NREGVAR; ! 140: putlbracket(ftnno, op); ! 141: return nlp; ! 142: } ! 143: # endif mc68000 ! 144: # endif PC ! 145: if (type == NIL) { ! 146: alignment = A_STACK; ! 147: } else if (type == nl+TPTR) { ! 148: alignment = A_POINT; ! 149: } else { ! 150: alignment = align(type); ! 151: } ! 152: op->curtmps.om_off = ! 153: roundup((int)(op->curtmps.om_off - size), alignment); ! 154: offset = op->curtmps.om_off; ! 155: if ( offset < op->om_max ) { ! 156: op->om_max = offset; ! 157: } ! 158: nlp = defnl( (char *) 0 , VAR , type , offset ); ! 159: # ifdef PC ! 160: nlp -> extra_flags = NLOCAL; ! 161: putlbracket(ftnno, op); ! 162: # endif PC ! 163: return nlp; ! 164: } ! 165: ! 166: /* ! 167: * deallocate runtime temporary variables ! 168: */ ! 169: /*ARGSUSED*/ ! 170: tmpfree(restore) ! 171: register struct tmps *restore; ! 172: { ! 173: # ifdef PC ! 174: register struct om *op = &sizes[ cbn ]; ! 175: bool change = FALSE; ! 176: ! 177: # ifdef vax ! 178: if (restore->next_avail[REG_GENERAL] ! 179: > op->curtmps.next_avail[REG_GENERAL]) { ! 180: op->curtmps.next_avail[REG_GENERAL] ! 181: = restore->next_avail[REG_GENERAL]; ! 182: change = TRUE; ! 183: } ! 184: # endif vax ! 185: # ifdef mc68000 ! 186: if (restore->next_avail[REG_DATA] ! 187: > op->curtmps.next_avail[REG_DATA]) { ! 188: op->curtmps.next_avail[REG_DATA] ! 189: = restore->next_avail[REG_DATA]; ! 190: change = TRUE; ! 191: } ! 192: if (restore->next_avail[REG_ADDR] ! 193: > op->curtmps.next_avail[REG_ADDR]) { ! 194: op->curtmps.next_avail[REG_ADDR] ! 195: = restore->next_avail[REG_ADDR]; ! 196: change = TRUE; ! 197: } ! 198: # endif mc68000 ! 199: if (restore->om_off > op->curtmps.om_off) { ! 200: op->curtmps.om_off = restore->om_off; ! 201: change = TRUE; ! 202: } ! 203: if (change) { ! 204: putlbracket(ftnno, op); ! 205: } ! 206: #endif PC ! 207: } ! 208: ! 209: #ifdef PC ! 210: #ifdef vax ! 211: /* ! 212: * create a save mask for registers which have been used ! 213: * in this level ! 214: */ ! 215: savmask() ! 216: { ! 217: int mask; ! 218: int i; ! 219: ! 220: mask = RSAVEMASK; ! 221: if (opt('t')) ! 222: mask |= RUNCHECK; ! 223: for (i = 0; i <= regtypes[REG_GENERAL].highreg; i++) { ! 224: if (i >= sizes[cbn].low_water[REG_GENERAL]) { ! 225: mask |= 1 << i; ! 226: } ! 227: } ! 228: return mask; ! 229: } ! 230: #endif vax ! 231: #endif PC
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.