Return to hppa-check.c CVS log

Up to [Apple XNU] / GNUtools / cctools / as

Annotation of GNUtools/cctools/as/hppa-check.c, revision 1.1

1.1     ! root        1: #include "hppa-opcode.h"
        !             2: #include <stdio.h>
        !             3: 
        !             4: extern long random();
        !             5: 
        !             6: #define RANGE(number)  (random() % (number))
        !             7: #define COIN                   (RANGE(2))
        !             8: #define IMM_NUM(range) {       int tmp000111000usv = RANGE(range); \
        !             9:                                                        if (tmp000111000usv == 0) \
        !            10:                                                                printf(" %d", tmp000111000usv); \
        !            11:                                                        else \
        !            12:                                                                printf(" %c%d", (COIN) ? '-' : ' ',  \
        !            13:                                                                        tmp000111000usv); \
        !            14:                                                }
        !            15: 
        !            16: 
        !            17: /* The 'cond' decode table */
        !            18: 
        !            19: typedef  struct  condition_decode {
        !            20:        char condition[4];
        !            21: }  condT;
        !            22: 
        !            23: char *get_cond_str(const condT table[8][2], int c, int f );
        !            24: 
        !            25: /* condition decode tables
        !            26:  * Refer to PA-RISC 1.1 Architecture and Instruction Set 
        !            27:  * Reference Manual, Second edition, Sep. 1992, pp. 5-2 - 5-8.
        !            28:  */
        !            29: 
        !            30: /* Note : In all the following tables
        !            31:  *        ""   ... never
        !            32:  *        "???"   ... Invalid combination 
        !            33:  */
        !            34: 
        !            35: /* compare/subtraclt instruction conditions */
        !            36: const condT c_comp_sub[8][2]  = { /* Table 5-3 */
        !            37:        { "", "TR" },
        !            38:        { "=", "<>" },
        !            39:        { "<", ">=" },
        !            40:        { "<=", ">" },
        !            41:        { "<<", ">>=" },
        !            42:        { "<<=", ">>" },
        !            43:        { "SV", "NSV" },
        !            44:        { "OD", "EV" }
        !            45: };
        !            46: 
        !            47: /* add instruction conditions */
        !            48: const condT c_add[8][2]  = { /* Table 5-4 */
        !            49:        { "", "TR" },
        !            50:        { "=", "<>" },
        !            51:        { "<", ">=" },
        !            52:        { "<=", ">" },
        !            53:        { "NUV", "UV"  },
        !            54:        { "ZNV", "VNZ" },
        !            55:        { "SV", "NSV" },
        !            56:        { "OD", "EV" }
        !            57: };
        !            58: 
        !            59: /* logical instruction conditions */
        !            60: const condT c_logical[8][2]  = { /* Table 5-5 */
        !            61:        { "", "TR" },
        !            62:        { "=", "<>" },
        !            63:        { "<", ">=" },
        !            64:        { "<=", ">" },
        !            65:        { "???", "???" },
        !            66:        { "???", "???" },
        !            67:        { "???", "???" },
        !            68:        { "OD", "EV" }
        !            69: };
        !            70: 
        !            71: /* unit instruction conditions */
        !            72: const condT c_unit[8][2]  = { /* Table 5-6 */
        !            73:        { "", "TR" },
        !            74:        { "???", "???" },
        !            75:        { "SBZ", "NBZ" },
        !            76:        { "SHZ", "NHZ" },
        !            77:        { "SDC", "NDC" },
        !            78:        { "???", "???" },
        !            79:        { "SBC", "NBC" },
        !            80:        { "SHC", "NHC" }
        !            81: };
        !            82: 
        !            83: /* shift/extract/deposit instruction conditions */
        !            84: const condT c_shift_extract_deposit[8][2]  = { /* Table 5-7 */
        !            85:        { "", "???" },
        !            86:        { "=", "???" },
        !            87:        { "<", "???" },
        !            88:        { "OD", "???" },
        !            89:        { "TR", "???" },
        !            90:        { "<>", "???" },
        !            91:        { ">=", "???" },
        !            92:        { "EV", "???" }
        !            93: };
        !            94: 
        !            95: 
        !            96: 
        !            97: char *controlregs[] = { "fir", "psr", "epsr", "dirbase", "db", "fsr" };
        !            98: #define NCREGS (sizeof controlregs / sizeof controlregs[0])
        !            99: 
        !           100: char *textlabels[] = { "foo", "bar", "baz", "xork" };
        !           101: #define NTLABELS       (sizeof textlabels / sizeof textlabels[0])
        !           102: 
        !           103: char *datalabels[] = { "data1", "data2", "data3", "data4" };
        !           104: #define NDLABELS       (sizeof datalabels / sizeof datalabels[0])
        !           105: 
        !           106: char *fp_cmp_cond[] =  {
        !           107:        "false?","false", "true?", "true", "!<=>", "!?>=", "!?<=",
        !           108:        "!<>", "!>=", "!?>", "?<=", "!<=", "!?<", "?>=", "!?=",
        !           109:        "!=t", "<=>", "=t", "?=", "?<", "<=", "!>", "?>", ">=",
        !           110:        "!<", "<>", "!=", "!?", "?", "=", "<", ">"
        !           111: };
        !           112: #define NFPCOND        (sizeof fp_cmp_cond / sizeof fp_cmp_cond[0])
        !           113: 
        !           114: char *fp_format_str[] = { "sgl", "dbl", "quad" };
        !           115: #define NFPFMT (sizeof fp_format_str / sizeof fp_format_str[0])
        !           116: 
        !           117: /*
        !           118:  * Traverse the opcode table, dumping out sample instructions.
        !           119:  */
        !           120: void
        !           121: main()
        !           122: {
        !           123:        int i;
        !           124:        const char *arg;
        !           125:        int do_not_nullify = 0;
        !           126:        
        !           127:        printf( "\t.text\n%s:", textlabels[0] );
        !           128:        /* a label at the begining of the file */
        !           129:        printf("label1:\n");
        !           130:        
        !           131:        for ( i = 0; i < NUMOPCODES; ++i )
        !           132:        {
        !           133:                if ( i == (NUMOPCODES/3) )
        !           134:                        printf( "%s:", textlabels[1] );
        !           135:                if ( i == (NUMOPCODES/2) )
        !           136:                        printf( "%s:", textlabels[2] );
        !           137: 
        !           138:                printf( "\t%s", pa_opcodes[i].name );
        !           139:                
        !           140:                for ( arg = pa_opcodes[i].args; *arg != '\0'; ++arg )
        !           141:                {
        !           142:                    switch( *arg ) {
        !           143: 
        !           144:                        case '\0':  /* end of args */
        !           145:                                break;
        !           146: 
        !           147:                        case '(':   /* these must match exactly */
        !           148:                                putchar(' '); /* and FALLTHRU  */
        !           149:                        case ')':
        !           150:                        case ',':
        !           151:                        case ' ':
        !           152:                                putchar(*arg);
        !           153:                                break;
        !           154: 
        !           155:                        case 'b':   /* 5 bit register field at 10 */
        !           156:                        case 'x':   /* 5 bit register field at 15 */
        !           157:                        case 't':   /* 5 bit register field at 31 */
        !           158:                        case 'v':   /* a 't' type extended to handle L/R register halves. */
        !           159:                        case 'E':   /* a 'b' type extended to handle L/R register halves. */
        !           160:                        case 'X':   /* an 'x' type extended to handle L/R register halves. */
        !           161:                        case '4':   /* 5 bit register field at 10 (used in 'fmpyadd' and 'fmpysub') */
        !           162:                        case '6':   /* 5 bit register field at 15 (used in 'fmpyadd' and 'fmpysub') */
        !           163:                        case '7':   /* 5 bit register field at 31 (used in 'fmpyadd' and 'fmpysub') */
        !           164:                        case '8':   /* 5 bit register field at 20 (used in 'fmpyadd' and 'fmpysub') */
        !           165:                        case '9':   /* 5 bit register field at 25 (used in 'fmpyadd' and 'fmpysub') */
        !           166:                                printf(" %%r%d", RANGE(32));
        !           167:                                break;
        !           168: 
        !           169:                        case 'r':   /* 5  bit immediate at 31 */
        !           170:                        case 'R':   /* 5  bit immediate at 15 */
        !           171:                                printf(" %d", RANGE(32));
        !           172:                                break;
        !           173:                        case 'T':   /* 5 bit field length at 31 (encoded as 32-T) */
        !           174:                                printf(" %d", RANGE(31) + 1);
        !           175:                                break;
        !           176: 
        !           177:                        case '5':   /* 5 bit immediate at 15 */
        !           178:                        case 'V':   /* 5  bit immediate at 31 */
        !           179:                        case 'p':   /* 5 bit shift count at 26 (to support SHD instr.) */
        !           180:                                                /* value is encoded in instr. as 31-p where p is   */
        !           181:                                                /* the value scanned here */
        !           182:                        case 'P':   /* 5-bit bit position at 26 */
        !           183:                        case 'Q':   /* 5  bit immediate at 10 (unsigned bit position */
        !           184:                                                /* value for the bb instruction) */
        !           185:                                IMM_NUM(15);
        !           186:                                continue;
        !           187: 
        !           188:                        case 's':   /* 2 bit space identifier at 17 */
        !           189:                                printf(" %d", RANGE(4));
        !           190:                                break;
        !           191: 
        !           192:                        case 'S':   /* 3 bit space identifier at 18 */
        !           193:                                printf(" %%sr%d", RANGE(8));
        !           194:                                break;
        !           195: 
        !           196:                        case 'c':   /* indexed load completer. */
        !           197:                        {
        !           198:                                int m, u, i;
        !           199:                                
        !           200:                                m = COIN;
        !           201:                                u = COIN;
        !           202:                                i = 0;
        !           203:                                if (COIN)
        !           204:                                        while (i < 2) {
        !           205:                                                if (m==1 && u==1) {
        !           206:                                                        printf(",sm");
        !           207:                                                        i++;
        !           208:                                                }
        !           209:                                                else if (m==1) 
        !           210:                                                        printf(",m");
        !           211:                                                        else if (u==1)
        !           212:                                                                printf(",s");
        !           213:                                                                else /* m==0 && u==0 */ {
        !           214:                                                                        printf(",sm");
        !           215:                                                                        i++;
        !           216:                                                                } /* probability distribution */
        !           217:                                                i++;
        !           218:                                        }
        !           219:                                continue;
        !           220:                        }
        !           221:                        case 'C':   /* short load and store completer */
        !           222:                                if (COIN) 
        !           223:                                        if (COIN)
        !           224:                                                printf(",mb");
        !           225:                                        else
        !           226:                                                printf(",ma");
        !           227:                                continue;
        !           228:                        case 'Y':   /* Store Bytes Short completer */
        !           229:                        {
        !           230:                                int i = 0, m, a;
        !           231:                                while ( i < 2 ) {
        !           232:                                        m = COIN;
        !           233:                                        a = COIN;
        !           234:                                
        !           235:                                        if (m==1) /* && (a==0 || a==1) */
        !           236:                                                printf(",m");
        !           237:                                        else if (a==0)  /* && m==0 */
        !           238:                                                printf(",b");
        !           239:                                                else if (a==1) /* && m==0 */
        !           240:                                                        printf(",e");
        !           241:                                        i++;
        !           242:                                }
        !           243:                                continue;
        !           244:                        }
        !           245:                        case '<':   /* non-negated compare/subtract conditions. */
        !           246:                        {
        !           247:                                int cmpltr;
        !           248:                                
        !           249:                                do {
        !           250:                                        cmpltr = RANGE(4);
        !           251:                                } while (cmpltr == 0);
        !           252:                                
        !           253:                                printf(",%s", get_cond_str(c_comp_sub, cmpltr, 0));
        !           254:                        }
        !           255:                                continue;
        !           256:                        case '?':   /* negated or non-negated cmp/sub conditions. */
        !           257:                                        /* used only by ``comb'' and ``comib'' pseudo-ops */
        !           258:                        case '-':   /* compare/subtract conditions */
        !           259:                        {
        !           260:                                int flag, cmpltr;
        !           261:                                char *tmp;
        !           262:                                
        !           263:                                do {
        !           264:                                        flag = COIN;
        !           265:                                        cmpltr = RANGE(8);
        !           266:                                } while ((flag & cmpltr) == 0 || (cmpltr == 0));
        !           267:                                
        !           268:                                tmp = get_cond_str(c_comp_sub, cmpltr, flag);                           
        !           269: 
        !           270:                                if (*tmp != '\0')
        !           271:                                        printf(",%s", tmp);
        !           272:                        }
        !           273:                                continue;
        !           274:                        case '+':   /* non-negated add conditions */
        !           275:                        case '!':   /* negated or non-negated add conditions. */
        !           276:                        {
        !           277:                                int flag, cmpltr;
        !           278:                                char *tmp;
        !           279:                                
        !           280:                                do {
        !           281:                                        flag = COIN;
        !           282:                                        cmpltr = RANGE(8);
        !           283:                                } while ((flag & cmpltr) == 0 || (cmpltr == 0));
        !           284:                                
        !           285:                                tmp = get_cond_str(c_add, cmpltr, flag);
        !           286:                                
        !           287:                                if (COIN && (*tmp != '\0')) /* condition */ {
        !           288:                                                printf(",%s", tmp);
        !           289:                                                if (COIN) { /* nullify */
        !           290:                                                        printf(",n ");
        !           291:                                                        do_not_nullify = 1;
        !           292:                                                }
        !           293:                                }
        !           294:                        }
        !           295:                                continue;               
        !           296:                        case '&':   /* logical instruction conditions */
        !           297:                        {
        !           298:                                int flag, cmpltr;
        !           299:                                char *tmp;
        !           300:                                
        !           301:                                flag = COIN;
        !           302:                                do {
        !           303:                                        cmpltr = RANGE(8);
        !           304:                                } while (cmpltr == 4 || cmpltr == 5 || cmpltr == 6);
        !           305:                                
        !           306:                                tmp = get_cond_str(c_logical, cmpltr, flag);                            
        !           307: 
        !           308:                                if (COIN && (*tmp != '\0')) /* condition */
        !           309:                                        printf(",%s", tmp);
        !           310:                        }
        !           311:                                continue;
        !           312:                        case 'U':   /* unit instruction conditions */
        !           313:                        {
        !           314:                                int flag, cmpltr;
        !           315:                                char *tmp;
        !           316: 
        !           317:                                flag = COIN;
        !           318:                                do {
        !           319:                                        cmpltr = RANGE(8);
        !           320:                                } while (cmpltr == 1 || cmpltr == 5);
        !           321:                                
        !           322:                                tmp = get_cond_str(c_unit, cmpltr, flag);                               
        !           323:                                if (COIN && (*tmp != '\0')) /* condition */
        !           324:                                        printf(",%s", tmp);
        !           325:                        }
        !           326:                                continue;
        !           327:                        case '>':   /* shift/extract/deposit conditions. */
        !           328:                        {
        !           329:                                int  cmpltr;
        !           330:                                char *tmp;
        !           331:                                
        !           332:                                cmpltr = RANGE(8);
        !           333:                                
        !           334:                                tmp = get_cond_str(c_shift_extract_deposit, cmpltr, 0);                         
        !           335: 
        !           336:                                if (COIN && (*tmp != '\0')) /* condition */
        !           337:                                        printf(",%s", tmp);
        !           338:                        }
        !           339:                                continue;
        !           340:                        case '~':   /* bvb,bb conditions */
        !           341:                                if (COIN)
        !           342:                                        printf(",<");
        !           343:                                else
        !           344:                                        printf(",>=");
        !           345:                                continue;
        !           346:                                
        !           347:                        case 'i':   /* 11 bit immediate at 31 */
        !           348:                                IMM_NUM(1024);
        !           349:                                continue;
        !           350:                                
        !           351:                        case 'j':   /* 14 bit immediate at 31 --- LO14 */
        !           352:                        case 'a':       /* for be, ble --- BR17*/
        !           353:                        {
        !           354:                                int field_selector = RANGE(3);
        !           355:                                switch (field_selector) {
        !           356:                                case 2: /* field selector R`*/
        !           357:                                        printf(" R`");
        !           358:                                        break;
        !           359:                                case 1: /* field selector L`*/
        !           360:                                        printf(" L`");
        !           361:                                        break;
        !           362:                                default:
        !           363:                                        break;
        !           364:                                }
        !           365:                                IMM_NUM(8192);
        !           366:                                continue;
        !           367:                        }  
        !           368:                        case 'k':   /* 21 bit immediate at 31 --- HI21 */
        !           369:                        {
        !           370:                                int field_selector = RANGE(3);
        !           371:                                switch (field_selector) {
        !           372:                                case 2: /* field selector R`*/
        !           373:                                        printf(" R`");
        !           374:                                        break;
        !           375:                                case 1: /* field selector L`*/
        !           376:                                        printf(" L`");
        !           377:                                        break;
        !           378:                                default:
        !           379:                                        break;
        !           380:                                }
        !           381:                                IMM_NUM(1048576);
        !           382:                                continue;
        !           383:                        }                       
        !           384:                        case 'n':   /* nullification for branch instructions */
        !           385:                                if (!do_not_nullify)
        !           386:                                        if (COIN)
        !           387:                                                printf(",n");
        !           388:                                else
        !           389:                                        do_not_nullify = 0;
        !           390:                                continue;               
        !           391:                        case 'w':   /* 12 bit branch displacement */
        !           392:                                IMM_NUM(2048);
        !           393:                                continue;
        !           394:                        case 'W':   /* 17 bit branch displacement --- BL17 */
        !           395:                        case '@':   /* 17 bit branch displacement --- JBSR */
        !           396:                        case 'z':   /* 17 bit branch displacement (non-pc-relative) */
        !           397:                                IMM_NUM(65536);
        !           398:                                continue;
        !           399:                        case 'B':   /* either "s,b" or "b" where b & s are defined above */
        !           400:                                if (COIN)
        !           401:                                        printf(" %d,", RANGE(4));
        !           402:                                printf(" %%r%d", RANGE(32));
        !           403:                                break;
        !           404:                        case 'A':   /* 13 bit immediate at 18 (to support BREAK instr.) */
        !           405:                                printf(" %d", RANGE(4096));
        !           406:                                continue;
        !           407:                        case 'Z':   /* System Control Completer(for LDA, LHA, etc.) */
        !           408:                                if (COIN)
        !           409:                                        printf(",M");
        !           410:                                continue;
        !           411:                        case 'D':   /* 26 bit immediate at 31 (to support DIAG instr.) */
        !           412:                                                /* the action (and interpretation of this operand is
        !           413:                                                        implementation dependent) */
        !           414:                                IMM_NUM(33554432);
        !           415:                                continue;
        !           416:                        case 'f':   /* 3 bit Special Function Unit (SFU) identifier at 25 */
        !           417:                        case 'u':   /* 3 bit coprocessor unit identifier at 25 */
        !           418:                                printf("%d", RANGE(8));
        !           419:                                continue;
        !           420:                        case 'O':   /* 20 bit SFU op. split between 15 bits at 20 and 5 bits at 31 */
        !           421:                                printf("%d", RANGE(1048576));
        !           422:                                continue;
        !           423:                        case 'o':   /* 15 bit Special Function Unit operation at 20 */
        !           424:                        case '1':   /* 15 bit SFU op. split between 10 bits at 20
        !           425:                                                        and 5 bits at 31 */
        !           426:                                printf("%d", RANGE(32768));
        !           427:                                continue;
        !           428:                        case '2':   /* 22 bit SFU op. split between 17 bits at 20
        !           429:                                                        and 5 bits at 31 */
        !           430:                                printf("%d", RANGE(4194304));
        !           431:                                continue;
        !           432:                        case '0':   /* 10 bit SFU op. split between 5 bits at 20
        !           433:                                                        and 5 bits at 31 */
        !           434:                                printf("%d", RANGE(1024));
        !           435:                                continue;
        !           436:                        case 'G':   /* Destination FP Operand Format Completer (2 bits at 18) */
        !           437:                        case 'F':   /* Source FP Operand Format Completer (2 bits at 20) */
        !           438:                                printf(",%s", fp_format_str[RANGE(NFPFMT)]);
        !           439:                                continue;
        !           440:                        case 'M':   /* FP Compare Conditions (encoded as 5 bits at 31) */
        !           441:                                printf(",%s", fp_cmp_cond[RANGE(NFPCOND)]);
        !           442:                                continue;
        !           443: 
        !           444: #if 0
        !           445:                        case 'H':  /* Floating Point Operand Format at 26 for       */
        !           446:                                                /* 'fmpyadd' and 'fmpysub' (very similar to 'F') */
        !           447:                                                /* bits are switched from other FP Operand       */
        !           448:                                                /* formats. 1=SGL, 1=<none>, 0=DBL               */
        !           449:                                f = pa_parse_fp_format(&s);
        !           450:                                switch (f) {
        !           451:                                case SGL:
        !           452:                                        opcode |= 0x20;
        !           453:                                case DBL:
        !           454:                                        the_insn.fpof1 = f;
        !           455:                                        continue;
        !           456: 
        !           457:                                case QUAD:
        !           458:                                case ILLEGAL_FMT:
        !           459:                                default:
        !           460:                                        as_bad("Illegal Floating Point Operand Format for"
        !           461:                                                "this instruction: '%s'",*s);
        !           462:                                }
        !           463:                                break;
        !           464:                        default:
        !           465:                                abort();
        !           466: #endif    /* 0 */
        !           467: 
        !           468:                        }
        !           469:                }
        !           470:                putchar( '\n' );
        !           471:        }
        !           472:        /* a label at the end of the file */
        !           473:        printf("label2:\n");
        !           474:        
        !           475: 
        !           476:        printf( "%s:\n", textlabels[3] );
        !           477:        printf( "\t.data\n" );
        !           478:        printf( "data1: .space 1024\n" );
        !           479:        printf( "data2: .space 1024\n" );
        !           480:        printf( "data3: .space 1024\n" );
        !           481:        printf( "data4: .space 1024\n" );
        !           482: 
        !           483: }
        !           484: 
        !           485: /* The function to search the condition decode table 
        !           486:  * and return the 'cond'
        !           487:  * The way tables are initialised ... NULL termination 
        !           488:  * of 'cond' is assured.
        !           489:  */ 
        !           490: char *get_cond_str(const condT table[8][2], int c, int f )
        !           491: {
        !           492: 
        !           493: /* do range check and return NULL if out of bound */
        !           494: /*     char *str;
        !           495:        if ( c < 0  || c > 7 )
        !           496:                *str = (char *) NULL;
        !           497:        else    if ( f < 0  || f > 1 )
        !           498:                *str = (char *) NULL;
        !           499:        else 
        !           500:                str = table[c][f].condition;
        !           501: 
        !           502:        return str;
        !           503: */
        !           504: 
        !           505: /* here goes the one liner */
        !           506: 
        !           507:        return (c<0 || c>7 || f<0 || f>1)
        !           508:                ? (char *)NULL : table[c][f].condition  ;
        !           509: }    /* end get_cond_str() */
        !           510: 

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