Annotation of GNUtools/cctools/as/i860-check.c, revision 1.1.1.1

1.1       root        1: #include "i860-opcode.h"
                      2: #include <stdio.h>
                      3: 
                      4: extern long random();
                      5: 
                      6: char *controlregs[] = { "fir", "psr", "epsr", "dirbase", "db", "fsr" };
                      7: #define NCREGS (sizeof controlregs / sizeof controlregs[0])
                      8: 
                      9: char *textlabels[] = { "foo", "bar", "baz", "xork" };
                     10: #define NTLABELS       (sizeof textlabels / sizeof textlabels[0])
                     11: 
                     12: char *datalabels[] = { "data1", "data2", "data3", "data4" };
                     13: #define NDLABELS       (sizeof datalabels / sizeof datalabels[0])
                     14: 
                     15: /*
                     16:  * Traverse the opcode table, dumping out sample instructions.
                     17:  */
                     18: void
                     19: main(
                     20: int argc,
                     21: char *argv[],
                     22: char *envp[])
                     23: {
                     24:        int i;
                     25:        const char *arg;
                     26:        int r1, r2, rd;
                     27:        
                     28:        printf( "\t.text\n%s:", textlabels[0] );
                     29:        for ( i = 0; i < NUMOPCODES; ++i )
                     30:        {
                     31:                if ( i == (NUMOPCODES/3) )
                     32:                        printf( "%s:", textlabels[1] );
                     33:                if ( i == (NUMOPCODES/2) )
                     34:                        printf( "%s:", textlabels[2] );
                     35: 
                     36:                if ( (random() & 0x30) == 0 &&
                     37:                     (i860_opcodes[i].match & OP_PREFIX_MASK) == PREFIX_FPU )
                     38:                {
                     39:                        printf( "\td.%s\t", i860_opcodes[i].name );
                     40:                }
                     41:                else
                     42:                        printf( "\t%s\t", i860_opcodes[i].name );
                     43:                r1 = random() & 0x1F;
                     44:                do
                     45:                        r2 = random() & 0x1F;
                     46:                while( (r2 & 0x1E) == (r1 & 0x1E) );
                     47:                do
                     48:                        rd = random() & 0x1F;
                     49:                while( (rd & 0x1E) == (r1 & 0x1E) || (rd & 0x1E) == (r2 & 0x1E) );
                     50:                
                     51:                for ( arg = i860_opcodes[i].args; *arg != '\0'; ++arg )
                     52:                {
                     53:                    switch( *arg )
                     54:                    {
                     55:                        case '1': /*    rs1 register, bits 11-15 of insn. */
                     56:                        case '2': /*    rs2 register, bits 21-25 of insn. */
                     57:                        case 'd': /*    rd register, bits 16-20 of insn.  */
                     58:                                printf( "r%d", random() % 32);
                     59:                                break;
                     60:                                
                     61:                        case 'e': /*    frs1 floating point register, bits 11-15 of insn*/
                     62:                                printf( "f%d", r1 );
                     63:                                break;
                     64:                                  
                     65:                        case 'f': /*    frs2 floating point register, bits 21-25 of insn*/
                     66:                                printf( "f%d", r2 );
                     67:                                break;
                     68:                                  
                     69:                        case 'g': /*    frsd floating point register, bits 16-20 of insn*/ 
                     70:                                printf( "f%d", rd );
                     71:                                break;
                     72:                                
                     73:                        case 'E': /*    frs1 floating point register, bits 11-15 of insn*/
                     74:                                printf( "f%d", r1 & 0x1E );
                     75:                                break;
                     76:                                  
                     77:                        case 'F': /*    frs2 floating point register, bits 21-25 of insn*/
                     78:                                printf( "f%d", r2 & 0x1E );
                     79:                                break;
                     80:                                  
                     81:                        case 'G': /*    frsd floating point register, bits 16-20 of insn*/ 
                     82:                                printf( "f%d", rd & 0x1E );
                     83:                                break;
                     84:                                  
                     85:                        case 'H': /*    frsd floating point register, bits 16-20 of insn*/ 
                     86:                                printf( "f%d", rd & 0x1C );
                     87:                                break;
                     88: 
                     89:                        case 'I': /*    16 bit High portion of address, I860_RELOC_HIGH. */
                     90:                                printf( "h%%%s", datalabels[random() % NDLABELS] );
                     91:                                break;
                     92:                                
                     93:                        case 'i': /*    16 bit byte address low half, */
                     94:                        case 'j': /*    16 bit short address, I860_RELOC_LOW1 */
                     95:                        case 'k': /*    16 bit word/int address low half, I860_RELOC_LOW2 */
                     96:                        case 'l': /*    16 bit 8-byte address (double) low half */
                     97:                        case 'm': /*    16 bit 16-byte address (quad) low half */
                     98:                        case 'n': /*    16 bit byte aligned low half, split fields */
                     99:                        case 'o': /*    16 bit short aligned low half, split fields */
                    100:                        case 'p': /*    16 bit int/word aligned low half, split fields */
                    101:                                printf( "l%%%s", datalabels[random() % NDLABELS] );
                    102:                                break;
                    103: 
                    104:                        case 'J': /*    16 bit High portion of addr requiring adjustment*/
                    105:                                printf( "ha%%%s", datalabels[random() % NDLABELS] );
                    106:                                break;
                    107:                                                        
                    108:                        case 'K': /*    26 bit branch displacement */
                    109:                        case 'L': /*    16 bit split branch displacement */
                    110:                                printf( textlabels[random() % NTLABELS] );
                    111:                                break;
                    112:                        
                    113:                        case 'D': /* constant for shift opcode */       
                    114:                        case 'B': /*    5 bit immediate, for bte and btne insn */
                    115:                                printf( "%d", random() % 32 );
                    116:                                break;
                    117:                                
                    118:                        case 'C': /*    Control Register */
                    119:                                printf( controlregs[random() % NCREGS] );
                    120:                                break;
                    121:                                
                    122:                        default:
                    123:                                putchar( *arg );
                    124:                                break;
                    125:                    }
                    126:                }
                    127:                putchar( '\n' );
                    128:        }
                    129:        printf( "%s:\n", textlabels[3] );
                    130:        printf( "nop\n" );
                    131:        printf( "\t.text\n" );
                    132:        printf( "data1: nop\n" );
                    133:        printf( "data2: nop\n" );
                    134:        printf( "data3: nop\n" );
                    135:        printf( "data4: nop\n" );
                    136: 
                    137: }

unix.superglobalmegacorp.com

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