Annotation of cci/usr/src/lib/c2/c23.c, revision 1.1.1.1

1.1       root        1: #include "c2.h"
                      2: #define readonly
                      3: 
                      4: readonly char revbr[] = {
                      5:        JNE, JEQ, JGT, JLT, JGE, JLE,
                      6:        JNE, JEQ, JHI, JLO, JHIS, JLOS,
                      7:        JBS, JBC, };
                      8: 
                      9: /* cursed be the preprocessor, whose impotence and stupidity
                     10: /* prevented this table being macro-generated from ../as/instrs
                     11: */
                     12: 
                     13: readonly struct optab optab[] = {
                     14: "jbr",JBR,0,
                     15: "jeql",CBR,JEQ,
                     16: "jneq",CBR,JNE,
                     17: "jleq",CBR,JLE,
                     18: "jgeq",CBR,JGE,
                     19: "jlss",CBR,JLT,
                     20: "jgtr",CBR,JGT,
                     21: "jbc",CBR,JBC,
                     22: "jbs",CBR,JBS,
                     23: "jlequ",CBR,JLOS,
                     24: "jgequ",CBR,JHIS,
                     25: "jlssu",CBR,JLO,
                     26: "jgtru",CBR,JHI,
                     27: "adda",ADDA,LONG,
                     28: "addb2",ADD,U(BYTE,OP2),
                     29: "addb3",ADD,U(BYTE,OP3),
                     30: "addl2",ADD,U(LONG,OP2),
                     31: "addl3",ADD,U(LONG,OP3),
                     32: "addw2",ADD,U(WORD,OP2),
                     33: "addw3",ADD,U(WORD,OP3),
                     34: "aobleq",AOBLEQ,0,
                     35: "aoblss",AOBLSS,0,
                     36: "shal",SHAL,LONG,
                     37: "shar",SHAR,LONG,
                     38: "shll",SHL,LONG,
                     39: "shrl",SHR,LONG,
                     40: "shlq",SHL,QUAD,
                     41: "shrq",SHR,QUAD,
                     42: "bbc",CBR,JBC,
                     43: "bbs",CBR,JBS,
                     44: "bcc",CBR,JHIS,
                     45: "bcs",CBR,JLO,
                     46: "beql",CBR,JEQ,
                     47: "beqlu",CBR,JEQ,
                     48: "bgeq",CBR,JGE,
                     49: "bgequ",CBR,JHIS,
                     50: "bgtr",CBR,JGT,
                     51: "bgtru",CBR,JHI,
                     52: "andb2",AND,U(BYTE,OP2),
                     53: "andb3",AND,U(BYTE,OP3),
                     54: "andl2",AND,U(LONG,OP2),
                     55: "andl3",AND,U(LONG,OP3),
                     56: "andw2",AND,U(WORD,OP2),
                     57: "andw3",AND,U(WORD,OP3),
                     58: "orb2",OR,U(BYTE,OP2),
                     59: "orb3",OR,U(BYTE,OP3),
                     60: "orl2",OR,U(LONG,OP2),
                     61: "orl3",OR,U(LONG,OP3),
                     62: "orw2",OR,U(WORD,OP2),
                     63: "orw3",OR,U(WORD,OP3),
                     64: "bitb",BIT,BYTE,
                     65: "bitl",BIT,LONG,
                     66: "bitw",BIT,WORD,
                     67: "bleq",CBR,JLE,
                     68: "blequ",CBR,JLOS,
                     69: "blss",CBR,JLT,
                     70: "blssu",CBR,JLO,
                     71: "bneq",CBR,JNE,
                     72: "bnequ",CBR,JNE,
                     73: "brb",JBR,0,
                     74: "brw",JBR,0,
                     75: "bvc",CBR,0,
                     76: "bvs",CBR,0,
                     77: "callf",CALLF,0,
                     78: "calls",CALLS,0,
                     79: "casel",CASE,LONG,
                     80: "clrb",CLR,BYTE,
                     81: "clrl",CLR,LONG,
                     82: "clrw",CLR,WORD,
                     83: "cmpb",CMP,BYTE,
                     84: "cmpl",CMP,LONG,
                     85: "cmpw",CMP,WORD,
                     86: "cvtbl",CVT,U(BYTE,LONG),
                     87: "cvtbw",CVT,U(BYTE,WORD),
                     88: "cvtlb",CVT,U(LONG,BYTE),
                     89: "cvtlw",CVT,U(LONG,WORD),
                     90: "cvtwb",CVT,U(WORD,BYTE),
                     91: "cvtwl",CVT,U(WORD,LONG),
                     92: "decb",DEC,BYTE,
                     93: "decl",DEC,LONG,
                     94: "decw",DEC,WORD,
                     95: "divl2",DIV,U(LONG,OP2),
                     96: "divl3",DIV,U(LONG,OP3),
                     97: "ediv",EDIV,LONG,
                     98: "incb",INC,BYTE,
                     99: "incl",INC,LONG,
                    100: "incw",INC,WORD,
                    101: "jmp",JMP,0,
                    102: "mcomb",COM,BYTE,
                    103: "mcoml",COM,LONG,
                    104: "mcomw",COM,WORD,
                    105: "mnegb",NEG,BYTE,
                    106: "mnegl",NEG,LONG,
                    107: "mnegw",NEG,WORD,
                    108: "movab",MOVA,BYTE,
                    109: "moval",MOVA,LONG,
                    110: "movaw",MOVA,WORD,
                    111: "movb",MOV,BYTE,
                    112: "movl",MOV,LONG,
                    113: "movw",MOV,WORD,
                    114: "movzbl",MOVZ,U(BYTE,LONG),
                    115: "movzbw",MOVZ,U(BYTE,WORD),
                    116: "movzwl",MOVZ,U(WORD,LONG),
                    117: "mull2",MUL,U(LONG,OP2),
                    118: "mull3",MUL,U(LONG,OP3),
                    119: "pushab",PUSHA,BYTE,
                    120: "pushal",PUSHA,LONG,
                    121: "pushaw",PUSHA,WORD,
                    122: "pushb",PUSH,BYTE,
                    123: "pushl",PUSH,LONG,
                    124: "pushw",PUSH,WORD,
                    125: "ret",JBR,RET,
                    126: "suba",SUBA,LONG,
                    127: "subb2",SUB,U(BYTE,OP2),
                    128: "subb3",SUB,U(BYTE,OP3),
                    129: "subl2",SUB,U(LONG,OP2),
                    130: "subl3",SUB,U(LONG,OP3),
                    131: "subw2",SUB,U(WORD,OP2),
                    132: "subw3",SUB,U(WORD,OP3),
                    133: "tstb",TST,BYTE,
                    134: "tstl",TST,LONG,
                    135: "tstw",TST,WORD,
                    136: "xorb2",XOR,U(BYTE,OP2),
                    137: "xorb3",XOR,U(BYTE,OP3),
                    138: "xorl2",XOR,U(LONG,OP2),
                    139: "xorl3",XOR,U(LONG,OP3),
                    140: "xorw2",XOR,U(WORD,OP2),
                    141: "xorw3",XOR,U(WORD,OP3),
                    142: "movblk",MOVBLK,0,
                    143: ".globl",EROU,0,
                    144: ".text",TEXT,0,
                    145: ".data",DATA,0,
                    146: ".bss",BSS,0,
                    147: ".align",ALIGN,0,
                    148: ".word",WGEN,0,
                    149: ".long",LGEN,0,
                    150: ".set",SET,0,
                    151: ".lcomm",LCOMM,0,
                    152: ".comm",COMM,0,
                    153: ".end",END,0,
                    154: "mfpr",MFPR,LONG,
                    155: "mtpr",MTPR,LONG,
                    156: "probe",PROBE,BYTE,
                    157: "adwc",0,0,
                    158: "movob",MOVO,BYTE,
                    159: "movow",MOVO,WORD,
                    160: "bbssi",0,0,
                    161: "bicpsw",0,0,
                    162: "bispsw",0,0,
                    163: "bpt",0,0,
                    164: "btcs",0,0,
                    165: "cmps2",0,0,
                    166: "cmps3",0,0,
                    167: "emul",0,0,
                    168: "ffc",0,0,
                    169: "ffs",0,0,
                    170: "halt",0,0,
                    171: "insque",0,0,
                    172: "kcall",0,0,
                    173: "ldpctx",0,0,
                    174: "loadr",0,0,
                    175: "movpsl",0,0,
                    176: "movs2",0,0,
                    177: "movs3",0,0,
                    178: "nop",0,0,
                    179: "rei",0,0,
                    180: "remque",0,0,
                    181: "sbwc",0,0,
                    182: "storer",0,0,
                    183: "svpctx",0,0,
                    184: 0,0,0};

unix.superglobalmegacorp.com

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