[BACK]Return to bytecode.def CVS log [TXT] [DIR] Up to [Apple XNU] / GNUtools / cc

Annotation of GNUtools/cc/bytecode.def, revision 1.1

1.1     ! root        1: # -*- C -*-
        !             2: # bytecode.def - definitions of bytecodes for the stack machine.
        !             3: 
        !             4: # The production of the bytecode interpreter and compiler is
        !             5: # heavily automated by using this file creatively.
        !             6: 
        !             7: # Various elementary data types are understood by the bytecode interpreter.
        !             8: # Q[IU] - quarter word (byte) signed and unsigned integers (char).
        !             9: # H[IU] - half word signed and unsigned integers (short int, maybe int).
        !            10: # S[IU] - single word signed and unsigned integers (maybe int, long int).
        !            11: # D[IU] - double word signed and unsigned integers (long long int).
        !            12: # SF - single precision floating point (float).
        !            13: # DF - double precision floating point (double).
        !            14: # XF - extended precision floating point (long double).
        !            15: # P - pointer type for address arithmetic and other purposes.
        !            16: 
        !            17: # The bytecode specification consists of a series of define_operator
        !            18: # forms, that are parsed by preprocessors to automatically build
        !            19: # various switch statements.
        !            20: #      define_operator(name,
        !            21: #                      <C prototype code for implementing the operator>,
        !            22: #                      <list of variations>)
        !            23: # The <C prototype> is self explanatory.
        !            24: # The <list of variations> consists of a (parenthesized list) of
        !            25: # variation items, each of which is in itself a list.  A variation
        !            26: # item consists of a name suffix, the types of the input arguments
        !            27: # expected on the stack (shallowest item first) and (optionally) the
        !            28: # types of the output arguments (similarly ordered).  Finally, the
        !            29: # types of the literal arguments (if any) may appear.
        !            30: 
        !            31: # Substitution in the C prototype code is as follows:
        !            32: # Substitution happens only after a dollar sign.  To get a literal
        !            33: # dollar sign (why would you ever want one anyway?) use $$.
        !            34: # $R1 means "result 1" $TR1 means "type name of result one"
        !            35: # $S1 means "source 1" and similarly with $TS1.
        !            36: # $L1 means "literal (inline) argument 1" and $TL1 means type thereof.
        !            37: #
        !            38: 
        !            39: # Notice that the number following $R doesn't affect the push order;
        !            40: # it's used only for clarity and orthogonality, although it's checked
        !            41: # to make sure it doesn't exceed the number of outputs. A $R reference
        !            42: # results in a push, and represents the result lvalue. E.g.
        !            43: 
        !            44: #      $R1 = 2\, $R2 = 17
        !            45: # will expand to:
        !            46: #      INTERP_PUSH($TR1) = 2, INTERP_PUSH($TR2) = 17
        !            47: #
        !            48: 
        !            49: # Opcode 0 should never happen.
        !            50: define_operator(neverneverland, abort\(\), (()))
        !            51: 
        !            52: # Stack manipulations.
        !            53: define_operator(drop, 0, ((, (SI))))
        !            54: define_operator(duplicate, 0, ((, (SI), (SI, SI))))
        !            55: define_operator(over, 0, ((, (SI), (SI, SI))))
        !            56: 
        !            57: # Adjust stack pointer
        !            58: 
        !            59: define_operator(setstack, 0, ((SI,,,(SI))))
        !            60: define_operator(adjstack, 0, ((SI,,,(SI))))
        !            61: 
        !            62: # Constants, loads, and stores.
        !            63: define_operator(const,
        !            64:                $R1 = $L1,
        !            65:                ((QI,, (QI), (QI)), (HI,, (HI), (HI)),
        !            66:                 (SI,, (SI), (SI)), (DI,, (DI), (DI)),
        !            67:                 (SF,, (SF), (SF)), (DF,, (DF), (DF)),
        !            68:                 (XF,, (XF), (XF)), (P,, (P), (P))))
        !            69: define_operator(load,
        !            70:                $R1 = *\($TR1 *\) $S1,
        !            71:                ((QI, (P), (QI)), (HI, (P), (HI)),
        !            72:                 (SI, (P), (SI)), (DI, (P), (DI)),
        !            73:                 (SF, (P), (SF)), (DF, (P), (DF)),
        !            74:                 (XF, (P), (XF)), (P, (P), (P))))
        !            75: define_operator(store,
        !            76:                *\($TS2 *\) $S1 = $S2,
        !            77:                ((QI, (P, QI)), (HI, (P, HI)),
        !            78:                 (SI, (P, SI)), (DI, (P, DI)),
        !            79:                 (SF, (P, SF)), (DF, (P, DF)),
        !            80:                 (XF, (P, XF)), (P, (P, P)),
        !            81:                 (BLK, (SI, BLK, BLK))))
        !            82: 
        !            83: # Clear memory block
        !            84: 
        !            85: define_operator(clear, $S1 + $S2, ((BLK, (SI, BLK))))
        !            86: 
        !            87: 
        !            88: # Advance pointer by SI constant
        !            89: 
        !            90: define_operator(addconst, $R1 = $S1, ((PSI, (P), (P), (SI))))
        !            91: 
        !            92: 
        !            93: # newlocalSI is used for creating variable-sized storage during function
        !            94: # initialization.
        !            95: 
        !            96: # Create local space, return pointer to block
        !            97: 
        !            98: define_operator(newlocal, $R1 = $S1, ((SI, (SI), (P))))
        !            99: 
        !           100: 
        !           101: # Push the address of a local variable.
        !           102: define_operator(local, $R1 = locals + $L1, ((P,, (P), (SI))))
        !           103: 
        !           104: # Push the address of an argument variable.
        !           105: define_operator(arg, $R1 = args + $L1, ((P,, (P), (SI))))
        !           106: 
        !           107: # Arithmetic conversions.
        !           108: define_operator(convert,
        !           109:                $R1 = \($TR1\) $S1,
        !           110:                (# Signed integral promotions (sign extensions).
        !           111:                 (QIHI, (QI), (HI)), (HISI, (HI), (SI)), (SIDI, (SI), (DI)),
        !           112:                 (QISI, (QI), (SI)),
        !           113:                 # Unsigned integral promotions (zero extensions).
        !           114:                 (QUHU, (QU), (HU)), (HUSU, (HU), (SU)), (SUDU, (SU), (DU)),
        !           115:                 (QUSU, (QU), (SU)),
        !           116:                 # Floating promotions.
        !           117:                 (SFDF, (SF), (DF)), (DFXF, (DF), (XF)),
        !           118:                 # Integral truncation.
        !           119:                 (HIQI, (HI), (QI)), (SIHI, (SI), (HI)), (DISI, (DI), (SI)),
        !           120:                 (SIQI, (SI), (QI)),
        !           121:                  # Unsigned truncation.
        !           122:                 (SUQU, (SU), (QU)),
        !           123:                 # Floating truncation.
        !           124:                 (DFSF, (DF), (SF)), (XFDF, (XF), (DF)),
        !           125:                 # Integral conversions to floating types.
        !           126:                 (SISF, (SI), (SF)), (SIDF, (SI), (DF)), (SIXF, (SI), (XF)),
        !           127:                 (SUSF, (SU), (SF)), (SUDF, (SU), (DF)), (SUXF, (SU), (XF)),
        !           128:                 (DISF, (DI), (SF)), (DIDF, (DI), (DF)), (DIXF, (DI), (XF)),
        !           129:                 (DUSF, (DU), (SF)), (DUDF, (DU), (DF)), (DUXF, (DU), (XF)),
        !           130:                 # Floating conversions to integral types.
        !           131:                 (SFSI, (SF), (SI)), (DFSI, (DF), (SI)), (XFSI, (XF), (SI)),
        !           132:                 (SFSU, (SF), (SU)), (DFSU, (DF), (SU)), (XFSU, (XF), (SU)),
        !           133:                 (SFDI, (SF), (DI)), (DFDI, (DF), (DI)), (XFDI, (XF), (DI)),
        !           134:                 (SFDU, (SF), (DU)), (DFDU, (DF), (DU)), (XFDU, (XF), (DU)),
        !           135:                 # Pointer/integer conversions.
        !           136:                 (PSI, (P), (SI)), (SIP, (SI), (P))))
        !           137: 
        !           138: # Truth value conversion.  These are necessary because conversions of, e.g.,
        !           139: # floating types to integers may not function correctly for large values.
        !           140: define_operator(convert,
        !           141:                $R1 = !!$S1,
        !           142:                ((SIT, (SI), (T)), (DIT, (DI), (T)),
        !           143:                 (SFT, (SF), (T)), (DFT, (DF), (T)),
        !           144:                 (XFT, (XF), (T)), (PT, (P), (T))))
        !           145: 
        !           146: # Bit field load/store.
        !           147: 
        !           148: # Load and zero-extend bitfield
        !           149: 
        !           150: define_operator(zxload, $R1 = $S1, ((BI, (SU, SU, P), (SU))))
        !           151: 
        !           152: # Load and sign-extend bitfield
        !           153: 
        !           154: define_operator(sxload, $R1 = $S1, ((BI, (SU, SU, P), (SI))))
        !           155: 
        !           156: # Store integer in bitfield
        !           157: 
        !           158: define_operator(sstore, $R1 = $S1, ((BI, (SU, SU, P, SI))))
        !           159: 
        !           160: 
        !           161: # Binary operations.
        !           162: define_operator(add,
        !           163:                $R1 = $S1 + $S2,
        !           164:                ((SI, (SI, SI), (SI)), (DI, (DI, DI), (DI)),
        !           165:                 (SF, (SF, SF), (SF)), (DF, (DF, DF), (DF)),
        !           166:                 (XF, (XF, XF), (XF)),
        !           167:                 (PSI, (P, SI), (P))))
        !           168: define_operator(sub,
        !           169:                $R1 = $S1 - $S2,
        !           170:                ((SI, (SI, SI), (SI)), (DI, (DI, DI), (DI)),
        !           171:                 (SF, (SF, SF), (SF)), (DF, (DF, DF), (DF)),
        !           172:                 (XF, (XF, XF), (XF)),
        !           173:                 (PP, (P, P), (SI))))
        !           174: define_operator(mul,
        !           175:                $R1 = $S1 * $S2,
        !           176:                ((SI, (SI, SI), (SI)), (DI, (DI, DI), (DI)),
        !           177:                 (SU, (SU, SU), (SU)), (DU, (DU, DU), (DU)),
        !           178:                 (SF, (SF, SF), (SF)), (DF, (DF, DF), (DF)),
        !           179:                 (XF, (XF, XF), (XF))))
        !           180: define_operator(div,
        !           181:                $R1 = $S1 / $S2,
        !           182:                ((SI, (SI, SI), (SI)), (DI, (DI, DI), (DI)),
        !           183:                 (SU, (SU, SU), (SU)), (DU, (DU, DU), (DU)),
        !           184:                 (SF, (SF, SF), (SF)), (DF, (DF, DF), (DF)),
        !           185:                 (XF, (XF, XF), (XF))))
        !           186: define_operator(mod,
        !           187:                $R1 = $S1 % $S2,
        !           188:                ((SI, (SI, SI), (SI)), (DI, (DI, DI), (DI)),
        !           189:                 (SU, (SU, SU), (SU)), (DU, (DU, DU), (DU))))
        !           190: define_operator(and,
        !           191:                $R1 = $S1 & $S2,
        !           192:                ((SI, (SI, SI), (SI)), (DI, (DI, DI), (DI))))
        !           193: define_operator(ior,
        !           194:                $R1 = $S1 | $S2,
        !           195:                ((SI, (SI, SI), (SI)), (DI, (DI, DI), (DI))))
        !           196: define_operator(xor,
        !           197:                $R1 = $S1 ^ $S2,
        !           198:                ((SI, (SI, SI), (SI)), (DI, (DI, DI), (DI))))
        !           199: define_operator(lshift,
        !           200:                $R1 = $S1 << $S2,
        !           201:                ((SI, (SI, SI), (SI)), (SU, (SU, SI), (SU)),
        !           202:                 (DI, (DI, SI), (DI)), (DU, (DU, SI), (DU))))
        !           203: define_operator(rshift,
        !           204:                $R1 = $S1 >> $S2,
        !           205:                ((SI, (SI, SI), (SI)), (SU, (SU, SI), (SU)),
        !           206:                 (DI, (DI, SI), (DI)), (DU, (DU, SI), (DU))))
        !           207: define_operator(lt,
        !           208:                $R1 = $S1 < $S2,
        !           209:                ((SI, (SI, SI), (T)), (SU, (SU, SU), (T)),
        !           210:                 (DI, (DI, DI), (T)), (DU, (DU, DU), (T)),
        !           211:                 (SF, (SF, SF), (T)), (DF, (DF, DF), (T)),
        !           212:                 (XF, (XF, XF), (T)), (P, (P, P), (T))))
        !           213: define_operator(le,
        !           214:                $R1 = $S1 <= $S2,
        !           215:                ((SI, (SI, SI), (T)), (SU, (SU, SU), (T)),
        !           216:                 (DI, (DI, DI), (T)), (DU, (DU, DU), (T)),
        !           217:                 (SF, (SF, SF), (T)), (DF, (DF, DF), (T)),
        !           218:                 (XF, (XF, XF), (T)), (P, (P, P), (T))))
        !           219: define_operator(ge,
        !           220:                $R1 = $S1 >= $S2,
        !           221:                ((SI, (SI, SI), (T)), (SU, (SU, SU), (T)),
        !           222:                 (DI, (DI, DI), (T)), (DU, (DU, DU), (T)),
        !           223:                 (SF, (SF, SF), (T)), (DF, (DF, DF), (T)),
        !           224:                 (XF, (XF, XF), (T)), (P, (P, P), (T))))
        !           225: define_operator(gt,
        !           226:                $R1 = $S1 > $S2,
        !           227:                ((SI, (SI, SI), (T)), (SU, (SU, SU), (T)),
        !           228:                 (DI, (DI, DI), (T)), (DU, (DU, DU), (T)),
        !           229:                 (SF, (SF, SF), (T)), (DF, (DF, DF), (T)),
        !           230:                 (XF, (XF, XF), (T)), (P, (P, P), (T))))
        !           231: define_operator(eq,
        !           232:                $R1 = $S1 == $S2,
        !           233:                ((SI, (SI, SI), (T)), (DI, (DI, DI), (T)),
        !           234:                 (SF, (SF, SF), (T)), (DF, (DF, DF), (T)),
        !           235:                 (XF, (XF, XF), (T)), (P, (P, P), (T))))
        !           236: define_operator(ne,
        !           237:                $R1 = $S1 != $S2,
        !           238:                ((SI, (SI, SI), (T)), (DI, (DI, DI), (T)),
        !           239:                 (SF, (SF, SF), (T)), (DF, (DF, DF), (T)),
        !           240:                 (XF, (XF, XF), (T)), (P, (P, P), (T))))
        !           241: 
        !           242: # Unary operations.
        !           243: define_operator(neg,
        !           244:                $R1 = -$S1,
        !           245:                ((SI, (SI), (SI)), (DI, (DI), (DI)),
        !           246:                 (SF, (SF), (SF)), (DF, (DF), (DF)),
        !           247:                 (XF, (XF), (XF))))
        !           248: define_operator(not,
        !           249:                $R1 = ~$S1,
        !           250:                ((SI, (SI), (SI)), (DI, (DI), (DI))))
        !           251: define_operator(not,
        !           252:                $R1 = !$S1,
        !           253:                ((T, (SI), (SI))))
        !           254: 
        !           255: # Increment operations.
        !           256: define_operator(predec,
        !           257:                $R1 = *\($TR1 *\) $S1 -= $S2,
        !           258:                ((QI, (P, QI), (QI)), (HI, (P, HI), (HI)),
        !           259:                 (SI, (P, SI), (SI)), (DI, (P, DI), (DI)),
        !           260:                 (P, (P, SI), (P)), (SF, (P, SF), (SF)),
        !           261:                 (DF, (P, DF), (DF)), (XF, (P, XF), (XF)),
        !           262:                 (BI, (SU, SU, P, SI), (SI))))
        !           263: 
        !           264: define_operator(preinc,
        !           265:                $R1 = *\($TR1 *\) $S1 += $S2,
        !           266:                ((QI, (P, QI), (QI)), (HI, (P, HI), (HI)),
        !           267:                 (SI, (P, SI), (SI)), (DI, (P, DI), (DI)),
        !           268:                 (P, (P, SI), (P)), (SF, (P, SF), (SF)),
        !           269:                 (DF, (P, DF), (DF)), (XF, (P, XF), (XF)),
        !           270:                 (BI, (SU, SU, P, SI), (SI))))
        !           271: 
        !           272: define_operator(postdec,
        !           273:                $R1 = *\($TR1 *\) $S1\, *\($TR1 *\) $S1 -= $S2,
        !           274:                ((QI, (P, QI), (QI)), (HI, (P, HI), (HI)),
        !           275:                 (SI, (P, SI), (SI)), (DI, (P, DI), (DI)),
        !           276:                 (P, (P, SI), (P)), (SF, (P, SF), (SF)),
        !           277:                 (DF, (P, DF), (DF)), (XF, (P, XF), (XF)),
        !           278:                 (BI, (SU, SU, P, SI), (SI))))
        !           279: 
        !           280: define_operator(postinc,
        !           281:                $R1 = *\($TR1 *\) $S1\, *\($TR1 *\) $S1 += $S2,
        !           282:                ((QI, (P, QI), (QI)), (HI, (P, HI), (HI)),
        !           283:                 (SI, (P, SI), (SI)), (DI, (P, DI), (DI)),
        !           284:                 (P, (P, SI), (P)), (SF, (P, SF), (SF)),
        !           285:                 (DF, (P, DF), (DF)), (XF, (P, XF), (XF)),
        !           286:                 (BI, (SU, SU, P, SI), (SI))))
        !           287: 
        !           288: # Jumps.
        !           289: define_operator(xjumpif, if \($S1\) pc = code->pc0 + $L1, ((, (T),, (SI))))
        !           290: define_operator(xjumpifnot, if \(! $S1\) pc = code->pc0 + $L1, ((, (T),, (SI))))
        !           291: define_operator(jump, pc = code->pc0 + $L1, ((,,,(SI))))
        !           292: 
        !           293: # This is for GCC2. It jumps to the address on the stack.
        !           294: define_operator(jump, pc = \(void *\) $S1, ((P,,)))
        !           295: 
        !           296: # Switches.  In order to (eventually) support ranges we provide four different
        !           297: # varieties of switches.  Arguments are the switch index from the stack, the
        !           298: # bytecode offset of the switch table, the size of the switch table, and 
        !           299: # the default label.
        !           300: define_operator(caseSI, CASESI\($S1\, $L1\, $L2\, $L3\), ((, (SI),, (SI, SI, SI))))
        !           301: define_operator(caseSU, CASESU\($S1\, $L1\, $L2\, $L3\), ((, (SU),, (SI, SI, SI))))
        !           302: define_operator(caseDI, CASEDI\($S1\, $L1\, $L2\, $L3\), ((, (DI),, (SI, SI, SI))))
        !           303: define_operator(caseDU, CASEDU\($S1\, $L1\, $L2\, $L3\), ((, (DU),, (SI, SI, SI))))
        !           304: 
        !           305: # Procedure call.
        !           306: # Stack arguments are (deepest first):
        !           307: #      procedure arguments in reverse order.
        !           308: #      pointer to the place to hold the return value.
        !           309: #      address of the call description vector.
        !           310: #      pointer to the procedure to be called.
        !           311: define_operator(call, CALL\($S1\, $S2\, $S3\, sp\), ((, (P, P, P))))
        !           312: 
        !           313: # Procedure return.
        !           314: # Pushes on interpreter stack:
        !           315: #       value of retptr (pointer to return value storage slot)
        !           316: define_operator(return, $R1 = retptr, ((P,,(P))))
        !           317: 
        !           318: # Really return.
        !           319: define_operator(ret, return, (()))
        !           320: 
        !           321: # Print an obnoxious line number.
        !           322: define_operator(linenote, fprintf\(stderr\, "%d\\n"\, $L1\), ((,,,(SI))))
unix.superglobalmegacorp.com

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