home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 1 / 1973 < prev    next >
Encoding:
Internet Message Format  |  1990-12-28  |  19.5 KB
  1. From: loic@adesign.uucp (Loic Dachary)
  2. Newsgroups: alt.sources
  3. Subject: gas-1.36 patches for COFF generation
  4. Message-ID: <LOIC.90Oct16093556@adesign.uucp>
  5. Date: 16 Oct 90 08:35:56 GMT
  6.  
  7. *** struc-symbol.h    Fri May 12 19:45:21 1989
  8. --- /lasvegas/spare/usenet/port/gas-1.36/struc-symbol.h    Mon Oct 15 08:41:38 1990
  9. ***************
  10. *** 17,31 ****
  11.   along with GAS; see the file COPYING.  If not, write to
  12.   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  13.   
  14. - #ifndef        VMS
  15. - #include "a.out.h"        /* Needed to define struct nlist. Sigh. */
  16. - #else
  17. - #include "a_out.h"
  18. - #endif
  19. - 
  20.   struct symbol            /* our version of an nlist node */
  21.   {
  22. !   struct nlist    sy_nlist;    /* what we write in .o file (if permitted) */
  23.     long unsigned sy_name_offset;    /* 4-origin position of sy_name in symbols */
  24.                   /* part of object file. */
  25.                   /* 0 for (nameless) .stabd symbols. */
  26. --- 17,25 ----
  27.   along with GAS; see the file COPYING.  If not, write to
  28.   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  29.   
  30.   struct symbol            /* our version of an nlist node */
  31.   {
  32. !   symbol_type   sy_symbol;      /* what we write in .o file (if permitted) */
  33.     long unsigned sy_name_offset;    /* 4-origin position of sy_name in symbols */
  34.                   /* part of object file. */
  35.                   /* 0 for (nameless) .stabd symbols. */
  36. ***************
  37. *** 34,54 ****
  38.                   /* Symbol numbers start at 0 and are */
  39.                   /* unsigned. */
  40.     struct symbol * sy_next;    /* forward chain, or NULL */
  41.     struct frag *    sy_frag;    /* NULL or -> frag this symbol attaches to. */
  42.     struct symbol *sy_forward;    /* value is really that of this other symbol */
  43.   };
  44.   
  45.   typedef struct symbol symbolS;
  46.   
  47. ! #define sy_name        sy_nlist .n_un. n_name
  48.                   /* Name field always points to a string. */
  49.                   /* 0 means .stabd-like anonymous symbol. */
  50. ! #define sy_type     sy_nlist.    n_type
  51. ! #define sy_other    sy_nlist.    n_other
  52. ! #define sy_desc        sy_nlist.    n_desc
  53. ! #define sy_value    sy_nlist.    n_value
  54.                   /* Value of symbol is this value + object */
  55.                   /* file address of sy_frag. */
  56.   
  57.   typedef unsigned valueT;    /* The type of n_value. Helps casting. */
  58.   
  59. --- 28,71 ----
  60.                   /* Symbol numbers start at 0 and are */
  61.                   /* unsigned. */
  62.     struct symbol * sy_next;    /* forward chain, or NULL */
  63. + #ifdef coff
  64. +   struct symbol * sy_previous;    /* backward chain, or NULL */
  65. + #endif /* coff */
  66.     struct frag *    sy_frag;    /* NULL or -> frag this symbol attaches to. */
  67.     struct symbol *sy_forward;    /* value is really that of this other symbol */
  68. + #ifdef coff
  69. +   unsigned int sy_flags;    /* Internal use only flags (see coff.h) */
  70. +   AUXENT sy_auxent;        /* Auxiliary entry. */
  71. + #endif /* coff */
  72.   };
  73.   
  74.   typedef struct symbol symbolS;
  75.   
  76. ! #ifdef coff
  77. ! 
  78. ! #define sy_name        sy_symbol.n_name    /* Symbol name */
  79. ! #define sy_zeroes    sy_symbol.n_zeroes    /* All 0 if pointer to str. */
  80. ! #define sy_offset    sy_symbol.n_offset    /* Offset in string table */
  81. ! #define    sy_value    sy_symbol.n_value    /* Symbol 0 or ptr in file */
  82. ! #define sy_scnum    sy_symbol.n_scnum    /* Section number */
  83. ! #define sy_type        sy_symbol.n_type    /* Type and derived type */
  84. ! #define sy_sclass    sy_symbol.n_sclass    /* Storage class */
  85. ! #define sy_numaux    sy_symbol.n_numaux    /* Number of aux. entries */
  86. ! 
  87. ! #else /* coff */
  88. ! 
  89. ! #define sy_name        sy_symbol.n_un.n_name
  90.                   /* Name field always points to a string. */
  91.                   /* 0 means .stabd-like anonymous symbol. */
  92. ! #define sy_strx        sy_symbol.n_un.n_strx
  93. ! #define sy_type     sy_symbol.n_type
  94. ! #define sy_other    sy_symbol.n_other
  95. ! #define sy_desc        sy_symbol.n_desc
  96. ! #define sy_value    sy_symbol.n_value
  97.                   /* Value of symbol is this value + object */
  98.                   /* file address of sy_frag. */
  99. + 
  100. + #endif /* coff */
  101.   
  102.   typedef unsigned valueT;    /* The type of n_value. Helps casting. */
  103.   
  104. *** subsegs.c    Wed Mar  1 23:48:46 1989
  105. --- /lasvegas/spare/usenet/port/gas-1.36/subsegs.c    Wed Sep 12 09:28:57 1990
  106. ***************
  107. *** 21,26 ****
  108. --- 21,27 ----
  109.    * Segments & sub-segments.
  110.    */
  111.   
  112. + #include "oformat.h"
  113.   #include "as.h"
  114.   #include "subsegs.h"
  115.   #include "obstack.h"
  116. ***************
  117. *** 33,40 ****
  118. --- 34,95 ----
  119.       *    data0_frchainP;
  120.   
  121.   
  122. + #ifdef coff
  123.   int                /* in: segT   out: N_TYPE bits */
  124.   seg_N_TYPE[] = {
  125. +   C_ABS_SECTION,
  126. +   C_TEXT_SECTION,
  127. +   C_DATA_SECTION,
  128. +   C_BSS_SECTION,
  129. +   C_UNDEF_SECTION,        /* SEG_UNKNOWN */
  130. +   C_UNDEF_SECTION,        /* SEG_NONE */
  131. +   C_UNDEF_SECTION,        /* SEG_PASS1 */
  132. +   C_UNDEF_SECTION,        /* SEG_GOOF */
  133. +   C_UNDEF_SECTION,        /* SEG_BIG */
  134. +   C_UNDEF_SECTION,        /* SEG_DIFFERENCE */
  135. +   C_DEBUG_SECTION,        /* SEG_DEBUG */
  136. +   C_NTV_SECTION,        /* SEG_NTV */
  137. +   C_PTV_SECTION,        /* SEG_PTV */
  138. + };
  139. + 
  140. + 
  141. + char *                /* in: segT   out: char* */
  142. + seg_name[] = {
  143. +   "absolute",
  144. +   "text",
  145. +   "data",
  146. +   "bss",
  147. +   "unknown",
  148. +   "absent",
  149. +   "pass1",
  150. +   "ASSEMBLER-INTERNAL-LOGIC-ERROR!",
  151. +   "bignum/flonum",
  152. +   "difference",
  153. +   "debug",
  154. +   "transfert vector preload",
  155. +   "transfert vector postload",
  156. +   ""
  157. +   };                /* Used by error reporters, dumpers etc. */
  158. + 
  159. + /* Add 4 to the real value to get the index and compensate the negatives */
  160. + 
  161. + segT N_TYPE_seg [32] =
  162. + {
  163. +   SEG_PTV,            /* C_PTV_SECTION    == -4    */
  164. +   SEG_NTV,            /* C_NTV_SECTION    == -3    */
  165. +   SEG_DEBUG,            /* C_DEBUG_SECTION    == -2     */
  166. +   SEG_ABSOLUTE,            /* C_ABS_SECTION    == -1    */
  167. +   SEG_UNKNOWN,            /* C_UNDEF_SECTION    == 0     */
  168. +   SEG_TEXT,            /* C_TEXT_SECTION    == 1    */
  169. +   SEG_DATA,            /* C_DATA_SECTION    == 2    */
  170. +   SEG_BSS,            /* C_BSS_SECTION    == 3    */
  171. +   SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF,
  172. +   SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF,
  173. +   SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF
  174. + };
  175. + #else /* coff */
  176. + int                /* in: segT   out: N_TYPE bits */
  177. + seg_N_TYPE[] = {
  178.     N_ABS,
  179.     N_TEXT,
  180.     N_DATA,
  181. ***************
  182. *** 78,83 ****
  183. --- 133,139 ----
  184.     SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF,
  185.     SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF
  186.   };
  187. + #endif /* coff */
  188.   
  189.   void
  190.   subsegs_begin()
  191. *** symbols.c    Fri Apr  6 17:51:22 1990
  192. --- /lasvegas/spare/usenet/port/gas-1.36/symbols.c    Mon Oct 15 10:30:08 1990
  193. ***************
  194. *** 18,23 ****
  195. --- 18,24 ----
  196.   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  197.   
  198.   
  199. + #include "oformat.h"
  200.   #include "as.h"
  201.   #include "hash.h"
  202.   #include "obstack.h"        /* For "symbols.h" */
  203. ***************
  204. *** 38,43 ****
  205. --- 39,49 ----
  206.   symbolS * symbol_rootP;
  207.   symbolS * symbol_lastP;
  208.   symbolS    abs_symbol;
  209. + 
  210. + symbolS*        dot_text_symbol;
  211. + symbolS*        dot_data_symbol;
  212. + symbolS*        dot_bss_symbol;
  213. + 
  214.   struct obstack    notes;
  215.   
  216.   
  217. ***************
  218. *** 84,90 ****
  219.     symbol_rootP = NULL;        /* In case we have 0 symbols (!!) */
  220.     sy_hash = hash_new();
  221.     bzero ((char *)(& abs_symbol), sizeof(abs_symbol));
  222. !   abs_symbol . sy_type = N_ABS;    /* Can't initialise a union. Sigh. */
  223.     bzero ((char *)(local_label_counter), sizeof(local_label_counter) );
  224.     local_bss_counter = 0;
  225.   }
  226. --- 90,96 ----
  227.     symbol_rootP = NULL;        /* In case we have 0 symbols (!!) */
  228.     sy_hash = hash_new();
  229.     bzero ((char *)(& abs_symbol), sizeof(abs_symbol));
  230. !   S_SET_ABS(&abs_symbol);    /* Can't initialise a union. Sigh. */
  231.     bzero ((char *)(local_label_counter), sizeof(local_label_counter) );
  232.     local_bss_counter = 0;
  233.   }
  234. ***************
  235. *** 157,162 ****
  236. --- 163,237 ----
  237.    * Changes since 1985: Symbol names may not contain '\0'. Sigh.
  238.    */
  239.   
  240. + #ifdef coff
  241. + 
  242. + symbolS *
  243. + symbol_new (name, segment, value, sclass, frag)
  244. + char*        name;     /* It is copied, the caller can destroy/modify */
  245. + segT        segment;/* Segment identifier (SEG_<something>) */
  246. + long        value;  /* Symbol value */
  247. + short        sclass; /* Symbol storage class */
  248. + fragS*        frag;    /* Associated fragment */
  249. + {
  250. +     register unsigned int    name_length;
  251. +     register char*        name_copy;
  252. +     register symbolS*        symbolP;
  253. +     register char        underscore = 0;      /* Symbol has leading _ */
  254. + 
  255. + #if STRIP_UNDERSCORE
  256. +     /* Remove leading underscore at the beginning of the symbol.
  257. +      * This is to be compatible with the standard librairies.
  258. +      */
  259. +     if(*name == '_') {
  260. +     underscore = 1;
  261. +     name++;
  262. +     } else
  263. +     underscore = 0;
  264. + #endif /* STRIP_UNDERSCORE */
  265. +     name_length = strlen(name) + 1; /* +1 for \0 */
  266. +     obstack_grow(¬es, name, name_length);
  267. +     name_copy = obstack_finish(¬es);
  268. +     symbolP = (symbolS *)obstack_alloc(¬es, sizeof(symbolS));
  269. +     
  270. +     /* Effective symbol */
  271. +     /* Store the pointer in the offset. */
  272. +     symbolP->sy_offset        = (long unsigned)name_copy;
  273. +     symbolP->sy_zeroes        = 0L;
  274. +     symbolP->sy_value        = value;
  275. +     symbolP->sy_scnum        = seg_SEG(segment);
  276. +     symbolP->sy_type        = T_NULL;
  277. +     symbolP->sy_sclass        = sclass;
  278. +     symbolP->sy_numaux        = 0;
  279. +     /* Additional information */
  280. +     symbolP->sy_next        = NULL;
  281. +     symbolP->sy_frag        = frag;
  282. +     symbolP->sy_forward        = NULL;
  283. +     symbolP->sy_name_offset    = ~0;
  284. +     symbolP->sy_number        = ~0;
  285. +     symbolP->sy_flags        = 0;
  286. +     /* Auxiliary entries */
  287. +     memset((char*)&symbolP->sy_auxent, '\0', AUXESZ);
  288. + 
  289. +     if(S_IS_STRING(symbolP))
  290. +     SF_SET_STRING(symbolP);
  291. +     if(!underscore && S_IS_LOCAL(symbolP))
  292. +     SF_SET_LOCAL(symbolP);
  293. +     /*
  294. +      * Link to end of symbol chain .
  295. +      */
  296. +     if (symbol_lastP) {
  297. +     symbol_lastP->sy_next = symbolP;
  298. +     symbolP->sy_previous = symbol_lastP;
  299. +     } else {
  300. +     symbol_rootP = symbolP;
  301. +     }
  302. +     symbol_lastP = symbolP;
  303. +     
  304. +     return (symbolP);
  305. + }
  306. + 
  307. + #else /* coff */
  308. + 
  309.   symbolS *
  310.   symbol_new (name, type, other, desc, value, frag)
  311.        char *        name;    /* We copy this: OK to alter your copy. */
  312. ***************
  313. *** 165,171 ****
  314.        short int        desc;    /* As in <a.out.h>. */
  315.        valueT        value;    /* As in <a.out.h>, often an address. */
  316.                   /* Often used as offset from frag address. */
  317. !      struct frag *    frag;    /* For sy_frag. */
  318.   {
  319.     register symbolS *        symbolP;
  320.     register char *        preserved_copy_of_name;
  321. --- 240,246 ----
  322.        short int        desc;    /* As in <a.out.h>. */
  323.        valueT        value;    /* As in <a.out.h>, often an address. */
  324.                   /* Often used as offset from frag address. */
  325. !      fragS*         frag;    /* For sy_frag. */
  326.   {
  327.     register symbolS *        symbolP;
  328.     register char *        preserved_copy_of_name;
  329. ***************
  330. *** 177,184 ****
  331.     p=obstack_finish(¬es);
  332.     /* obstack_1done( ¬es, name, name_length, &p ); */
  333.     preserved_copy_of_name = p;
  334. !   p=obstack_alloc(¬es,sizeof(struct symbol));
  335. !   /* obstack_1blank( ¬es, sizeof(struct symbol), &p ); */
  336.     symbolP            = (symbolS *) p;
  337.     symbolP -> sy_name        = preserved_copy_of_name;
  338.     symbolP -> sy_type        = type;
  339. --- 252,259 ----
  340.     p=obstack_finish(¬es);
  341.     /* obstack_1done( ¬es, name, name_length, &p ); */
  342.     preserved_copy_of_name = p;
  343. !   p=obstack_alloc(¬es,sizeof(symbolS));
  344. !   /* obstack_1blank( ¬es, sizeof(symbolS), &p ); */
  345.     symbolP            = (symbolS *) p;
  346.     symbolP -> sy_name        = preserved_copy_of_name;
  347.     symbolP -> sy_type        = type;
  348. ***************
  349. *** 207,212 ****
  350. --- 282,289 ----
  351.   
  352.     return (symbolP);
  353.   }
  354. + 
  355. + #endif /* coff */
  356.   
  357.   /*
  358.    *            colon()
  359. ***************
  360. *** 222,228 ****
  361.        register char *  sym_name; /* symbol name, as a cannonical string */
  362.                   /* We copy this string: OK to alter later. */
  363.   {
  364. !   register struct symbol * symbolP; /* symbol we are working with */
  365.   
  366.   #ifdef SUN_ASM_SYNTAX
  367.     /* Sun local labes go out of scope whenever a non-local symbol is
  368. --- 299,305 ----
  369.        register char *  sym_name; /* symbol name, as a cannonical string */
  370.                   /* We copy this string: OK to alter later. */
  371.   {
  372. !   register symbolS * symbolP; /* symbol we are working with */
  373.   
  374.   #ifdef SUN_ASM_SYNTAX
  375.     /* Sun local labes go out of scope whenever a non-local symbol is
  376. ***************
  377. *** 264,270 ****
  378.          *    If the new symbol is .comm AND it has a size of zero,
  379.          *    we ignore it (i.e. the old symbol overrides it)
  380.          */
  381. !       if ((seg_N_TYPE [(int) now_seg] == (N_UNDF | N_EXT)) &&
  382.         ((obstack_next_free(& frags) - frag_now -> fr_literal) == 0))
  383.           return;
  384.         /*
  385. --- 341,347 ----
  386.          *    If the new symbol is .comm AND it has a size of zero,
  387.          *    we ignore it (i.e. the old symbol overrides it)
  388.          */
  389. !       if ((seg_SEG((int) now_seg) == (N_UNDF | N_EXT)) &&
  390.         ((obstack_next_free(& frags) - frag_now -> fr_literal) == 0))
  391.           return;
  392.         /*
  393. ***************
  394. *** 275,281 ****
  395.         (symbolP->sy_value == 0)) {
  396.             symbolP -> sy_frag  = frag_now;
  397.             symbolP -> sy_value = obstack_next_free(& frags) - frag_now -> fr_literal;
  398. !           symbolP -> sy_type |= seg_N_TYPE [(int) now_seg]; /* keep N_EXT bit */
  399.             return;
  400.         }
  401.   #endif    /* VMS */
  402. --- 352,358 ----
  403.         (symbolP->sy_value == 0)) {
  404.             symbolP -> sy_frag  = frag_now;
  405.             symbolP -> sy_value = obstack_next_free(& frags) - frag_now -> fr_literal;
  406. !           symbolP -> sy_type |= seg_SEG((int) now_seg); /* keep N_EXT bit */
  407.             return;
  408.         }
  409.   #endif    /* VMS */
  410. ***************
  411. *** 282,297 ****
  412.         /*
  413.          *    Now check for undefined symbols
  414.          */
  415. !       if ((symbolP -> sy_type & N_TYPE) == N_UNDF)
  416.       {
  417. !       if(   symbolP -> sy_other == 0
  418. !          && symbolP -> sy_desc  == 0
  419. !          && symbolP -> sy_value == 0)
  420.           {
  421.             symbolP -> sy_frag  = frag_now;
  422. !           symbolP -> sy_value = obstack_next_free(& frags) - frag_now -> fr_literal;
  423. !           know( N_UNDF == 0 );
  424. !           symbolP -> sy_type |= seg_N_TYPE [(int) now_seg]; /* keep N_EXT bit */
  425.           }
  426.         else
  427.           {
  428. --- 359,382 ----
  429.         /*
  430.          *    Now check for undefined symbols
  431.          */
  432. !       if (!S_IS_DEFINED(symbolP))
  433.       {
  434. !       if(
  435. ! #ifdef aout
  436. !          S_GET_OTHER(symbolP) == 0 &&
  437. !          S_GET_DESC(symbolP)  == 0 &&
  438. ! #endif /* aout */
  439. !          S_GET_VALUE(symbolP) == 0)
  440.           {
  441.             symbolP -> sy_frag  = frag_now;
  442. !           S_SET_VALUE(symbolP, obstack_next_free(& frags) - 
  443. !                        frag_now -> fr_literal);
  444. !           switch(now_seg) {
  445. !         case SEG_TEXT: S_SET_TEXT(symbolP); break;
  446. !         case SEG_DATA: S_SET_DATA(symbolP); break;
  447. !         case SEG_BSS: S_SET_BSS(symbolP); break;
  448. !         case SEG_ABSOLUTE: S_SET_ABS(symbolP); break;
  449. !           }
  450.           }
  451.         else
  452.           {
  453. ***************
  454. *** 303,309 ****
  455.              *        A .comm/.lcomm symbol being redefined with
  456.              *            a larger size is also OK
  457.              */
  458. !           char New_Type = seg_N_TYPE [(int) now_seg];
  459.             if (((symbolP->sy_type == (N_UNDF | N_EXT)) ||
  460.              (symbolP->sy_type == N_BSS)) &&
  461.             (((New_Type & ~N_EXT) == N_DATA) ||
  462. --- 388,394 ----
  463.              *        A .comm/.lcomm symbol being redefined with
  464.              *            a larger size is also OK
  465.              */
  466. !           char New_Type = seg_SEG((int) now_seg);
  467.             if (((symbolP->sy_type == (N_UNDF | N_EXT)) ||
  468.              (symbolP->sy_type == N_BSS)) &&
  469.             (((New_Type & ~N_EXT) == N_DATA) ||
  470. ***************
  471. *** 331,345 ****
  472.                    */
  473.                   symbolP -> sy_frag  = frag_now;
  474.                   symbolP -> sy_value = obstack_next_free(& frags) - frag_now -> fr_literal;
  475. !                 symbolP -> sy_type |= seg_N_TYPE [(int) now_seg]; /* keep N_EXT bit */
  476.               }
  477.             } else {
  478.   #endif    /* VMS */
  479.             as_fatal( "Symbol \"%s\" is already defined as \"%s\"/%d.%d.%d.",
  480.                 sym_name,
  481. !               seg_name [(int) N_TYPE_seg [symbolP -> sy_type & N_TYPE]],
  482. !               symbolP -> sy_other, symbolP -> sy_desc,
  483. !               symbolP -> sy_value);
  484.   #ifdef    VMS
  485.           }
  486.   #endif    /* VMS */
  487. --- 416,437 ----
  488.                    */
  489.                   symbolP -> sy_frag  = frag_now;
  490.                   symbolP -> sy_value = obstack_next_free(& frags) - frag_now -> fr_literal;
  491. !                 symbolP -> sy_type |= seg_SEG((int) now_seg); /* keep N_EXT bit */
  492.               }
  493.             } else {
  494.   #endif    /* VMS */
  495. + #ifdef coff
  496. +           as_fatal( "Symbol \"%s\" is already defined as \"%s\"/%d.",
  497. +               sym_name,
  498. +               segment_name((int)SEG_seg(S_GET_SEGMENT(symbolP))),
  499. +               S_GET_VALUE(symbolP));
  500. + #else /* coff */
  501.             as_fatal( "Symbol \"%s\" is already defined as \"%s\"/%d.%d.%d.",
  502.                 sym_name,
  503. !               segment_name((int)SEG_seg(S_GET_SEGMENT(symbolP))),
  504. !               S_GET_OTHER(symbolP), S_GET_DESC(symbolP),
  505. !               S_GET_VALUE(symbolP));
  506. ! #endif /* coff */
  507.   #ifdef    VMS
  508.           }
  509.   #endif    /* VMS */
  510. ***************
  511. *** 352,363 ****
  512.       }
  513.     else
  514.       {
  515.         symbolP = symbol_new (sym_name,
  516. !                 (unsigned char)(seg_N_TYPE [(int) now_seg]),
  517.                   0,
  518.                   0,
  519.                   (valueT)(obstack_next_free(&frags)-frag_now->fr_literal),
  520.                   frag_now);
  521.         symbol_table_insert (symbolP);
  522.       }
  523.   }
  524. --- 444,461 ----
  525.       }
  526.     else
  527.       {
  528. + #ifdef coff
  529. +       symbolP = symbol_new (sym_name, now_seg, 
  530. +                 (valueT)(obstack_next_free(&frags)-frag_now->fr_literal),
  531. +                 0, frag_now);
  532. + #else /* coff */
  533.         symbolP = symbol_new (sym_name,
  534. !                 (unsigned char)(seg_SEG((int) now_seg)),
  535.                   0,
  536.                   0,
  537.                   (valueT)(obstack_next_free(&frags)-frag_now->fr_literal),
  538.                   frag_now);
  539. + #endif /* coff */
  540.         symbol_table_insert (symbolP);
  541.       }
  542.   }
  543. ***************
  544. *** 372,387 ****
  545.   
  546.   void
  547.   symbol_table_insert (symbolP)
  548. !      struct symbol *    symbolP;
  549.   {
  550.     register char *    error_string;
  551.   
  552. !   know( symbolP );
  553. !   know( symbolP -> sy_name );
  554. !   if ( * (error_string = hash_jam (sy_hash, symbolP -> sy_name, (char *)symbolP)))
  555.       {
  556.         as_fatal( "Inserting \"%s\" into symbol table failed: %s",
  557. !           symbolP -> sy_name, error_string);
  558.       }
  559.   }
  560.   
  561. --- 470,487 ----
  562.   
  563.   void
  564.   symbol_table_insert (symbolP)
  565. !      symbolS *    symbolP;
  566.   {
  567.     register char *    error_string;
  568.   
  569. !   know(symbolP);
  570. !   know(S_GET_NAME(symbolP));
  571. ! 
  572. !   if ( * (error_string = hash_jam (sy_hash, S_GET_NAME(symbolP),
  573. !                    (char *)symbolP)))
  574.       {
  575.         as_fatal( "Inserting \"%s\" into symbol table failed: %s",
  576. !           S_GET_NAME(symbolP), error_string);
  577.       }
  578.   }
  579.   
  580. ***************
  581. *** 392,409 ****
  582.    * it into the symbol table. Return a pointer to it.
  583.    */
  584.   symbolS *
  585. ! symbol_find_or_make (name)
  586. !      char *    name;
  587.   {
  588. !   register symbolS *    symbolP;
  589.   
  590. !   symbolP = symbol_table_lookup (name);
  591. !   if (symbolP == NULL)
  592. !     {
  593. !       symbolP = symbol_new (name, N_UNDF, 0, 0, 0, & zero_address_frag);
  594. !       symbol_table_insert (symbolP);
  595. !     }
  596. !   return (symbolP);
  597.   }
  598.   
  599.   /*
  600. --- 492,514 ----
  601.    * it into the symbol table. Return a pointer to it.
  602.    */
  603.   symbolS *
  604. !     symbol_find_or_make (name)
  605. ! char *    name;
  606.   {
  607. !     register symbolS *    symbolP;
  608.   
  609. !     symbolP = symbol_table_lookup (name);
  610. ! 
  611. !     if (symbolP == NULL)
  612. !     {
  613. ! #ifdef coff 
  614. !         symbolP = symbol_new (name, SEG_UNKNOWN, 0, 0, &zero_address_frag);
  615. ! #else /* coff */
  616. !         symbolP = symbol_new (name, N_UNDF, 0, 0, 0, & zero_address_frag);
  617. ! #endif /* coff */
  618. !         symbol_table_insert (symbolP);
  619. !     }
  620. !     return (symbolP);
  621.   }
  622.   
  623.   /*
  624. ***************
  625. *** 417,426 ****
  626.   
  627.   symbolS *
  628.   symbol_find (name)
  629. !      char *    name;
  630.   {
  631. !   return ( (symbolS *) hash_find( sy_hash, name ));
  632.   }
  633.   
  634.   
  635.   /* end: symbols.c */
  636. --- 522,539 ----
  637.   
  638.   symbolS *
  639.   symbol_find (name)
  640. ! char* name;
  641.   {
  642. !     return symbol_find_base(name, STRIP_UNDERSCORE);
  643.   }
  644.   
  645. + symbolS *
  646. + symbol_find_base (name, strip_underscore)
  647. +      char *    name;
  648. + int strip_underscore;
  649. + {
  650. +     if(strip_underscore && *name == '_') name++;
  651. +     return ( (symbolS *) hash_find( sy_hash, name ));
  652. + }
  653.   
  654.   /* end: symbols.c */
  655. *** symbols.h    Wed Mar  1 23:48:43 1989
  656. --- /lasvegas/spare/usenet/port/gas-1.36/symbols.h    Mon Oct 15 10:29:43 1990
  657. ***************
  658. *** 30,36 ****
  659. --- 30,41 ----
  660.   
  661.   extern symbolS    abs_symbol;
  662.   
  663. + extern symbolS*        dot_text_symbol;
  664. + extern symbolS*        dot_data_symbol;
  665. + extern symbolS*        dot_bss_symbol;
  666. + 
  667.   symbolS *    symbol_find();
  668. + symbolS *    symbol_find_base();
  669.   void        symbol_begin();
  670.   char *        local_label_name();
  671.   void        local_colon();
  672. --
  673. Loic Dachary     loic@adesign.uucp or loic@afp.uucp 
  674. Voice        +33 1 40 35 20 20
  675.