[ros-diffs] [gvg] 12895: Include COFF symbols in our .sym files

Include COFF symbols in our .sym files
Modified: trunk/reactos/include/coff.h
Modified: trunk/reactos/include/ntos/kdbgsyms.h
Modified: trunk/reactos/ntoskrnl/dbg/kdb_stabs.c
Modified: trunk/reactos/ntoskrnl/dbg/kdb_symbols.c
Modified: trunk/reactos/tools/rsym.c
  _____  

Modified: trunk/reactos/include/coff.h
--- trunk/reactos/include/coff.h	2005-01-08 23:36:03 UTC (rev
12894)
+++ trunk/reactos/include/coff.h	2005-01-09 00:00:31 UTC (rev
12895)
@@ -6,12 +6,6 @@

 extern "C" {
 #endif
 
-/*
- * #ifndef __dj_ENFORCE_ANSI_FREESTANDING
- * #ifndef __STRICT_ANSI__
- * #ifndef _POSIX_SOURCE
- */
-
 /*** coff information for Intel 386/486.  */
 
 /********************** FILE HEADER **********************/
@@ -329,13 +323,6 @@
 /* For new sections we havn't heard of before */
 #define DEFAULT_SECTION_ALIGNMENT 4
 
-/*
- * #endif /* !_POSIX_SOURCE */
- * #endif /* !__STRICT_ANSI__ */
- * #endif /* !__dj_ENFORCE_ANSI_FREESTANDING */
- */
-#ifndef __dj_ENFORCE_FUNCTION_CALLS
-#endif /* !__dj_ENFORCE_FUNCTION_CALLS */
 
 #ifdef __cplusplus
 }
  _____  

Modified: trunk/reactos/include/ntos/kdbgsyms.h
--- trunk/reactos/include/ntos/kdbgsyms.h	2005-01-08 23:36:03 UTC
(rev 12894)
+++ trunk/reactos/include/ntos/kdbgsyms.h	2005-01-09 00:00:31 UTC
(rev 12895)
@@ -8,6 +8,10 @@

   ULONG_PTR ImageBase;
   ULONG_PTR ImageSize;
   PVOID FileBuffer;
+  PVOID StabsBase;
+  ULONG StabsLength;
+  PVOID StabStringsBase;
+  ULONG StabStringsLength;
   PVOID SymbolsBase;
   ULONG SymbolsLength;
   PVOID SymbolStringsBase;
  _____  

Modified: trunk/reactos/ntoskrnl/dbg/kdb_stabs.c
--- trunk/reactos/ntoskrnl/dbg/kdb_stabs.c	2005-01-08 23:36:03 UTC
(rev 12894)
+++ trunk/reactos/ntoskrnl/dbg/kdb_stabs.c	2005-01-09 00:00:31 UTC
(rev 12895)
@@ -69,8 +69,8 @@

   PVOID StabsEnd;
   ULONG_PTR AddrFound = 0;
 
-  StabEntry = SymbolInfo->SymbolsBase;
-  StabsEnd = (PVOID)((ULONG_PTR)SymbolInfo->SymbolsBase +
SymbolInfo->SymbolsLength);
+  StabEntry = SymbolInfo->StabsBase;
+  StabsEnd = (PVOID)((ULONG_PTR)SymbolInfo->StabsBase +
SymbolInfo->StabsLength);
   if (StartEntry != NULL)
     {
       ASSERT((ULONG_PTR)StartEntry >= (ULONG_PTR)StabEntry);
  _____  

Modified: trunk/reactos/ntoskrnl/dbg/kdb_symbols.c
--- trunk/reactos/ntoskrnl/dbg/kdb_symbols.c	2005-01-08 23:36:03 UTC
(rev 12894)
+++ trunk/reactos/ntoskrnl/dbg/kdb_symbols.c	2005-01-09 00:00:31 UTC
(rev 12895)
@@ -17,6 +17,34 @@

  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 /*
+ * Parts of this file based on work Copyright (c) 1990, 1993
+ *      The Regents of the University of California.  All rights
reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
the
+ *    documentation and/or other materials provided with the
distribution.
+ * 4. Neither the name of the University nor the names of its
contributors
+ *    may be used to endorse or promote products derived from this
software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS''
AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE
LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
OF
+ * SUCH DAMAGE.
+ */
+/*
  * PROJECT:              ReactOS kernel
  * FILE:                 ntoskrnl/dbg/kdb_symbols.c
  * PURPOSE:              Getting symbol information...
@@ -41,6 +69,7 @@
 #include <internal/safe.h>
 #include <internal/kd.h>
 #include <rosrtl/string.h>
+#include <coff.h>
 
 #define NDEBUG
 #include <internal/debug.h>
@@ -55,6 +84,10 @@
   ULONG StabsLength;
   ULONG StabstrOffset;
   ULONG StabstrLength;
+  ULONG SymbolsOffset;
+  ULONG SymbolsLength;
+  ULONG SymbolstrOffset;
+  ULONG SymbolstrLength;
 } SYMBOLFILE_HEADER, *PSYMBOLFILE_HEADER;
 
 typedef struct _IMAGE_SYMBOL_INFO_CACHE {
@@ -62,6 +95,10 @@
   ULONG RefCount;
   UNICODE_STRING FileName;
   PVOID FileBuffer;
+  PVOID StabsBase;
+  ULONG StabsLength;
+  PVOID StabStringsBase;
+  ULONG StabStringsLength;
   PVOID SymbolsBase;
   ULONG SymbolsLength;
   PVOID SymbolStringsBase;
@@ -282,7 +319,68 @@
   return TRUE;
 }
 
+/*! \brief Find a COFF symbol entry...
+ *
+ * Finds the COFF symbol as close as possible before the specified
address
+ *
+ * \param SymbolInfo       Pointer to the symbol info.
+ * \param RelativeAddress  Relative address of address to look for.
+ *
+ * \returns Pointer to a external_syment
+ * \retval NULL  No entry found.
+ */
+static struct external_syment *
+KdbpSymbolsFindEntry(IN PIMAGE_SYMBOL_INFO SymbolInfo,
+                     IN ULONG_PTR RelativeAddress)
+{
+  /*
+   * Perform a binary search.
+   *
+   * The code below is a bit sneaky.  After a comparison fails, we
+   * divide the work in half by moving either left or right. If lim
+   * is odd, moving left simply involves halving lim: e.g., when lim
+   * is 5 we look at item 2, so we change lim to 2 so that we will
+   * look at items 0 & 1.  If lim is even, the same applies.  If lim
+   * is odd, moving right again involes halving lim, this time moving
+   * the base up one item past p: e.g., when lim is 5 we change base
+   * to item 3 and make lim 2 so that we will look at items 3 and 4.
+   * If lim is even, however, we have to shrink it by one before
+   * halving: e.g., when lim is 4, we still looked at item 2, so we
+   * have to make lim 3, then halve, obtaining 1, so that we will only
+   * look at item 3.
+   */
+  struct external_syment *Base = (struct external_syment *)
SymbolInfo->SymbolsBase;
+  ULONG Lim;
+  struct external_syment *Mid, *Low;
 
+  if (SymbolInfo->SymbolsLength < sizeof(struct external_syment)
+      || RelativeAddress < Base->e_value)
+    {
+      return NULL;
+    }
+
+  Low = Base;
+  for (Lim = SymbolInfo->SymbolsLength / sizeof(struct
external_syment); Lim != 0; Lim >>= 1)
+    {
+      Mid = Base + (Lim >> 1);
+      if (RelativeAddress == Mid->e_value)
+        {
+          return Mid;
+        }
+      if (Mid->e_value < RelativeAddress)  /* key > mid: move right */
+        {
+          Low = Mid;
+          Base = Mid + 1;
+          Lim--;
+        }               /* else move left */
+    }
+
+  ASSERT(Low->e_value < RelativeAddress);
+
+  return Low;
+}
+
+
 /*! \brief Get information for an address (source file, line number,
  *         function name)
  *
@@ -306,12 +404,13 @@
                             OUT PCH FileName  OPTIONAL,
                             OUT PCH FunctionName  OPTIONAL)
 {
-  PSTAB_ENTRY FunctionEntry = NULL, FileEntry = NULL, LineEntry = NULL;
+  PSTAB_ENTRY StabsFunctionEntry = NULL, FileEntry = NULL, LineEntry =
NULL;
+  struct external_syment *SymbolsFunctionEntry = NULL;
 
   DPRINT("RelativeAddress = 0x%08x\n", RelativeAddress);
 
-  if (SymbolInfo->SymbolsBase == NULL || SymbolInfo->SymbolsLength == 0
||
-      SymbolInfo->SymbolStringsBase == NULL ||
SymbolInfo->SymbolStringsLength == 0)
+  if (SymbolInfo->StabsBase == NULL || SymbolInfo->StabsLength == 0 ||
+      SymbolInfo->StabStringsBase == NULL ||
SymbolInfo->StabStringsLength == 0)
     {
       return STATUS_UNSUCCESSFUL;
     }
@@ -330,24 +429,24 @@
   if (LineNumber != NULL || FunctionName != NULL)
     {
       /* find stab entry for function */
-      FunctionEntry = KdbpStabFindEntry(SymbolInfo, N_FUN,
(PVOID)RelativeAddress, NULL);
-      if (FunctionEntry == NULL)
+      StabsFunctionEntry = KdbpStabFindEntry(SymbolInfo, N_FUN,
(PVOID)RelativeAddress, NULL);
+      if (StabsFunctionEntry == NULL)
         {
           DPRINT("No function stab entry found. RelativeAddress %p\n",
RelativeAddress);
         }
 
-      if (LineNumber != NULL && FunctionEntry != NULL)
+      if (LineNumber != NULL && StabsFunctionEntry != NULL)
         {
           /* find stab entry for line number */
-          ULONG_PTR FunctionRelativeAddress = RelativeAddress -
FunctionEntry->n_value;
+          ULONG_PTR FunctionRelativeAddress = RelativeAddress -
StabsFunctionEntry->n_value;
           ULONG_PTR AddrFound = 0;
           PSTAB_ENTRY NextLineEntry;
 
-          LineEntry = NextLineEntry = FunctionEntry;
+          LineEntry = NextLineEntry = StabsFunctionEntry;
           while (NextLineEntry != NULL)
             {
               NextLineEntry++;
-              if ((ULONG_PTR)NextLineEntry >=
((ULONG_PTR)SymbolInfo->SymbolsBase + SymbolInfo->SymbolsLength))
+              if ((ULONG_PTR)NextLineEntry >=
((ULONG_PTR)SymbolInfo->StabsBase + SymbolInfo->StabsLength))
                 break;
               if (NextLineEntry->n_type == N_FUN)
                 break;
@@ -364,6 +463,14 @@
         }
     }
 
+  if (FunctionName != NULL
+      && SymbolInfo->SymbolsBase != NULL &&
SymbolInfo->SymbolsLength
!= 0
+      && SymbolInfo->SymbolStringsBase != NULL &&
SymbolInfo->SymbolStringsLength != 0)
+    {
+      /* find symbol entry for function */
+      SymbolsFunctionEntry = KdbpSymbolsFindEntry(SymbolInfo,
RelativeAddress);
+    }
+
   if (FileName != NULL)
     {
       /* find stab entry for file name */
@@ -373,7 +480,7 @@
       FileEntry = KdbpStabFindEntry(SymbolInfo, N_SO,
(PVOID)RelativeAddress, NULL);
       if (FileEntry != NULL)
         {
-          p = (PCHAR)SymbolInfo->SymbolStringsBase + FileEntry->n_strx;
+          p = (PCHAR)SymbolInfo->StabStringsBase + FileEntry->n_strx;
           Length = strlen(p);
           if (p[Length - 1] == '/' || p[Length - 1] == '\\') /* source
dir */
             FileEntry = KdbpStabFindEntry(SymbolInfo, N_SO,
(PVOID)RelativeAddress, FileEntry + 1);
@@ -384,9 +491,10 @@
         }
     }
 
-  if (((LineNumber   != NULL && LineEntry     == NULL) || LineNumber
== NULL) &&
-      ((FileName     != NULL && FileEntry     == NULL) || FileName
== NULL) &&
-      ((FunctionName != NULL && FunctionEntry == NULL) || FunctionName
== NULL))
+  if (((LineNumber   != NULL && LineEntry          == NULL) ||
LineNumber   == NULL) &&
+      ((FileName     != NULL && FileEntry          == NULL) || FileName
== NULL) &&
+      ((FunctionName != NULL && StabsFunctionEntry == NULL &&
SymbolsFunctionEntry == NULL) ||
+       FunctionName == NULL))
     {
       DPRINT("None of the requested information was found!\n");
       return STATUS_UNSUCCESSFUL;
@@ -403,18 +511,56 @@
       PCHAR Name = "";
       if (FileEntry != NULL)
         {
-          Name = (PCHAR)SymbolInfo->SymbolStringsBase +
FileEntry->n_strx;
+          Name = (PCHAR)SymbolInfo->StabStringsBase +
FileEntry->n_strx;
         }
       strcpy(FileName, Name);
     }
   if (FunctionName != NULL)
     {
       PCHAR Name = "", p;
-      if (FunctionEntry != NULL)
-        Name = (PCHAR)SymbolInfo->SymbolStringsBase +
FunctionEntry->n_strx;
-      strcpy(FunctionName, Name);
-      if ((p = strchr(FunctionName, ':')) != NULL) /* remove extra info
from function name */
-        *p = '\0';
+      if (StabsFunctionEntry != NULL)
+        {
+          if (SymbolsFunctionEntry == NULL ||
+              SymbolsFunctionEntry->e_value <=
StabsFunctionEntry->n_value)
+            {
+              Name = (PCHAR)SymbolInfo->StabStringsBase +
StabsFunctionEntry->n_strx;
+              strcpy(FunctionName, Name);
+              if ((p = strchr(FunctionName, ':')) != NULL) /* remove
extra info from function name */
+                {
+                  *p = '\0';
+                }
+            }
+          else if (SymbolsFunctionEntry != NULL)
+            {
+              if (SymbolsFunctionEntry->e.e.e_zeroes == 0)
+                {
+                  Name = (PCHAR) SymbolInfo->SymbolStringsBase +
SymbolsFunctionEntry->e.e.e_offset;
+                  strcpy(FunctionName, Name);
+                }
+              else
+                {
+                  memcpy(FunctionName, SymbolsFunctionEntry->e.e_name,
E_SYMNMLEN);
+                  FunctionName[E_SYMNMLEN] = '\0';
+                }
+            }
+        }
+      else if (SymbolsFunctionEntry != NULL)
+        {
+          if (SymbolsFunctionEntry->e.e.e_zeroes == 0)
+            {
+              Name = (PCHAR) SymbolInfo->SymbolStringsBase +
SymbolsFunctionEntry->e.e.e_offset;
+              strcpy(FunctionName, Name);
+            }
+          else
+            {
+              memcpy(FunctionName, SymbolsFunctionEntry->e.e_name,
E_SYMNMLEN);
+              FunctionName[E_SYMNMLEN] = '\0';
+            }
+        }
+      else
+        {
+          FunctionName[0] = '\0';
+        }
     }
 
   return STATUS_SUCCESS;
@@ -449,14 +595,14 @@
 
   FileNameLength = strlen(FileName);
   FuncNameLength = strlen(FuncName);
-  for (Entry = SymbolInfo->SymbolsBase;
-       (ULONG_PTR)Entry < (ULONG_PTR)(SymbolInfo->SymbolsBase +
SymbolInfo->SymbolsLength);
+  for (Entry = SymbolInfo->StabsBase;
+       (ULONG_PTR)Entry < (ULONG_PTR)(SymbolInfo->StabsBase +
SymbolInfo->StabsLength);
        Entry++)
     {
       if (Entry->n_type != N_SO)
         continue;
 
-      SymbolName = (PCHAR)SymbolInfo->SymbolStringsBase +
Entry->n_strx;
+      SymbolName = (PCHAR)SymbolInfo->StabStringsBase + Entry->n_strx;
       Length = strlen(SymbolName);
       if (SymbolName[Length -  1] == '/' ||
           SymbolName[Length -  1] == '\\')
@@ -473,7 +619,7 @@
         continue;
 
       Entry++;
-      for (;(ULONG_PTR)Entry < (ULONG_PTR)(SymbolInfo->SymbolsBase +
SymbolInfo->SymbolsLength);
+      for (;(ULONG_PTR)Entry < (ULONG_PTR)(SymbolInfo->StabsBase +
SymbolInfo->StabsLength);
            Entry++)
         {
           if (Entry->n_type == N_FUN)
@@ -487,7 +633,7 @@
             continue;
           else /* if (FunctionName != NULL) */
             {
-              SymbolName = (PCHAR)SymbolInfo->SymbolStringsBase +
Entry->n_strx;
+              SymbolName = (PCHAR)SymbolInfo->StabStringsBase +
Entry->n_strx;
               p = strchr(SymbolName, ':');
               if (p == NULL)
                 return FALSE;
@@ -589,6 +735,10 @@
   ASSERT(CacheEntry->FileName.Buffer);
   CacheEntry->RefCount = 1;
   CacheEntry->FileBuffer = SymbolInfo->FileBuffer;
+  CacheEntry->StabsBase = SymbolInfo->StabsBase;
+  CacheEntry->StabsLength = SymbolInfo->StabsLength;
+  CacheEntry->StabStringsBase = SymbolInfo->StabStringsBase;
+  CacheEntry->StabStringsLength = SymbolInfo->StabStringsLength;
   CacheEntry->SymbolsBase = SymbolInfo->SymbolsBase;
   CacheEntry->SymbolsLength = SymbolInfo->SymbolsLength;
   CacheEntry->SymbolStringsBase = SymbolInfo->SymbolStringsBase;
@@ -692,6 +842,10 @@
     {
       DPRINT("Found cached symbol file %wZ\n", &SymFileName);
       SymbolInfo->FileBuffer = CachedSymbolFile->FileBuffer;
+      SymbolInfo->StabsBase = CachedSymbolFile->StabsBase;
+      SymbolInfo->StabsLength = CachedSymbolFile->StabsLength;
+      SymbolInfo->StabStringsBase = CachedSymbolFile->StabStringsBase;
+      SymbolInfo->StabStringsLength =
CachedSymbolFile->StabStringsLength;
       SymbolInfo->SymbolsBase = CachedSymbolFile->SymbolsBase;
       SymbolInfo->SymbolsLength = CachedSymbolFile->SymbolsLength;
       SymbolInfo->SymbolStringsBase =
CachedSymbolFile->SymbolStringsBase;
@@ -769,16 +923,23 @@
 
   SymbolFileHeader = (PSYMBOLFILE_HEADER) FileBuffer;
   SymbolInfo->FileBuffer = FileBuffer;
-  SymbolInfo->SymbolsBase = FileBuffer + SymbolFileHeader->StabsOffset;
-  SymbolInfo->SymbolsLength = SymbolFileHeader->StabsLength;
-  SymbolInfo->SymbolStringsBase = FileBuffer +
SymbolFileHeader->StabstrOffset;
-  SymbolInfo->SymbolStringsLength = SymbolFileHeader->StabstrLength;
+  SymbolInfo->StabsBase = FileBuffer + SymbolFileHeader->StabsOffset;
+  SymbolInfo->StabsLength = SymbolFileHeader->StabsLength;
+  SymbolInfo->StabStringsBase = FileBuffer +
SymbolFileHeader->StabstrOffset;
+  SymbolInfo->StabStringsLength = SymbolFileHeader->StabstrLength;
+  SymbolInfo->SymbolsBase = FileBuffer +
SymbolFileHeader->SymbolsOffset;
+  SymbolInfo->SymbolsLength = SymbolFileHeader->SymbolsLength;
+  SymbolInfo->SymbolStringsBase = FileBuffer +
SymbolFileHeader->SymbolstrOffset;
+  SymbolInfo->SymbolStringsLength = SymbolFileHeader->SymbolstrLength;
 
   /* add file to cache */
   KdbpSymAddCachedFile(&SymFileName, SymbolInfo);
 
-  DPRINT("Installed stabs: %wZ (%08x-%08x,%08x)\n",
+  DPRINT("Installed stabs: %wZ (%08x-%08x,%08x) (%08x-%08x,%08x)\n",
 	 FileName,
+	 SymbolInfo->StabsBase,
+	 SymbolInfo->StabsLength + SymbolInfo->StabsBase,
+	 SymbolInfo->StabStringsBase,
 	 SymbolInfo->SymbolsBase,
 	 SymbolInfo->SymbolsLength + SymbolInfo->SymbolsBase,
 	 SymbolInfo->SymbolStringsBase);
@@ -800,6 +961,8 @@
     {
       KdbpSymRemoveCachedFile(SymbolInfo);
       SymbolInfo->FileBuffer = NULL;
+      SymbolInfo->StabsBase = NULL;
+      SymbolInfo->StabsLength = 0;
       SymbolInfo->SymbolsBase = NULL;
       SymbolInfo->SymbolsLength = 0;
     }
@@ -955,10 +1118,14 @@
 	       KeLoaderModules[i].ModEnd - KeLoaderModules[i].ModStart);
  
         SymbolInfo->FileBuffer = SymbolFileHeader;
-        SymbolInfo->SymbolsBase = (PVOID)SymbolFileHeader +
SymbolFileHeader->StabsOffset;
-        SymbolInfo->SymbolsLength = SymbolFileHeader->StabsLength;
-        SymbolInfo->SymbolStringsBase = (PVOID)SymbolFileHeader +
SymbolFileHeader->StabstrOffset;
-        SymbolInfo->SymbolStringsLength =
SymbolFileHeader->StabstrLength;
+        SymbolInfo->StabsBase = (PVOID)SymbolFileHeader +
SymbolFileHeader->StabsOffset;
+        SymbolInfo->StabsLength = SymbolFileHeader->StabsLength;
+        SymbolInfo->StabStringsBase = (PVOID)SymbolFileHeader +
SymbolFileHeader->StabstrOffset;
+        SymbolInfo->StabStringsLength =
SymbolFileHeader->StabstrLength;
+        SymbolInfo->SymbolsBase = (PVOID)SymbolFileHeader +
SymbolFileHeader->SymbolsOffset;
+        SymbolInfo->SymbolsLength = SymbolFileHeader->SymbolsLength;
+        SymbolInfo->SymbolStringsBase = (PVOID)SymbolFileHeader +
SymbolFileHeader->SymbolstrOffset;
+        SymbolInfo->SymbolStringsLength =
SymbolFileHeader->SymbolstrLength;
 
         /* add file to cache */
         RtlInitAnsiString(&AnsiString, SymbolName);
@@ -966,10 +1133,13 @@
         KdbpSymAddCachedFile(&UnicodeString, SymbolInfo);
         RtlFreeUnicodeString(&UnicodeString);
 
-        DPRINT("Installed stabs: %s@%08x-%08x (%08x-%08x,%08x)\n",
+        DPRINT("Installed stabs: %s@%08x-%08x (%08x-%08x,%08x)
(%08x-%08x,%08x)\n",
 	       FileName,
 	       ModuleObject->Base,
 	       ModuleObject->Length + ModuleObject->Base,
+	       SymbolInfo->StabsBase,
+	       SymbolInfo->StabsLength + SymbolInfo->StabsBase,
+	       SymbolInfo->StabStringsBase,
 	       SymbolInfo->SymbolsBase,
 	       SymbolInfo->SymbolsLength + SymbolInfo->SymbolsBase,
 	       SymbolInfo->SymbolStringsBase);
  _____  

Modified: trunk/reactos/tools/rsym.c
--- trunk/reactos/tools/rsym.c	2005-01-08 23:36:03 UTC (rev 12894)
+++ trunk/reactos/tools/rsym.c	2005-01-09 00:00:31 UTC (rev 12895)
@@ -111,6 +111,10 @@

   unsigned long StabsLength;
   unsigned long StabstrOffset;
   unsigned long StabstrLength;
+  unsigned long SymbolsOffset;
+  unsigned long SymbolsLength;
+  unsigned long SymbolstrOffset;
+  unsigned long SymbolstrLength;
 } SYMBOLFILE_HEADER, *PSYMBOLFILE_HEADER;
 
 typedef struct _STAB_ENTRY {
@@ -133,6 +137,83 @@
    unsigned long Length;
 } STR_ENTRY, *PSTR_ENTRY;
 
+/* COFF symbol table */
+
+#define E_SYMNMLEN	8	/* # characters in a symbol name
*/
+#define E_FILNMLEN	14	/* # characters in a file name
*/
+#define E_DIMNUM	4	/* # array dimensions in auxiliary entry
*/
+
+#define N_BTMASK	(0xf)
+#define N_TMASK		(0x30)
+#define N_BTSHFT	(4)
+#define N_TSHIFT	(2)
+
+/* derived types, in e_type */
+#define DT_NON		(0)	/* no derived type */
+#define DT_PTR		(1)	/* pointer */
+#define DT_FCN		(2)	/* function */
+#define DT_ARY		(3)	/* array */
+
+#define BTYPE(x)	((x) & N_BTMASK)
+
+#define ISPTR(x)	(((x) & N_TMASK) == (DT_PTR << N_BTSHFT))
+#define ISFCN(x)	(((x) & N_TMASK) == (DT_FCN << N_BTSHFT))
+#define ISARY(x)	(((x) & N_TMASK) == (DT_ARY << N_BTSHFT))
+#define ISTAG(x)	((x)==C_STRTAG||(x)==C_UNTAG||(x)==C_ENTAG)
+#define DECREF(x) ((((x)>>N_TSHIFT)&~N_BTMASK)|((x)&N_BTMASK))
+
+#define C_EFCN		0xff	/* physical end of function	*/
+#define C_NULL		0
+#define C_AUTO		1	/* automatic variable		*/
+#define C_EXT		2	/* external symbol		*/
+#define C_STAT		3	/* static			*/
+#define C_REG		4	/* register variable		*/
+#define C_EXTDEF	5	/* external definition		*/
+#define C_LABEL		6	/* label
*/
+#define C_ULABEL	7	/* undefined label		*/
+#define C_MOS		8	/* member of structure		*/
+#define C_ARG		9	/* function argument		*/
+#define C_STRTAG	10	/* structure tag		*/
+#define C_MOU		11	/* member of union		*/
+#define C_UNTAG		12	/* union tag
*/
+#define C_TPDEF		13	/* type definition
*/
+#define C_USTATIC	14	/* undefined static		*/
+#define C_ENTAG		15	/* enumeration tag
*/
+#define C_MOE		16	/* member of enumeration	*/
+#define C_REGPARM	17	/* register parameter		*/
+#define C_FIELD		18	/* bit field
*/
+#define C_AUTOARG	19	/* auto argument		*/
+#define C_LASTENT	20	/* dummy entry (end of block)	*/
+#define C_BLOCK		100	/* ".bb" or ".eb"
*/
+#define C_FCN		101	/* ".bf" or ".ef"		*/
+#define C_EOS		102	/* end of structure		*/
+#define C_FILE		103	/* file name			*/
+#define C_LINE		104	/* line # reformatted as symbol table
entry */
+#define C_ALIAS	 	105	/* duplicate tag
*/
+#define C_HIDDEN	106	/* ext symbol in dmert public lib */
+
+#pragma pack(push,1)
+typedef struct _EXTERNAL_SYMENT
+{
+  union
+    {
+      char e_name[E_SYMNMLEN];
+      struct
+        {
+          unsigned long e_zeroes;
+          unsigned long e_offset;
+        }
+      e;
+    }
+  e;
+  unsigned long e_value;
+  short e_scnum;
+  unsigned short e_type;
+  unsigned char e_sclass;
+  unsigned char e_numaux;
+} EXTERNAL_SYMENT, *PEXTERNAL_SYMENT;
+#pragma pack(pop)
+
 char* convert_path(char* origpath)
 {
    char* newpath;
@@ -161,6 +242,52 @@
    return(newpath);
 }
 
+static void
+RelocateString(ULONG *Offset, PSTR_ENTRY StrEntry, ULONG *StrCount,
PVOID SymbolStringsBase)
+{
+  ULONG i;
+
+  for (i = 0; i < *StrCount; i++)
+    {
+      if (*Offset == StrEntry[i].OldOffset)
+        {
+          *Offset = StrEntry[i].NewOffset;
+          return;
+        }
+    }
+
+  StrEntry[*StrCount].OldOffset = *Offset;
+  StrEntry[*StrCount].Name = (char*) SymbolStringsBase +
StrEntry[*StrCount].OldOffset;
+  StrEntry[*StrCount].Length = strlen(StrEntry[*StrCount].Name) + 1;
+  if (*StrCount == 0)
+    {
+      StrEntry[*StrCount].NewOffset = 0;
+    }
+  else
+    {
+      StrEntry[*StrCount].NewOffset = StrEntry[*StrCount - 1].NewOffset
+                                      + StrEntry[*StrCount - 1].Length;
+    }
+  *Offset = StrEntry[*StrCount].NewOffset;
+  (*StrCount)++;
+}
+
+static int
+CompareSyment(const PEXTERNAL_SYMENT SymEntry1, const PEXTERNAL_SYMENT
SymEntry2)
+{
+  if (SymEntry1->e_value < SymEntry2->e_value)
+    {
+      return -1;
+    }
+
+  if (SymEntry2->e_value < SymEntry1->e_value)
+    {
+      return +1;
+    }
+
+  return 0;
+} 
+
 #define TRANSFER_SIZE      (65536)
 
 int main(int argc, char* argv[])
@@ -175,6 +302,10 @@
   ULONG SymbolsLength;
   PVOID SymbolStringsBase;
   ULONG SymbolStringsLength;
+  PVOID CoffSymbolsBase;
+  ULONG CoffSymbolsLength;
+  PVOID CoffSymbolStringsBase;
+  ULONG CoffSymbolStringsLength;
   ULONG Idx;
   char* path1;
   char* path2;
@@ -188,31 +319,34 @@
   ULONG SymbolsCount;
   PSTR_ENTRY StrEntry;
   ULONG StrCount;
-  ULONG j;
+  PSTR_ENTRY CoffStrEntry;
+  ULONG CoffStrCount;
+  PEXTERNAL_SYMENT SymEntry;
+  unsigned NumAux;
 
-   if (argc != 3)
-     {
-	fprintf(stderr, "Too many arguments\n");
-	exit(1);
-     }
+  if (argc != 3)
+    {
+      fprintf(stderr, "Too many arguments\n");
+      exit(1);
+    }
 
-   path1 = convert_path(argv[1]);
-   path2 = convert_path(argv[2]);
+  path1 = convert_path(argv[1]);
+  path2 = convert_path(argv[2]);
 
-   in = fopen(path1, "rb");
-   if (in == NULL)
-     {
-	perror("Cannot open input file");
-	exit(1);
-     }
+  in = fopen(path1, "rb");
+  if (in == NULL)
+    {
+      perror("Cannot open input file");
+      exit(1);
+    }
 
-   out = fopen(path2, "wb");
-   if (out == NULL)
-     {
-	perror("Cannot open output file");
-	fclose(in);
-	exit(1);
-     }
+  out = fopen(path2, "wb");
+  if (out == NULL)
+    {
+      perror("Cannot open output file");
+      fclose(in);
+      exit(1);
+    }
 
   /* Check if MZ header exists  */
   n_in = fread(&PEDosHeader, 1, sizeof(PEDosHeader), in);
@@ -302,30 +436,7 @@
 
   for (i = 0; i < Count; i++)
     {
-      for (j = 0; j < StrCount; j++)
-        {
-	  if (StabEntry[i].n_strx == StrEntry[j].OldOffset)
-	    {
-	      StabEntry[i].n_strx = StrEntry[j].NewOffset;
-	      break;
-	    }
-	}
-      if (j >= StrCount)
-        {
-	  StrEntry[StrCount].OldOffset = StabEntry[i].n_strx;
-	  StrEntry[StrCount].Name = (char*)SymbolStringsBase +
StrEntry[StrCount].OldOffset;
-	  StrEntry[StrCount].Length = strlen(StrEntry[StrCount].Name) +
1;
-	  if (StrCount == 0)
-	    {
-	      StrEntry[StrCount].NewOffset = 0;
-	    }
-	  else
-	    {
-	      StrEntry[StrCount].NewOffset =
StrEntry[StrCount-1].NewOffset + StrEntry[StrCount-1].Length;
-	    }
-	  StabEntry[i].n_strx = StrEntry[StrCount].NewOffset;
-	  StrCount++;
-	}
+      RelocateString(&StabEntry[i].n_strx, StrEntry, &StrCount,
SymbolStringsBase);
     }
 
   SymbolFileHeader.StabsOffset = sizeof(SYMBOLFILE_HEADER);
@@ -333,12 +444,93 @@
   SymbolFileHeader.StabstrOffset = SymbolFileHeader.StabsOffset +
SymbolFileHeader.StabsLength;
   SymbolFileHeader.StabstrLength = StrEntry[StrCount-1].NewOffset +
StrEntry[StrCount-1].Length;
 
+  if (0 == PEFileHeader.PointerToSymbolTable || 0 ==
PEFileHeader.NumberOfSymbols)
+    {
+      /* No COFF symbol table */
+      SymbolFileHeader.SymbolsOffset = 0;
+      SymbolFileHeader.SymbolsLength = 0;
+      SymbolFileHeader.SymbolstrOffset = 0;
+      SymbolFileHeader.SymbolstrLength = 0;
+    }
+  else
+    {
+      CoffSymbolsLength = PEFileHeader.NumberOfSymbols *
sizeof(EXTERNAL_SYMENT);
+      CoffSymbolsBase = malloc(CoffSymbolsLength);
+      if (NULL == CoffSymbolsBase)
+        {
+          fprintf(stderr, "Unable to allocate %u bytes for COFF
symbols\n",
+                  (unsigned) CoffSymbolsLength);
+	  exit(1);
+        }
+      fseek(in, PEFileHeader.PointerToSymbolTable, SEEK_SET);
+      n_in = fread(CoffSymbolsBase, 1, CoffSymbolsLength, in);
+
+      SymEntry = CoffSymbolsBase;
+      Count = 0;
+      for (i = 0; i < PEFileHeader.NumberOfSymbols; i++)
+        {
+          NumAux = SymEntry[i].e_numaux;
+          if (ISFCN(SymEntry[i].e_type))
+            {
+              SymEntry[Count] = SymEntry[i];
+              if (0 < SymEntry[Count].e_scnum)
+                {
+                  if (PEFileHeader.NumberOfSections <
SymEntry[Count].e_scnum)
+                    {
+                      fprintf(stderr, "Invalid section number %d in
COFF symbols (only %d sections present)\n",
+                              SymEntry[Count].e_scnum,
PEFileHeader.NumberOfSections);
+                      exit(1);
+                    }
+                  SymEntry[Count].e_value +=
PESectionHeaders[SymEntry[Count].e_scnum - 1].VirtualAddress;
+                  SymEntry[Count].e_scnum = -3;
+                  SymEntry[Count].e_numaux = 0;
+                }
+              Count++;
+            }
+          i += NumAux;
+        }
+
+      qsort(CoffSymbolsBase, Count, sizeof(EXTERNAL_SYMENT), (int
(*)(const void *, const void *)) CompareSyment);
+
+      n_in = fread(&CoffSymbolStringsLength, 1, sizeof(ULONG), in);
+      CoffSymbolStringsBase = malloc(CoffSymbolStringsLength);
+      if (NULL == CoffSymbolStringsBase)
+        {
+          fprintf(stderr, "Unable to allocate %u bytes for COFF symbol
strings\n",
+                  (unsigned) CoffSymbolStringsLength);
+	  exit(1);
+        }
+      n_in = fread((char *) CoffSymbolStringsBase + sizeof(ULONG), 1,
CoffSymbolStringsLength - 4, in);
+
+      CoffStrEntry = malloc(sizeof(STR_ENTRY) * Count);
+      CoffStrCount = 0;
+
+      for (i = 0; i < Count; i++)
+        {
+          if (0 == SymEntry[i].e.e.e_zeroes)
+            {
+              RelocateString(&SymEntry[i].e.e.e_offset, CoffStrEntry,
&CoffStrCount, CoffSymbolStringsBase);
+            }
+        }
+
+      SymbolFileHeader.SymbolsOffset = SymbolFileHeader.StabstrOffset +
SymbolFileHeader.StabstrLength;
+      SymbolFileHeader.SymbolsLength = Count * sizeof(EXTERNAL_SYMENT);
+      SymbolFileHeader.SymbolstrOffset = SymbolFileHeader.SymbolsOffset
+ SymbolFileHeader.SymbolsLength;
+      SymbolFileHeader.SymbolstrLength = CoffStrEntry[CoffStrCount -
1].NewOffset
+                                         + CoffStrEntry[CoffStrCount -
1].Length;
+    }
+
   n_out = fwrite(&SymbolFileHeader, 1, sizeof(SYMBOLFILE_HEADER), out);
   n_out = fwrite(SymbolsBase, 1, SymbolFileHeader.StabsLength, out);
   for (i = 0; i < StrCount; i++)
     {
       fwrite(StrEntry[i].Name, 1, StrEntry[i].Length, out);
     }
+  n_out = fwrite(CoffSymbolsBase, 1, SymbolFileHeader.SymbolsLength,
out);
+  for (i = 0; i < CoffStrCount; i++)
+    {
+      fwrite(CoffStrEntry[i].Name, 1, CoffStrEntry[i].Length, out);
+    }
 
   fclose(out);
   exit(0);