Return to asm.c CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / lib / old_compiler / dbx

Annotation of 43BSDTahoe/lib/old_compiler/dbx/asm.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1983 Regents of the University of California.
        !             3:  * All rights reserved.  The Berkeley software License Agreement
        !             4:  * specifies the terms and conditions for redistribution.
        !             5:  */
        !             6: 
        !             7: #ifndef lint
        !             8: static char sccsid[] = "@(#)asm.c      5.2 (Berkeley) 1/11/88";
        !             9: #endif not lint
        !            10: 
        !            11: static char rcsid[] = "$Header: asm.c,v 1.2 87/03/25 19:24:09 donn Exp $";
        !            12: 
        !            13: /*
        !            14:  * Assembly language dependent symbol routines.
        !            15:  */
        !            16: 
        !            17: #include "defs.h"
        !            18: #include "symbols.h"
        !            19: #include "asm.h"
        !            20: #include "languages.h"
        !            21: #include "tree.h"
        !            22: #include "eval.h"
        !            23: #include "operators.h"
        !            24: #include "mappings.h"
        !            25: #include "process.h"
        !            26: #include "runtime.h"
        !            27: #include "machine.h"
        !            28: 
        !            29: #define isdouble(range) ( \
        !            30:     range->symvalue.rangev.upper == 0 and range->symvalue.rangev.lower > 0 \
        !            31: )
        !            32: 
        !            33: /*
        !            34:  * Initialize assembly language information.
        !            35:  */
        !            36: 
        !            37: public asm_init()
        !            38: {
        !            39:     Language lang;
        !            40: 
        !            41:     lang = language_define("assembler", ".s");
        !            42:     language_setop(lang, L_PRINTDECL, asm_printdecl);
        !            43:     language_setop(lang, L_PRINTVAL, asm_printval);
        !            44:     language_setop(lang, L_TYPEMATCH, asm_typematch);
        !            45:     language_setop(lang, L_BUILDAREF, asm_buildaref);
        !            46:     language_setop(lang, L_EVALAREF, asm_evalaref);
        !            47:     language_setop(lang, L_MODINIT, asm_modinit);
        !            48:     language_setop(lang, L_HASMODULES, asm_hasmodules);
        !            49:     language_setop(lang, L_PASSADDR, asm_passaddr);
        !            50: }
        !            51: 
        !            52: /*
        !            53:  * Test if two types are compatible.
        !            54:  */
        !            55: 
        !            56: public Boolean asm_typematch(type1, type2)
        !            57: Symbol type1, type2;
        !            58: {
        !            59:     Boolean b;
        !            60: 
        !            61:     b = false;
        !            62:     return b;
        !            63: }
        !            64: 
        !            65: public asm_printdecl(s)
        !            66: Symbol s;
        !            67: {
        !            68:     switch (s->class) {
        !            69:        case CONST:
        !            70:            printf("%s = %d", symname(s), s->symvalue.constval->value.lcon);
        !            71:            break;
        !            72: 
        !            73:        case VAR:
        !            74:        case REF:
        !            75:            printf("&%s = 0x%x", symname(s), s->symvalue.offset);
        !            76:            break;
        !            77: 
        !            78:        case PROC:
        !            79:        case FUNC:
        !            80:            printf("%s (0x%x):", symname(s), codeloc(s));
        !            81:            break;
        !            82: 
        !            83:        case TYPE:
        !            84:            printf("%s", symname(s));
        !            85:            break;
        !            86: 
        !            87:        case ARRAY:
        !            88:            printf("$string");
        !            89:            break;
        !            90: 
        !            91:        default:
        !            92:            printf("[%s]", classname(s));
        !            93:            break;
        !            94:     }
        !            95:     putchar('\n');
        !            96: }
        !            97: 
        !            98: /*
        !            99:  * Print out the value on the top of the expression stack
        !           100:  * in the format for the type of the given symbol.
        !           101:  */
        !           102: 
        !           103: public asm_printval(s)
        !           104: register Symbol s;
        !           105: {
        !           106:     register Symbol t;
        !           107:     register Integer len;
        !           108: 
        !           109:     switch (s->class) {
        !           110:        case ARRAY:
        !           111:            t = rtype(s->type);
        !           112:            if (t->class == RANGE and istypename(t->type, "$char")) {
        !           113:                len = size(s);
        !           114:                sp -= len;
        !           115:                printf("\"%.*s\"", len, sp);
        !           116:            } else {
        !           117:                printarray(s);
        !           118:            }
        !           119:            break;
        !           120: 
        !           121:        default:
        !           122:            printf("0x%x", pop(Integer));
        !           123:            break;
        !           124:     }
        !           125: }
        !           126: 
        !           127: /*
        !           128:  * Treat subscripting as indirection through pointer to integer.
        !           129:  */
        !           130: 
        !           131: public Node asm_buildaref(a, slist)
        !           132: Node a, slist;
        !           133: {
        !           134:     Symbol t, eltype;
        !           135:     Node p, r;
        !           136: 
        !           137:     t = rtype(a->nodetype);
        !           138:     eltype = t->type;
        !           139:     p = slist->value.arg[0];
        !           140:     r = build(O_MUL, p, build(O_LCON, (long) size(eltype)));
        !           141:     r = build(O_ADD, build(O_RVAL, a), r);
        !           142:     r->nodetype = eltype;
        !           143:     return r;
        !           144: }
        !           145: 
        !           146: /*
        !           147:  * Evaluate a subscript index.  Assumes dimension is [0..n].
        !           148:  */
        !           149: 
        !           150: public asm_evalaref(s, base, i)
        !           151: Symbol s;
        !           152: Address base;
        !           153: long i;
        !           154: {
        !           155:     Symbol t;
        !           156: 
        !           157:     t = rtype(s);
        !           158:     push(long, base + i * size(t->type));
        !           159: }
        !           160: 
        !           161: public asm_modinit (typetable)
        !           162: Symbol typetable[];
        !           163: {
        !           164:     /* nothing for right now */
        !           165: }
        !           166: 
        !           167: public boolean asm_hasmodules ()
        !           168: {
        !           169:     return false;
        !           170: }
        !           171: 
        !           172: public boolean asm_passaddr (param, exprtype)
        !           173: Symbol param, exprtype;
        !           174: {
        !           175:     return false;
        !           176: }

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