Return to pseudoop.c CVS log

Up to [Research Unix] / researchv9 / cmd / sun / c2

Annotation of researchv9/cmd/sun/c2/pseudoop.c, revision 1.1

1.1     ! root        1: #ifndef lint
        !             2: static char sccsid[] = "@(#)pseudoop.c 1.1 86/02/03 Copyr 1985 Sun Micro";
        !             3: #endif
        !             4: 
        !             5: /*
        !             6:  * Copyright (c) 1985 by Sun Microsystems, Inc.
        !             7:  */
        !             8: 
        !             9: #include "as.h"
        !            10: #include "c2.h"
        !            11: 
        !            12: /* Csect descriptor */
        !            13: struct csect {
        !            14:        char *name_cs;    /* print name                                          */
        !            15:        long len_cs;     /* Length in machine addresses,                 */ 
        !            16:                          /* i.e., highest address referenced            */
        !            17:        long dot_cs;     /* current dot in this cs, in machine addresses */
        !            18:        short id_cs;     /* UNIX a.out name for this csect               */
        !            19:        short which_cs;  /* our name for this csect (see below)          */
        !            20: };
        !            21: 
        !            22: /* table used to determine node type. */
        !            23: /* 
        !            24:  * we would really like this table to be subscripted by the enumerated type
        !            25:  * opcode_t, but C cannot hack that. Order here is VERY IMPORTANT,
        !            26:  * and this table must change if the opcode order or number changes!!
        !            27:  */
        !            28: char opcodetypes[] = {
        !            29:        0,                      /* FIRST        */
        !            30:        PSEUDONOCODE,           /* COMMENT      */
        !            31:        0,                      /* LABEL        */
        !            32:        PSEUDOCODE,             /* LONG         */
        !            33:        PSEUDOCODE,             /* WORD         */
        !            34:        PSEUDOCODE,             /* BYTE         */
        !            35:        PSEUDONOCODE,           /* TEXT         */
        !            36:        PSEUDONOCODE,           /* DATA         */
        !            37:        PSEUDONOCODE,           /* DATA1        */
        !            38:        PSEUDONOCODE,           /* DATA2        */
        !            39:        PSEUDONOCODE,           /* BSS          */
        !            40:        PSEUDONOCODE,           /* GLOBL        */
        !            41:        PSEUDONOCODE,           /* COMM         */
        !            42:        PSEUDOCODE,             /* EVEN         */
        !            43:        PSEUDOCODE,             /* ALIGN        */
        !            44:        PSEUDOCODE,             /* ASCIZ        */
        !            45:        PSEUDOCODE,             /* ASCII        */
        !            46:        PSEUDOCODE,             /* SINGLE       */
        !            47:        PSEUDOCODE,             /* DOUBLE       */
        !            48:        PSEUDONOCODE,           /* STABS        */
        !            49:        PSEUDONOCODE,           /* STABD        */
        !            50:        PSEUDONOCODE,           /* STABN        */
        !            51:        PSEUDOCODE,             /* SKIP         */
        !            52:        PSEUDONOCODE,           /* LCOMM        */
        !            53:        PSEUDONOCODE,           /* CPID         */
        !            54:        INSTRTYPE|BRANCHTYPE,   /* CSWITCH      */
        !            55:        INSTRTYPE|BRANCHTYPE,   /* FSWITCH      */
        !            56:        INSTRTYPE|BRANCHTYPE,   /* BRANCH       */
        !            57:        INSTRTYPE,              /* MOVE         */
        !            58:        INSTRTYPE,              /* MOVEM        */
        !            59:        INSTRTYPE|BRANCHTYPE,   /* EXIT         */
        !            60:        INSTRTYPE|BRANCHTYPE,   /* DBRA         */
        !            61:        INSTRTYPE,              /* CALL         */
        !            62:        INSTRTYPE|BRANCHTYPE|JUMPTYPE,  /* JUMP         */
        !            63:        INSTRTYPE|BRANCHTYPE|JUMPTYPE,  /* DJMP         */
        !            64:        INSTRTYPE,              /* LINK         */
        !            65:        INSTRTYPE,              /* CMP          */
        !            66:        INSTRTYPE,              /* PEA          */
        !            67:        INSTRTYPE,              /* ADD          */
        !            68:        INSTRTYPE,              /* AND          */
        !            69:        INSTRTYPE,              /* EXT          */
        !            70:        INSTRTYPE,              /* OR           */
        !            71:        INSTRTYPE,              /* TST          */
        !            72:        INSTRTYPE,              /* ASL          */
        !            73:        INSTRTYPE,              /* ASR          */
        !            74:        INSTRTYPE,              /* SUB          */
        !            75:        INSTRTYPE,              /* UNLK         */
        !            76:        INSTRTYPE,              /* LEA          */
        !            77:        INSTRTYPE,              /* CLR          */
        !            78:        INSTRTYPE,              /* BOP          */
        !            79:        INSTRTYPE,              /* EOR          */
        !            80:        INSTRTYPE,              /* FTST         */
        !            81:        INSTRTYPE,              /* OTHER        */
        !            82: };
        !            83: extern struct sym_bkt *dot_bkt;
        !            84: 
        !            85: struct csect csects[] = {
        !            86:   ".text", 0,0,0,C_TEXT,               /* text csect */
        !            87:   ".data", 0,0,0,C_DATA,               /* data csect */
        !            88:   ".data1",0,0,0,C_DATA1,              /* data csect */
        !            89:   ".data2",0,0,0,C_DATA2,              /* data csect */
        !            90:   ".bss",  0,0,0, C_BSS,               /* uninitialized csect */
        !            91:   0
        !            92: } ;
        !            93: 
        !            94: struct csect *cur_csect   = &(csects[0]);/* ptr to current csect */
        !            95: struct csect *all_csects[] = { 0 ,
        !            96:        &(csects[0]), &(csects[1]), &(csects[2]), &(csects[3]), &(csects[4])
        !            97: };
        !            98: 
        !            99: short cur_csect_name      = C_TEXT;
        !           100: 
        !           101: void
        !           102: init_csects(){
        !           103:     register struct sym_bkt *sbp;
        !           104:     struct csect *csp;
        !           105:     for (csp = csects; csp->name_cs != NULL; csp++){
        !           106:        sbp = lookup(csp->name_cs);
        !           107:        sbp->attr_s |= S_DEC | S_DEF | S_LOCAL;
        !           108:        sbp->csect_s = csp->which_cs;
        !           109:        sbp->value_s = 0;
        !           110:     }
        !           111: }
        !           112: 
        !           113: void
        !           114: new_csect()
        !           115: { 
        !           116:     extern struct csect    *cur_csect; /* ptr to current csect */
        !           117:     extern struct sym_bkt  *dot_bkt;   /* sym_bkt for location counter */
        !           118:        
        !           119:     cur_csect = all_csects[cur_csect_name];
        !           120:     dot = cur_csect->dot_cs;
        !           121:     dot_bkt->csect_s = cur_csect_name;/* update dot's csect. dot_bkt->value_s */
        !           122:                                       /* will be updated in the main loop     */
        !           123: }
        !           124: 
        !           125: int
        !           126: ascii(csectname)
        !           127: {      register char *p;
        !           128:        int count;
        !           129:        extern char *malloc();
        !           130: 
        !           131:        if (numops!=1 || operands[0].type_o!=T_STRING)
        !           132:          { PROG_ERROR(E_OPERAND); return 0; }
        !           133:        if (csectname == C_TEXT){
        !           134:            count = strlen(operands[0].stringval_o);
        !           135:            p = malloc( count+1);
        !           136:            strcpy( p, operands[0].stringval_o);
        !           137:            operands[0].stringval_o = p;
        !           138:        } else
        !           139:            p = operands[0].stringval_o;
        !           140:        /* scan out the string, so we can figure how much space it will take */
        !           141:        count = 0;
        !           142:        while (*p) {
        !           143:                count++;
        !           144:                if ( *p++ == '\\' )
        !           145:                    switch ( *p ){
        !           146:                    case '\\':
        !           147:                    case '"':
        !           148:                            p++;
        !           149:                            break;
        !           150:                    default:
        !           151:                    {
        !           152:                        register i;
        !           153:                        /* \octal number.  Max of 3 octal digits */
        !           154: 
        !           155:                        for(i=0;i<3;i++,p++) {
        !           156:                                if (!((*p >= '0') && (*p <= '7'))) 
        !           157:                                    break;
        !           158:                        }
        !           159:                    }
        !           160:                }
        !           161:        }
        !           162:        return count;
        !           163: }
        !           164: 
        !           165: int
        !           166: pseudo_size( ip )
        !           167:     struct ins_bkt *ip;
        !           168: {
        !           169:     int val, delta;
        !           170:     switch( ip->op_i ){
        !           171:     case OP_LONG:
        !           172:        return numops*sizeof(long);
        !           173:     case OP_WORD:
        !           174:        return numops*sizeof(short);
        !           175:     case OP_BYTE:
        !           176:        return numops*sizeof(char);
        !           177:     case OP_SKIP:
        !           178:        return operands[0].value_o;
        !           179:     case OP_EVEN:
        !           180:        return dot&1;
        !           181:     case OP_ALIGN:
        !           182:        val = operands[0].value_o;
        !           183:        delta = val - (dot%val);
        !           184:        if (delta == val) delta = 0;
        !           185:        return delta;
        !           186:     }
        !           187:     return 0;
        !           188: }
        !           189: 
        !           190: int
        !           191: pseudo_code( op ) opcode_t op; 
        !           192: {
        !           193:     /*
        !           194:      *  1 => can generate code
        !           195:      *  0 => cannot generate code
        !           196:      * -1 => not a pseudo-op
        !           197:      */
        !           198:     if (opcodetypes[(int)op]&PSEUDONOCODE) return 0;
        !           199:     if (opcodetypes[(int)op]&PSEUDOCODE  ) return 1;
        !           200:     return -1;
        !           201: }
        !           202: 
        !           203: void
        !           204: save_stabs(csectname)
        !           205: {
        !           206:     char *p;
        !           207:     /* IF IN TEXT, save stabs string */
        !           208:     if (csectname != C_TEXT) return;
        !           209:     /* like ascii above */
        !           210:     p = malloc( 1 + strlen(operands[0].stringval_o));
        !           211:     strcpy( p, operands[0].stringval_o);
        !           212:     operands[0].stringval_o = p;
        !           213: }

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