Changeset 804

Timestamp:

Oct 5, 2003, 6:04:56 AM (22 years ago)

Author:

bird

Message:

#456: Two bool fixes. Make the type an enum. When passed as parameter it's
32bit, but GCC moves it to a 8bit auto variable - thus GCC generates two stabs
for it. Debugger needs a { between them to see both.
#456: Made fake struct for struct/class forward declarations. (stupid GCC)

File:

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

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

@@ -1313 +1313 @@
   t.d.types.list = list;
   t1 = type_add (&t);
+  free (list);
 
   t = *tp;
@@ -1650 +1651 @@
         t.index = 0x80;         /* 8 bit signed */
       else if (range_lo == -32768 && range_hi == 32767)
-        t.index = 0x80;         /* 16 bit signed */
+        t.index = 0x81;         /* 16 bit signed */
       else if (range_lo == -2147483647 - 1 && range_hi == 2147483647)
         t.index = 0x82;         /* 32 bit signed */
@@ -1867 +1868 @@
           if (size == 8 && code == -16)
             {
+#if 0 /* debugger doesn't understand this game */
               t.tag = ty_prim;
               t.index = 0x90;   /* 8 bit boolean */
+#else
+              t.tag = ty_values;
+              t.d.values.count = 2;
+              t.d.values.list = xmalloc (2 * sizeof (*t.d.values.list));
+              t.d.values.list[0].index = 0;
+              t.d.values.list[0].name  = strpool_add (str_pool, "false");
+              t.d.values.list[1].index = 1;
+              t.d.values.list[1].name  = strpool_add (str_pool, "true");
+              t1 = type_add (&t);
+              free (t.d.values.list);
+
+              t.tag = ty_prim;
+              t.index = 0x80;
+              t2 = type_add (&t);
+
+              t.tag = ty_enu;
+              t.index = -1;
+              t.d.enu.values = t1;
+              t.d.enu.type = t2;
+              t.d.enu.name = add_struct_name (NULL);
+              t.d.enu.first = 0;
+              t.d.enu.last = 1;
+#endif
             }
           else
@@ -1927 +1952 @@
         case 'u':
           {
+            /* make a fake structure. */
+            t.tag = ty_prim;
+            t.index = 0x80;
+            tlist = xmalloc (1 * sizeof (*t.d.types.list));
+            tlist[0] = type_add (&t);
+            t.tag = ty_types;
+            t.index = -1;
+            t.d.types.count = 1;
+            t.d.types.list = tlist;
+            t1 = type_add (&t);
+            free (tlist);
+
+            t.tag = ty_fields;
+            t.index = -1;
+            t.d.fields.count = 1;
+            t.d.fields.list = xmalloc (1 * sizeof (*t.d.fields.list));
+            t.d.fields.list[0].offset = 0;
+            t.d.fields.list[0].name = strpool_add (str_pool, "This_Is_an_Incomplete_Structure_SORRY");
+            t2 = type_add (&t);
+            free (t.d.fields.list);
+
             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.index = -1;
+            t.d.struc.types = t1;
+            t.d.struc.fields = t2;
+            t.d.struc.size = 1;
+            t.d.struc.count = 1;
             t.d.struc.name = strpool_addn (str_pool, parse_ptr, p1 - parse_ptr);
             t.d.struc.flags = STRUC_FORWARD;
@@ -2030 +2077 @@
                   /* kso #456 2003-06-11: Don't mess with forward defines! */
                   if (!(   (t1->d.struc.flags & STRUC_FORWARD)
-                        && t1->d.struc.types == NULL
-                        && t1->d.struc.fields == NULL))
+                        /*&& t1->d.struc.types == NULL
+                        && t1->d.struc.fields == NULL*/))
                     struct_to_class (t1);
                   break;
@@ -2296 +2343 @@
           for (t3 = type_head; t3 != NULL; t3 = t3->next)
             if (t3->tag == ty_struc && t3->d.struc.name == t.d.class.name
-                && t3->d.struc.types == NULL && t3->d.struc.fields == NULL
+                /*&& t3->d.struc.types == NULL && t3->d.struc.fields == NULL */
                 && (t3->d.struc.flags & STRUC_FORWARD))
               {
@@ -2326 +2373 @@
             }
           t2 = type_add (&t);
+          free (t.d.fields.list);
 
           t.tag = ty_struc;
@@ -2340 +2388 @@
           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.types == NULL && t3->d.struc.fields == NULL
+                /* && t3->d.struc.types == NULL && t3->d.struc.fields == NULL */
                 && (t3->d.struc.flags & STRUC_FORWARD))
               {
@@ -2393 +2441 @@
         }
       t1 = type_add (&t);
+      free (t.d.values.list);
 
       t.tag = ty_prim;
@@ -2619 +2668 @@
           t.d.types.list = list;
           t1 = type_add (&t);
+          free (list);
 
           make_type (t1, &ti_1);
@@ -3144 +3194 @@
       hll_end (block_stack[block_grow.count].patch_ptr, 0,
                sym_ptr[i].n_value - block_stack[block_grow.count].addr);
+      if (block_grow.count == 1) /* we make one extra begin */
+        {
+          --block_grow.count;
+          hll_end (block_stack[block_grow.count].patch_ptr, 0,
+                   sym_ptr[i].n_value - block_stack[block_grow.count].addr);
+        }
       if (block_grow.count == 0 && proc_patch_base != 0)
         fun_end (i);
@@ -3171 +3227 @@
     abort ();
   n = p - str;
-  name = strpool_addn(str_pool, str, n);
+
+  /*
+   * The debuggers doesn't like looong names. Besides it doesn't know how to
+   * demangle them either. This is the place to deal with this.
+   * (The limit seems to be 106 bytes.)
+   *
+   * For now we'll just make sure the name ain't too long.
+   */
+  if (n > 106)
+    {
+      char szName[106];
+      memcpy(szName, str, sizeof(szName) - 1);
+      szName[sizeof(szName) - 1] = '!'; /* mark it as cut. */
+      name = strpool_addn(str_pool, str, sizeof(szName));
+    }
+  else
+    name = strpool_addn(str_pool, str, n);
 
   proc_start_addr = symbol->n_value;
@@ -3576 +3648 @@
 
           /* Now look for N_LBRAC */
-
           next_lbrac (i);
           if (lbrac_index != -1)
@@ -3585 +3656 @@
           else
             {/* kso #456 2003-06-05: We need a begin to catch the parameters. */
-              struct relocation_info r = {0};
-              sst_start (SST_begin);
-              r.r_address = sst.size;
-              buffer_dword (&sst, proc_start_addr);         /* Segment offset */
-              buffer_dword (&sst, text_size - proc_start_addr); /* Length */
-              sst_end ();
-              r.r_length = 2;
-              r.r_symbolnum = N_TEXT;
-              buffer_mem (&sst_reloc, &r, sizeof (r));
               prologue_length = 0;
+              block_begin (proc_start_addr);
             }
 
           /* Parameters */
-
           while (*index + 1 < sym_count && sym_ptr[*index+1].n_type == N_PSYM)
             {
@@ -3605 +3667 @@
             }
 
+          /* Start another block for the local variables. This is to work
+             around some missing bracets in stabs and to fix problem with
+             C++ bool type.  */
+          dword addr = proc_start_addr + prologue_length;
+          if (lbrac_index >= 0 && sym_ptr[lbrac_index].n_value > addr)
+            addr = sym_ptr[lbrac_index].n_value;
+          block_begin (addr);
+
+          /* Local variables  (fix for boolparam testcase too). */
+          while (*index + 1 < sym_count && sym_ptr[*index+1].n_type == N_LSYM)
+            {
+              ++(*index);
+              parse_symbol (index, -1, "LSYM", TRUE);
+            }
+
           /* If there's no N_LBRAC, write SST_end now */
-
           if (lbrac_index == -1)
             {/* kso #456 2003-06-05: We need a begin to catch the parameters. */
-              //block_end (proc_start_addr);
-              sst_start (SST_end);
-              sst_end ();
-              fun_end (*index+1);
+              while (block_grow.count > 0)
+                block_end (*index+1);
             }
           break;