home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 1 / 1971 < prev    next >
Encoding:
Internet Message Format  |  1990-12-28  |  29.3 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.90Oct16093447@adesign.uucp>
  5. Date: 16 Oct 90 08:34:47 GMT
  6.  
  7. *** /dev/null    Mon Oct 15 09:51:48 1990
  8. --- coff.c    Mon Oct 15 08:53:16 1990
  9. ***************
  10. *** 0 ****
  11. --- 1,367 ----
  12. + #include "oformat.h"
  13. + #include "as.h"
  14. + #include "md.h"
  15. + #include "struc-symbol.h"
  16. + #include "symbols.h"    
  17. + #include "write.h"
  18. + 
  19. + /* Relocation. */
  20. + 
  21. + /*
  22. +  *        emit_relocations()
  23. +  *
  24. +  * Crawl along a fixS chain. Emit the segment's relocations.
  25. +  */
  26. +     
  27. + void
  28. + emit_relocations (fixP, segment_address_in_file)
  29. + register fixS *    fixP;    /* Fixup chain for this segment. */
  30. + relax_addressT    segment_address_in_file;
  31. + {
  32. +     RELOC            ri;
  33. +     register symbolS *        symbolP;
  34. +     
  35. +     bzero((char *)&ri,sizeof(ri));
  36. +     for ( ;  fixP;  fixP = fixP->fx_next) {
  37. +     if (symbolP = fixP->fx_addsy) {
  38. + #if defined(PROCESSOR_68000)
  39. +         ri.r_type = (fixP->fx_pcrel ? 
  40. +              ( fixP->fx_size == 1 ? R_PCRBYTE :
  41. +               fixP->fx_size == 2 ? R_PCRWORD :
  42. +               R_PCRLONG):
  43. +              ( fixP->fx_size == 1 ? R_RELBYTE :
  44. +               fixP->fx_size == 2 ? R_RELWORD :
  45. +               R_RELLONG));
  46. + #elif defined(PROCESSOR_i386)
  47. +         /* !!!! R_OFF8 & R_DIR16 are a vague guess, completly unested. */
  48. +         ri.r_type = (fixP->fx_pcrel ? 
  49. +              ( fixP->fx_size == 1 ? R_PCRBYTE :
  50. +               fixP->fx_size == 2 ? R_PCRWORD :
  51. +               R_PCRLONG):
  52. +              ( fixP->fx_size == 1 ? R_OFF8 :
  53. +               fixP->fx_size == 2 ? R_DIR16 :
  54. +               R_DIR32));
  55. + #else
  56. +         you lose
  57. + #endif /* PROCESSOR_68000 || PROCESSOR_i386 */
  58. +         ri.r_vaddr = fixP->fx_frag->fr_address + fixP->fx_where;
  59. +         /* If symbol associated to relocation entry is a bss symbol 
  60. +            or undefined symbol just remember the index of the symbol.
  61. +            Otherwise store the index of the symbol describing the 
  62. +            section the symbol belong to. This heuristic speeds up ld.
  63. +            */
  64. +         /* Local symbols can generate relocation information. In case
  65. +            of structure return for instance. But they have no symbol
  66. +            number because they won't be emitted in the final object.
  67. +            In the case where they are in the BSS section, this leads
  68. +            to an incorrect r_symndx.
  69. +            Under bsd the loader do not care if the symbol reference is
  70. +            incorrect. But the SYS V ld complains about this. To avoid
  71. +            this we associate the symbol to the associated section, 
  72. +            *even* if it is the BSS section. */
  73. +         /* If someone can tell me why the other symbols of the bss 
  74. +            section are not associated with the .bss section entry, 
  75. +            I'd be gratefull. I guess that it has to do with the special
  76. +            nature of the .bss section. Or maybe this is because the 
  77. +            bss symbols are declared in the common section and can
  78. +            be resized later. Can it break code some where ? */
  79. +         ri.r_symndx =
  80. +     S_GET_SEGMENT(symbolP) == C_TEXT_SECTION ? dot_text_symbol->sy_number :
  81. +     S_GET_SEGMENT(symbolP) == C_DATA_SECTION ? dot_data_symbol->sy_number :
  82. +            (SF_GET_LOCAL(symbolP) ? dot_bss_symbol->sy_number :
  83. +         symbolP->sy_number); /* bss or undefined */
  84. +         
  85. +         /* md_ri_to_chars((char *) &ri, ri);  /* Last step : write md f */
  86. +         append (&next_object_file_charP,
  87. +             (char *)& ri,
  88. +             (unsigned long)RELSZ);
  89. +     }
  90. +     }
  91. + }
  92. + 
  93. + /* Coff file generation & utilities */
  94. + 
  95. + /* Convert a lvalue to machine dependent data */
  96. + #define MD(s,v)   \
  97. +   md_number_to_chars((char *)&(s)->v,(s)->v, sizeof((s)->v))
  98. + 
  99. + void
  100. + c_header_append(aouthdr, filehdr, where)
  101. + AOUTHDR*    aouthdr;
  102. + FILHDR*        filehdr;
  103. + char**        where;
  104. + {
  105. +     /* Eventually swap bytes for cross compilation for file header */
  106. +     MD(filehdr, f_magic);
  107. +     MD(filehdr, f_nscns);
  108. +     MD(filehdr, f_timdat);
  109. +     MD(filehdr, f_symptr);
  110. +     MD(filehdr, f_nsyms);
  111. +     MD(filehdr, f_opthdr);
  112. +     MD(filehdr, f_flags);
  113. +     append(where, (char *)filehdr, FILHSZ);
  114. + 
  115. +     /* Eventually swap bytes for cross compilation for a.out header */
  116. +     MD(aouthdr, magic);
  117. +     MD(aouthdr, vstamp);
  118. +     MD(aouthdr, tsize);
  119. +     MD(aouthdr, dsize);
  120. +     MD(aouthdr, bsize);
  121. +     MD(aouthdr, entry);
  122. +     MD(aouthdr, text_start);
  123. +     MD(aouthdr, data_start);
  124. +     append(where, (char *)aouthdr, sizeof(struct aouthdr));
  125. + }
  126. + 
  127. + /*
  128. +  * Beware ! If you cross compile to another ENDIAN machine,
  129. +  * the symbol table values will not be valid any more.
  130. +  */
  131. + 
  132. + void
  133. + c_symbol_append(symbolP, where)
  134. + symbolS *    symbolP;
  135. + char**        where;
  136. + {
  137. +     SYMENT            *syment    = &symbolP->sy_symbol;
  138. +     char              numaux    = syment->n_numaux;
  139. +     register AUXENT*        auxP    = &symbolP->sy_auxent;
  140. +     register unsigned short    type     = S_GET_DATA_TYPE(symbolP);
  141. + 
  142. +     MD(syment, n_value);
  143. +     MD(syment, n_scnum);
  144. +     MD(syment, n_type);
  145. +     MD(syment, n_sclass);
  146. +     MD(syment, n_numaux);
  147. +     append(where, (char *)syment, SYMESZ);
  148. + 
  149. +     /* Should do the following : if(.file entry) MD(..)... else
  150. +        if(static entry) MD(..)
  151. +      */
  152. +     if(numaux == 1) {
  153. + #if 0 /* This code has never been tested */
  154. +     /* The most common case, x_sym entry. */
  155. +     if((SF_GET(symbolP) & (SF_FILE | SF_STATICS)) == 0) {
  156. +         MD(auxP, x_sym.x_tagndx);
  157. +         if(ISFCN(type))
  158. +         MD(auxP, x_sym.x_misc.x_fsize);
  159. +         else {
  160. +         MD(auxP, x_sym.x_misc.x_lnno);
  161. +         MD(auxP, x_sym.x_misc.x_size);
  162. +         }
  163. +         if(ISARY(type)) {
  164. +         register int index;
  165. +         for(index = 0; index < DIMNUM; index++)
  166. +             MD(auxP, x_sym.x_fcnary.x_ary.x_dimen[index]);
  167. +         } else {
  168. +         MD(auxP, x_sym.x_fcnary.x_fcn.x_lnnoptr);
  169. +         MD(auxP, x_sym.x_fcnary.x_fcn.x_endndx);
  170. +         }
  171. +         MD(auxP, x_sym.x_tvndx);
  172. +     } else if(SF_GET_FILE(symbolP))    /* .file */
  173. +         ;
  174. +     else if(SF_GET_STATICS(symbolP)) { /* .text, .data, .bss symbols */
  175. +         MD(auxP, x_scn.x_scnlen);
  176. +         MD(auxP, x_scn.x_nreloc);
  177. +         MD(auxP, x_scn.x_nlinno);
  178. +     }
  179. + #endif /* 0 */
  180. +     append(where, (char *)auxP, AUXESZ);
  181. +     } else if(numaux > 0)
  182. +     as_warn("more than one auxent for symbol");
  183. +     
  184. +     return;
  185. + }
  186. + 
  187. + void
  188. + c_section_header_append(header, where)
  189. + SCNHDR*        header;
  190. + char**        where;
  191. + {
  192. +     MD(header, s_paddr);
  193. +     MD(header, s_vaddr);
  194. +     MD(header, s_size);
  195. +     MD(header, s_scnptr);
  196. +     MD(header, s_relptr);
  197. +     MD(header, s_lnnoptr);
  198. +     MD(header, s_nreloc);
  199. +     MD(header, s_nlnno);
  200. +     MD(header, s_flags);
  201. +     append(where, (char *)header, SCNHSZ);
  202. + 
  203. +     return;
  204. + }
  205. + 
  206. + 
  207. + void emit_symbols(symbol_rootP, where)
  208. + symbolS *    symbol_rootP;
  209. + char**        where;
  210. + {
  211. +     symbolS *    symbolP;
  212. +     /*
  213. +      * Emit all symbols left in the symbol chain.
  214. +      */
  215. +     for(symbolP = symbol_rootP; symbolP; symbolP = symbolP -> sy_next) {
  216. +     /* Used to save the offset of the name. It is used to point
  217. +        to the string in memory but must be a file offset. */
  218. +     register char *    temp;
  219. + 
  220. +     temp = S_GET_NAME(symbolP);
  221. +     if (SF_GET_STRING(symbolP)) {
  222. +         S_SET_OFFSET(symbolP, symbolP->sy_name_offset);
  223. +         S_SET_ZEROES(symbolP, 0);
  224. +     } else {
  225. +         memset(symbolP->sy_name, '\0', SYMNMLEN);
  226. +         strncpy(symbolP->sy_name, temp, SYMNMLEN);
  227. +     }
  228. +     SYMBOL_OUTPUT(symbolP, where);
  229. +     S_SET_NAME(symbolP,temp);
  230. +     }
  231. + }
  232. + 
  233. + /* Merge a debug symbol containing debug information into a normal
  234. +    symbol. */
  235. + 
  236. + void
  237. + c_symbol_merge(debug, normal)
  238. + symbolS* debug;
  239. + symbolS* normal;
  240. + {
  241. +     S_SET_DATA_TYPE(normal, S_GET_DATA_TYPE(debug));
  242. +     S_SET_STORAGE_CLASS(normal, S_GET_STORAGE_CLASS(debug));
  243. +     S_SET_NUMBER_AUXILIARY(normal, S_GET_NUMBER_AUXILIARY(debug));
  244. +     /* Move all the auxiliary information */
  245. +     if(S_GET_NUMBER_AUXILIARY(debug))
  246. +     memcpy((char*)&normal->sy_auxent, (char*)&debug->sy_auxent,
  247. +            AUXESZ);
  248. +     /* Move the debug flags. */
  249. +     SF_SET_DEBUG_FIELD(normal, SF_GET_DEBUG_FIELD(debug));
  250. + }
  251. + 
  252. + c_dot_file_symbol(filename)
  253. + char*    filename;
  254. + {
  255. +     symbolS* symbolP;
  256. +     symbolS* ante_lastP;
  257. + 
  258. +     ante_lastP = symbol_lastP;
  259. +     
  260. +     symbolP = symbol_new(".file", SEG_DEBUG, 0,
  261. +                    C_FILE, &zero_address_frag);
  262. +     S_SET_NUMBER_AUXILIARY(symbolP, 1);
  263. +     SA_SET_FILE_FNAME(symbolP, filename);
  264. +     SF_SET_DEBUG(symbolP);
  265. + 
  266. +     /* Make sure that the symbol is first on the symbol chain */
  267. +     if(symbol_rootP != symbolP) {
  268. +     symbol_lastP = ante_lastP;
  269. +     symbol_lastP->sy_next = NULL;
  270. +     symbolP->sy_next = symbol_rootP;
  271. +     symbol_rootP = symbolP;
  272. +     }
  273. + }
  274. + /* 
  275. +  * Build a 'section static' symbol.
  276. +  */
  277. + 
  278. + char* 
  279. + c_section_symbol(name, value, length, nreloc, nlnno)
  280. + char* name;
  281. + long value;
  282. + long length;
  283. + unsigned short nreloc;
  284. + unsigned short nlnno;
  285. + {
  286. +     symbolS*    symbolP;
  287. + 
  288. +     symbolP = symbol_new(name,
  289. +                    (name[1] == 't' ? SEG_TEXT : 
  290. +                 name[1] == 'd' ? SEG_DATA :
  291. +                                      SEG_BSS),
  292. +                    value,
  293. +                    C_STAT,
  294. +                    &zero_address_frag);
  295. + 
  296. +     S_SET_NUMBER_AUXILIARY(symbolP, 1);
  297. + 
  298. +     SA_SET_SCN_SCNLEN(symbolP, length);
  299. +     SA_SET_SCN_NRELOC(symbolP, nreloc);
  300. +     SA_SET_SCN_NLINNO(symbolP, nlnno);
  301. + 
  302. +     SF_SET_STATICS(symbolP);
  303. + 
  304. +     return (char*)symbolP;
  305. + }
  306. + 
  307. + void
  308. + c_section_header(header, name, core_address, size,
  309. +          data_ptr, reloc_ptr, lineno_ptr,
  310. +          reloc_number, lineno_number)
  311. + SCNHDR*            header;
  312. + char*            name;
  313. + long            core_address;
  314. + long            size;
  315. + long            data_ptr;
  316. + long            reloc_ptr;
  317. + long            lineno_ptr;
  318. + long            reloc_number;
  319. + long            lineno_number;
  320. + {
  321. +     strncpy(header->s_name, name, 8);
  322. +     header->s_paddr = header->s_vaddr = core_address;
  323. +     header->s_size = size;
  324. +     header->s_scnptr = data_ptr;
  325. +     header->s_relptr = reloc_ptr;
  326. +     header->s_lnnoptr = lineno_ptr;
  327. +     header->s_nreloc = reloc_number;
  328. +     header->s_nlnno = lineno_number;
  329. +     header->s_flags = STYP_REG | ( name[1] == 't' ? STYP_TEXT :
  330. +                                name[1] == 'd' ? STYP_DATA :
  331. +                    name[1] == 'b' ? STYP_BSS  :
  332. +                    STYP_INFO );
  333. +     return ;
  334. + }
  335. + 
  336. + /* Line number handling */
  337. + 
  338. + int text_lineno_number = 0;
  339. + lineno* lineno_rootP = (lineno*)0;
  340. + lineno* lineno_lastP = (lineno*)0;
  341. + 
  342. + lineno*
  343. + c_line_new(paddr, line_number, frag)
  344. + long paddr;
  345. + unsigned short line_number;
  346. + fragS* frag;
  347. + {
  348. +     lineno* new_line = (lineno*)xmalloc(sizeof(lineno));
  349. + 
  350. +     new_line->line.l_addr.l_paddr = paddr;
  351. +     new_line->line.l_lnno = line_number;
  352. +     new_line->frag = (char*)frag;
  353. +     new_line->next = (lineno*)0;
  354. + 
  355. +     if(lineno_rootP == (lineno*)0)
  356. +     lineno_rootP = new_line;
  357. +     else 
  358. +     lineno_lastP->next = new_line;
  359. +     lineno_lastP = new_line;
  360. + }
  361. + 
  362. + void
  363. + emit_lineno(line, where)
  364. + lineno* line;
  365. + char** where;
  366. + {
  367. +     register LINENO* line_entry;
  368. + 
  369. +     for(;line;line = line->next) {
  370. +     line_entry = &line->line;
  371. +     /* No matter which member of the union we process, they are
  372. +        both long. */
  373. +     MD(line_entry, l_addr.l_paddr);
  374. +     MD(line_entry, l_lnno);
  375. +     append(where, (char *)line_entry, LINESZ);
  376. +     }
  377. +     return ;
  378. + }
  379. *** /dev/null    Mon Oct 15 09:51:48 1990
  380. --- m-i386.h    Mon Oct 15 08:14:18 1990
  381. ***************
  382. *** 0 ****
  383. --- 1,10 ----
  384. + /* Machine specific defines for the SCO Unix V.3.2 ODT */
  385. + #define scounix
  386. + #define PROCESSOR_i386
  387. + 
  388. + /* Return true if s (a non null string pointer), points to a local variable
  389. +    name. */
  390. + #define S_LOCAL_NAME(s)  (S_GET_NAME(s)[0] == '.' && S_GET_NAME(s)[1] == 'L')
  391. + 
  392. + /* Compiler does not generate symbol names with a leading underscore. */
  393. + #define STRIP_UNDERSCORE 0
  394. *** /dev/null    Mon Oct 15 09:51:48 1990
  395. --- stack.h    Wed Aug 29 13:17:30 1990
  396. ***************
  397. *** 0 ****
  398. --- 1,13 ----
  399. + typedef struct {
  400. +     unsigned long chunk_size;
  401. +     unsigned long element_size;
  402. +     unsigned long size;
  403. +     char*      data;
  404. +     unsigned long pointer;
  405. + } stack;
  406. + 
  407. + extern stack* stack_init();
  408. + extern void stack_delete();
  409. + extern char* stack_push();
  410. + extern char* stack_pop();
  411. + extern char* stack_top();
  412. *** as.c    Tue Mar 20 19:33:57 1990
  413. --- /lasvegas/spare/usenet/port/gas-1.36/as.c    Mon Oct 15 09:24:35 1990
  414. ***************
  415. *** 35,40 ****
  416. --- 35,41 ----
  417.   #include <signal.h>
  418.   
  419.   #define COMMON
  420. + #include "oformat.h"
  421.   #include "as.h"
  422.   #include "struc-symbol.h"
  423.   #include "write.h"
  424. *** as.h    Wed Mar  1 23:49:37 1989
  425. --- /lasvegas/spare/usenet/port/gas-1.36/as.h    Sat Oct 13 09:29:35 1990
  426. ***************
  427. *** 158,166 ****
  428.                   /* Invented so we don't crash printing */
  429.                   /* error message involving weird segment. */
  430.       SEG_BIG,            /* Bigger than 32 bits constant. */
  431. !     SEG_DIFFERENCE        /* Mythical Segment: absolute difference. */
  432.   }        segT;
  433.   #define SEG_MAXIMUM_ORDINAL (SEG_DIFFERENCE)
  434.   
  435.   typedef unsigned char    subsegT;
  436.   
  437. --- 158,175 ----
  438.                   /* Invented so we don't crash printing */
  439.                   /* error message involving weird segment. */
  440.       SEG_BIG,            /* Bigger than 32 bits constant. */
  441. !     SEG_DIFFERENCE,        /* Mythical Segment: absolute difference. */
  442. ! #ifdef coff
  443. !     SEG_DEBUG,        /* Debug segment */
  444. !     SEG_NTV,        /* Transfert vector preload segment */
  445. !     SEG_PTV,        /* Transfert vector postload segment */
  446. ! #endif /* coff */
  447.   }        segT;
  448. + #ifdef coff
  449. + #define SEG_MAXIMUM_ORDINAL (SEG_PTV)
  450. + #else /* coff */
  451.   #define SEG_MAXIMUM_ORDINAL (SEG_DIFFERENCE)
  452. + #endif /* coff */
  453.   
  454.   typedef unsigned char    subsegT;
  455.   
  456. ***************
  457. *** 176,181 ****
  458. --- 185,207 ----
  459.   extern char    *seg_name[];
  460.   extern int    seg_N_TYPE[];
  461.   extern segT    N_TYPE_seg[];
  462. + #ifdef coff
  463. + #define        segment_name(v)    (seg_name[(v)])
  464. + /* Machine independent -> machine dependent */
  465. + #define        seg_SEG(v)    (seg_N_TYPE[(v)])
  466. + /*
  467. +  * +4 shift the value of the mnemonics from -4, -3, -2, -1, 0, 1, 2, 3
  468. +  * to 0, 1, 2, 3, 4, 5, 6, 7
  469. +  */
  470. + /* Machine dependent -> machine independent */
  471. + #define        SEG_seg(v)    (N_TYPE_seg[(v) + 4])
  472. + #else /* coff */
  473. + #define        segment_name(v)    (seg_name[(v)])
  474. + /* Machine independent -> machine dependent */
  475. + #define        seg_SEG(v)    (seg_N_TYPE[(v)])
  476. + /* Machine dependent -> machine independent */
  477. + #define        SEG_seg(v)    (N_TYPE_seg[(v)])
  478. + #endif /* coff */
  479.   void    subsegs_begin();
  480.   void    subseg_change();
  481.   void    subseg_new();
  482. *** expr.c    Fri Apr  6 17:51:21 1990
  483. --- /lasvegas/spare/usenet/port/gas-1.36/expr.c    Wed Sep 12 09:28:48 1990
  484. ***************
  485. *** 25,30 ****
  486. --- 25,31 ----
  487.    */
  488.   
  489.   #include <ctype.h>
  490. + #include "oformat.h"
  491.   #include "as.h"
  492.   #include "flonum.h"
  493.   #include "read.h"
  494. ***************
  495. *** 84,90 ****
  496.   {
  497.     register char        c;
  498.     register char *name;    /* points to name of symbol */
  499. !   register struct symbol *    symbolP; /* Points to symbol */
  500.   
  501.     extern  char hex_value[];    /* In hex_value.c */
  502.     char    *local_label_name();
  503. --- 85,91 ----
  504.   {
  505.     register char        c;
  506.     register char *name;    /* points to name of symbol */
  507. !   register symbolS *    symbolP; /* Points to symbol */
  508.   
  509.     extern  char hex_value[];    /* In hex_value.c */
  510.     char    *local_label_name();
  511. ***************
  512. *** 249,263 ****
  513.                  */
  514.                 name = local_label_name ((int)number, 0);
  515.                 if ( (symbolP = symbol_table_lookup(name)) /* seen before */
  516. !               && (symbolP -> sy_type & N_TYPE) != N_UNDF /* symbol is defined: OK */
  517. !               )
  518.               {        /* Expected path: symbol defined. */
  519.                 /* Local labels are never absolute. Don't waste time checking absoluteness. */
  520. !               know(   (symbolP -> sy_type & N_TYPE) == N_DATA
  521. !                    || (symbolP -> sy_type & N_TYPE) == N_TEXT );
  522.                 expressionP -> X_add_symbol = symbolP;
  523.                 expressionP -> X_add_number = 0;
  524. !               expressionP -> X_seg          = N_TYPE_seg [symbolP -> sy_type];
  525.               }
  526.                 else
  527.               {        /* Either not seen or not defined. */
  528. --- 250,262 ----
  529.                  */
  530.                 name = local_label_name ((int)number, 0);
  531.                 if ( (symbolP = symbol_table_lookup(name)) /* seen before */
  532. !               && (S_IS_DEFINED(symbolP)))
  533.               {        /* Expected path: symbol defined. */
  534.                 /* Local labels are never absolute. Don't waste time checking absoluteness. */
  535. !               know((S_IS_DATA(symbolP)) || S_IS_TEXT(symbolP));
  536.                 expressionP -> X_add_symbol = symbolP;
  537.                 expressionP -> X_add_number = 0;
  538. !               expressionP -> X_seg = SEG_seg(S_GET_SEGMENT(symbolP));
  539.               }
  540.                 else
  541.               {        /* Either not seen or not defined. */
  542. ***************
  543. *** 288,300 ****
  544.                 if ( symbolP = symbol_table_lookup( name ))
  545.                   {
  546.                     /* We have no need to check symbol properties. */
  547. !                   know(   (symbolP -> sy_type & N_TYPE) == N_UNDF
  548. !                    || (symbolP -> sy_type & N_TYPE) == N_DATA
  549. !                    || (symbolP -> sy_type & N_TYPE) == N_TEXT);
  550.                   }
  551.                 else
  552.                   {
  553. !                   symbolP = symbol_new (name, N_UNDF, 0,0,0, & zero_address_frag);
  554.                     symbol_table_insert (symbolP);
  555.                   }
  556.                 expressionP -> X_add_symbol      = symbolP;
  557. --- 287,305 ----
  558.                 if ( symbolP = symbol_table_lookup( name ))
  559.                   {
  560.                     /* We have no need to check symbol properties. */
  561. !                   know(!S_IS_DEFINED(symbolP) ||
  562. !                    S_IS_DATA(symbolP) || S_IS_TEXT(symbolP));
  563.                   }
  564.                 else
  565.                   {
  566. ! #ifdef coff
  567. !                 symbolP = symbol_new(name, SEG_UNKNOWN,
  568. !                              0, 0,
  569. !                               &zero_address_frag);
  570. ! #else /* coff */
  571. !                   symbolP = symbol_new (name, N_UNDF, 0,0,0, 
  572. !                             & zero_address_frag);
  573. ! #endif /* coff */
  574.                     symbol_table_insert (symbolP);
  575.                   }
  576.                 expressionP -> X_add_symbol      = symbolP;
  577. ***************
  578. *** 357,368 ****
  579.          JF:  '.' is pseudo symbol with value of current location in current
  580.          segment. . .
  581.        */
  582.       symbolP = symbol_new("L0\001",
  583. !              (unsigned char)(seg_N_TYPE[(int)now_seg]),
  584.                0,
  585.                0,
  586.                (valueT)(obstack_next_free(&frags)-frag_now->fr_literal),
  587.                frag_now);
  588.       expressionP->X_add_number=0;
  589.       expressionP->X_add_symbol=symbolP;
  590.       expressionP->X_seg = now_seg;
  591. --- 362,378 ----
  592.          JF:  '.' is pseudo symbol with value of current location in current
  593.          segment. . .
  594.        */
  595. + #ifdef coff
  596. +     symbolP = symbol_new("L0\001", now_seg, (valueT)(obstack_next_free(&frags)-
  597. +                  frag_now->fr_literal), 0, frag_now);
  598. + #else /* coff */
  599.       symbolP = symbol_new("L0\001",
  600. !              (unsigned char)(seg_SEG((int)now_seg)),
  601.                0,
  602.                0,
  603.                (valueT)(obstack_next_free(&frags)-frag_now->fr_literal),
  604.                frag_now);
  605. + #endif /* coff */
  606.       expressionP->X_add_number=0;
  607.       expressionP->X_add_symbol=symbolP;
  608.       expressionP->X_seg = now_seg;
  609. ***************
  610. *** 383,389 ****
  611.              */
  612.             register segT        seg;
  613.   
  614. !           seg = N_TYPE_seg [(int) symbolP -> sy_type & N_TYPE];
  615.             if ((expressionP -> X_seg = seg) == SEG_ABSOLUTE )
  616.           {
  617.             expressionP -> X_add_number = symbolP -> sy_value;
  618. --- 393,399 ----
  619.              */
  620.             register segT        seg;
  621.   
  622. !           seg = SEG_seg((int)S_GET_SEGMENT(symbolP));
  623.             if ((expressionP -> X_seg = seg) == SEG_ABSOLUTE )
  624.           {
  625.             expressionP -> X_add_number = symbolP -> sy_value;
  626. ***************
  627. *** 398,404 ****
  628. --- 408,418 ----
  629.       {
  630.         expressionP -> X_add_symbol
  631.           = symbolP
  632. + #ifdef coff
  633. +         = symbol_new (name, SEG_UNKNOWN, 0, 0, &zero_address_frag);
  634. + #else /* coff */
  635.           = symbol_new (name, N_UNDF, 0,0,0, & zero_address_frag);
  636. + #endif /* coff */
  637.   
  638.         expressionP -> X_add_number  = 0;
  639.         expressionP -> X_seg         = SEG_UNKNOWN;
  640. ***************
  641. *** 553,578 ****
  642.   
  643.   static segT
  644.   expr_part (symbol_1_PP, symbol_2_P)
  645. !      struct symbol **    symbol_1_PP;
  646. !      struct symbol *    symbol_2_P;
  647.   {
  648.     segT            return_value;
  649.   
  650.     know(    (* symbol_1_PP)                   == NULL
  651. !        || ((* symbol_1_PP) -> sy_type & N_TYPE) == N_TEXT
  652. !        || ((* symbol_1_PP) -> sy_type & N_TYPE) == N_DATA
  653. !        || ((* symbol_1_PP) -> sy_type & N_TYPE) == N_BSS
  654. !        || ((* symbol_1_PP) -> sy_type & N_TYPE) == N_UNDF
  655.          );
  656.     know(      symbol_2_P             == NULL
  657. !        ||    (symbol_2_P   -> sy_type & N_TYPE) == N_TEXT
  658. !        ||    (symbol_2_P   -> sy_type & N_TYPE) == N_DATA
  659. !        ||    (symbol_2_P   -> sy_type & N_TYPE) == N_BSS
  660. !        ||    (symbol_2_P   -> sy_type & N_TYPE) == N_UNDF
  661.          );
  662.     if (* symbol_1_PP)
  663.       {
  664. !       if (((* symbol_1_PP) -> sy_type & N_TYPE) == N_UNDF)
  665.       {
  666.         if (symbol_2_P)
  667.           {
  668. --- 567,592 ----
  669.   
  670.   static segT
  671.   expr_part (symbol_1_PP, symbol_2_P)
  672. !      symbolS **    symbol_1_PP;
  673. !      symbolS *    symbol_2_P;
  674.   {
  675.     segT            return_value;
  676.   
  677.     know(    (* symbol_1_PP)                   == NULL
  678. !        || (S_IS_TEXT(* symbol_1_PP))
  679. !        || (S_IS_DATA(* symbol_1_PP))
  680. !        || (S_IS_BSS(* symbol_1_PP))
  681. !        || (!S_IS_DEFINED(* symbol_1_PP))
  682.          );
  683.     know(      symbol_2_P             == NULL
  684. !        || (S_IS_TEXT(symbol_2_P))
  685. !        || (S_IS_DATA(symbol_2_P))
  686. !        || (S_IS_BSS(symbol_2_P))
  687. !        || (!S_IS_DEFINED(symbol_2_P))
  688.          );
  689.     if (* symbol_1_PP)
  690.       {
  691. !       if (!S_IS_DEFINED(* symbol_1_PP))
  692.       {
  693.         if (symbol_2_P)
  694.           {
  695. ***************
  696. *** 581,587 ****
  697.           }
  698.         else
  699.           {
  700. !           know( ((* symbol_1_PP) -> sy_type & N_TYPE) == N_UNDF)
  701.             return_value = SEG_UNKNOWN;
  702.           }
  703.       }
  704. --- 595,601 ----
  705.           }
  706.         else
  707.           {
  708. !           know(!S_IS_DEFINED(* symbol_1_PP));
  709.             return_value = SEG_UNKNOWN;
  710.           }
  711.       }
  712. ***************
  713. *** 589,595 ****
  714.       {
  715.         if (symbol_2_P)
  716.           {
  717. !           if ((symbol_2_P -> sy_type & N_TYPE) == N_UNDF)
  718.           {
  719.             * symbol_1_PP = NULL;
  720.             return_value = SEG_PASS1;
  721. --- 603,609 ----
  722.       {
  723.         if (symbol_2_P)
  724.           {
  725. !           if (!S_IS_DEFINED(symbol_2_P))
  726.           {
  727.             * symbol_1_PP = NULL;
  728.             return_value = SEG_PASS1;
  729. ***************
  730. *** 598,604 ****
  731.           {
  732.             /* {seg1} - {seg2} */
  733.             as_warn( "Expression too complex, 2 symbols forgotten: \"%s\" \"%s\"",
  734. !               (* symbol_1_PP) -> sy_name, symbol_2_P -> sy_name );
  735.             * symbol_1_PP = NULL;
  736.             return_value = SEG_ABSOLUTE;
  737.           }
  738. --- 612,618 ----
  739.           {
  740.             /* {seg1} - {seg2} */
  741.             as_warn( "Expression too complex, 2 symbols forgotten: \"%s\" \"%s\"",
  742. !               S_GET_NAME(* symbol_1_PP), S_GET_NAME(symbol_2_P));
  743.             * symbol_1_PP = NULL;
  744.             return_value = SEG_ABSOLUTE;
  745.           }
  746. ***************
  747. *** 605,611 ****
  748.           }
  749.         else
  750.           {
  751. !           return_value = N_TYPE_seg [(* symbol_1_PP) -> sy_type & N_TYPE];
  752.           }
  753.       }
  754.       }
  755. --- 619,625 ----
  756.           }
  757.         else
  758.           {
  759. !           return_value = SEG_seg(S_GET_SEGMENT(* symbol_1_PP));
  760.           }
  761.       }
  762.       }
  763. ***************
  764. *** 614,620 ****
  765.         if (symbol_2_P)
  766.       {
  767.         * symbol_1_PP = symbol_2_P;
  768. !       return_value = N_TYPE_seg [(symbol_2_P) -> sy_type & N_TYPE];
  769.       }
  770.         else
  771.       {
  772. --- 628,634 ----
  773.         if (symbol_2_P)
  774.       {
  775.         * symbol_1_PP = symbol_2_P;
  776. !       return_value = SEG_seg(S_GET_SEGMENT(symbol_2_P));
  777.       }
  778.         else
  779.       {
  780. ***************
  781. *** 630,636 ****
  782.          || return_value == SEG_PASS1            
  783.          );
  784.     know(   (* symbol_1_PP) == NULL                
  785. !        || ((* symbol_1_PP) -> sy_type & N_TYPE) == seg_N_TYPE [(int) return_value] );
  786.     return (return_value);
  787.   }                /* expr_part() */
  788.   
  789. --- 644,650 ----
  790.          || return_value == SEG_PASS1            
  791.          );
  792.     know(   (* symbol_1_PP) == NULL                
  793. !        || (S_GET_SEGMENT(* symbol_1_PP) == seg_SEG((int) return_value) ));
  794.     return (return_value);
  795.   }                /* expr_part() */
  796.   
  797. ***************
  798. *** 792,798 ****
  799.              * does not cause any further inaccuracy.
  800.              */
  801.   
  802. !           register struct symbol *    symbolP;
  803.   
  804.             right . X_add_number      = - right . X_add_number;
  805.             symbolP                   = right . X_add_symbol;
  806. --- 806,812 ----
  807.              * does not cause any further inaccuracy.
  808.              */
  809.   
  810. !           register symbolS *    symbolP;
  811.   
  812.             right . X_add_number      = - right . X_add_number;
  813.             symbolP                   = right . X_add_symbol;
  814. ***************
  815. *** 858,865 ****
  816.                 know( resultP -> X_add_symbol      );
  817.                 know( resultP -> X_subtract_symbol );
  818.                 as_warn("Expression too complex: forgetting %s - %s",
  819. !                   resultP -> X_add_symbol      -> sy_name,
  820. !                   resultP -> X_subtract_symbol -> sy_name);
  821.                 resultP -> X_seg = SEG_ABSOLUTE;
  822.                 /* Clean_up_expression() will do the rest. */
  823.               }
  824. --- 872,879 ----
  825.                 know( resultP -> X_add_symbol      );
  826.                 know( resultP -> X_subtract_symbol );
  827.                 as_warn("Expression too complex: forgetting %s - %s",
  828. !                   S_GET_NAME(resultP -> X_add_symbol),
  829. !                   S_GET_NAME(resultP -> X_subtract_symbol));
  830.                 resultP -> X_seg = SEG_ABSOLUTE;
  831.                 /* Clean_up_expression() will do the rest. */
  832.               }
  833. *** frags.c    Thu Aug 17 20:53:21 1989
  834. --- /lasvegas/spare/usenet/port/gas-1.36/frags.c    Wed Sep 12 09:28:49 1990
  835. ***************
  836. *** 17,22 ****
  837. --- 17,23 ----
  838.   along with GAS; see the file COPYING.  If not, write to
  839.   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  840.   
  841. + #include "oformat.h"
  842.   #include "as.h"
  843.   #include "subsegs.h"
  844.   #include "obstack.h"
  845. *** hash.c    Wed Mar  1 23:49:18 1989
  846. --- /lasvegas/spare/usenet/port/gas-1.36/hash.c    Wed Sep 12 09:28:45 1990
  847. ***************
  848. *** 129,134 ****
  849. --- 129,137 ----
  850.   #define min(a, b)    ((a) < (b) ? (a) : (b))
  851.   
  852.   #include "hash.h"
  853. + 
  854. + #define error    as_fatal
  855. + 
  856.   char *xmalloc();
  857.   
  858.   #define DELETED     ((char *)1)    /* guarenteed invalid address */
  859. *** i386.c    Wed May 16 16:29:04 1990
  860. --- /lasvegas/spare/usenet/port/gas-1.36/i386.c    Sat Oct 13 11:34:21 1990
  861. ***************
  862. *** 37,42 ****
  863. --- 37,43 ----
  864.   #define index strchr
  865.   #endif
  866.   
  867. + #include "oformat.h"
  868.   #include "as.h"
  869.   #include "read.h"
  870.   #include "flonum.h"
  871. ***************
  872. *** 168,176 ****
  873.       { "tfloat",    float_cons,    'x' },
  874.       { "value",      cons,           2 },
  875.       { "ident",      dummy,          0   }, /* ignore these directives */
  876. !     { "def",        dummy,          0   },
  877.       { "version",    dummy,          0   },
  878. !     { "ln",    dummy,          0   },
  879.       { 0, 0, 0 }
  880.   };
  881.   
  882. --- 169,177 ----
  883.       { "tfloat",    float_cons,    'x' },
  884.       { "value",      cons,           2 },
  885.       { "ident",      dummy,          0   }, /* ignore these directives */
  886. ! /*    { "def",        dummy,          0   },*/
  887.       { "version",    dummy,          0   },
  888. ! /*    { "ln",    dummy,          0   },*/
  889.       { 0, 0, 0 }
  890.   };
  891.   
  892. ***************
  893. *** 372,391 ****
  894.     }
  895.   }
  896.   
  897. ! #define SYMBOL_TYPE(t) \
  898. !   (((t&N_TYPE) == N_UNDF) ? "UNDEFINED" : \
  899. !    (((t&N_TYPE) == N_ABS) ? "ABSOLUTE" : \
  900. !     (((t&N_TYPE) == N_TEXT) ? "TEXT" : \
  901. !      (((t&N_TYPE) == N_DATA) ? "DATA" : \
  902. !       (((t&N_TYPE) == N_BSS) ? "BSS" : "Bad n_type!")))))
  903.   
  904.   static void ps (s)
  905.        symbolS *s;
  906.   {
  907.     fprintf (stdout, "%s type %s%s",
  908. !        s->sy_nlist.n_un.n_name,
  909. !        (s->sy_nlist.n_type&N_EXT) ? "EXTERNAL " : "",
  910. !        SYMBOL_TYPE (s->sy_nlist.n_type));
  911.   }
  912.   
  913.   struct type_name {
  914. --- 373,387 ----
  915.     }
  916.   }
  917.   
  918. ! #define SYMBOL_TYPE(t) segment_name(SEG_seg(t))
  919.   
  920.   static void ps (s)
  921.        symbolS *s;
  922.   {
  923.     fprintf (stdout, "%s type %s%s",
  924. !        S_GET_NAME(s),
  925. !        S_IS_EXTERNAL(s) ? "EXTERNAL " : "",
  926. !        SYMBOL_TYPE(S_GET_SEGMENT(s))
  927.   }
  928.   
  929.   struct type_name {
  930. ***************
  931. *** 1543,1549 ****
  932.   int
  933.   md_estimate_size_before_relax (fragP, segment_type)
  934.        register fragS *    fragP;
  935. !      register int    segment_type; /* N_DATA or N_TEXT. */
  936.   {
  937.     register uchar *    opcode;
  938.     register int        old_fr_fix;
  939. --- 1539,1545 ----
  940.   int
  941.   md_estimate_size_before_relax (fragP, segment_type)
  942.        register fragS *    fragP;
  943. !      register int    segment_type; /* DATA or TEXT. */
  944.   {
  945.     register uchar *    opcode;
  946.     register int        old_fr_fix;
  947. ***************
  948. *** 1552,1558 ****
  949.     opcode = (uchar *) fragP -> fr_opcode;
  950.     /* We've already got fragP->fr_subtype right;  all we have to do is check
  951.        for un-relaxable symbols. */
  952. !   if ((fragP -> fr_symbol -> sy_type & N_TYPE) != segment_type) {
  953.       /* symbol is undefined in this segment */
  954.       switch (opcode[0]) {
  955.       case JUMP_PC_RELATIVE:    /* make jmp (0xeb) a dword displacement jump */
  956. --- 1548,1554 ----
  957.     opcode = (uchar *) fragP -> fr_opcode;
  958.     /* We've already got fragP->fr_subtype right;  all we have to do is check
  959.        for un-relaxable symbols. */
  960. !   if (S_GET_SEGMENT(fragP->fr_symbol) != segment_type) {
  961.       /* symbol is undefined in this segment */
  962.       switch (opcode[0]) {
  963.       case JUMP_PC_RELATIVE:    /* make jmp (0xeb) a dword displacement jump */
  964. ***************
  965. *** 1605,1611 ****
  966.     opcode = (uchar *) fragP -> fr_opcode;
  967.   
  968.     /* Address we want to reach in file space. */
  969. !   target_address = fragP->fr_symbol->sy_value + fragP->fr_offset;
  970.   
  971.     /* Address opcode resides at in file space. */
  972.     opcode_address = fragP->fr_address + fragP->fr_fix;
  973. --- 1601,1607 ----
  974.     opcode = (uchar *) fragP -> fr_opcode;
  975.   
  976.     /* Address we want to reach in file space. */
  977. !   target_address = S_GET_VALUE(fragP->fr_symbol) + fragP->fr_offset;
  978.   
  979.     /* Address opcode resides at in file space. */
  980.     opcode_address = fragP->fr_address + fragP->fr_fix;
  981. ***************
  982. *** 1684,1690 ****
  983.     long offset;
  984.   
  985.     if (flagseen['m']) {
  986. !     offset = to_addr - to_symbol->sy_value;
  987.       md_number_to_chars (ptr, 0xe9, 1); /* opcode for long jmp */
  988.       md_number_to_chars (ptr + 1, offset, 4);
  989.       fix_new (frag, (ptr+1) - frag->fr_literal, 4,
  990. --- 1680,1686 ----
  991.     long offset;
  992.   
  993.     if (flagseen['m']) {
  994. !     offset = to_addr - S_GET_VALUE(to_symbol);
  995.       md_number_to_chars (ptr, 0xe9, 1); /* opcode for long jmp */
  996.       md_number_to_chars (ptr + 1, offset, 4);
  997.       fix_new (frag, (ptr+1) - frag->fr_literal, 4,
  998. ***************
  999. *** 1833,1838 ****
  1000. --- 1829,1837 ----
  1001.     return retval;
  1002.   }
  1003.   
  1004. + /* Not needed for coff since relocation structure does not 
  1005. +    contain bitfields. */
  1006. + #ifdef aout
  1007.   void md_ri_to_chars(ri_p, ri)
  1008.        struct relocation_info *ri_p, ri;
  1009.   {
  1010. ***************
  1011. *** 1849,1854 ****
  1012. --- 1848,1854 ----
  1013.     /* now put it back where you found it */
  1014.     bcopy (the_bytes, (char *)ri_p, sizeof(struct relocation_info));
  1015.   }
  1016. + #endif /* aout */
  1017.   
  1018.   
  1019.   #define MAX_LITTLENUMS 6
  1020. --
  1021. Loic Dachary     loic@adesign.uucp or loic@afp.uucp 
  1022. Voice        +33 1 40 35 20 20
  1023.