Changeset 746

Timestamp:

Sep 29, 2003, 4:00:10 PM (22 years ago)

Author:

bird

Message:

#456: Fixing problems with cyclic make_type(). Fake forward refs to enums. Corrected class search in define_fun. More info on warnings.

File:

• trunk/src/emx/src/emxomf/stabshll.c (modified) (18 diffs, 1 prop)

trunk/src/emx/src/emxomf/stabshll.c

@@ -282 +282 @@
 static const char *parse_ptr;
 
-/* Start of the stabs string we're parsing. Usful when printing
+/* Start of the stabs string we're parsing. Useful when printing
    messages. */
 static const char *parse_start;
+
+/* Current stabs index. Useful when printing messages. */
+static int        *parse_pindex;
 
 /* The next HLL type index.  When creating a complex type, this index
@@ -400 +403 @@
   fputc ('\n', stderr);
 
+
   if (parse_ptr && parse_start && parse_ptr >= parse_start)
-    fprintf (stderr, "emxomf info: Currently parsing '%c' at position %ld in\n%s\n",
-             *parse_ptr, parse_ptr - parse_start, parse_start);
+    {
+      if (parse_pindex && *parse_pindex >= 0 && *parse_pindex < sym_count)
+        fprintf (stderr, "emxomf info: parsing sym no.%d type=%d at char '%c' in position %ld:\n%s\n",
+                 *parse_pindex, sym_ptr[*parse_pindex].n_type,
+                 *parse_ptr, parse_ptr - parse_start, parse_start);
+      else
+        fprintf (stderr, "emxomf info: parsing '%c' at position %ld:\n%s\n",
+                 *parse_ptr, parse_ptr - parse_start, parse_start);
+    }
 }
 
@@ -1563 +1574 @@
 {
   const char *saved_ptr, *p1;
+  char ch;
   struct type t, *result, *t1, *t2, *t3, **tlist;
   int i, n, class_flag, is_void;
@@ -1902 +1914 @@
 
       ++parse_ptr;
-      switch (*parse_ptr)
+      ch = *parse_ptr++;
+      p1 = nextcolon (parse_ptr);
+      if (p1 == NULL)
+        {
+          warning ("Invalid forward reference: missing colon");
+          goto syntax;
+        }
+
+      switch (ch)
         {
         case 's':
         case 'u':
-          break;
-        case 'e':
-          warning ("Cannot convert incomplete enum type");
-          goto syntax;
-        default:
-          warning ("Unknown forward reference: %c", *parse_ptr);
-          goto syntax;
-        }
-      ++parse_ptr;
-      p1 = nextcolon (parse_ptr);
-      if (p1 == NULL)
-        {
-          warning ("Invalid forward reference: missing colon");
-          goto syntax;
-        }
-      t.tag = ty_struc;
-      t.d.struc.types = NULL;
-      t.d.struc.fields = NULL;
-      t.d.struc.size = 0;
-      t.d.struc.count = 0;
-      t.d.struc.name = strpool_addn (str_pool, parse_ptr, p1 - parse_ptr);
-      t.d.struc.flags = STRUC_FORWARD;
-
-      /* Avoid adding an incomplete type if the complete one is
-         already defined.  We're ignoring scoping (TODO). */
-
-      for (t3 = type_head; t3 != NULL; t3 = t3->next)
-        if ((t3->tag == ty_struc && t3->d.struc.name == t.d.struc.name
-             && !(t3->d.struc.flags & STRUC_FORWARD))
-            || (t3->tag == ty_class && t3->d.class.name == t.d.struc.name))
           {
-            result = t3;
+            t.tag = ty_struc;
+            t.d.struc.types = NULL;
+            t.d.struc.fields = NULL;
+            t.d.struc.size = 0;
+            t.d.struc.count = 0;
+            t.d.struc.name = strpool_addn (str_pool, parse_ptr, p1 - parse_ptr);
+            t.d.struc.flags = STRUC_FORWARD;
+
+            /* Avoid adding an incomplete type if the complete one is
+               already defined.  We're ignoring scoping (TODO). */
+
+            for (t3 = type_head; t3 != NULL; t3 = t3->next)
+              if ((t3->tag == ty_struc && t3->d.struc.name == t.d.struc.name
+                   && !(t3->d.struc.flags & STRUC_FORWARD))
+                  || (t3->tag == ty_class && t3->d.class.name == t.d.struc.name))
+                {
+                  result = t3;
+                  break;
+                }
             break;
           }
+
+        case 'e':
+          { /* just make it a primary. */
+            /** @todo make an enum perhaps? */
+            t.tag = ty_prim;
+            t.index = 0x82;             /* 32 bit signed */
+            break;
+          }
+
+        default:
+          warning ("Unknown forward reference: %c", ch);
+          parse_ptr = p1 + 1;
+          goto syntax;
+        }
       parse_ptr = p1 + 1;
       break;
 
-    case 's':                   /* struct, class */
-    case 'u':                   /* union */
+    case 's':                           /* struct, class */
+    case 'u':                           /* union */
 
       /* Structures, unions and classes:
@@ -2488 +2510 @@
 {
   struct type *t1;
-  int ti_1, ti_2, i, qual;
+  int ti_1, ti_2, ti_3, i, qual;
   int patch1;
 
 #define RETURN(X) do {*hll = (X); return;} while (0)
 
-  if (tp->index == -2)
-    {
-      warning_parse ("Cycle detected by make_type.");
-      RETURN (0);
-    }
-  if (tp->index != -1)
+  if (tp->index <= -2)
+    {
+      /* bird: A hack where we allow a 2nd recursion of rectain types.
+       * The normal issue is C++ class references. */
+      if (tp->tag != ty_alias || tp->index <= -3)
+        {
+          warning_parse ("Cycle detected by make_type.");
+          RETURN (0);
+        }
+    }
+  if (tp->index > -1)
     RETURN (tp->index);
-  tp->index = -2;
+  tp->index--;
   switch (tp->tag)
     {
@@ -2637 +2664 @@
 
     case ty_member:
-      make_type (tp->d.member.type, &ti_1);
       qual = 0;
       if (tp->d.member.flags & MEMBER_STATIC)
@@ -2643 +2669 @@
       tt_start (0x46, qual);
       tt_byte (tp->d.member.flags & MEMBER_VIS);
-      tt_word (ti_1);
+      patch1 = tt.size;
+      tt_word (0);
       tt_unsigned_span (tp->d.member.offset);
       if (tp->d.member.flags & MEMBER_STATIC)
@@ -2652 +2679 @@
       tt_end ();
       *hll = tp->index = hll_type_index++;
+
+      make_type (tp->d.member.type, &ti_1);
+      buffer_patch_word (&tt, patch1, ti_1);
       break;
 
@@ -2688 +2718 @@
 
     case ty_func:
+      tt_start (0x54, 0x05);          /* Function */
+      tt_word (tp->d.func.arg_count); /* Number of parameters */
+      tt_word (tp->d.func.arg_count); /* Max. Number of parameters */
+      patch1 = tt.size;
+      tt_index (0);                   /* Return value */
+      tt_index (0);                   /* Argument list */
+      tt_end ();
+      *hll = tp->index = hll_type_index++;
+
+      if (tp->d.func.domain)
+        make_type (tp->d.func.domain, &ti_3);
       make_type (tp->d.func.ret, &ti_1);
       if (tp->d.func.args == NULL)
@@ -2693 +2734 @@
       else
         make_type (tp->d.func.args, &ti_2);
-      tt_start (0x54, 0x05);          /* Function */
-      tt_word (tp->d.func.arg_count); /* Number of parameters */
-      tt_word (tp->d.func.arg_count); /* Max. Number of parameters */
-      tt_index (ti_1);                /* Return value */
-      tt_index (ti_2);                /* Argument list */
-      tt_end ();
-      *hll = tp->index = hll_type_index++;
+      buffer_patch_word (&tt, patch1+1, ti_1);
+      buffer_patch_word (&tt, patch1+4, ti_2);
       break;
 
@@ -2902 +2938 @@
 
   alloc_flag = concat_symbols (index, &str);
+  parse_start = str;
+  parse_pindex = index;
   p = nextcolon (str);
   if (p != NULL)
@@ -2912 +2950 @@
       printf ("LSYM/LCSYM/GSYM/PSYM/RSYM/STSYM/FUN %s\n", str);
 #endif
-      parse_start = parse_ptr = p + 1;
+      parse_ptr = p + 1;
       switch (*parse_ptr)
         {
@@ -3122 +3160 @@
   struct type t, *t1, *t2, *t3;
   struct relocation_info r;
-  const char *str, *p;
+  const char *str, *p, *p2;
   const char *name;
   int n,                                /* size of name. */
@@ -3145 +3183 @@
   if (t1)
     { /* C++ member function */
-      ti = t1->index;
-      if (ti == -1)
-        make_type (t1, &ti);
-
       t2 = t1->d.memfunc.type;
       if (t2 && t2->tag == ty_func && t2->d.func.domain)
-          ticlass = t2->d.func.domain->index;
+        make_type (t2->d.func.domain, &ticlass);
       else
-        { /* the hard way - search for the freaking string in suitable .stabs. */
+        { /* the hard way - search for the freaking string in suitable .stabs.
+           * I think this is rather slow when done for many members.. :/ */
           int i;
           for (i = 0, t3 = NULL, ticlass = -1; !t3 && i < sym_count; ++i)
@@ -3161 +3196 @@
                 {
                   str = str_ptr + sym_ptr[i].n_un.n_strx;
-                  if ((p = strstr (str, name)) != NULL
-                   /** @todo parse the string to get the name right. */
-                   && p[-1] == ':' && p[n] == ';')
+                  p = nextcolon (str);
+                  if (p && p[1] == 'T' && p[2] == 't')
                     {
-                      p = nextcolon (str);
-                      if (p && p[1] == 'T' && p[2] == 't')
+                      /* Now, there can be several name which NAME is a
+                       * substring in.
+                       */
+                      /** @todo: the string parsing still is a bit spooky. */
+                      for (p2 = p; (p2 = strstr (p2, name)) != NULL; p2 += n)
+                        if (p2[-1] == ':' && p2[n] == ';')
                         {
-                          int stab = atoi (&p[3]);
-                          t3 = stype_find (stab);
+                            int stab = atoi (&p[3]);
+                            t3 = stype_find (stab);
+                            break;
                         }
                     }
@@ -3184 +3223 @@
         }
 
+      make_type (t1, &ti);
       sst_start (SST_memfunc);
       r.r_address = sst.size;
@@ -3280 +3320 @@
   symbol = &sym_ptr[*index];
   alloc_flag = concat_symbols (index, &str);
+  parse_start = str;
+  parse_pindex = index;
   p = nextcolon (str);
   if (p != NULL)
@@ -3291 +3333 @@
 #endif
 
-      parse_start = parse_ptr = p + 1;
+      parse_ptr = p + 1;
       switch (*parse_ptr)
         {