BSD 4_3_Tahoe release

[unix-history] / usr / src / ucb / dbx / symbols.c

diff --git a/usr/src/ucb/dbx/symbols.c b/usr/src/ucb/dbx/symbols.c
index b4ad438..89961c3 100644 (file)
--- a/usr/src/ucb/dbx/symbols.c
+++ b/usr/src/ucb/dbx/symbols.c
@@ -5,10 +5,10 @@
  */
 
 #ifndef lint
  */
 
 #ifndef lint

-static char sccsid[] = "@(#)symbols.c  5.2 (Berkeley) 9/5/85";
+static char sccsid[] = "@(#)symbols.c  5.5 (Berkeley) 5/11/88";

 #endif not lint
 
 #endif not lint
 

-static char rcsid[] = "$Header: symbols.c,v 1.6 84/12/26 10:42:31 linton Exp $";
+static char rcsid[] = "$Header: symbols.c,v 1.4 88/04/02 01:29:03 donn Exp $";

 
 /*
  * Symbol management.
 
 /*
  * Symbol management.


@@ -41,7 +41,8 @@ typedef struct Symbol *Symbol;
  */
 
 typedef enum {
  */
 
 typedef enum {

-    BADUSE, CONST, TYPE, VAR, ARRAY, DYNARRAY, SUBARRAY, PTRFILE, RECORD, FIELD,
+    BADUSE, CONST, TYPE, VAR, ARRAY, OPENARRAY, DYNARRAY, SUBARRAY,
+    PTRFILE, RECORD, FIELD,

     PROC, FUNC, FVAR, REF, PTR, FILET, SET, RANGE, 
     LABEL, WITHPTR, SCAL, STR, PROG, IMPROPER, VARNT,
     FPROC, FFUNC, MODULE, TAG, COMMON, EXTREF, TYPEREF
     PROC, FUNC, FVAR, REF, PTR, FILET, SET, RANGE, 
     LABEL, WITHPTR, SCAL, STR, PROG, IMPROPER, VARNT,
     FPROC, FFUNC, MODULE, TAG, COMMON, EXTREF, TYPEREF


@@ -49,11 +50,18 @@ typedef enum {
 
 typedef enum { R_CONST, R_TEMP, R_ARG, R_ADJUST } Rangetype; 
 
 
 typedef enum { R_CONST, R_TEMP, R_ARG, R_ADJUST } Rangetype; 
 

+#define INREG 0
+#define STK 1
+#define EXT 2
+
+typedef unsigned integer Storage;
+

 struct Symbol {
     Name name;
     Language language;
     Symclass class : 8;
 struct Symbol {
     Name name;
     Language language;
     Symclass class : 8;

-    Integer level : 8;
+    Storage storage : 2;
+    unsigned int level : 6;    /* for variables stored on stack only */

     Symbol type;
     Symbol chain;
     union {
     Symbol type;
     Symbol chain;
     union {


@@ -125,7 +133,7 @@ boolean showaggrs;
 #define nosource(f) (not (f)->symvalue.funcv.src)
 #define isinline(f) ((f)->symvalue.funcv.inline)
 
 #define nosource(f) (not (f)->symvalue.funcv.src)
 #define isinline(f) ((f)->symvalue.funcv.inline)
 

-#define isreg(s)               (s->level < 0)
+#define isreg(s)               (s->storage == INREG)

 
 #include "tree.h"
 
 
 #include "tree.h"
 


@@ -149,19 +157,21 @@ boolean showaggrs;
 
 /*
  * Symbol table structure currently does not support deletions.
 
 /*
  * Symbol table structure currently does not support deletions.

+ * Hash table size is a power of two to make hashing faster.
+ * Using a non-prime is ok since we aren't doing rehashing.

  */
 
  */
 

-#define HASHTABLESIZE 2003
+#define HASHTABLESIZE 8192

 
 private Symbol hashtab[HASHTABLESIZE];
 
 
 private Symbol hashtab[HASHTABLESIZE];
 

-#define hash(name) ((((unsigned) name) >> 2) mod HASHTABLESIZE)
+#define hash(name) ((((unsigned) name) >> 2) & (HASHTABLESIZE - 1))

 
 /*
  * Allocate a new symbol.
  */
 
 
 /*
  * Allocate a new symbol.
  */
 

-#define SYMBLOCKSIZE 100
+#define SYMBLOCKSIZE 1000

 
 typedef struct Sympool {
     struct Symbol sym[SYMBLOCKSIZE];
 
 typedef struct Sympool {
     struct Symbol sym[SYMBLOCKSIZE];


@@ -177,7 +187,7 @@ public Symbol symbol_alloc()
 
     if (nleft <= 0) {
        newpool = new(Sympool);
 
     if (nleft <= 0) {
        newpool = new(Sympool);

-       bzero(newpool, sizeof(newpool));
+       bzero(newpool, sizeof(*newpool));

        newpool->prevpool = sympool;
        sympool = newpool;
        nleft = SYMBLOCKSIZE;
        newpool->prevpool = sympool;
        sympool = newpool;
        nleft = SYMBLOCKSIZE;


@@ -240,6 +250,7 @@ Symbol chain;
     s = symbol_alloc();
     s->name = name;
     s->language = primlang;
     s = symbol_alloc();
     s->name = name;
     s->language = primlang;

+    s->storage = EXT;

     s->level = blevel;
     s->class = class;
     s->type = type;
     s->level = blevel;
     s->class = class;
     s->type = type;


@@ -513,7 +524,7 @@ Symbol s;
     integer r;
 
     checkref(s);
     integer r;
 
     checkref(s);

-    if (s->level < 0) {
+    if (s->storage == INREG) {

        r = s->symvalue.offset;
     } else {
        r = -1;
        r = s->symvalue.offset;
     } else {
        r = -1;


@@ -549,9 +560,9 @@ Symbol s;
  *     register        - offset is register number
  */
 
  *     register        - offset is register number
  */
 

-#define isglobal(s)            (s->level == 1)
-#define islocaloff(s)          (s->level >= 2 and s->symvalue.offset < 0)
-#define isparamoff(s)          (s->level >= 2 and s->symvalue.offset >= 0)
+#define isglobal(s)            (s->storage == EXT)
+#define islocaloff(s)          (s->storage == STK and s->symvalue.offset < 0)
+#define isparamoff(s)          (s->storage == STK and s->symvalue.offset >= 0)

 
 public Address address (s, frame)
 Symbol s;
 
 public Address address (s, frame)
 Symbol s;


@@ -610,7 +621,8 @@ integer r;
     s = insert(n);
     s->language = t_addr->language;
     s->class = VAR;
     s = insert(n);
     s->language = t_addr->language;
     s->class = VAR;

-    s->level = -3;
+    s->storage = INREG;
+    s->level = 3;

     s->type = t_addr;
     s->symvalue.offset = r;
 }
     s->type = t_addr;
     s->symvalue.offset = r;
 }


@@ -756,6 +768,7 @@ Symbol sym;
            r = nel*elsize;
            break;
 
            r = nel*elsize;
            break;
 

+       case OPENARRAY:

        case DYNARRAY:
            r = (t->symvalue.ndims + 1) * sizeof(Word);
            break;
        case DYNARRAY:
            r = (t->symvalue.ndims + 1) * sizeof(Word);
            break;


@@ -782,9 +795,16 @@ Symbol sym;
            break;
 
        case TYPE:
            break;
 
        case TYPE:

+           /*
+            * This causes problems on the IRIS because of the compiler bug
+            * with stab offsets for parameters.  Not sure it's really
+            * necessary anyway.
+            */
+#          ifndef IRIS

            if (t->type->class == PTR and t->type->type->class == BADUSE) {
                findtype(t);
            }
            if (t->type->class == PTR and t->type->type->class == BADUSE) {
                findtype(t);
            }

+#          endif

            r = size(t->type);
            break;
 
            r = size(t->type);
            break;
 


@@ -885,7 +905,7 @@ Symbol s;
 
     if (s->class == REF) {
        t = rtype(s->type);
 
     if (s->class == REF) {
        t = rtype(s->type);

-       if (t->class == DYNARRAY) {
+       if (t->class == OPENARRAY) {

            r = (t->symvalue.ndims + 1) * sizeof(Word);
        } else if (t->class == SUBARRAY) {
            r = (2 * t->symvalue.ndims + 1) * sizeof(Word);
            r = (t->symvalue.ndims + 1) * sizeof(Word);
        } else if (t->class == SUBARRAY) {
            r = (2 * t->symvalue.ndims + 1) * sizeof(Word);


@@ -925,7 +945,7 @@ Symbol type;
     Symbol t;
 
     t = rtype(type);
     Symbol t;
 
     t = rtype(type);

-    return (boolean) (t->class == DYNARRAY);
+    return (boolean) (t->class == OPENARRAY);

 }
 
 /*
 }
 
 /*


@@ -1051,17 +1071,17 @@ register Symbol t1, t2;
        b = isblock(t2);
     } else if (t2 == procsym) {
        b = isblock(t1);
        b = isblock(t2);
     } else if (t2 == procsym) {
        b = isblock(t1);

-    } else if (t1->language == primlang) {
-       if (t2->language == primlang) {
-           b = primlang_typematch(rtype(t1), rtype(t2));
-       } else {
-           b = (boolean) (*language_op(t2->language, L_TYPEMATCH))(t1, t2);
-       }
-    } else if (t2->language == primlang) {
-       b = (boolean) (*language_op(t1->language, L_TYPEMATCH))(t1, t2);

     } else if (t1->language == nil) {
        if (t2->language == nil) {
            b = false;
     } else if (t1->language == nil) {
        if (t2->language == nil) {
            b = false;

+       } else if (t2->language == primlang) {
+           b = (boolean) primlang_typematch(rtype(t1), rtype(t2));
+       } else {
+           b = (boolean) (*language_op(t2->language, L_TYPEMATCH))(t1, t2);
+       }
+    } else if (t1->language == primlang) {
+       if (t2->language == primlang or t2->language == nil) {
+           b = primlang_typematch(rtype(t1), rtype(t2));

        } else {
            b = (boolean) (*language_op(t2->language, L_TYPEMATCH))(t1, t2);
        }
        } else {
            b = (boolean) (*language_op(t2->language, L_TYPEMATCH))(t1, t2);
        }


@@ -1346,8 +1366,6 @@ Symbol t;
 /*
  * Convert a tree to a type via a conversion operator;
  * if this isn't possible generate an error.
 /*
  * Convert a tree to a type via a conversion operator;
  * if this isn't possible generate an error.

- *
- * Note the tree is call by address, hence the #define below.

  */
 
 private convert(tp, typeto, op)
  */
 
 private convert(tp, typeto, op)


@@ -1362,15 +1380,13 @@ Operator op;
     s = rtype(tree->nodetype);
     t = rtype(typeto);
     if (compatible(t, t_real) and compatible(s, t_int)) {
     s = rtype(tree->nodetype);
     t = rtype(typeto);
     if (compatible(t, t_real) and compatible(s, t_int)) {

+       /* we can convert int => floating but not the reverse */

        tree = build(op, tree);
     } else if (not compatible(s, t)) {
        beginerrmsg();
        tree = build(op, tree);
     } else if (not compatible(s, t)) {
        beginerrmsg();

-       fprintf(stderr, "expected integer or real, found \"");

        prtree(stderr, tree);
        prtree(stderr, tree);

-       fprintf(stderr, "\"");
+       fprintf(stderr, ": illegal type in operation");

        enderrmsg();
        enderrmsg();

-    } else if (op != O_NOP and s != t) {
-       tree = build(op, tree);

     }
     *tp = tree;
 }
     }
     *tp = tree;
 }