Return to asm.c CVS log

Up to [CSRG BSD Unix] / 43BSD / ucb / dbx

Annotation of 43BSD/ucb/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.1 (Berkeley) 5/31/85";
        !             9: #endif not lint
        !            10: 
        !            11: static char rcsid[] = "$Header: asm.c,v 1.5 84/12/26 10:38:19 linton 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_HASMODULES, asm_hasmodules);
        !            48:     language_setop(lang, L_PASSADDR, asm_passaddr);
        !            49: }
        !            50: 
        !            51: /*
        !            52:  * Test if two types are compatible.
        !            53:  */
        !            54: 
        !            55: public Boolean asm_typematch(type1, type2)
        !            56: Symbol type1, type2;
        !            57: {
        !            58:     Boolean b;
        !            59: 
        !            60:     b = false;
        !            61:     return b;
        !            62: }
        !            63: 
        !            64: public asm_printdecl(s)
        !            65: Symbol s;
        !            66: {
        !            67:     switch (s->class) {
        !            68:        case CONST:
        !            69:            printf("%s = %d", symname(s), s->symvalue.constval->value.lcon);
        !            70:            break;
        !            71: 
        !            72:        case VAR:
        !            73:        case REF:
        !            74:            printf("&%s = 0x%x", symname(s), s->symvalue.offset);
        !            75:            break;
        !            76: 
        !            77:        case PROC:
        !            78:        case FUNC:
        !            79:            printf("%s (0x%x):", symname(s), codeloc(s));
        !            80:            break;
        !            81: 
        !            82:        case TYPE:
        !            83:            printf("%s", symname(s));
        !            84:            break;
        !            85: 
        !            86:        case ARRAY:
        !            87:            printf("$string");
        !            88:            break;
        !            89: 
        !            90:        default:
        !            91:            printf("[%s]", classname(s));
        !            92:            break;
        !            93:     }
        !            94:     putchar('\n');
        !            95: }
        !            96: 
        !            97: /*
        !            98:  * Print out the value on the top of the expression stack
        !            99:  * in the format for the type of the given symbol.
        !           100:  */
        !           101: 
        !           102: public asm_printval(s)
        !           103: register Symbol s;
        !           104: {
        !           105:     register Symbol t;
        !           106:     register Integer len;
        !           107: 
        !           108:     switch (s->class) {
        !           109:        case ARRAY:
        !           110:            t = rtype(s->type);
        !           111:            if (t->class == RANGE and istypename(t->type, "$char")) {
        !           112:                len = size(s);
        !           113:                sp -= len;
        !           114:                printf("\"%.*s\"", len, sp);
        !           115:            } else {
        !           116:                printarray(s);
        !           117:            }
        !           118:            break;
        !           119: 
        !           120:        default:
        !           121:            printf("0x%x", pop(Integer));
        !           122:            break;
        !           123:     }
        !           124: }
        !           125: 
        !           126: /*
        !           127:  * Treat subscripting as indirection through pointer to integer.
        !           128:  */
        !           129: 
        !           130: public Node asm_buildaref(a, slist)
        !           131: Node a, slist;
        !           132: {
        !           133:     Symbol t, eltype;
        !           134:     Node p, r;
        !           135: 
        !           136:     t = rtype(a->nodetype);
        !           137:     eltype = t->type;
        !           138:     p = slist->value.arg[0];
        !           139:     r = build(O_MUL, p, build(O_LCON, (long) size(eltype)));
        !           140:     r = build(O_ADD, build(O_RVAL, a), r);
        !           141:     r->nodetype = eltype;
        !           142:     return r;
        !           143: }
        !           144: 
        !           145: /*
        !           146:  * Evaluate a subscript index.  Assumes dimension is [0..n].
        !           147:  */
        !           148: 
        !           149: public asm_evalaref(s, base, i)
        !           150: Symbol s;
        !           151: Address base;
        !           152: long i;
        !           153: {
        !           154:     Symbol t;
        !           155: 
        !           156:     t = rtype(s);
        !           157:     push(long, base + i * size(t->type));
        !           158: }
        !           159: 
        !           160: public boolean asm_hasmodules ()
        !           161: {
        !           162:     return false;
        !           163: }
        !           164: 
        !           165: public boolean asm_passaddr (param, exprtype)
        !           166: Symbol param, exprtype;
        !           167: {
        !           168:     return false;
        !           169: }

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