home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 1 / 1974 < prev    next >
Internet Message Format  |  1990-12-28  |  39KB
  1. From: loic@adesign.uucp (Loic Dachary)
  2. Newsgroups: alt.sources
  3. Subject: gas-1.36 patches for COFF generation
  4. Message-ID: <LOIC.90Oct16093626@adesign.uucp>
  5. Date: 16 Oct 90 08:36:26 GMT
  6.  
  7. *** write.c    Thu Apr 12 17:23:42 1990
  8. --- /lasvegas/spare/usenet/port/gas-1.36/write.c    Mon Oct 15 12:35:38 1990
  9. ***************
  10. *** 30,35 ****
  11. --- 30,36 ----
  12.      trouble.
  13.    */
  14.   
  15. + #include "oformat.h"
  16.   #include "as.h"
  17.   #include "md.h"
  18.   #include "subsegs.h"
  19. ***************
  20. *** 37,64 ****
  21.   #include "struc-symbol.h"
  22.   #include "write.h"
  23.   #include "symbols.h"
  24.   
  25.   #ifdef SPARC
  26.   #include "sparc.h"
  27.   #endif
  28.   
  29. - void    append();
  30. - 
  31.   #ifdef hpux
  32.   #define EXEC_MACHINE_TYPE HP9000S200_ID
  33.   #endif
  34.   
  35. ! /*
  36. !  * In: length of relocation (or of address) in chars: 1, 2 or 4.
  37. !  * Out: GNU LD relocation length code: 0, 1, or 2.
  38. !  */
  39. ! 
  40. ! static unsigned char
  41. ! 
  42. ! nbytes_r_length [] = {
  43. !   42, 0, 1, 42, 2
  44. !   };
  45. ! 
  46.   
  47.   static struct frag *    text_frag_root;
  48.   static struct frag *    data_frag_root;
  49. --- 38,59 ----
  50.   #include "struc-symbol.h"
  51.   #include "write.h"
  52.   #include "symbols.h"
  53. + #include "append.h"
  54. + #ifdef coff
  55. + #include <sys/types.h>
  56. + #endif /* coff */
  57.   
  58.   #ifdef SPARC
  59.   #include "sparc.h"
  60.   #endif
  61.   
  62.   #ifdef hpux
  63.   #define EXEC_MACHINE_TYPE HP9000S200_ID
  64.   #endif
  65.   
  66. ! #ifdef coff
  67. ! extern time_t        time();
  68. ! #endif /* coff */
  69.   
  70.   static struct frag *    text_frag_root;
  71.   static struct frag *    data_frag_root;
  72. ***************
  73. *** 66,84 ****
  74.   static struct frag *    text_last_frag;    /* Last frag in segment. */
  75.   static struct frag *    data_last_frag;    /* Last frag in segment. */
  76.   
  77. ! static struct exec    the_exec;
  78.   
  79.   static long int string_byte_count;
  80.   
  81.   static char *        the_object_file;
  82.   
  83. - #ifndef SPARC
  84. - static
  85. - #endif
  86.   char *        next_object_file_charP;    /* Tracks object file bytes. */
  87.   
  88. - static long int        size_of_the_object_file; /* # bytes in object file. */
  89. - 
  90.   /* static long int        length; JF unused */    /* String length, including trailing '\0'. */
  91.   
  92.   static void    relax_segment();
  93. --- 61,74 ----
  94.   static struct frag *    text_last_frag;    /* Last frag in segment. */
  95.   static struct frag *    data_last_frag;    /* Last frag in segment. */
  96.   
  97. ! static object_headers    headers;
  98.   
  99.   static long int string_byte_count;
  100.   
  101.   static char *        the_object_file;
  102.   
  103.   char *        next_object_file_charP;    /* Tracks object file bytes. */
  104.   
  105.   /* static long int        length; JF unused */    /* String length, including trailing '\0'. */
  106.   
  107.   static void    relax_segment();
  108. ***************
  109. *** 85,93 ****
  110.   void        emit_segment();
  111.   static relax_addressT    relax_align();
  112.   static long int    fixup_segment();
  113. - #ifndef SPARC
  114. - static void        emit_relocations();
  115. - #endif
  116.    /*
  117.    *            fix_new()
  118.    *
  119. --- 75,80 ----
  120. ***************
  121. *** 144,150 ****
  122.     register struct frchain *    next_frchainP;
  123.     register fragS * *        prev_fragPP;
  124.     register char *        name;
  125. !   register symbolS *        symbolP;
  126.     register symbolS **        symbolPP;
  127.     /* register fixS *        fixP; JF unused */
  128.     unsigned
  129. --- 131,137 ----
  130.     register struct frchain *    next_frchainP;
  131.     register fragS * *        prev_fragPP;
  132.     register char *        name;
  133. !   symbolS *            symbolP;
  134.     register symbolS **        symbolPP;
  135.     /* register fixS *        fixP; JF unused */
  136.     unsigned
  137. ***************
  138. *** 153,158 ****
  139. --- 140,152 ----
  140.       syms_siz,
  141.       tr_siz,
  142.       dr_siz;
  143. + #ifdef coff
  144. +   SCNHDR            text_section_header;
  145. +   SCNHDR            data_section_header;
  146. +   SCNHDR            bss_section_header;
  147. +   symbolS*            last_functionP = (symbolS*)0;
  148. +   symbolS*            last_tagP;
  149. + #endif /* coff */
  150.     void output_file_create();
  151.     void output_file_append();
  152.     void output_file_close();
  153. ***************
  154. *** 160,168 ****
  155. --- 154,168 ----
  156.     void gdb_emit();
  157.     void gdb_end();
  158.   #endif
  159. +   long int object_file_size;
  160.     extern long omagic;        /* JF magic # to write out.  Is different for
  161.                      Suns and Vaxen and other boxes */
  162.   
  163. + #ifdef coff
  164. +   /* Initialize the stack used to keep track of the matching .bb .be */
  165. +   stack* block_stack = stack_init(512, sizeof(symbolS*));
  166. + #endif /* coff */
  167. + 
  168.   #ifdef    VMS
  169.     /*
  170.      *    Under VMS we try to be compatible with VAX-11 "C".  Thus, we
  171. ***************
  172. *** 261,273 ****
  173.      */
  174.   
  175.     know(   text_last_frag -> fr_type   == rs_fill && text_last_frag -> fr_offset == 0 );
  176. !   text_siz=text_last_frag->fr_address;
  177.   #ifdef SPARC
  178. !   text_siz= (text_siz+7)&(~7);
  179. !   text_last_frag->fr_address=text_siz;
  180.   #endif
  181. -   md_number_to_chars((char *)&the_exec.a_text,text_siz, sizeof(the_exec.a_text));
  182. -   /* the_exec . a_text = text_last_frag -> fr_address; */
  183.   
  184.     /*
  185.      * Join the 2 segments into 1 huge segment.
  186. --- 261,272 ----
  187.      */
  188.   
  189.     know(   text_last_frag -> fr_type   == rs_fill && text_last_frag -> fr_offset == 0 );
  190. !   H_SET_TEXT_SIZE(&headers,text_last_frag->fr_address);
  191.   #ifdef SPARC
  192. !   H_SET_TEXT_SIZE(&headers,H_GET_TEXT_SIZE(&headers) + 
  193. !                    (H_GET_TEXT_SIZE(&headers)+7)&(~7));
  194. !   text_last_frag->fr_address=H_GET_TEXT_SIZE(&headers);
  195.   #endif
  196.   
  197.     /*
  198.      * Join the 2 segments into 1 huge segment.
  199. ***************
  200. *** 281,294 ****
  201.         register relax_addressT    slide;
  202.   
  203.         know(   text_last_frag -> fr_type   == rs_fill && text_last_frag -> fr_offset == 0 );
  204. !       data_siz=data_last_frag->fr_address;
  205.   #ifdef SPARC
  206. !       data_siz += (8 - (data_siz % 8)) % 8;
  207. !       data_last_frag->fr_address = data_siz;
  208.   #endif
  209. !       md_number_to_chars((char *)&the_exec.a_data,data_siz,sizeof(the_exec.a_data));
  210. !       /* the_exec . a_data = data_last_frag -> fr_address; */
  211. !       slide = text_siz; /* Address in file of the data segment. */
  212.         for (fragP = data_frag_root;
  213.          fragP;
  214.          fragP = fragP -> fr_next)
  215. --- 280,292 ----
  216.         register relax_addressT    slide;
  217.   
  218.         know(   text_last_frag -> fr_type   == rs_fill && text_last_frag -> fr_offset == 0 );
  219. !       H_SET_DATA_SIZE(&headers,data_last_frag->fr_address);
  220.   #ifdef SPARC
  221. !       H_SET_DATA_SIZE(&headers,(H_GET_DATA_SIZE(&headers) + 
  222. !                 (8 - (H_GET_DATA_SIZE(&headers) % 8)) % 8));
  223. !       data_last_frag->fr_address = H_GET_DATA_SIZE(&headers);
  224.   #endif
  225. !       slide = H_GET_TEXT_SIZE(&headers); /* & in file of the data segment. */
  226.         for (fragP = data_frag_root;
  227.          fragP;
  228.          fragP = fragP -> fr_next)
  229. ***************
  230. *** 298,314 ****
  231.         know( text_last_frag );
  232.         text_last_frag -> fr_next = data_frag_root;
  233.       }
  234. !   else {
  235. !       md_number_to_chars((char *)&the_exec.a_data,0,sizeof(the_exec.a_data));
  236. !       data_siz = 0;
  237. !   }
  238.   
  239. !   bss_address_frag . fr_address = text_siz + data_siz;
  240.   #ifdef SPARC
  241.     local_bss_counter=(local_bss_counter+7)&(~7);
  242.   #endif
  243. !   md_number_to_chars((char *)&the_exec.a_bss,local_bss_counter,sizeof(the_exec.a_bss));
  244. ! 
  245.             
  246.     /*
  247.      *
  248. --- 296,310 ----
  249.         know( text_last_frag );
  250.         text_last_frag -> fr_next = data_frag_root;
  251.       }
  252. !   else
  253. !       H_SET_DATA_SIZE(&headers,0);
  254.   
  255. !   bss_address_frag . fr_address = H_GET_TEXT_SIZE(&headers) + 
  256. !                                   H_GET_DATA_SIZE(&headers);
  257.   #ifdef SPARC
  258.     local_bss_counter=(local_bss_counter+7)&(~7);
  259.   #endif
  260. !   H_SET_BSS_SIZE(&headers,local_bss_counter);
  261.             
  262.     /*
  263.      *
  264. ***************
  265. *** 340,380 ****
  266.           symbolP->sy_forward=0;
  267.       }
  268.     }
  269. !   symbolPP = & symbol_rootP;    /* -> last symbol chain link. */
  270.     {
  271. !     register long int        symbol_number;
  272.   
  273. !     symbol_number = 0;
  274.       while (symbolP  = * symbolPP)
  275.         {
  276. !     name = symbolP -> sy_name;
  277. !     if(flagseen['R'] && (symbolP->sy_nlist.n_type&N_DATA)) {
  278. !       symbolP->sy_nlist.n_type&= ~N_DATA;
  279. !       symbolP->sy_nlist.n_type|= N_TEXT;
  280. !     }
  281. !     /* if(symbolP->sy_forward) {
  282. !       symbolP->sy_value += symbolP->sy_forward->sy_value + symbolP->sy_forward->sy_frag->fr_address;
  283. !     } */
  284.       
  285.       symbolP -> sy_value += symbolP -> sy_frag -> fr_address;
  286. -         /* JF the 128 bit is a hack so stabs like
  287. -            "LET_STMT:23. . ."  don't go away */
  288. -     /* CPH: 128 bit hack is moby loser.  N_SO for file "Lower.c"
  289. -        fell through the cracks.  I think that N_STAB should be
  290. -        used instead of 128. */
  291.           /* JF the \001 bit is to make sure that local labels
  292.              ( 1: - 9: don't make it into the symtable either */
  293.   #ifndef    VMS    /* Under VMS we need to keep local symbols */
  294. !     if ( !name || (symbolP->sy_nlist.n_type&N_STAB)
  295. !         || (name[0]!='\001' && (flagseen ['L'] || name [0] != 'L' )))
  296.   #endif    /* not VMS */
  297.         {
  298. -         symbolP -> sy_number = symbol_number ++;
  299.   #ifndef    VMS
  300. !         if (name)
  301.             {            /* Ordinary case. */
  302.           symbolP -> sy_name_offset = string_byte_count;
  303. !         string_byte_count += strlen (symbolP  -> sy_name) + 1;
  304.             }
  305.           else            /* .Stabd case. */
  306.   #endif    /* not VMS */
  307. --- 336,581 ----
  308.           symbolP->sy_forward=0;
  309.       }
  310.     }
  311. ! 
  312.     {
  313. !       register int    symbol_number = 0;
  314. ! #if defined(coff)
  315. !       symbolS*        symbol_externP = (symbolS*)0;
  316. !       symbolS*        symbol_extern_lastP = (symbolS*)0;
  317. !       
  318. !   /* The symbol list should be ordered according to the following sequence
  319. !    * order :
  320. !    * . .file symbol
  321. !    * . debug entries for functions
  322. !    * . fake symbols for .text .data and .bss
  323. !    * . defined symbols
  324. !    * . undefined symbols
  325. !    * But this is not mandatory. The only important point is to put the
  326. !    * undefined symbols at the end of the list.
  327. !    */
  328. ! 
  329. !       {
  330. !       /* Is there a .file symbol ? If not insert one at the beginning. */
  331. !       if(symbol_rootP == NULL ||
  332. !          S_GET_STORAGE_CLASS(symbol_rootP) != C_FILE)
  333. !           c_dot_file_symbol("fake");
  334. !       
  335. !       /*
  336. !        * Build up static symbols for .text, .data and .bss
  337. !        */
  338. !       dot_text_symbol = (symbolS*)
  339. !           c_section_symbol(".text", 0, H_GET_TEXT_SIZE(&headers),
  340. !              0/*text_relocation_number*/, 0/*text_lineno_number*/);
  341. !       dot_data_symbol = (symbolS*)
  342. !           c_section_symbol(".data", H_GET_TEXT_SIZE(&headers),
  343. !             H_GET_DATA_SIZE(&headers),
  344. !             0/*data_relocation_number*/,
  345. !             0); /* There is no data lineno entries */
  346. !       dot_bss_symbol = (symbolS*)
  347. !           c_section_symbol(".bss", H_GET_TEXT_SIZE(&headers) +
  348. !             H_GET_DATA_SIZE(&headers),
  349. !             H_GET_BSS_SIZE(&headers),
  350. !             0, /* No relocation for a bss section. */
  351. !             0); /* There is no bss lineno entries */
  352. !       }
  353. !           
  354. !       symbolP = symbol_rootP;
  355. !       if(symbolP) {
  356. !        while(symbolP) {
  357. !           /* If the symbol has a tagndx entry, resolve it */
  358. !           if(SF_GET_TAGGED(symbolP)) {
  359. !           SA_SET_SYM_TAGNDX(symbolP,
  360. !                     ((symbolS*)SA_GET_SYM_TAGNDX(symbolP))->sy_number);
  361. !           }
  362. !           /* Debug symbol do not need all this rubbish */
  363. !           if(!SF_GET_DEBUG(symbolP)) {
  364. !           symbolS* real_symbolP;
  365. !           /* L* and C_EFCN symbols never merge. */
  366. !           if(!SF_GET_LOCAL(symbolP) &&
  367. !              (real_symbolP =
  368. !               symbol_find_base(S_GET_NAME(symbolP), DO_NOT_STRIP)) &&
  369. !              real_symbolP != symbolP) {
  370. !               /* Move the debug data from the debug symbol to the
  371. !              real symbol. Do NOT do the oposite (i.e. move from
  372. !              real symbol to symbol and remove real symbol from the
  373. !              list.) Because some pointers refer to the real symbol
  374. !              whereas no pointers refer to the symbol. */
  375. !               c_symbol_merge(symbolP, real_symbolP);
  376. !               /* Replace the current symbol by the real one */
  377. !               /* The symbols will never be the last or the first
  378. !              because : 1st symbol is .file and 3 last symbols are
  379. !              .text, .data, .bss */
  380. !               real_symbolP->sy_previous->sy_next = real_symbolP->sy_next;
  381. !               real_symbolP->sy_next->sy_previous = real_symbolP->sy_previous;
  382. !               symbolP->sy_previous->sy_next = real_symbolP;
  383. !               symbolP->sy_next->sy_previous = real_symbolP;
  384. !               real_symbolP->sy_next = symbolP->sy_next;
  385. !               real_symbolP->sy_previous = symbolP->sy_previous;
  386. !               symbolP = real_symbolP;
  387. !           }
  388. !           if(flagseen['R'] && S_IS_DATA(symbolP))
  389. !               S_SET_TEXT(symbolP);
  390. !           
  391. !           symbolP->sy_value += symbolP->sy_frag->fr_address;
  392. !           
  393. !           if(!S_IS_DEFINED(symbolP))
  394. !               S_SET_EXTERNAL(symbolP);
  395. !           else if(S_GET_STORAGE_CLASS(symbolP) == C_NULL)
  396. !               S_SET_STORAGE_CLASS(symbolP, C_STAT);
  397. !           
  398. !           /* Mainly to speed up if not -g */
  399. !           if(SF_GET_PROCESS(symbolP)) {
  400. !               /* Handle the nested blocks auxiliary info. */
  401. !               if(S_GET_STORAGE_CLASS(symbolP) == C_BLOCK) {
  402. !               if(!strcmp(S_GET_NAME(symbolP), ".bb"))
  403. !                   stack_push(block_stack, &symbolP);
  404. !               else { /* .eb */
  405. !                   register symbolS* begin_symbolP;
  406. !                   begin_symbolP = *(symbolS**)stack_pop(block_stack);
  407. !                   if(begin_symbolP == (symbolS*)0)
  408. !                   as_warn("mismatched .eb");
  409. !                   else
  410. !                   SA_SET_SYM_ENDNDX(begin_symbolP, symbol_number);
  411. !               }
  412. !               }
  413. !               /* If we are able to identify the type of a function, and we
  414. !              are out of a function (last_functionP == 0) then, the
  415. !              function symbol will be associated with an auxiliary
  416. !              entry. */
  417. !               if(last_functionP == (symbolS*)0 &&
  418. !              SF_GET_FUNCTION(symbolP)) {
  419. !               last_functionP = symbolP;
  420. !               S_SET_NUMBER_AUXILIARY(symbolP, 1);
  421. !               /* Clobber possible stale .dim information. */
  422. !               memset(&symbolP->sy_auxent, '\0', sizeof(union auxent));
  423. !               }
  424. !               /* The C_FCN do not need any additional information.
  425. !              I don't even know if this is needed for sdb. But the
  426. !              standard assembler generate it, so...
  427. !              */
  428. !               if(S_GET_STORAGE_CLASS(symbolP) == C_EFCN) {
  429. !               if(last_functionP == (symbolS*)0)
  430. !                   as_fatal("C_EFCN symbol out of scope");
  431. !               SA_SET_SYM_FSIZE(last_functionP,
  432. !                        (long)(symbolP->sy_value -
  433. !                           last_functionP->sy_value));
  434. !               SA_SET_SYM_ENDNDX(last_functionP, symbol_number);
  435. !               last_functionP = (symbolS*)0;
  436. !               }
  437. !           }
  438. !           } else {
  439. !           /* First descriptor of a structure must point to the next
  440. !              slot outside the structure description. */
  441. !           if(SF_GET_TAG(symbolP))
  442. !               last_tagP = symbolP;
  443. !           else if(S_GET_STORAGE_CLASS(symbolP) == C_EOS)
  444. !               /* +2 take in account the current symbol */
  445. !               SA_SET_SYM_ENDNDX(last_tagP, symbol_number+2);
  446. !           }
  447. ! 
  448. !           /* We must put the external symbols appart. The loader
  449. !          does not bomb if we do not. But the references in
  450. !          the endndx field for a .bb symbol are not corrected
  451. !          if an external symbol is removed between .bb and .be.
  452. !          I.e int the following case :
  453. !          [20] .bb endndx = 22
  454. !          [21] foo external
  455. !          [22] .be
  456. !          ld will move the symbol 21 to the end of the list but
  457. !          endndx will still be 22 instead of 21. */
  458. !           {
  459. !           register symbolS* thisP = symbolP;
  460. ! 
  461. !           symbolP = thisP->sy_next;
  462. !           /* remove C_EFCN and LOCAL (L...) symbols */
  463. !           if(SF_GET_LOCAL(thisP)) {
  464. !               thisP->sy_next->sy_previous = thisP->sy_previous;
  465. !               thisP->sy_previous->sy_next = thisP->sy_next;
  466. !           } else {
  467. !               if(S_GET_STORAGE_CLASS(thisP) == C_EXT &&
  468. !              !SF_GET_FUNCTION(thisP)) {
  469. !               /* Remove from the list */
  470. !               thisP->sy_next->sy_previous = thisP->sy_previous;
  471. !               thisP->sy_previous->sy_next = thisP->sy_next;
  472. !               /* Move at the end of the list */
  473. !               if (symbol_extern_lastP) {
  474. !                   symbol_extern_lastP->sy_next = thisP;
  475. !                   thisP->sy_previous = symbol_extern_lastP;
  476. !               } else {
  477. !                   symbol_externP = thisP;
  478. !               }
  479. !               thisP->sy_next = (symbolS*)0;
  480. !               symbol_extern_lastP = thisP;
  481. !               } else {
  482. !               if(SF_GET_STRING(thisP)) {
  483. !                   thisP->sy_name_offset = string_byte_count;
  484. !                   string_byte_count += strlen(S_GET_NAME(thisP)) + 1;
  485. !               } else
  486. !                   thisP->sy_name_offset = 0;
  487. !               thisP->sy_number = symbol_number;
  488. !               symbol_number += 1 + S_GET_NUMBER_AUXILIARY(thisP);
  489. !               }
  490. !           }
  491. !           }
  492. !       }
  493.   
  494. !       symbol_lastP->sy_next = symbol_externP;
  495. !       symbolP = symbol_externP;
  496. !       while(symbolP) {
  497. !           if(SF_GET_STRING(symbolP)) {
  498. !           symbolP->sy_name_offset = string_byte_count;
  499. !           string_byte_count += strlen(S_GET_NAME(symbolP)) + 1;
  500. !           } else
  501. !           symbolP->sy_name_offset = 0;
  502. !           symbolP->sy_number = symbol_number;
  503. !           symbol_number += 1 + S_GET_NUMBER_AUXILIARY(symbolP);
  504. !           symbolP = symbolP->sy_next;
  505. !       }
  506. !       }
  507. !       {
  508. !       lineno* lineP;
  509. !       for(lineP = lineno_rootP; lineP; lineP = lineP->next) {
  510. !           if(lineP->line.l_lnno)
  511. !           lineP->line.l_addr.l_paddr +=
  512. !               ((fragS*)lineP->frag)->fr_address;
  513. !           else {
  514. !           /* There is a good chance that the symbol pointed to
  515. !              is not the one that will be emitted and that the 
  516. !              sy_number is not accurate. */
  517. !           char* name;
  518. !           name = (char*)lineP->line.l_addr.l_symndx;
  519. !           if((symbolP = symbol_find_base(name, DO_NOT_STRIP)) ==
  520. !              (symbolS*)0)
  521. !               as_warn("line number lost symbol %s", name);
  522. !           else
  523. !               lineP->line.l_addr.l_symndx = symbolP->sy_number;
  524. !           }
  525. !           text_lineno_number++;
  526. !       }
  527. !       }
  528. ! #elif defined(aout)
  529. !     symbolPP = & symbol_rootP;    /* -> last symbol chain link. */
  530.       while (symbolP  = * symbolPP)
  531.         {
  532. !     name = S_GET_NAME(symbolP);
  533. !     if(flagseen['R'] && S_IS_DATA(symbolP))
  534. !       S_SET_TEXT(symbolP);
  535.       
  536.       symbolP -> sy_value += symbolP -> sy_frag -> fr_address;
  537.           /* JF the \001 bit is to make sure that local labels
  538.              ( 1: - 9: don't make it into the symtable either */
  539.   #ifndef    VMS    /* Under VMS we need to keep local symbols */
  540. !     if (!S_IS_LOCAL(symbolP))
  541.   #endif    /* not VMS */
  542.         {
  543.   #ifndef    VMS
  544. ! /* The + 1 after strlen account for the \0 at the end of each string */
  545. !         symbolP -> sy_number = symbol_number ++;
  546. !         if(!S_IS_STABD(symbolP))
  547.             {            /* Ordinary case. */
  548.           symbolP -> sy_name_offset = string_byte_count;
  549. !         string_byte_count += 
  550. !             strlen (S_GET_NAME(symbolP)) + 1;
  551.             }
  552.           else            /* .Stabd case. */
  553.   #endif    /* not VMS */
  554. ***************
  555. *** 382,397 ****
  556.           symbolPP = & (symbolP -> sy_next);
  557.         }
  558.   #ifndef    VMS
  559. !     else
  560.           * symbolPP = symbolP -> sy_next;
  561.   #endif    /* not VMS */
  562.         }                /* for each symbol */
  563.   
  564. !     syms_siz = sizeof( struct nlist) * symbol_number;
  565. !     md_number_to_chars((char *)&the_exec.a_syms,syms_siz,sizeof(the_exec.a_syms));
  566. !     /* the_exec . a_syms = sizeof( struct nlist) * symbol_number; */
  567.     }
  568. - 
  569.     /*
  570.      * Addresses of frags now reflect addresses we use in the object file.
  571.      * Symbol values are correct.
  572. --- 583,601 ----
  573.           symbolPP = & (symbolP -> sy_next);
  574.         }
  575.   #ifndef    VMS
  576. !     else /* skip the symbol */
  577.           * symbolPP = symbolP -> sy_next;
  578.   #endif    /* not VMS */
  579.         }                /* for each symbol */
  580.   
  581. ! #elif defined(elf)
  582. !       do it yourself !
  583. ! #else
  584. !       you lose
  585. ! #endif
  586. !     H_SET_STRING_SIZE(&headers,string_byte_count);
  587. !     H_SET_SYMBOL_TABLE_SIZE(&headers, symbol_number);
  588.     }
  589.     /*
  590.      * Addresses of frags now reflect addresses we use in the object file.
  591.      * Symbol values are correct.
  592. ***************
  593. *** 553,595 ****
  594.      * Scan every FixS performing fixups. We had to wait until now to do
  595.      * this because md_convert_frag() may have made some fixSs.
  596.      */
  597. !   /* the_exec . a_trsize
  598. !     = sizeof(struct relocation_info) * fixup_segment (text_fix_root, N_TEXT);
  599. !   the_exec . a_drsize
  600. !     = sizeof(struct relocation_info) * fixup_segment (data_fix_root, N_DATA); */
  601. ! 
  602. !   tr_siz=sizeof(struct relocation_info) * fixup_segment (text_fix_root, N_TEXT);
  603. !   md_number_to_chars((char *)&the_exec.a_trsize, tr_siz ,sizeof(the_exec.a_trsize));
  604. !   dr_siz=sizeof(struct relocation_info) * fixup_segment (data_fix_root, N_DATA);
  605. !   md_number_to_chars((char *)&the_exec.a_drsize, dr_siz, sizeof(the_exec.a_drsize));
  606. !   md_number_to_chars((char *)&the_exec.a_magic,omagic,sizeof(the_exec.a_magic));
  607. !   md_number_to_chars((char *)&the_exec.a_entry,0,sizeof(the_exec.a_entry));
  608.   
  609.   #ifdef EXEC_MACHINE_TYPE
  610. !   md_number_to_chars((char *)&the_exec.a_machtype, EXEC_MACHINE_TYPE, sizeof(the_exec.a_machtype));
  611.   #endif
  612.   #ifdef EXEC_VERSION
  613. !   md_number_to_chars((char *)&the_exec.a_version,EXEC_VERSION,sizeof(the_exec.a_version));
  614.   #endif
  615. -   
  616. -   /* the_exec . a_entry = 0; */
  617.   
  618. !   size_of_the_object_file =
  619. !     sizeof( the_exec ) +
  620. !       text_siz +
  621. !         data_siz +
  622. !       syms_siz +
  623. !         tr_siz +
  624. !           dr_siz +
  625. !         string_byte_count;
  626. !     
  627. !   next_object_file_charP
  628. !     = the_object_file
  629. !       = xmalloc ( size_of_the_object_file );
  630.   
  631.     output_file_create (out_file_name);
  632.   
  633. !   append (& next_object_file_charP, (char *)(&the_exec), (unsigned long)sizeof(the_exec));
  634.   
  635.     /*
  636.      * Emit code.
  637. --- 757,876 ----
  638.      * Scan every FixS performing fixups. We had to wait until now to do
  639.      * this because md_convert_frag() may have made some fixSs.
  640.      */
  641. !   
  642. !   H_SET_RELOCATION_SIZE(&headers,
  643. !        RELSZ*fixup_segment (text_fix_root, SEG_TEXT),
  644. !        RELSZ*fixup_segment (data_fix_root, SEG_DATA));
  645. !   H_SET_MAGIC_NUMBER(&headers,omagic);
  646. !   H_SET_ENTRY_POINT(&headers,0);
  647.   
  648.   #ifdef EXEC_MACHINE_TYPE
  649. !   H_SET_MACHINE_TYPE(&headers,EXEC_MACHINE_TYPE);
  650.   #endif
  651.   #ifdef EXEC_VERSION
  652. !   H_SET_VERSION(&headers,EXEC_VERSION);
  653.   #endif
  654.   
  655. ! #ifdef coff
  656. !   {
  657. !       register int        text_relocation_number = 0;
  658. !       register int        data_relocation_number = 0;
  659. !       register fixS*    fixP;
  660. !       
  661. !       /* Count the number of relocation entries for text and data */
  662. !       for(fixP = text_fix_root; fixP; fixP = fixP->fx_next)
  663. !       if(fixP->fx_addsy)
  664. !           text_relocation_number++;
  665. !       SA_SET_SCN_NRELOC(dot_text_symbol, text_relocation_number);
  666. !       /* Assign the number of line number entries for the text section */
  667. !       SA_SET_SCN_NLINNO(dot_text_symbol, text_lineno_number);
  668. !       /* Assign the size of the section */
  669. !       SA_SET_SCN_SCNLEN(dot_text_symbol, H_GET_TEXT_SIZE(&headers));
  670. !       
  671. !       for(fixP = data_fix_root; fixP; fixP = fixP->fx_next)
  672. !       if(fixP->fx_addsy)
  673. !           data_relocation_number++;
  674. !       SA_SET_SCN_NRELOC(dot_data_symbol, data_relocation_number);
  675. !       /* Assign the size of the section */
  676. !       SA_SET_SCN_SCNLEN(dot_data_symbol, H_GET_DATA_SIZE(&headers));
  677. ! 
  678. !       /* Assign the size of the section */
  679. !       SA_SET_SCN_SCNLEN(dot_bss_symbol, H_GET_BSS_SIZE(&headers));
  680. !   }
  681. ! 
  682. !   /* Fill in extra coff fields */
  683. ! 
  684. !   /* Initialize general line number information. */
  685. !   H_SET_LINENO_SIZE(&headers, text_lineno_number * LINESZ);
  686. ! 
  687. !   /* filehdr */
  688. !   H_SET_FILE_MAGIC_NUMBER(&headers, FILE_HEADER_MAGIC);
  689. !   H_SET_NUMBER_OF_SECTIONS(&headers, 3); /* text+data+bss */
  690. !   H_SET_TIME_STAMP(&headers, (long)time((long*)0));
  691. !   H_SET_SYMBOL_TABLE_POINTER(&headers,
  692. !                  H_GET_SYMBOL_TABLE_FILE_OFFSET(&headers));
  693. !   /* symbol table size allready set */
  694. !   H_SET_SIZEOF_OPTIONAL_HEADER(&headers, AOUTHDRSZ);
  695. !   H_SET_FLAGS(&headers, (text_lineno_number == 0 ? F_LNNO : 0 ) | 
  696. !           BYTE_ORDERING);
  697. ! 
  698. !   /* aouthdr */
  699. !   /* magic number allready set */
  700. !   H_SET_VERSION_STAMP(&headers, 0);
  701. !   /* Text, data, bss size; entry point; text_start and data_start
  702. !      are already set */
  703. ! 
  704. !   /* Build section headers */
  705. !   
  706. !   c_section_header(&text_section_header,
  707. !            ".text",
  708. !            0,
  709. !            H_GET_TEXT_SIZE(&headers),
  710. !            H_GET_TEXT_FILE_OFFSET(&headers),
  711. !            SA_GET_SCN_NRELOC(dot_text_symbol) ?
  712. !              H_GET_RELOCATION_FILE_OFFSET(&headers) : 0,
  713. !            text_lineno_number ? H_GET_LINENO_FILE_OFFSET(&headers) : 0,
  714. !            SA_GET_SCN_NRELOC(dot_text_symbol),
  715. !            text_lineno_number);
  716. !   c_section_header(&data_section_header,
  717. !            ".data",
  718. !            H_GET_TEXT_SIZE(&headers),
  719. !            H_GET_DATA_SIZE(&headers),
  720. !            H_GET_DATA_SIZE(&headers) ?
  721. !              H_GET_DATA_FILE_OFFSET(&headers) : 0,
  722. !            SA_GET_SCN_NRELOC(dot_data_symbol) ?
  723. !              H_GET_RELOCATION_FILE_OFFSET(&headers) +
  724. !              text_section_header.s_nreloc * RELSZ : 0,
  725. !            0, /* No line number information */
  726. !            SA_GET_SCN_NRELOC(dot_data_symbol),
  727. !            0);  /* No line number information */
  728. !   c_section_header(&bss_section_header,
  729. !            ".bss",
  730. !            H_GET_TEXT_SIZE(&headers) + H_GET_DATA_SIZE(&headers),
  731. !            H_GET_BSS_SIZE(&headers),
  732. !            0, /* No file offset */
  733. !            0, /* No relocation information */
  734. !            0, /* No line number information */
  735. !            0, /* No relocation information */
  736. !            0); /* No line number information */
  737. !   
  738. ! #endif /* coff */
  739. !   
  740. !   object_file_size = H_GET_FILE_SIZE(&headers);
  741. !   next_object_file_charP = the_object_file = xmalloc ( object_file_size );
  742.   
  743.     output_file_create (out_file_name);
  744.   
  745. ! 
  746. !   H_OUTPUT(&headers, &next_object_file_charP);
  747. ! 
  748. ! #ifdef coff
  749. !   /* Output the section headers */
  750. !   c_section_header_append(&text_section_header, &next_object_file_charP);
  751. !   c_section_header_append(&data_section_header, &next_object_file_charP);
  752. !   c_section_header_append(&bss_section_header, &next_object_file_charP);
  753. ! #endif /* coff */
  754. ! 
  755.   
  756.     /*
  757.      * Emit code.
  758. ***************
  759. *** 614,642 ****
  760.      */
  761.     emit_relocations (text_fix_root, (relax_addressT)0);
  762.     emit_relocations (data_fix_root, text_last_frag -> fr_address);
  763.     /*
  764. !    * Emit all symbols left in the symbol chain.
  765. !    * Any symbol still undefined is made N_EXT.
  766.      */
  767. !   for (   symbolP = symbol_rootP;   symbolP;   symbolP = symbolP -> sy_next   )
  768. !     {
  769. !       register char *    temp;
  770. ! 
  771. !       temp = symbolP -> sy_nlist . n_un . n_name;
  772. !       /* JF fix the numbers up. Call by value RULES! */
  773. !       md_number_to_chars((char *)&(symbolP -> sy_nlist  . n_un . n_strx ),symbolP -> sy_name_offset,sizeof(symbolP -> sy_nlist  . n_un . n_strx ));
  774. !       md_number_to_chars((char *)&(symbolP->sy_nlist.n_desc),symbolP->sy_nlist.n_desc,sizeof(symbolP -> sy_nlist  . n_desc));
  775. !       md_number_to_chars((char *)&(symbolP->sy_nlist.n_value),symbolP->sy_nlist.n_value,sizeof(symbolP->sy_nlist.n_value));
  776. !       /* symbolP -> sy_nlist  . n_un . n_strx = symbolP -> sy_name_offset; JF replaced by md above */
  777. !       if (symbolP -> sy_type == N_UNDF)
  778. !       symbolP -> sy_type |= N_EXT; /* Any undefined symbols become N_EXT. */
  779. !       append (& next_object_file_charP, (char *)(& symbolP -> sy_nlist),
  780. !           (unsigned long)sizeof(struct nlist));
  781. !       symbolP -> sy_nlist . n_un . n_name = temp;
  782. !     }                /* for each symbol */
  783.   
  784.     /*
  785. -    * next_object_file_charP -> slot for next object byte.
  786.      * Emit strings.
  787.      * Find strings by crawling along symbol table chain.
  788.      */
  789. --- 895,914 ----
  790.      */
  791.     emit_relocations (text_fix_root, (relax_addressT)0);
  792.     emit_relocations (data_fix_root, text_last_frag -> fr_address);
  793. + 
  794. + #ifdef coff
  795.     /*
  796. !    * Emit line number entries.
  797.      */
  798. !   emit_lineno(lineno_rootP, &next_object_file_charP);
  799. ! #endif /* coff */
  800. ! 
  801. !   /*
  802. !    * Emit symbols.
  803. !    */
  804. !   emit_symbols (symbol_rootP,&next_object_file_charP);
  805.   
  806.     /*
  807.      * Emit strings.
  808.      * Find strings by crawling along symbol table chain.
  809.      */
  810. ***************
  811. *** 644,661 ****
  812.     md_number_to_chars((char *)&string_byte_count, string_byte_count, sizeof(string_byte_count));
  813.   
  814.     append (& next_object_file_charP, (char *)&string_byte_count, (unsigned long)sizeof(string_byte_count));
  815. !   for (   symbolP = symbol_rootP;   symbolP;   symbolP = symbolP -> sy_next   )
  816. !     {
  817. !       if (symbolP -> sy_name)
  818. !     {            /* Ordinary case: not .stabd. */
  819. !       append (& next_object_file_charP, symbolP -> sy_name,
  820. !           (unsigned long)(strlen (symbolP -> sy_name) + 1));
  821. !     }
  822. !     }                /* for each symbol */
  823. ! 
  824. !   know( next_object_file_charP == the_object_file + size_of_the_object_file );
  825.   
  826. !   output_file_append (the_object_file, size_of_the_object_file, out_file_name);
  827.   
  828.   #ifdef DONTDEF
  829.     if (flagseen['G'])        /* GDB symbol file to be appended? */
  830. --- 916,934 ----
  831.     md_number_to_chars((char *)&string_byte_count, string_byte_count, sizeof(string_byte_count));
  832.   
  833.     append (& next_object_file_charP, (char *)&string_byte_count, (unsigned long)sizeof(string_byte_count));
  834. !   for(symbolP = symbol_rootP; symbolP; symbolP = symbolP->sy_next) {
  835. ! #ifdef coff
  836. !       if(SF_GET_STRING(symbolP))
  837. ! #else /* coff */
  838. !       if(S_GET_NAME(symbolP))
  839. ! #endif /* coff */
  840. !       append(&next_object_file_charP, S_GET_NAME(symbolP),
  841. !          (unsigned long)(strlen (S_GET_NAME(symbolP)) + 1));
  842. !   }
  843.   
  844. !   know( next_object_file_charP == the_object_file + object_file_size);
  845. !   /* Write the data to the file */
  846. !   output_file_append (the_object_file,object_file_size,out_file_name);
  847.   
  848.   #ifdef DONTDEF
  849.     if (flagseen['G'])        /* GDB symbol file to be appended? */
  850. ***************
  851. *** 692,698 ****
  852.   void
  853.   relax_segment (segment_frag_root, segment_type)
  854.        struct frag *    segment_frag_root;
  855. !      segT        segment_type; /* N_DATA or N_TEXT */
  856.   {
  857.     register struct frag *    fragP;
  858.     register relax_addressT    address;
  859. --- 965,971 ----
  860.   void
  861.   relax_segment (segment_frag_root, segment_type)
  862.        struct frag *    segment_frag_root;
  863. !      segT        segment_type; /* SEG_DATA or SEG_TEXT */
  864.   {
  865.     register struct frag *    fragP;
  866.     register relax_addressT    address;
  867. ***************
  868. *** 730,736 ****
  869.   
  870.       case rs_machine_dependent:
  871.         address += md_estimate_size_before_relax
  872. !         (fragP, seg_N_TYPE [(int) segment_type]);
  873.         break;
  874.   
  875.   #ifndef WORKING_DOT_WORD
  876. --- 1003,1009 ----
  877.   
  878.       case rs_machine_dependent:
  879.         address += md_estimate_size_before_relax
  880. !         (fragP, seg_SEG((int) segment_type));
  881.         break;
  882.   
  883.   #ifndef WORKING_DOT_WORD
  884. ***************
  885. *** 837,845 ****
  886.           target = offset;
  887.           if (symbolP)
  888.             {
  889. !             know(   ((symbolP -> sy_type & N_TYPE) == N_ABS) || ((symbolP -> sy_type & N_TYPE) == N_DATA) || ((symbolP -> sy_type & N_TYPE) == N_TEXT));
  890. !             know( symbolP -> sy_frag );
  891. !             know( (symbolP->sy_type&N_TYPE)!=N_ABS || symbolP->sy_frag==&zero_address_frag );
  892.               target +=
  893.                 symbolP -> sy_value
  894.               + symbolP -> sy_frag -> fr_address;
  895. --- 1110,1121 ----
  896.           target = offset;
  897.           if (symbolP)
  898.             {
  899. !             know(S_IS_ABS(symbolP) ||
  900. !              S_IS_DATA(symbolP) ||
  901. !              S_IS_TEXT(symbolP))
  902. !             know(symbolP -> sy_frag);
  903. !             know(!S_IS_ABS(symbolP) || 
  904. !              symbolP->sy_frag==&zero_address_frag );
  905.               target +=
  906.                 symbolP -> sy_value
  907.               + symbolP -> sy_frag -> fr_address;
  908. ***************
  909. *** 866,875 ****
  910.           target = offset;
  911.           if (symbolP)
  912.             {
  913. !  know(   ((symbolP -> sy_type & N_TYPE) == N_ABS) || ((symbolP -> sy_type &
  914. !  N_TYPE) == N_DATA) || ((symbolP -> sy_type & N_TYPE) == N_TEXT));
  915. !             know( symbolP -> sy_frag );
  916. !             know( (symbolP->sy_type&N_TYPE)!=N_ABS || symbolP->sy_frag==&zero_address_frag );
  917.               target +=
  918.                 symbolP -> sy_value
  919.               + symbolP -> sy_frag -> fr_address;
  920. --- 1142,1153 ----
  921.           target = offset;
  922.           if (symbolP)
  923.             {
  924. !             know(S_IS_ABS(symbolP) ||
  925. !              S_IS_DATA(symbolP) ||
  926. !              S_IS_TEXT(symbolP))
  927. !             know(symbolP -> sy_frag);
  928. !             know(!S_IS_ABS(symbolP) || 
  929. !              symbolP->sy_frag==&zero_address_frag );
  930.               target +=
  931.                 symbolP -> sy_value
  932.               + symbolP -> sy_frag -> fr_address;
  933. ***************
  934. *** 1021,1045 ****
  935.         add_number  = fixP  -> fx_offset;
  936.         pcrel      = fixP  -> fx_pcrel;
  937.         if(add_symbolP)
  938. !     add_symbol_N_TYPE = add_symbolP -> sy_type & N_TYPE;
  939.         if (sub_symbolP)
  940.       {
  941.         if(!add_symbolP)    /* Its just -sym */
  942.           {
  943. !           if(sub_symbolP->sy_type!=N_ABS)
  944. !             as_warn("Negative of non-absolute symbol %s", sub_symbolP->sy_name);
  945. !           add_number-=sub_symbolP->sy_value;
  946.           }
  947. !       else if (   ((sub_symbolP -> sy_type ^ add_symbol_N_TYPE) & N_TYPE) == 0
  948. !           && (   add_symbol_N_TYPE == N_DATA
  949. !           || add_symbol_N_TYPE == N_TEXT
  950. !           || add_symbol_N_TYPE == N_BSS
  951. !           || add_symbol_N_TYPE == N_ABS))
  952.           {
  953.             /* Difference of 2 symbols from same segment. */
  954.             /* Can't make difference of 2 undefineds: 'value' means */
  955.             /* something different for N_UNDF. */
  956. !           add_number += add_symbolP -> sy_value - sub_symbolP -> sy_value;
  957.             add_symbolP = NULL;
  958.             fixP -> fx_addsy = NULL;
  959.           }
  960. --- 1299,1328 ----
  961.         add_number  = fixP  -> fx_offset;
  962.         pcrel      = fixP  -> fx_pcrel;
  963.         if(add_symbolP)
  964. !     add_symbol_N_TYPE = SEG_seg(S_GET_SEGMENT(add_symbolP));
  965.         if (sub_symbolP)
  966.       {
  967.         if(!add_symbolP)    /* Its just -sym */
  968.           {
  969. !           if(SEG_seg(sub_symbolP->sy_type)!=SEG_ABSOLUTE)
  970. !             as_warn("Negative of non-absolute symbol %s", 
  971. !             S_GET_NAME(sub_symbolP));
  972. !           add_number-=S_GET_VALUE(sub_symbolP);
  973.           }
  974. !       /* if sub_symbol is in the same segment that add_symbol
  975. !          and add_symbol is either in DATA, TEXT, BSS or ABSOLUTE */
  976. !       else if((SEG_seg(S_GET_SEGMENT(sub_symbolP)) == 
  977. !            add_symbol_N_TYPE) &&
  978. !           ((add_symbol_N_TYPE == SEG_DATA) ||
  979. !            (add_symbol_N_TYPE == SEG_TEXT) ||
  980. !            (add_symbol_N_TYPE == SEG_BSS)  ||
  981. !            (add_symbol_N_TYPE == SEG_ABSOLUTE)))
  982.           {
  983.             /* Difference of 2 symbols from same segment. */
  984.             /* Can't make difference of 2 undefineds: 'value' means */
  985.             /* something different for N_UNDF. */
  986. !           add_number += S_GET_VALUE(add_symbolP) - 
  987. !                     S_GET_VALUE(sub_symbolP);
  988.             add_symbolP = NULL;
  989.             fixP -> fx_addsy = NULL;
  990.           }
  991. ***************
  992. *** 1046,1059 ****
  993.         else
  994.           {
  995.             /* Different segments in subtraction. */
  996. !           know( sub_symbolP -> sy_type != (N_ABS | N_EXT))
  997. !         if (sub_symbolP -> sy_type == N_ABS)
  998. !             add_number -= sub_symbolP -> sy_value;
  999.           else
  1000.             {
  1001. !                as_warn("Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %d.",
  1002. !                     seg_name[(int)N_TYPE_seg[sub_symbolP->sy_type&N_TYPE]],
  1003. !                     sub_symbolP -> sy_name, fragP -> fr_address + where);
  1004.             }
  1005.           }
  1006.       }
  1007. --- 1329,1342 ----
  1008.         else
  1009.           {
  1010.             /* Different segments in subtraction. */
  1011. !           know(!(S_IS_EXTERNAL(sub_symbolP) && S_IS_ABS(sub_symbolP)));
  1012. !         if (S_IS_ABS(sub_symbolP))
  1013. !             add_number -= S_GET_VALUE(sub_symbolP);
  1014.           else
  1015.             {
  1016. !             as_warn("Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %d.",
  1017. !               segment_name((int)SEG_seg(S_GET_SEGMENT(sub_symbolP))),
  1018. !               S_GET_NAME(sub_symbolP), fragP -> fr_address + where);
  1019.             }
  1020.           }
  1021.       }
  1022. ***************
  1023. *** 1066,1072 ****
  1024.              * SEG_UNKNOWN, but it is now in the local segment.
  1025.              * So we know how to do the address without relocation.
  1026.              */
  1027. !           add_number += add_symbolP -> sy_value;
  1028.             add_number -= size + where + fragP -> fr_address;
  1029.             pcrel = 0;    /* Lie. Don't want further pcrel processing. */
  1030.             fixP -> fx_addsy = NULL; /* No relocations please. */
  1031. --- 1349,1355 ----
  1032.              * SEG_UNKNOWN, but it is now in the local segment.
  1033.              * So we know how to do the address without relocation.
  1034.              */
  1035. !           add_number += S_GET_VALUE(add_symbolP);
  1036.             add_number -= size + where + fragP -> fr_address;
  1037.             pcrel = 0;    /* Lie. Don't want further pcrel processing. */
  1038.             fixP -> fx_addsy = NULL; /* No relocations please. */
  1039. ***************
  1040. *** 1082,1101 ****
  1041.           {
  1042.             switch (add_symbol_N_TYPE)
  1043.           {
  1044. !         case N_ABS:
  1045. !           add_number += add_symbolP -> sy_value;
  1046.             fixP -> fx_addsy = NULL;
  1047.             add_symbolP = NULL;
  1048.             break;
  1049.             
  1050. !         case N_BSS:
  1051. !         case N_DATA:
  1052. !         case N_TEXT:
  1053.             seg_reloc_count ++;
  1054. !           add_number += add_symbolP -> sy_value;
  1055.             break;
  1056.             
  1057. !         case N_UNDF:
  1058.             seg_reloc_count ++;
  1059.             break;
  1060.             
  1061. --- 1365,1388 ----
  1062.           {
  1063.             switch (add_symbol_N_TYPE)
  1064.           {
  1065. !         case SEG_ABSOLUTE:
  1066. !           add_number += S_GET_VALUE(add_symbolP);
  1067.             fixP -> fx_addsy = NULL;
  1068.             add_symbolP = NULL;
  1069.             break;
  1070.             
  1071. !         case SEG_BSS:
  1072. !         case SEG_DATA:
  1073. !         case SEG_TEXT:
  1074.             seg_reloc_count ++;
  1075. !           add_number += S_GET_VALUE(add_symbolP);
  1076.             break;
  1077.             
  1078. !         case SEG_UNKNOWN:
  1079. ! #ifdef coff
  1080. !           if(S_IS_COMMON(add_symbolP))
  1081. !               add_number += S_GET_VALUE(add_symbolP);
  1082. ! #endif /* coff */
  1083.             seg_reloc_count ++;
  1084.             break;
  1085.             
  1086. ***************
  1087. *** 1125,1131 ****
  1088.       case 0:
  1089.   #ifdef SPARC
  1090.         fixP->fx_addnumber = add_number;
  1091. !       md_number_to_imm(place, add_number, size, fixP, this_segment_type);
  1092.   #else
  1093.         md_number_to_imm (place, add_number, size);
  1094.         /* OVE: the immediates, like disps, have lsb at lowest address */
  1095. --- 1412,1419 ----
  1096.       case 0:
  1097.   #ifdef SPARC
  1098.         fixP->fx_addnumber = add_number;
  1099. !       md_number_to_imm(place, add_number, size, fixP, 
  1100. !                seg_SEG(this_segment_type));
  1101.   #else
  1102.         md_number_to_imm (place, add_number, size);
  1103.         /* OVE: the immediates, like disps, have lsb at lowest address */
  1104. ***************
  1105. *** 1149,1215 ****
  1106.     return (seg_reloc_count);
  1107.   }                /* fixup_segment() */
  1108.   
  1109. - 
  1110. - /* The sparc needs its own emit_relocations() */
  1111. - #ifndef SPARC
  1112. - /*
  1113. -  *        emit_relocations()
  1114. -  *
  1115. -  * Crawl along a fixS chain. Emit the segment's relocations.
  1116. -  */
  1117. - static void
  1118. - emit_relocations (fixP, segment_address_in_file)
  1119. -      register fixS *    fixP;    /* Fixup chain for this segment. */
  1120. -      relax_addressT    segment_address_in_file;
  1121. - {
  1122. -   struct relocation_info    ri;
  1123. -   register symbolS *        symbolP;
  1124. - 
  1125. -     /* JF this is for paranoia */
  1126. -   bzero((char *)&ri,sizeof(ri));
  1127. -   for ( ;  fixP;  fixP = fixP -> fx_next)
  1128. -     {
  1129. -       if (symbolP = fixP -> fx_addsy)
  1130. -     {
  1131. - 
  1132. - #ifndef hpux
  1133. -         /* These two 'cuz of NS32K */
  1134. -       ri . r_bsr        = fixP -> fx_bsr;
  1135. -       ri . r_disp        = fixP -> fx_im_disp;
  1136. - #endif
  1137. - 
  1138. -       ri . r_length        = nbytes_r_length [fixP -> fx_size];
  1139. -       ri . r_pcrel        = fixP -> fx_pcrel;
  1140. -       ri . r_address    = fixP -> fx_frag -> fr_address
  1141. -         +   fixP -> fx_where
  1142. -           - segment_address_in_file;
  1143. -       if ((symbolP -> sy_type & N_TYPE) == N_UNDF)
  1144. -         {
  1145. -           ri . r_extern    = 1;
  1146. -           ri . r_symbolnum    = symbolP -> sy_number;
  1147. -         }
  1148. -       else
  1149. -         {
  1150. -           ri . r_extern    = 0;
  1151. -           ri . r_symbolnum    = symbolP -> sy_type & N_TYPE;
  1152. -         }
  1153. - 
  1154. -       /* 
  1155. -         The 68k machines assign bit-fields from higher bits to 
  1156. -         lower bits ("left-to-right") within the int.  VAXen assign 
  1157. -         bit-fields from lower bits to higher bits ("right-to-left").
  1158. -         Both handle multi-byte numbers in their usual fashion
  1159. -         (Big-endian and little-endian stuff).
  1160. -         Thus we need a machine dependent routine to make
  1161. -         sure the structure is written out correctly.  FUN!
  1162. -        */
  1163. -       md_ri_to_chars((char *) &ri, ri); 
  1164. -       append (&next_object_file_charP, (char *)& ri, (unsigned long)sizeof(ri));
  1165. -     }
  1166. -     }
  1167. - 
  1168. - }
  1169. - #endif
  1170.   
  1171.   int
  1172.   is_dnrange(f1,f2)
  1173. --- 1437,1442 ----
  1174. *** write.h    Tue May 30 20:36:06 1989
  1175. --- /lasvegas/spare/usenet/port/gas-1.36/write.h    Wed Sep 12 09:29:10 1990
  1176. ***************
  1177. *** 72,77 ****
  1178. --- 72,79 ----
  1179.   COMMON fixS *    data_fix_root;    /* Chains fixSs. */
  1180.   COMMON fixS **    seg_fix_rootP;    /* -> one of above. */
  1181.   
  1182. + COMMON char *    next_object_file_charP;
  1183. + 
  1184.   bit_fixS *bit_fix_new();
  1185.   /* end: write.h */
  1186.   
  1187. *** xmalloc.c    Wed Mar  1 23:48:34 1989
  1188. --- /lasvegas/spare/usenet/port/gas-1.36/xmalloc.c    Wed Sep 12 09:28:43 1990
  1189. ***************
  1190. *** 43,48 ****
  1191. --- 43,50 ----
  1192.   #include <malloc.h>
  1193.   #endif
  1194.   
  1195. + #define error as_fatal
  1196. + 
  1197.   char * xmalloc(n)
  1198.        long n;
  1199.   {
  1200. *** xrealloc.c    Wed Mar  1 23:48:33 1989
  1201. --- /lasvegas/spare/usenet/port/gas-1.36/xrealloc.c    Wed Sep 12 09:28:43 1990
  1202. ***************
  1203. *** 45,50 ****
  1204. --- 45,52 ----
  1205.   #include <malloc.h>
  1206.   #endif
  1207.   
  1208. + #define error as_fatal
  1209. + 
  1210.   char   *
  1211.   xrealloc (ptr, n)
  1212.   register char  *ptr;
  1213. --
  1214. Loic Dachary     loic@adesign.uucp or loic@afp.uucp 
  1215. Voice        +33 1 40 35 20 20
  1216.