Return to machdep.c CVS log

Up to [Net/2] / Net2 / arch / vax / inline

Annotation of Net2/arch/vax/inline/machdep.c, revision 1.1

1.1     ! root        1: /*-
        !             2:  * Copyright (c) 1984, 1986 The Regents of the University of California.
        !             3:  * All rights reserved.
        !             4:  *
        !             5:  * Redistribution and use in source and binary forms, with or without
        !             6:  * modification, are permitted provided that the following conditions
        !             7:  * are met:
        !             8:  * 1. Redistributions of source code must retain the above copyright
        !             9:  *    notice, this list of conditions and the following disclaimer.
        !            10:  * 2. Redistributions in binary form must reproduce the above copyright
        !            11:  *    notice, this list of conditions and the following disclaimer in the
        !            12:  *    documentation and/or other materials provided with the distribution.
        !            13:  * 3. All advertising materials mentioning features or use of this software
        !            14:  *    must display the following acknowledgement:
        !            15:  *     This product includes software developed by the University of
        !            16:  *     California, Berkeley and its contributors.
        !            17:  * 4. Neither the name of the University nor the names of its contributors
        !            18:  *    may be used to endorse or promote products derived from this software
        !            19:  *    without specific prior written permission.
        !            20:  *
        !            21:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
        !            22:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
        !            23:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
        !            24:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
        !            25:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
        !            26:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
        !            27:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
        !            28:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
        !            29:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
        !            30:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
        !            31:  * SUCH DAMAGE.
        !            32:  */
        !            33: 
        !            34: #ifndef lint
        !            35: static char sccsid[] = "@(#)machdep.c  7.2 (Berkeley) 5/8/91";
        !            36: #endif /* not lint */
        !            37: 
        !            38: #include <stdio.h>
        !            39: #include <ctype.h>
        !            40: #include "inline.h"
        !            41: 
        !            42: extern char *strcpy();
        !            43: extern char *strcat();
        !            44: extern char *index();
        !            45: 
        !            46: /*
        !            47:  * The routines and tables in this file must be rewritten
        !            48:  * for each new machine that this program is ported to.
        !            49:  */
        !            50: 
        !            51: #ifdef vax
        !            52: /*
        !            53:  * Instruction stop table.
        !            54:  * All instructions that implicitly modify any of the temporary
        !            55:  * registers, change control flow, or implicitly loop must be
        !            56:  * listed in this table. It is used to find the end of a basic
        !            57:  * block when scanning backwards through the instruction stream
        !            58:  * trying to merge the inline expansion.
        !            59:  */
        !            60: struct inststoptbl inststoptable[] = {
        !            61:        { "jbc" }, { "jlbc" }, { "jbs" }, { "jlbs" }, { "jbcc" },
        !            62:        { "jbsc" }, { "jbcs" }, { "jbss" }, { "jbr" }, { "jcc" },
        !            63:        { "jcs" }, { "jvc" }, { "jvs" }, { "jlss" }, { "jlssu" },
        !            64:        { "jleq" }, { "jlequ" }, { "jeql" }, { "jeqlu" }, { "jneq" },
        !            65:        { "jnequ" }, { "jgeq" }, { "jgequ" }, { "jgtr" }, { "jgtru" },
        !            66:        { "chmk" }, { "chme" }, { "chms" }, { "chmu" }, { "rei" },
        !            67:        { "ldpctx" }, { "svpctx" }, { "xfc" }, { "bpt" },
        !            68:        { "bugw" }, { "bugl" }, { "halt" }, { "pushr" }, { "popr" },
        !            69:        { "polyf" }, { "polyd" }, { "polyg" }, { "polyh" },
        !            70:        { "bneq" }, { "bnequ" }, { "beql" }, { "beqlu" }, { "bgtr" },
        !            71:        { "bleq" }, { "bgeq" }, { "blss" }, { "bgtru" }, { "blequ" },
        !            72:        { "bvc" }, { "bvs" }, { "bgequ" }, { "bcc" }, { "blssu" },
        !            73:        { "bcs" }, { "brb" }, { "brw" }, { "jmp" },
        !            74:        { "bbs" }, { "bbc" }, { "bbss" }, { "bbcs" }, { "bbsc" },
        !            75:        { "bbcc" }, { "bbssi" }, { "bbcci" }, { "blbs" }, { "blbc" },
        !            76:        { "acbb" }, { "acbw" }, { "acbl" }, { "acbf" }, { "acbd" },
        !            77:        { "acbg" }, { "acbh" }, { "aoblss" }, { "aobleq" },
        !            78:        { "sobgeq" }, { "sobgtr" }, { "caseb" }, { "casew" }, { "casel" },
        !            79:        { "bsbb" }, { "bsbw" }, { "jsb" }, { "rsb" },
        !            80:        { "callg" }, { "calls" }, { "ret" },
        !            81:        { "movc3" }, { "movc5" }, { "movtc" }, { "movtuc" },
        !            82:        { "cmpc3" }, { "cmpc5" }, { "scanc" }, { "spanc" },
        !            83:        { "locc" }, { "skpc" }, { "matchc" }, { "crc" },
        !            84:        { "movp" }, { "cmpp3" }, { "cmpp4" }, { "addp4" }, { "addp6" },
        !            85:        { "subp4" }, { "subp6" }, { "mulp" }, { "divp" }, { "cvtlp" },
        !            86:        { "cvtpl" }, { "cvtpt" }, { "cvttp" }, { "cvtps" }, { "cvtsp" },
        !            87:        { "ashp" }, { "editpc" },
        !            88:        { "escd" }, { "esce" }, { "escf" },
        !            89:        { "" }
        !            90: };
        !            91: 
        !            92: /*
        !            93:  * Check to see if a line is a candidate for replacement.
        !            94:  * Return pointer to name to be looked up in pattern table.
        !            95:  */
        !            96: char *
        !            97: doreplaceon(cp)
        !            98:        char *cp;
        !            99: {
        !           100: 
        !           101:        if (bcmp(cp, "calls\t", 6) != 0)
        !           102:                return (0);
        !           103:        if ((cp = index(cp + 6, ',')) == 0)
        !           104:                return (0);
        !           105:        return (++cp);
        !           106: }
        !           107: 
        !           108: /*
        !           109:  * Find out how many arguments the function is being called with.
        !           110:  * A return value of -1 indicates that the count can't be determined.
        !           111:  */
        !           112: int
        !           113: countargs(cp)
        !           114:        char *cp;
        !           115: {
        !           116: 
        !           117:        if ((cp = index(cp, '$')) == 0)
        !           118:                return (-1);
        !           119:        if (!isdigit(*++cp))
        !           120:                return (-1);
        !           121:        return (atoi(cp));
        !           122: }
        !           123: 
        !           124: /*
        !           125:  * Find the next argument to the function being expanded.
        !           126:  */
        !           127: nextarg(argc, argv)
        !           128:        int argc;
        !           129:        char *argv[];
        !           130: {
        !           131:        register char *lastarg = argv[2];
        !           132: 
        !           133:        if (argc == 3 &&
        !           134:            bcmp(argv[0], "mov", 3) == 0 &&
        !           135:            bcmp(argv[1], "(sp)+", 6) == 0 &&
        !           136:            lastarg[0] == 'r' && isdigit(lastarg[1]) && lastarg[2] == '\0')
        !           137:                return (lastarg[1] - '0');
        !           138:        return (-1);
        !           139: }
        !           140: 
        !           141: /*
        !           142:  * Determine whether the current line pushes an argument.
        !           143:  */
        !           144: ispusharg(argc, argv)
        !           145:        int argc;
        !           146:        char *argv[];
        !           147: {
        !           148: 
        !           149:        if (argc < 2)
        !           150:                return (0);
        !           151:        if (argc == 2 && bcmp(argv[0], "push", 4) == 0)
        !           152:                return (1);
        !           153:        if (bcmp(argv[argc - 1], "-(sp)", 6) == 0)
        !           154:                return (1);
        !           155:        return (0);
        !           156: }
        !           157: 
        !           158: /*
        !           159:  * Determine which (if any) registers are modified
        !           160:  * Return register number that is modified, -1 if none are modified.
        !           161:  */
        !           162: modifies(argc, argv)
        !           163:        int argc;
        !           164:        char *argv[];
        !           165: {
        !           166:        /*
        !           167:         * For the VAX all we care about are r0 to r5
        !           168:         */
        !           169:        register char *lastarg = argv[argc - 1];
        !           170: 
        !           171:        if (lastarg[0] == 'r' && isdigit(lastarg[1]) && lastarg[2] == '\0')
        !           172:                return (lastarg[1] - '0');
        !           173:        return (-1);
        !           174: }
        !           175: 
        !           176: /*
        !           177:  * Rewrite the instruction in (argc, argv) to store its
        !           178:  * contents into arg instead of onto the stack. The new
        !           179:  * instruction is placed in the buffer that is provided.
        !           180:  */
        !           181: rewrite(instbuf, argc, argv, target)
        !           182:        char *instbuf;
        !           183:        int argc;
        !           184:        char *argv[];
        !           185:        int target;
        !           186: {
        !           187: 
        !           188:        switch (argc) {
        !           189:        case 0:
        !           190:                instbuf[0] = '\0';
        !           191:                fprintf(stderr, "blank line to rewrite?\n");
        !           192:                return;
        !           193:        case 1:
        !           194:                sprintf(instbuf, "\t%s\n", argv[0]);
        !           195:                fprintf(stderr, "rewrite?-> %s", instbuf);
        !           196:                return;
        !           197:        case 2:
        !           198:                if (bcmp(argv[0], "push", 4) == 0) {
        !           199:                        sprintf(instbuf, "\tmov%s\t%s,r%d\n",
        !           200:                                &argv[0][4], argv[1], target);
        !           201:                        return;
        !           202:                }
        !           203:                sprintf(instbuf, "\t%s\tr%d\n", argv[0], target);
        !           204:                return;
        !           205:        case 3:
        !           206:                sprintf(instbuf, "\t%s\t%s,r%d\n", argv[0], argv[1], target);
        !           207:                return;
        !           208:        case 4:
        !           209:                sprintf(instbuf, "\t%s\t%s,%s,r%d\n",
        !           210:                        argv[0], argv[1], argv[2], target);
        !           211:                return;
        !           212:        case 5:
        !           213:                sprintf(instbuf, "\t%s\t%s,%s,%s,r%d\n",
        !           214:                        argv[0], argv[1], argv[2], argv[3], target);
        !           215:                return;
        !           216:        default:
        !           217:                sprintf(instbuf, "\t%s\t%s", argv[0], argv[1]);
        !           218:                argc -= 2, argv += 2;
        !           219:                while (argc-- > 0) {
        !           220:                        (void) strcat(instbuf, ",");
        !           221:                        (void) strcat(instbuf, *argv++);
        !           222:                }
        !           223:                (void) strcat(instbuf, "\n");
        !           224:                fprintf(stderr, "rewrite?-> %s", instbuf);
        !           225:                return;
        !           226:        }
        !           227: }
        !           228: 
        !           229: /*
        !           230:  * Do any necessary post expansion cleanup.
        !           231:  */
        !           232: /*ARGSUSED*/
        !           233: cleanup(numargs)
        !           234:        int numargs;
        !           235: {
        !           236: 
        !           237:        return;
        !           238: }
        !           239: #endif vax
        !           240: 
        !           241: #ifdef mc68000
        !           242: /*
        !           243:  * Instruction stop table.
        !           244:  * All instructions that implicitly modify any of the temporary
        !           245:  * registers, change control flow, or implicitly loop must be
        !           246:  * listed in this table. It is used to find the end of a basic
        !           247:  * block when scanning backwards through the instruction stream
        !           248:  * trying to merge the inline expansion.
        !           249:  */
        !           250: struct inststoptbl inststoptable[] = {
        !           251:        { "" }
        !           252: };
        !           253: 
        !           254: /*
        !           255:  * Check to see if a line is a candidate for replacement.
        !           256:  * Return pointer to name to be looked up in pattern table.
        !           257:  */
        !           258: char *
        !           259: doreplaceon(cp)
        !           260:        char *cp;
        !           261: {
        !           262: 
        !           263:        if (bcmp(cp, "jbsr\t", 5) == 0)
        !           264:                return (cp + 5);
        !           265:        return (0);
        !           266: }
        !           267: 
        !           268: /*
        !           269:  * Find out how many arguments the function is being called with.
        !           270:  * A return value of -1 indicates that the count can't be determined.
        !           271:  */
        !           272: /* ARGSUSED */
        !           273: int
        !           274: countargs(cp)
        !           275:        char *cp;
        !           276: {
        !           277: 
        !           278:        /*
        !           279:         * TODO
        !           280:         * Figure out what the count should be. 
        !           281:         * Probably have to read the next instruction here
        !           282:         * instead of in cleanup() below.
        !           283:         */
        !           284:        return (-1);
        !           285: }
        !           286: 
        !           287: /*
        !           288:  * Find the next argument to the function being expanded.
        !           289:  */
        !           290: nextarg(argc, argv)
        !           291:        int argc;
        !           292:        char *argv[];
        !           293: {
        !           294:        register char *lastarg = argv[2];
        !           295: 
        !           296:        if (argc == 3 &&
        !           297:            bcmp(argv[0], "movl", 5) == 0 &&
        !           298:            bcmp(argv[1], "sp@+", 5) == 0 &&
        !           299:            (lastarg[1] == '0' || lastarg[1] == '1') &&
        !           300:            lastarg[2] == '\0') {
        !           301:                if (lastarg[0] == 'd')
        !           302:                        return (lastarg[1] - '0');
        !           303:                return (lastarg[1] - '0' + 8);
        !           304:        }
        !           305:        return (-1);
        !           306: }
        !           307: 
        !           308: /*
        !           309:  * Determine whether the current line pushes an argument.
        !           310:  */
        !           311: ispusharg(argc, argv)
        !           312:        int argc;
        !           313:        char *argv[];
        !           314: {
        !           315: 
        !           316:        if (argc < 2)
        !           317:                return (0);
        !           318:        if (argc == 2 && bcmp(argv[0], "pea", 4) == 0)
        !           319:                return (1);
        !           320:        if (bcmp(argv[argc - 1], "sp@-", 5) == 0)
        !           321:                return (1);
        !           322:        return (0);
        !           323: }
        !           324: 
        !           325: /*
        !           326:  * Determine which (if any) registers are modified
        !           327:  * Return register number that is modified, -1 if none are modified.
        !           328:  */
        !           329: modifies(argc, argv)
        !           330:        int argc;
        !           331:        char *argv[];
        !           332: {
        !           333:        /*
        !           334:         * For the MC68000 all we care about are d0, d1, a0, and a1.
        !           335:         */
        !           336:        register char *lastarg = argv[argc - 1];
        !           337: 
        !           338:        if (lastarg[0] == 'd' && isdigit(lastarg[1]) && lastarg[2] == '\0')
        !           339:                return (lastarg[1] - '0');
        !           340:        if (lastarg[0] == 'a' && isdigit(lastarg[1]) && lastarg[2] == '\0')
        !           341:                return (lastarg[1] - '0' + 8);
        !           342:        return (-1);
        !           343: }
        !           344: 
        !           345: /*
        !           346:  * Rewrite the instruction in (argc, argv) to store its
        !           347:  * contents into arg instead of onto the stack. The new
        !           348:  * instruction is placed in the buffer that is provided.
        !           349:  */
        !           350: rewrite(instbuf, argc, argv, target)
        !           351:        char *instbuf;
        !           352:        int argc;
        !           353:        char *argv[];
        !           354:        int target;
        !           355: {
        !           356:        int regno;
        !           357:        char regtype;
        !           358: 
        !           359:        if (target < 8) {
        !           360:                regtype = 'd';
        !           361:                regno = target;
        !           362:        } else {
        !           363:                regtype = 'a';
        !           364:                regno = target - 8;
        !           365:        }
        !           366:        switch (argc) {
        !           367:        case 0:
        !           368:                instbuf[0] = '\0';
        !           369:                fprintf(stderr, "blank line to rewrite?\n");
        !           370:                return;
        !           371:        case 1:
        !           372:                sprintf(instbuf, "\t%s\n", argv[0]);
        !           373:                fprintf(stderr, "rewrite?-> %s", instbuf);
        !           374:                return;
        !           375:        case 2:
        !           376:                if (bcmp(argv[0], "pea", 4) == 0) {
        !           377:                        if (regtype == 'a') {
        !           378:                                sprintf(instbuf, "\tlea\t%s,%c%d\n",
        !           379:                                        argv[1], regtype, regno);
        !           380:                                return;
        !           381:                        }
        !           382:                        if (argv[1][0] == '_' || isdigit(argv[1][0])) {
        !           383:                                sprintf(instbuf, "\tmovl\t#%s,%c%d\n",
        !           384:                                        argv[1], regtype, regno);
        !           385:                                return;
        !           386:                        }
        !           387:                        sprintf(instbuf,
        !           388:                                "\texg\ta0,d%d\n\tlea\t%s,a0\n\texg\ta0,d%d\n",
        !           389:                                regno, argv[1], regno);
        !           390:                        return;
        !           391:                }
        !           392:                sprintf(instbuf, "\t%s\t%c%d\n", argv[0], regtype, regno);
        !           393:                return;
        !           394:        case 3:
        !           395:                sprintf(instbuf, "\t%s\t%s,%c%d\n",
        !           396:                        argv[0], argv[1], regtype, regno);
        !           397:                return;
        !           398:        default:
        !           399:                sprintf(instbuf, "\t%s\t%s", argv[0], argv[1]);
        !           400:                argc -= 2, argv += 2;
        !           401:                while (argc-- > 0) {
        !           402:                        (void) strcat(instbuf, ",");
        !           403:                        (void) strcat(instbuf, *argv++);
        !           404:                }
        !           405:                (void) strcat(instbuf, "\n");
        !           406:                fprintf(stderr, "rewrite?-> %s", instbuf);
        !           407:                return;
        !           408:        }
        !           409: }
        !           410: 
        !           411: /*
        !           412:  * Do any necessary post expansion cleanup.
        !           413:  */
        !           414: cleanup(numargs)
        !           415:        int numargs;
        !           416: {
        !           417:        extern int lineno;
        !           418:        
        !           419:        if (numargs == 0)
        !           420:                return;
        !           421:        /*
        !           422:         * delete instruction to pop arguments.
        !           423:         * TODO:
        !           424:         *      CHECK FOR LABEL
        !           425:         *      CHECK THAT INSTRUCTION IS A POP
        !           426:         */
        !           427:        fgets(line[bufhead], MAXLINELEN, stdin);
        !           428:        lineno++;
        !           429: }
        !           430: #endif mc68000

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.