home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / misc / volume23 / xenix-gnu / part03 / gas-1.38.pch
Encoding:
Text File  |  1991-09-27  |  46.2 KB  |  1,773 lines
  1. *** gas-1.38/Makefile    Thu Oct 18 15:26:42 1990
  2. --- Makefile    Fri Jul 12 06:02:10 1991
  3. ***************
  4. *** 50,55 ****
  5. --- 50,61 ----
  6.   # and un-comment the next two lines.
  7.   # G0 = -g -I. -DUSE_SYSTEM_HDR -DEXEC_VERSION=1
  8.   # LOADLIBES = -lc /usr/att/lib/libc.a
  9. + #
  10. + # To compile gas for a Xenix 386, comment out all the above lines,
  11. + # and un-comment the next two lines.  (If you are using GCC, comment out the
  12. + # alloca.o part) (Get alloca from the emacs distribution, or use GCC.)
  13. + G0 = -O -I. -DUSG -DWORKING_DOT_WORD
  14. + LOADLIBES = alloca.o -lmalloc
  15.   
  16.   # If you just want to compile the vax assembler, type 'make avax'
  17.   
  18. ***************
  19. *** 129,134 ****
  20. --- 135,144 ----
  21.   CFLAGS = $(G0) $(G1) $(G2) $(G3) $(G4)
  22.   
  23.   #
  24. + #
  25. + # To make the XENIX 386 assembler compile as the default, un-comment the next
  26. + # line and commment out all the other lines that start with DEFAULT_GAS
  27. + #DEFAULT_GAS=ax386
  28.   # To make the 68020 assembler compile as the default, un-comment the next
  29.   # line, and comment out all the other lines that start with DEFAULT_GAS
  30.   DEFAULT_GAS=a68
  31. ***************
  32. *** 245,250 ****
  33. --- 255,269 ----
  34.   
  35.   a386: $a $x
  36.       $(CC) -o a386 $(LDFLAGS) $a $x $(LOADLIBES)
  37. + 
  38. + # XENIX 80386 GAS --------------------------------------------------------------
  39. + u = xenixomf.o omfwrite.o
  40. + U = xenixomf.c xenixomf.h msomf.h omfwrite.c
  41. + 
  42. + xenixomf.o:    xenixomf.h msomf.h
  43. + 
  44. + ax386: $a $x $u
  45. +     $(CC) -o ax386 $(LDFLAGS) $a $u $x $(LOADLIBES)
  46.   
  47.   # 68020 GAS ------------------------------------------------------------------
  48.   y = m68k.o  atof-ieee.o write.o read.o
  49. *** gas-1.38/as.c    Thu Oct 11 11:26:17 1990
  50. --- as.c    Wed Jul 10 09:01:54 1991
  51. ***************
  52. *** 84,89 ****
  53. --- 84,90 ----
  54.       myname=argv[0];
  55.       bzero (flagseen, sizeof(flagseen)); /* aint seen nothing yet */
  56.       out_file_name    = "a.out";    /* default .o file */
  57. +     module_name = "unknown.s";
  58.       symbol_begin();        /* symbols.c */
  59.       subsegs_begin();        /* subsegs.c */
  60.       read_begin();            /* read.c */
  61. *** gas-1.38/as.h    Thu Oct 11 11:26:18 1990
  62. --- as.h    Wed Jul 10 09:01:58 1991
  63. ***************
  64. *** 286,291 ****
  65. --- 286,292 ----
  66.   
  67.   COMMON int    need_pass_2;    /* TRUE if we need a second pass. */
  68.   
  69. + COMMON char *module_name;    /* Name given in the file directive */
  70.   
  71.   #endif                /* #ifdef asH */
  72.   
  73. *** gas-1.38/config.h
  74. --- config.h    Wed Jul 10 09:16:07 1991
  75. ***************
  76. *** 0 ****
  77. --- 1 ----
  78. + #define XENIX
  79. *** gas-1.38/msomf.h
  80. --- msomf.h    Wed Jul 10 09:02:22 1991
  81. ***************
  82. *** 0 ****
  83. --- 1,24 ----
  84. + 
  85. + /* Segment indexes for segdefs */
  86. + 
  87. + #define SDEF_TEXT    1
  88. + #define SDEF_DATA    2
  89. + #define SDEF_CONST    3
  90. + #define SDEF_BSS    4
  91. + #define SDEF_SYMBOLS    5
  92. + #define SDEF_TYPES    6
  93. + #define SDEF_SIZE    4
  94. + #define SDEF_G_SIZE    6
  95. + 
  96. + #define GDEF_DGROUP    1
  97. + 
  98. + #define I386        1
  99. + #define FRAME_THREAD    1
  100. + #define TARGET_THREAD    0
  101. + 
  102. + #define TEXT_FRAME_THREAD    0
  103. + #define DGROUP_FRAME_THREAD    1
  104. + #define CONST_TGT_THREAD    0
  105. + #define DATA_TGT_THREAD        1
  106. + #define TEXT_TGT_THREAD        2
  107. + #define BSS_TGT_THREAD        3
  108. *** gas-1.38/omfwrite.c
  109. --- omfwrite.c    Wed Jul 10 09:02:24 1991
  110. ***************
  111. *** 0 ****
  112. --- 1,672 ----
  113. + /* write.c - emit .o file - Copyright(C)1986 Free Software Foundation, Inc.
  114. +    Copyright (C) 1986,1987 Free Software Foundation, Inc.
  115. + 
  116. + This file is part of GAS, the GNU Assembler.
  117. + 
  118. + GAS is free software; you can redistribute it and/or modify
  119. + it under the terms of the GNU General Public License as published by
  120. + the Free Software Foundation; either version 1, or (at your option)
  121. + any later version.
  122. + 
  123. + GAS is distributed in the hope that it will be useful,
  124. + but WITHOUT ANY WARRANTY; without even the implied warranty of
  125. + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  126. + GNU General Public License for more details.
  127. + 
  128. + You should have received a copy of the GNU General Public License
  129. + along with GAS; see the file COPYING.  If not, write to
  130. + the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  131. + 
  132. + #include "as.h"
  133. + #include "md.h"
  134. + #include "subsegs.h"
  135. + #include "obstack.h"
  136. + #include "struc-symbol.h"
  137. + #include "write.h"
  138. + #include "symbols.h"
  139. + 
  140. + #include "xenixomf.h"
  141. + #include "msomf.h"
  142. + 
  143. + #if __STDC__
  144. + #include <stddef.h>
  145. + #else
  146. + #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
  147. + #endif
  148. + 
  149. + void    append();
  150. + 
  151. + /*
  152. +  * In: length of relocation (or of address) in chars: 1, 2 or 4.
  153. +  * Out: OMF LOC type.
  154. +  */
  155. + 
  156. + static unsigned char nbytes_r_length [] = {
  157. +   15, LOC_LOBYTE, LOC_OFFSET, 15, LOC_OFFSET32
  158. +   };
  159. + 
  160. + 
  161. + static struct frag *    text_frag_root;
  162. + static struct frag *    data_frag_root;
  163. + 
  164. + static struct frag *    text_last_frag;    /* Last frag in segment. */
  165. + static struct frag *    data_last_frag;    /* Last frag in segment. */
  166. + 
  167. + static struct exec    the_exec;
  168. + 
  169. + static long int string_byte_count;
  170. + static long int stab_symbol_count;
  171. + 
  172. + void    relax_segment();
  173. + long int    fixup_segment();
  174. + 
  175. + static void threads(type, trgt_thrd, frm_thrd)
  176. + int type;
  177. + int *trgt_thrd, *frm_thrd;
  178. + {
  179. +       switch (type)
  180. +       {
  181. +         case PRIVDATA:    *trgt_thrd = DATA_TGT_THREAD;
  182. +                 *frm_thrd = DGROUP_FRAME_THREAD;
  183. +                 break;
  184. +         case PRIVBSS:    *trgt_thrd = BSS_TGT_THREAD;
  185. +                 *frm_thrd = DGROUP_FRAME_THREAD;
  186. +                 break;
  187. +         case PRIVTEXT:    *trgt_thrd = TEXT_TGT_THREAD;
  188. +                 *frm_thrd = TEXT_FRAME_THREAD;
  189. +                 break;
  190. +         case PUBLICDATA:    *trgt_thrd = DATA_TGT_THREAD;
  191. +                 *frm_thrd = DGROUP_FRAME_THREAD;
  192. +                 break;
  193. +         case PUBLICTEXT:    *trgt_thrd = TEXT_TGT_THREAD;
  194. +                 *frm_thrd = TEXT_FRAME_THREAD;
  195. +                 break;
  196. +         default:        *trgt_thrd = CONST_TGT_THREAD;
  197. +                 *frm_thrd = DGROUP_FRAME_THREAD;
  198. +                 break;
  199. +       }
  200. + }
  201. + 
  202. + void
  203. + write_object_file()
  204. + {
  205. +   register struct frchain *    frchainP; /* Track along all frchains. */
  206. +   register fragS *        fragP;    /* Track along all frags. */
  207. +   register struct frchain *    next_frchainP;
  208. +   register fragS * *        prev_fragPP;
  209. +   register char *        name;
  210. +   register symbolS *        symbolP;
  211. +   register symbolS **        symbolPP;
  212. +   /* register fixS *        fixP; JF unused */
  213. +   unsigned long
  214. +       text_siz,
  215. +     data_siz,
  216. +     syms_siz,
  217. +     tr_siz,
  218. +     dr_siz;
  219. +   void output_file_create();
  220. +   void output_file_append();
  221. +   void output_file_close();
  222. +   extern long omagic;        /* JF magic # to write out.  Is different for
  223. +                    Suns and Vaxen and other boxes */
  224. + 
  225. +   /*
  226. +    * After every sub-segment, we fake an ".align ...". This conforms to BSD4.2
  227. +    * brane-damage. We then fake ".fill 0" because that is the kind of frag
  228. +    * that requires least thought. ".align" frags like to have a following
  229. +    * frag since that makes calculating their intended length trivial.
  230. +    */
  231. + #define SUB_SEGMENT_ALIGN (2)
  232. +   for ( frchainP=frchain_root; frchainP; frchainP=frchainP->frch_next )
  233. +     {
  234. +       subseg_new (frchainP -> frch_seg, frchainP -> frch_subseg);
  235. +       frag_align (SUB_SEGMENT_ALIGN, 0);
  236. +                 /* frag_align will have left a new frag. */
  237. +                 /* Use this last frag for an empty ".fill". */
  238. +       /*
  239. +        * For this segment ...
  240. +        * Create a last frag. Do not leave a "being filled in frag".
  241. +        */
  242. +       frag_wane (frag_now);
  243. +       frag_now -> fr_fix    = 0;
  244. +       know( frag_now -> fr_next == NULL );
  245. +       /* know( frags . obstack_c_base == frags . obstack_c_next_free ); */
  246. +       /* Above shows we haven't left a half-completed object on obstack. */
  247. +     }
  248. + 
  249. +   /*
  250. +    * From now on, we don't care about sub-segments.
  251. +    * Build one frag chain for each segment. Linked thru fr_next.
  252. +    * We know that there is at least 1 text frchain & at least 1 data frchain.
  253. +    */
  254. +   prev_fragPP = &text_frag_root;
  255. +   for ( frchainP=frchain_root; frchainP; frchainP=next_frchainP )
  256. +     {
  257. +       know( frchainP -> frch_root );
  258. +       * prev_fragPP = frchainP -> frch_root;
  259. +       prev_fragPP = & frchainP -> frch_last -> fr_next;
  260. +       if (   ((next_frchainP = frchainP->frch_next) == NULL)
  261. +       || next_frchainP == data0_frchainP)
  262. +     {
  263. +       prev_fragPP = & data_frag_root;
  264. +       if ( next_frchainP )
  265. +         {
  266. +           text_last_frag = frchainP -> frch_last;
  267. +         }
  268. +       else
  269. +         {
  270. +           data_last_frag = frchainP -> frch_last;
  271. +         }
  272. +     }
  273. +     }                /* for(each struct frchain) */
  274. + 
  275. +   relax_segment (text_frag_root, SEG_TEXT);
  276. +   relax_segment (data_frag_root, SEG_DATA);
  277. +   /*
  278. +    * Now the addresses of frags are correct within the segment.
  279. +    */
  280. + 
  281. +   text_siz=text_last_frag->fr_address;
  282. + 
  283. +   /*
  284. +    *
  285. +    * Determine a_data [length of data segment].
  286. +    */
  287. +   if (data_frag_root)
  288. +       data_siz=data_last_frag->fr_address;
  289. +   else
  290. +       data_siz = 0;
  291. + 
  292. +   bss_address_frag . fr_address = 0;
  293. +           
  294. +   /*
  295. +    *
  296. +    * Crawl the symbol chain.
  297. +    *
  298. +    * For each symbol whose value depends on a frag, take the address of
  299. +    * that frag and subsume it into the value of the symbol.
  300. +    * After this, there is just one way to lookup a symbol value.
  301. +    * Values are left in their final state for object file emission.
  302. +    * We adjust the values of 'L' local symbols, even if we do
  303. +    * not intend to emit them to the object file, because their values
  304. +    * are needed for fix-ups.
  305. +    *
  306. +    * Unless we saw a -L flag, remove all symbols that begin with 'L'
  307. +    * from the symbol chain.
  308. +    *
  309. +    * Count the (length of the nlists of the) (remaining) symbols.
  310. +    * Assign a symbol number to each symbol.
  311. +    * Count the number of string-table chars we will emit.
  312. +    *
  313. +    */
  314. +   string_byte_count = sizeof( string_byte_count );
  315. + 
  316. +   /* JF deal with forward references first. . . */
  317. +   for(symbolP=symbol_rootP;symbolP;symbolP=symbolP->sy_next) {
  318. +       if(symbolP->sy_forward) {
  319. +         symbolP->sy_value+=symbolP->sy_forward->sy_value+symbolP->sy_forward->sy_frag->fr_address;
  320. +         symbolP->sy_forward=0;
  321. +     }
  322. +   }
  323. +   symbolPP = & symbol_rootP;    /* -> last symbol chain link. */
  324. +   {
  325. +     register long int        symbol_number;
  326. + 
  327. +     symbol_number = 1;  stab_symbol_count = 0;
  328. + 
  329. +     while (symbolP  = * symbolPP)
  330. +       {
  331. +     name = symbolP -> sy_name;
  332. +     symbolP -> sy_value += symbolP -> sy_frag -> fr_address;
  333. +     if ( !name || (symbolP->sy_nlist.n_type&N_STAB)
  334. +         || (name[0]!='\001' && (flagseen ['L'] || name [0] != 'L' )))
  335. +       {
  336. +         if (EXTDEF(symbolP->sy_nlist.n_type))
  337. +             symbolP -> sy_number = symbol_number ++;
  338. +         else
  339. +             symbolP -> sy_number = 0;
  340. +         if (symbolP->sy_nlist.n_type&N_STAB)
  341. +         stab_symbol_count++;
  342. +         if (name && symbolP->sy_nlist.n_type&N_STAB)
  343. +           {            /* Ordinary case. */
  344. +         symbolP -> sy_name_offset = string_byte_count;
  345. +         string_byte_count += strlen (symbolP  -> sy_name) + 1;
  346. +           }
  347. +         else            /* .Stabd case. */
  348. +         symbolP -> sy_name_offset = 0;
  349. +         symbolPP = & (symbolP -> sy_next);
  350. +       }
  351. +     else
  352. +         * symbolPP = symbolP -> sy_next;
  353. +       }                /* for each symbol */
  354. + 
  355. +     syms_siz = sizeof( struct nlist) * symbol_number;
  356. +   }
  357. + 
  358. +   /*
  359. +    * Addresses of frags now reflect addresses we use in the object file.
  360. +    * Symbol values are correct.
  361. +    * Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
  362. +    * Also converting any machine-dependent frags using md_convert_frag();
  363. +    */
  364. +   subseg_change( SEG_TEXT, 0);
  365. + 
  366. +   for (fragP = text_frag_root;  fragP;  fragP = fragP -> fr_next)
  367. +     {
  368. +       switch (fragP -> fr_type)
  369. +     {
  370. +     case rs_align:
  371. +     case rs_org:
  372. +       fragP -> fr_type = rs_fill;
  373. +       know( fragP -> fr_var == 1 );
  374. +       know( fragP -> fr_next );
  375. +       fragP -> fr_offset
  376. +         =     fragP -> fr_next -> fr_address
  377. +           -   fragP -> fr_address
  378. +         - fragP -> fr_fix;
  379. +       break;
  380. + 
  381. +     case rs_fill:
  382. +       break;
  383. + 
  384. +     case rs_machine_dependent:
  385. +       md_convert_frag (fragP);
  386. +       /*
  387. +        * After md_convert_frag, we make the frag into a ".space 0".
  388. +        * Md_convert_frag() should set up any fixSs and constants
  389. +        * required.
  390. +        */
  391. +       frag_wane (fragP);
  392. +       break;
  393. + 
  394. +     default:
  395. +       BAD_CASE( fragP -> fr_type );
  396. +       break;
  397. +     }            /* switch (fr_type) */
  398. +     }                /* for each frag. */
  399. + 
  400. + 
  401. +   subseg_change( SEG_DATA, 0);
  402. + 
  403. +   for (fragP = data_frag_root;  fragP;  fragP = fragP -> fr_next)
  404. +     {
  405. +       switch (fragP -> fr_type)
  406. +     {
  407. +     case rs_align:
  408. +     case rs_org:
  409. +       fragP -> fr_type = rs_fill;
  410. +       know( fragP -> fr_var == 1 );
  411. +       know( fragP -> fr_next );
  412. +       fragP -> fr_offset
  413. +         =     fragP -> fr_next -> fr_address
  414. +           -   fragP -> fr_address
  415. +         - fragP -> fr_fix;
  416. +       break;
  417. + 
  418. +     case rs_fill:
  419. +       break;
  420. + 
  421. +     case rs_machine_dependent:
  422. +       md_convert_frag (fragP);
  423. +       /*
  424. +        * After md_convert_frag, we make the frag into a ".space 0".
  425. +        * Md_convert_frag() should set up any fixSs and constants
  426. +        * required.
  427. +        */
  428. +       frag_wane (fragP);
  429. +       break;
  430. + 
  431. +     default:
  432. +       BAD_CASE( fragP -> fr_type );
  433. +       break;
  434. +     }            /* switch (fr_type) */
  435. +     }                /* for each frag. */
  436. + 
  437. +   subseg_change( SEG_TEXT, 0);
  438. + 
  439. +   fixup_segment (text_fix_root, N_TEXT);
  440. +   fixup_segment (data_fix_root, N_DATA);
  441. +   output_file_create (out_file_name);
  442. +   omf_initialize_a_out(module_name, text_siz, data_siz,
  443. +                (long) local_bss_counter, 0L,
  444. +                flagseen['g'], stab_symbol_count * sizeof(struct nlist),
  445. +                string_byte_count);
  446. + 
  447. + /*  Traverse the symbol chain emitting external symbol definitions
  448. +  *  for external, public and common symbols.
  449. +  */
  450. + 
  451. +   for (   symbolP = symbol_rootP;   symbolP;   symbolP = symbolP -> sy_next   )
  452. +   {
  453. +       if (EXTDEF(symbolP->sy_type))
  454. +       {
  455. +           if (COMMDEF(symbolP->sy_type))
  456. +           {
  457. +               omf_start_comdef();
  458. +               omf_comdef(symbolP->sy_name, TD_CNEAR, symbolP->sy_value, 0L);
  459. +               omf_end_comdef();
  460. +           }
  461. +           else
  462. +               omf_extdef(symbolP->sy_name, 0);
  463. +       }
  464. +   }
  465. + 
  466. + /*  Traverse the symbol chain emitting public definitions
  467. +  */
  468. + 
  469. +   for (   symbolP = symbol_rootP;   symbolP;   symbolP = symbolP -> sy_next   )
  470. +   {
  471. +     if (PUBLIC(symbolP->sy_type))
  472. +     {
  473. +         unsigned int group = 0, segment = 0;
  474. + 
  475. +         if (symbolP->sy_type == PUBLICTEXT)
  476. +             segment = SDEF_TEXT;
  477. +         if (symbolP->sy_type == PUBLICDATA)
  478. +         {
  479. +             group = GDEF_DGROUP;  segment = SDEF_DATA;
  480. +         }
  481. +         
  482. +         omf_start_pubdef(I386, group, segment, 0);
  483. +         omf_pubdef(I386, symbolP->sy_name, symbolP->sy_value, 0);
  484. +         omf_end_pubdef();
  485. +     }
  486. +   }
  487. +   
  488. + 
  489. +   /* Setup threads for DGROUP and the segments ready for relocation */
  490. + 
  491. +   omf_start_thread(I386);
  492. +   omf_thread(CONST_TGT_THREAD, TARGET_THREAD, FRM_SI, SDEF_CONST);
  493. +   omf_thread(DATA_TGT_THREAD, TARGET_THREAD, FRM_SI, SDEF_DATA);
  494. +   omf_thread(TEXT_TGT_THREAD, TARGET_THREAD, FRM_SI, SDEF_TEXT);
  495. +   omf_thread(BSS_TGT_THREAD, TARGET_THREAD, FRM_SI, SDEF_BSS);
  496. +   omf_thread(TEXT_FRAME_THREAD, FRAME_THREAD, FRM_SI, SDEF_TEXT);
  497. +   omf_thread(DGROUP_FRAME_THREAD, FRAME_THREAD, FRM_GI, GDEF_DGROUP);
  498. +   omf_end_thread();
  499. +   
  500. +   /*
  501. +    * Emit code.
  502. +    */
  503. + 
  504. +   for (fragP = data_frag_root;  fragP;  fragP = fragP -> fr_next)
  505. +   {
  506. +       register long int count;
  507. +       register char * fill_literal;
  508. +       register long int fill_size;
  509. +       register fixS * fixP;
  510. +       register symbolS * symbolP;
  511. +       int started_fixup;
  512. + 
  513. +       know( fragP -> fr_type == rs_fill );
  514. + 
  515. +       if (fragP->fr_fix != 0 || fragP->fr_offset != 0)
  516. +       {
  517. +           omf_start_ledata(I386, SDEF_DATA, fragP->fr_address);
  518. +           if (fragP->fr_fix != 0)
  519. +               omf_ledata(fragP->fr_literal, (int)fragP->fr_fix);
  520. +           fill_literal = fragP->fr_literal + fragP -> fr_fix;
  521. +           fill_size = fragP->fr_var;
  522. +           count = fragP -> fr_offset;
  523. +       if ((fragP->fr_fix + count * fill_size) < 1016)
  524. +       {
  525. +               for ( ; count; count--)
  526. +                   omf_ledata(fill_literal, (int)fill_size);
  527. +       }
  528. +       else  /* filling will exceed the 1024 byte record size */
  529. +       {
  530. +           /* This code assumes that fill_size <= 8 bytes.
  531. +            * This is infact the case because of
  532. +            * compatability with other assemblers 
  533. +            */
  534. +           register int fcount;
  535. + 
  536. +           fcount = (1016 - fragP->fr_fix) / fill_size;
  537. +           count -= fcount;
  538. +           for ( ; fcount > 0; fcount--)
  539. +                   omf_ledata(fill_literal, (int)fill_size);
  540. +           
  541. +       }
  542. +           omf_end_ledata();
  543. + 
  544. +           /* Emit the relocations for this frag
  545. +            */
  546. + 
  547. +           fixP = data_fix_root;  started_fixup = 0;
  548. +           for ( ;  fixP;  fixP = fixP -> fx_next)
  549. +           {
  550. +               if (fixP->fx_frag == fragP && (symbolP = fixP->fx_addsy))
  551. +               {
  552. +           int trgt_thrd, frm_thrd;
  553. +           int external = EXTDEF(symbolP->sy_type);
  554. + 
  555. +           threads(symbolP->sy_type, &trgt_thrd, &frm_thrd);
  556. +           if (fixP->fx_pcrel)
  557. +             frm_thrd = TEXT_FRAME_THREAD;
  558. + 
  559. +                   if (!started_fixup)
  560. +                   {
  561. +                       omf_start_fixup(I386);
  562. +                       started_fixup++;
  563. +                   }
  564. +                   omf_fixup(I386, !fixP->fx_pcrel,
  565. +                 nbytes_r_length [fixP->fx_size], fixP->fx_where,
  566. +                 external ? 0 : 1,
  567. +                 external ? FRM_TRGT : frm_thrd,
  568. +                 external ? 0 : 1,
  569. +                 external ? TGT_EI : trgt_thrd,
  570. +                 1, /* No offset */
  571. +             0, /* No frame required */
  572. +                 EXTDEF(symbolP->sy_type) ? symbolP->sy_number : 0,
  573. +             0);
  574. +           }
  575. +           }
  576. +           if (started_fixup)
  577. +               omf_end_fixup();
  578. +       
  579. +       while (count > 0)    /* still sum fill data to emit */
  580. +       {
  581. +           unsigned long address;
  582. +           unsigned int len;
  583. + 
  584. +               address = fragP->fr_address + fragP->fr_fix +
  585. +               (fragP->fr_offset - count) * fill_size;
  586. +               omf_start_ledata(I386, SDEF_DATA, address);
  587. +               for ( len = 0; count && (len < 1000); count--, len += fill_size)
  588. +                   omf_ledata(fill_literal, (int)fill_size);
  589. +               omf_end_ledata();
  590. +       }
  591. +       }
  592. +   }
  593. + 
  594. +   for (fragP = text_frag_root;  fragP;  fragP = fragP -> fr_next)
  595. +   {
  596. +       register long int count;
  597. +       register char * fill_literal;
  598. +       register long int fill_size;
  599. +       register fixS * fixP;
  600. +       register symbolS * symbolP;
  601. +       int started_fixup;
  602. + 
  603. +       know( fragP -> fr_type == rs_fill );
  604. + 
  605. +       if (fragP->fr_fix != 0 || fragP->fr_offset != 0)
  606. +       {
  607. +           omf_start_ledata(I386, SDEF_TEXT, fragP->fr_address);
  608. +           if (fragP->fr_fix != 0)
  609. +               omf_ledata(fragP->fr_literal, (int)fragP->fr_fix);
  610. +           fill_literal = fragP->fr_literal + fragP -> fr_fix;
  611. +           fill_size = fragP->fr_var;
  612. +           for (count = fragP -> fr_offset;  count;  count --)
  613. +               omf_ledata(fill_literal, (int)fill_size);
  614. +           omf_end_ledata();
  615. + 
  616. +           /* Emit the relocations for this frag
  617. +            */
  618. + 
  619. +           fixP = text_fix_root;  started_fixup = 0;
  620. +           for ( ;  fixP;  fixP = fixP -> fx_next)
  621. +           {
  622. +               if (fixP->fx_frag == fragP && (symbolP = fixP->fx_addsy))
  623. +               {
  624. +           int trgt_thrd, frm_thrd;
  625. +           int external = EXTDEF(symbolP->sy_type);
  626. + 
  627. +           threads(symbolP->sy_type, &trgt_thrd, &frm_thrd);
  628. +           if (fixP->fx_pcrel)
  629. +             frm_thrd = TEXT_FRAME_THREAD;
  630. + 
  631. +                   if (!started_fixup)
  632. +                   {
  633. +                       omf_start_fixup(I386);
  634. +                       started_fixup++;
  635. +                   }
  636. +                   omf_fixup(I386, !fixP->fx_pcrel,
  637. +                 nbytes_r_length [fixP->fx_size], fixP->fx_where,
  638. +                 external ? 0 : 1,
  639. +                 external ? FRM_TRGT : frm_thrd,
  640. +                 external ? 0 : 1,
  641. +                 external ? TGT_EI : trgt_thrd,
  642. +                 1, /* No offset */
  643. +             0, /* No frame required */
  644. +                 external ? symbolP->sy_number : 0,
  645. +             0);
  646. +           }
  647. +           }
  648. +           if (started_fixup)
  649. +               omf_end_fixup();
  650. +       }
  651. +   }
  652. + 
  653. + /*  Traverse the symbol chain emitting stabs.
  654. +  */
  655. + 
  656. + #define VAL_OFF offsetof(struct nlist, n_value)
  657. + 
  658. +   if (flagseen['g'] && stab_symbol_count)
  659. +   {   
  660. +       long count = 0, ncount = 0;
  661. +       symbolS *last_startP;
  662. +       char *temp;
  663. +       symbolS *fsymP;
  664. +       int i;
  665. +       int start_fixup = 0;
  666. + 
  667. +       omf_start_ledata(I386, SDEF_SYMBOLS, 0);
  668. +       last_startP = symbol_rootP;
  669. +       for (symbolP = symbol_rootP; symbolP; symbolP = symbolP -> sy_next)
  670. +       {
  671. +      if (symbolP->sy_nlist.n_type & N_STAB)
  672. +      {
  673. +             if ((ncount + 1) * sizeof(struct nlist) >= 1016)
  674. +             {
  675. +                omf_end_ledata();
  676. + 
  677. +                /* emit relocations */
  678. + 
  679. +                start_fixup = 0;
  680. +            for (i = 0, fsymP=last_startP; i < ncount; fsymP=fsymP->sy_next)
  681. +            {
  682. +               if (fsymP->sy_nlist.n_type & N_STAB)
  683. +           {
  684. +                      if (fsymP->sy_type & N_TYPE) /* if relocation required */
  685. +              {
  686. +                int trgt_thrd, frm_thrd;
  687. +                int external = EXTDEF(fsymP->sy_type & N_TYPE);
  688. + 
  689. +                threads(fsymP->sy_type & N_TYPE,&trgt_thrd,&frm_thrd);
  690. +                if (!start_fixup)
  691. +                {
  692. +                            omf_start_fixup(I386);
  693. +                start_fixup++;
  694. +                }
  695. +                omf_fixup(I386, 1, /* segment relative */
  696. +                   LOC_OFFSET32, i * sizeof(struct nlist) + VAL_OFF,
  697. +                   external ? 0 : 1,
  698. +                   external ? FRM_TRGT : frm_thrd,
  699. +                   external ? 0 : 1,
  700. +                   external ? TGT_EI : trgt_thrd,
  701. +                   1, /* No offset */
  702. +               0, /* No frame required */
  703. +                   external ? fsymP->sy_number : 0,
  704. +               0);
  705. +              }
  706. +              i++;
  707. +           }
  708. +            }
  709. +            if (start_fixup)
  710. +                   omf_end_fixup();
  711. + 
  712. +                /* start new segment */
  713. + 
  714. +                ncount = 0;  last_startP = symbolP;
  715. +                omf_start_ledata(I386, SDEF_SYMBOLS, count*sizeof(struct nlist));
  716. +             }
  717. +             temp = symbolP->sy_nlist.n_un.n_name;
  718. +             symbolP->sy_nlist.n_un.n_strx = symbolP->sy_name_offset;
  719. +             omf_ledata(&(symbolP->sy_nlist), sizeof(struct nlist));
  720. +             symbolP->sy_nlist.n_un.n_name = temp;
  721. +            ncount++;  count++;
  722. +      }
  723. +       }
  724. +       omf_end_ledata();
  725. +       start_fixup = 0;
  726. +       for (i = 0, fsymP = last_startP; i < ncount; fsymP = fsymP->sy_next)
  727. +       {
  728. +          if (fsymP->sy_nlist.n_type & N_STAB)
  729. +      {
  730. +             if (fsymP->sy_type & N_TYPE) /* if relocation required */
  731. +         {
  732. +           int trgt_thrd, frm_thrd;
  733. +           int external = EXTDEF(fsymP->sy_type & N_TYPE);
  734. + 
  735. +           threads(fsymP->sy_type & N_TYPE,&trgt_thrd,&frm_thrd);
  736. +           if (!start_fixup)
  737. +               {
  738. +                  omf_start_fixup(I386);
  739. +                  start_fixup++;
  740. +               }
  741. +           omf_fixup(I386, 1, /* segment relative */
  742. +              LOC_OFFSET32, i * sizeof(struct nlist) + VAL_OFF,
  743. +              external ? 0 : 1,
  744. +              external ? FRM_TRGT : frm_thrd,
  745. +              external ? 0 : 1,
  746. +              external ? TGT_EI : trgt_thrd,
  747. +              1, /* No offset */
  748. +                   0, /* No frame required */
  749. +              external ? fsymP->sy_number : 0,
  750. +           0);
  751. +         }
  752. +         i++;
  753. +      }
  754. +       }
  755. +       if (start_fixup)
  756. +          omf_end_fixup();
  757. + 
  758. +       count = sizeof(string_byte_count);  ncount = count;
  759. +       omf_start_ledata(I386, SDEF_TYPES, 0);
  760. +       omf_ledata(&string_byte_count, sizeof(string_byte_count));
  761. +       for (symbolP = symbol_rootP; symbolP; symbolP = symbolP -> sy_next)
  762. +       {
  763. +          if (symbolP->sy_nlist.n_type & N_STAB && symbolP -> sy_name)
  764. +      {
  765. +         int len = strlen(symbolP -> sy_name) + 1;
  766. + 
  767. +         if (ncount + len > 1016)
  768. +         {
  769. +            omf_end_ledata();
  770. +                omf_start_ledata(I386, SDEF_TYPES, count);
  771. +            ncount = 0;
  772. +         }
  773. +             omf_ledata(symbolP->sy_name, len);
  774. +         count += len;  ncount += len;
  775. +      }
  776. +       }
  777. +       omf_end_ledata();
  778. +   }
  779. +   
  780. + 
  781. +   omf_modend(I386);
  782. +   output_file_close (out_file_name);
  783. + 
  784. + }                /* write_object_file() */
  785. *** gas-1.38/read.c    Tue Oct 30 13:42:03 1990
  786. --- read.c    Wed Jul 10 12:53:36 1991
  787. ***************
  788. *** 711,717 ****
  789.       int    length;
  790.   
  791.       /* Some assemblers tolerate immediately following '"' */
  792. !     if ( s = demand_copy_string( & length ) ) {
  793.           new_logical_line (s, -1);
  794.           demand_empty_rest_of_line();
  795.       }
  796. --- 711,718 ----
  797.       int    length;
  798.   
  799.       /* Some assemblers tolerate immediately following '"' */
  800. !     if ( s = demand_copy_C_string( & length ) ) {
  801. !         module_name = s;
  802.           new_logical_line (s, -1);
  803.           demand_empty_rest_of_line();
  804.       }
  805. ***************
  806. *** 1697,1703 ****
  807.   void    /* JF was static, but can't be if VAX.C is goning to use it */
  808.   float_cons(float_type)        /* Worker to do .float etc statements. */
  809.                   /* Clobbers input_line-pointer, checks end-of-line. */
  810. !      register float_type;    /* 'f':.ffloat ... 'F':.float ... */
  811.   {
  812.     register char *    p;
  813.     register char        c;
  814. --- 1698,1704 ----
  815.   void    /* JF was static, but can't be if VAX.C is goning to use it */
  816.   float_cons(float_type)        /* Worker to do .float etc statements. */
  817.                   /* Clobbers input_line-pointer, checks end-of-line. */
  818. !      register int float_type;    /* 'f':.ffloat ... 'F':.float ... */
  819.   {
  820.     register char *    p;
  821.     register char        c;
  822. *** gas-1.38/subsegs.c    Thu Oct 11 11:26:23 1990
  823. --- subsegs.c    Wed Jul 10 09:02:02 1991
  824. ***************
  825. *** 96,102 ****
  826. --- 96,106 ----
  827.     know( SEG_MAXIMUM_ORDINAL == SEG_DIFFERENCE );
  828.     know( seg_name [(int) SEG_MAXIMUM_ORDINAL + 1] [0] == 0 );
  829.   
  830. + #ifdef M_XENIX
  831. +   obstack_begin( &frags, 1000);
  832. + #else
  833.     obstack_begin( &frags, 5000);
  834. + #endif /* M_XENIX */
  835.     frchain_root = NULL;
  836.     frchain_now  = NULL;        /* Warn new_subseg() that we are booting. */
  837.                   /* Fake up 1st frag. */
  838. *** gas-1.38/write.c    Thu Oct 11 11:26:15 1990
  839. --- write.c    Wed Jul 10 09:06:47 1991
  840. ***************
  841. *** 38,43 ****
  842. --- 38,46 ----
  843.   #include "write.h"
  844.   #include "symbols.h"
  845.   
  846. + static relax_addressT    relax_align();
  847. + 
  848. + #ifndef M_XENIX
  849.   #ifdef SPARC
  850.   #include "sparc.h"
  851.   #endif
  852. ***************
  853. *** 93,103 ****
  854.   
  855.   static void    relax_segment();
  856.   void        emit_segment();
  857. - static relax_addressT    relax_align();
  858.   static long int    fixup_segment();
  859.   #if !defined(SPARC) && !defined(I860)
  860.   static void        emit_relocations();
  861.   #endif
  862.    /*
  863.    *            fix_new()
  864.    *
  865. --- 96,107 ----
  866.   
  867.   static void    relax_segment();
  868.   void        emit_segment();
  869.   static long int    fixup_segment();
  870.   #if !defined(SPARC) && !defined(I860)
  871.   static void        emit_relocations();
  872.   #endif
  873. + 
  874. + #endif /* M_XENIX */
  875.    /*
  876.    *            fix_new()
  877.    *
  878. ***************
  879. *** 146,151 ****
  880. --- 150,156 ----
  881.     * seg_fix_rootP = fixP;
  882.   }
  883.   
  884. + #ifndef M_XENIX
  885.   void
  886.   write_object_file()
  887.   {
  888. ***************
  889. *** 683,688 ****
  890. --- 688,694 ----
  891.     VMS_write_object_file(text_siz, data_siz, text_frag_root, data_frag_root);
  892.   #endif    /* VMS */
  893.   }                /* write_object_file() */
  894. + #endif /* M_XENIX */
  895.   
  896.   /*
  897.    *            relax_segment()
  898. ***************
  899. *** 697,703 ****
  900. --- 703,711 ----
  901.    * these frag addresses may not be the same as final object-file addresses.
  902.    */
  903.   #ifndef    VMS
  904. + #ifndef M_XENIX
  905.   static
  906. + #endif    /* not M_XENIX */
  907.   #endif    /* not VMS */
  908.   void
  909.   relax_segment (segment_frag_root, segment_type)
  910. ***************
  911. *** 1010,1016 ****
  912.   /*
  913.    *            fixup_segment()
  914.    */
  915. ! static long int
  916.   fixup_segment (fixP, this_segment_type)
  917.        register fixS *    fixP;
  918.        int        this_segment_type; /* N_TYPE bits for segment. */
  919. --- 1018,1027 ----
  920.   /*
  921.    *            fixup_segment()
  922.    */
  923. ! #ifndef M_XENIX 
  924. ! static
  925. ! #endif /* not M_XENIX */
  926. ! long int
  927.   fixup_segment (fixP, this_segment_type)
  928.        register fixS *    fixP;
  929.        int        this_segment_type; /* N_TYPE bits for segment. */
  930. ***************
  931. *** 1137,1142 ****
  932. --- 1148,1156 ----
  933.       }            /* if there was a + symbol */
  934.         if (pcrel)
  935.       {
  936. + #ifdef M_XENIX
  937. +       if (add_symbol_N_TYPE != N_UNDF)
  938. + #endif
  939.         add_number -=
  940.   #ifndef NS32K
  941.             size + 
  942. ***************
  943. *** 1184,1189 ****
  944. --- 1198,1204 ----
  945.   }                /* fixup_segment() */
  946.   
  947.   
  948. + #ifndef M_XENIX
  949.   /* The sparc needs its own emit_relocations() */
  950.   #if !defined(SPARC) && !defined(I860)
  951.   /*
  952. ***************
  953. *** 1244,1249 ****
  954. --- 1259,1265 ----
  955.   
  956.   }
  957.   #endif
  958. + #endif /* M_XENIX */
  959.   
  960.   int
  961.   is_dnrange(f1,f2)
  962. *** gas-1.38/xenixomf.c
  963. --- xenixomf.c    Wed Jul 10 09:02:18 1991
  964. ***************
  965. *** 0 ****
  966. --- 1,660 ----
  967. + #include <string.h>
  968. + #include <stdio.h>
  969. + #include "xenixomf.h"
  970. + #include "msomf.h"
  971. + 
  972. + #ifdef M_XENIX
  973. + #  undef i386
  974. + #endif
  975. + 
  976. + #define MAXRECORDSIZE    (14 * 1024)    /* 1k data => 1024 fixups */
  977. + #define I386    1
  978. + 
  979. + extern char *out_file_name;
  980. + 
  981. + static char chksum = 0;
  982. + static unsigned char recordbuff[MAXRECORDSIZE];
  983. + static unsigned char *record_ptr;
  984. + 
  985. + static void copy_bytes_to_record(p, count)
  986. + unsigned char *p;
  987. + int count;
  988. + {
  989. +     while (count--)
  990. +     {
  991. +         *record_ptr++ = *p;
  992. +         chksum += *p++;
  993. +     }
  994. + }
  995. + 
  996. + static void start_record(type)
  997. + unsigned char type;
  998. + {
  999. +     chksum = 0;
  1000. +     record_ptr = recordbuff;
  1001. +     copy_bytes_to_record(&type, 1);
  1002. +     record_ptr += 2;    /* leave space for the record size */
  1003. + }
  1004. + 
  1005. + static void output_record()
  1006. + {
  1007. +     int length;
  1008. +     unsigned char b;
  1009. + 
  1010. +     length = (record_ptr - recordbuff) + 1; /* 1 for chksum */
  1011. + 
  1012. +     /* patch the record length into the header and put -chksum
  1013. +      * at the end of the record.
  1014. +      */
  1015. + 
  1016. +     b = (length - 3) & 0xff;  /* -3 as record length excludes type + len */
  1017. +     chksum += b;  recordbuff[1] = b;
  1018. +     b = ((length - 3) >> 8) & 0xff;
  1019. +     chksum += b;  recordbuff[2] = b;
  1020. +     *record_ptr = (unsigned char)(-chksum);
  1021. + 
  1022. +     output_file_append (recordbuff, length, out_file_name);
  1023. + }
  1024. + 
  1025. + static void copy_string_to_record(s)
  1026. + char *s;
  1027. + {
  1028. +     unsigned char len;
  1029. + 
  1030. +     len = strlen(s);
  1031. +     if (len > OMFNAMELENGTH)
  1032. +     {
  1033. +         char tname[OMFNAMELENGTH+2];
  1034. + 
  1035. +         strncpy(tname, s, OMFNAMELENGTH);
  1036. +         tname[OMFNAMELENGTH] = '\0';
  1037. +         fprintf(stderr, "Identifier truncated to %s (%d chars)\n",
  1038. +                 tname, OMFNAMELENGTH);
  1039. +         len = OMFNAMELENGTH;
  1040. +         copy_bytes_to_record(&len, 1);
  1041. +         copy_bytes_to_record(s, OMFNAMELENGTH);
  1042. +     }
  1043. +     else
  1044. +     {
  1045. +         copy_bytes_to_record(&len, 1);
  1046. +         if (len > 0)
  1047. +             copy_bytes_to_record(s, len);
  1048. +     }
  1049. + }
  1050. + 
  1051. + static void copy_index_to_record(index)
  1052. + unsigned int index;
  1053. + {
  1054. +     unsigned char b;
  1055. + 
  1056. +     if (index < 128)
  1057. +     {
  1058. +         b = (unsigned char)(index & 0xff);
  1059. +         copy_bytes_to_record(&b, 1);
  1060. +     }
  1061. +     else
  1062. +     {
  1063. +         b = (unsigned char)(((index >> 8) & 0xff) | 0x80);
  1064. +         copy_bytes_to_record(&b, 1);
  1065. +         b = (unsigned char)(index & 0xff);
  1066. +         copy_bytes_to_record(&b, 1);
  1067. +     }
  1068. + }
  1069. + 
  1070. + static void copy_vint_to_record(value, count)
  1071. + long value;
  1072. + int count;
  1073. + {
  1074. +     unsigned char b;
  1075. + 
  1076. +     while (count--)
  1077. +     {
  1078. +         b = (unsigned char)(value & 0xff);
  1079. +         copy_bytes_to_record(&b, 1);
  1080. +         value >>= 8;
  1081. +     }
  1082. + }
  1083. + 
  1084. + static void copy_word_to_record(value)
  1085. + unsigned int value;
  1086. + {
  1087. +     copy_vint_to_record((long)value, 2);
  1088. + }
  1089. + 
  1090. + static void copy_offset_to_record(i386, value)
  1091. + int i386;
  1092. + long value;
  1093. + {
  1094. +     copy_vint_to_record(value, i386 ? 4 : 2);
  1095. + }
  1096. + 
  1097. + static void copy_comsize_to_record(value)
  1098. + long value;
  1099. + {
  1100. +     unsigned char b;
  1101. + 
  1102. +     if (value < 128)
  1103. +         copy_vint_to_record((long)value, 1);
  1104. +     else if (value < 65536L)
  1105. +     {
  1106. +         b = 0x81;
  1107. +         copy_bytes_to_record(&b, 1);
  1108. +         copy_vint_to_record((long)value, 2);
  1109. +     }
  1110. +     else if (value < 16777216L)
  1111. +     {
  1112. +         b = 0x84;
  1113. +         copy_bytes_to_record(&b, 1);
  1114. +         copy_vint_to_record((long)value, 3);
  1115. +     }
  1116. +     else
  1117. +     {
  1118. +         b = 0x88;
  1119. +         copy_bytes_to_record(&b, 1);
  1120. +         copy_vint_to_record((long)value, 4);
  1121. +     }
  1122. + 
  1123. + }
  1124. + 
  1125. + void omf_theadr(name)
  1126. + unsigned char *name;
  1127. + {
  1128. +     start_record(MTHEADR);
  1129. +     copy_string_to_record(name);
  1130. +     output_record();
  1131. + }
  1132. + 
  1133. + void omf_coment(p, count, class)
  1134. + unsigned char *p;
  1135. + int count;
  1136. + unsigned char class;
  1137. + {
  1138. +     unsigned char attrib;
  1139. + 
  1140. +     start_record(MCOMENT);
  1141. +     attrib = 0;        /* Purge and List attributes */
  1142. +     copy_bytes_to_record(&attrib, 1);
  1143. +     copy_bytes_to_record(&class, 1);
  1144. +     copy_bytes_to_record(p, count);
  1145. +     output_record();
  1146. + }
  1147. + 
  1148. + void omf_extdef(name, type)
  1149. + unsigned char *name;
  1150. + {
  1151. +     start_record(MEXTDEF);
  1152. +     copy_string_to_record(name);
  1153. +     copy_bytes_to_record(&type, 1);
  1154. +     output_record();
  1155. + }
  1156. + 
  1157. + void omf_start_pubdef(i386, group, segment, frame)
  1158. + int i386;
  1159. + int group, segment, frame;
  1160. + {
  1161. +     if (i386)
  1162. +         start_record(MPUB386);
  1163. +     else
  1164. +         start_record(MPUBDEF);
  1165. + 
  1166. +     copy_index_to_record(group);
  1167. +     copy_index_to_record(segment);
  1168. +     if (group == 0 && segment == 0)
  1169. +         copy_word_to_record(frame);
  1170. + }
  1171. + 
  1172. + void omf_pubdef(i386, name, offset, type)
  1173. + int i386;
  1174. + unsigned char *name;
  1175. + int type;
  1176. + long offset;
  1177. + {
  1178. +     copy_string_to_record(name);
  1179. +     copy_offset_to_record(i386, offset);
  1180. +     copy_index_to_record(type);
  1181. + }
  1182. + 
  1183. + void omf_end_pubdef()
  1184. + {
  1185. +     output_record();
  1186. + }
  1187. + 
  1188. + void omf_start_lnames()
  1189. + {
  1190. +     start_record(MLNAMES);
  1191. + }
  1192. + 
  1193. + void omf_lnames(name)
  1194. + unsigned char *name;
  1195. + {
  1196. +     copy_string_to_record(name);
  1197. + }
  1198. + 
  1199. + void omf_end_lnames()
  1200. + {
  1201. +     output_record();
  1202. + }
  1203. + 
  1204. + void omf_segdef(i386, acbp, frame, offset, seglen, segname, segclass)
  1205. + int i386;
  1206. + unsigned char acbp;
  1207. + unsigned int frame;
  1208. + unsigned int offset;
  1209. + long seglen;
  1210. + unsigned int segname, segclass;
  1211. + {
  1212. +     unsigned int ovlindex = 0;
  1213. +     if (i386)
  1214. +         start_record(MSEG386);
  1215. +     else
  1216. +         start_record(MSEGDEF);
  1217. + 
  1218. +     copy_bytes_to_record(&acbp, 1);
  1219. +     if ((acbp & SD_ALIGN) == SD_ABS)
  1220. +     {
  1221. +         copy_word_to_record(frame);
  1222. +         copy_word_to_record(offset);  /* should be byte - Fix Me */
  1223. +     }
  1224. +     copy_offset_to_record(i386, seglen);
  1225. +     copy_index_to_record(segname);
  1226. +     copy_index_to_record(segclass);
  1227. +     copy_index_to_record(ovlindex);
  1228. +     output_record();
  1229. + }
  1230. + 
  1231. + void omf_start_grpdef(grpname)
  1232. + unsigned int grpname;
  1233. + {
  1234. +     start_record(MGRPDEF);
  1235. +     copy_index_to_record(grpname);
  1236. + }
  1237. + 
  1238. + void omf_grpdef(segindex)
  1239. + unsigned int segindex;
  1240. + {
  1241. +     unsigned char b = 0xff;
  1242. + 
  1243. +     copy_bytes_to_record(&b, 1);
  1244. +     copy_index_to_record(segindex);
  1245. + }
  1246. + 
  1247. + void omf_end_grpdef()
  1248. + {
  1249. +     output_record();
  1250. + }
  1251. + 
  1252. + void omf_start_comdef()
  1253. + {
  1254. +     start_record(MCOMDEF);
  1255. + }
  1256. + 
  1257. + void omf_comdef(name, dataseg_type, length, el_size)
  1258. + unsigned char *name;
  1259. + unsigned char dataseg_type;
  1260. + {
  1261. +     unsigned char type = 0;
  1262. + 
  1263. +     copy_string_to_record(name);
  1264. +     copy_bytes_to_record(&type, 1);
  1265. +     copy_bytes_to_record(&dataseg_type, 1);
  1266. + 
  1267. +     copy_comsize_to_record(length);
  1268. +     if (dataseg_type == TD_CFAR)
  1269. +     {
  1270. +         copy_comsize_to_record(el_size);
  1271. +     }
  1272. + }
  1273. + 
  1274. + void omf_end_comdef()
  1275. + {
  1276. +     output_record();
  1277. + }
  1278. + 
  1279. + void omf_start_linnum(i386, segindex)
  1280. + {
  1281. +     unsigned char grpindex = 0;
  1282. + 
  1283. +     if (i386)
  1284. +         start_record(MLIN386);
  1285. +     else
  1286. +         start_record(MLINNUM);
  1287. + 
  1288. +     copy_bytes_to_record(&grpindex, 1);
  1289. +     copy_index_to_record(segindex);
  1290. + }
  1291. + 
  1292. + void omf_linnum(i386, line, offset)
  1293. + int i386;
  1294. + unsigned int line;
  1295. + long offset;
  1296. + {
  1297. +     copy_word_to_record(line);
  1298. +     copy_offset_to_record(i386, offset);
  1299. + }
  1300. + 
  1301. + void omf_end_linnum()
  1302. + {
  1303. +     output_record();
  1304. + }
  1305. + 
  1306. + void omf_start_thread(i386)
  1307. + {
  1308. +     if (i386)
  1309. +         start_record(MFIX386);
  1310. +     else
  1311. +         start_record(MFIXUPP);
  1312. + }
  1313. + 
  1314. + void omf_thread(thread, framethread, method, index)
  1315. + unsigned char thread;
  1316. + int framethread;
  1317. + unsigned char method;
  1318. + unsigned int index;
  1319. + {
  1320. +     unsigned char thread_data;
  1321. + 
  1322. +     thread_data = thread | (method << TRD_MTHDSHFT);
  1323. +     if (framethread)
  1324. +         thread_data |= TRD_FRAME;
  1325. +     copy_bytes_to_record(&thread_data, 1);
  1326. + 
  1327. +     if (framethread)
  1328. +     {
  1329. +         switch (method)
  1330. +         {
  1331. +         case FRM_SI:
  1332. +         case FRM_GI:
  1333. +         case FRM_EI:
  1334. +         case FRM_ABS:
  1335. +             copy_index_to_record(index);
  1336. +             break;
  1337. +         case FRM_LOC:
  1338. +         case FRM_TRGT:
  1339. +             break;
  1340. +         }
  1341. +     }
  1342. +     else
  1343. +         copy_index_to_record(index);
  1344. + }
  1345. + 
  1346. + void omf_end_thread()
  1347. + {
  1348. +     output_record();
  1349. + }
  1350. + 
  1351. + void omf_start_fixup(i386)
  1352. + {
  1353. +     if (i386)
  1354. +         start_record(MFIX386);
  1355. +     else
  1356. +         start_record(MFIXUPP);
  1357. + }
  1358. + 
  1359. + static void generate_fixdat(i386, f_thrd, frame, t_thrd, trgt, t_sec,
  1360. +                        frame_index, target_index, offset)
  1361. + int i386;
  1362. + int f_thrd;
  1363. + unsigned int frame;
  1364. + int t_thrd;
  1365. + unsigned int trgt;
  1366. + int t_sec;
  1367. + unsigned int frame_index, target_index;
  1368. + long offset;
  1369. + {
  1370. +     unsigned char fixdat, b;
  1371. + 
  1372. +     fixdat = (f_thrd ? FIXDAT_FTHRD : 0) | (frame << FIXDAT_FRSHFT);
  1373. +     fixdat |= (t_thrd ? FIXDAT_TTHRD : 0) | trgt | (t_sec ? FIXDAT_TSCND:0);
  1374. +     copy_bytes_to_record(&fixdat, 1);
  1375. + 
  1376. +     if (!f_thrd)
  1377. +     {
  1378. +         switch (frame)
  1379. +         {
  1380. +         case FRM_SI:
  1381. +         case FRM_GI:
  1382. +         case FRM_EI:
  1383. +         case FRM_ABS:
  1384. +             copy_index_to_record(frame_index);
  1385. +             break;
  1386. +         case FRM_LOC:
  1387. +         case FRM_TRGT:
  1388. +             break;
  1389. +         }
  1390. +     }
  1391. + 
  1392. +     if (!t_thrd)
  1393. +         copy_index_to_record(target_index);
  1394. +     
  1395. +     if (!t_sec)
  1396. +         copy_offset_to_record(i386, offset);
  1397. + }
  1398. + 
  1399. + void omf_fixup(i386, segrel, loc, data_off, f_thrd, frame, t_thrd, trgt, t_sec,
  1400. +            frame_index, target_index, offset)
  1401. + int i386, segrel;
  1402. + unsigned char loc;
  1403. + unsigned int data_off;
  1404. + int f_thrd;
  1405. + unsigned int frame;
  1406. + int t_thrd;
  1407. + unsigned int trgt;
  1408. + int t_sec;
  1409. + unsigned int frame_index, target_index;
  1410. + long offset;
  1411. + {
  1412. +     unsigned int locat = 0x8000;
  1413. +     unsigned char fixdat, b;
  1414. + 
  1415. +     locat |= (segrel ? FIX_SEG : 0) | (loc << FIX_LOCSHFT) |
  1416. +          (data_off & FIX_DATAOFF);
  1417. +     b = (locat >> 8) & 0xff;  copy_bytes_to_record(&b, 1);
  1418. +     b = locat & 0xff;  copy_bytes_to_record(&b, 1);
  1419. +     generate_fixdat(i386, f_thrd, frame, t_thrd, trgt, t_sec, frame_index,
  1420. +             target_index, offset);
  1421. + }
  1422. + 
  1423. + void omf_end_fixup()
  1424. + {
  1425. +     output_record();
  1426. + }
  1427. + 
  1428. + void omf_start_ledata(i386, segindex, start_offset)
  1429. + int i386;
  1430. + unsigned int segindex;
  1431. + long start_offset;
  1432. + {
  1433. +     if (i386)
  1434. +         start_record(MLED386);
  1435. +     else
  1436. +         start_record(MLEDATA);
  1437. + 
  1438. +     copy_index_to_record(segindex);
  1439. +     copy_offset_to_record(i386, start_offset);
  1440. + }
  1441. + 
  1442. + void omf_ledata(data, count)
  1443. + unsigned char *data;
  1444. + int count;
  1445. + {
  1446. +     copy_bytes_to_record(data, count);
  1447. +     
  1448. + }
  1449. + 
  1450. + void omf_end_ledata()
  1451. + {
  1452. +     output_record();
  1453. + }
  1454. + 
  1455. + void omf_main_modend(i386, f_thrd, frame, t_thrd, trgt, t_sec, frame_index,
  1456. +              target_index, offset)
  1457. + int i386;
  1458. + int f_thrd;
  1459. + unsigned int frame;
  1460. + int t_thrd;
  1461. + unsigned int trgt;
  1462. + int t_sec;
  1463. + unsigned int frame_index, target_index;
  1464. + long offset;
  1465. + {
  1466. +     unsigned char mtype = 0xc1;
  1467. + 
  1468. +     if (i386)
  1469. +         start_record(M386END);
  1470. +     else
  1471. +         start_record(MMODEND);
  1472. + 
  1473. +     copy_bytes_to_record(&mtype, 1);
  1474. + 
  1475. +     generate_fixdat(i386, f_thrd, frame, t_thrd, trgt, t_sec, frame_index,
  1476. +             target_index, offset);
  1477. +     output_record();
  1478. + }
  1479. + 
  1480. + void omf_modend(i386)
  1481. + int i386;
  1482. + {
  1483. +     unsigned char mtype = 0;
  1484. + 
  1485. +     if (i386)
  1486. +         start_record(M386END);
  1487. +     else
  1488. +         start_record(MMODEND);
  1489. + 
  1490. +     copy_bytes_to_record(&mtype, 1);
  1491. +     output_record();
  1492. + }
  1493. + 
  1494. + /** Definitions required to produce a standard Microsoft .o file
  1495. +  */
  1496. + 
  1497. + /** LNAMES, SEGDEF, GRPDEF and COMENT stuff
  1498. +  *
  1499. +  *  NB the following defines must reflect the position of the string in
  1500. +  *  the lnames_tab table.
  1501. +  */
  1502. + 
  1503. + #define    L_BLANK        1
  1504. + #define    L_DGROUP    2
  1505. + #define L_UTEXT        3
  1506. + #define L_CODE        4
  1507. + #define L_UDATA        5
  1508. + #define L_DATA        6
  1509. + #define L_CONST        7
  1510. + #define L_UBSS        8
  1511. + #define L_BSS        9
  1512. + #define L_TYPES        10
  1513. + #define L_DEBTYP    11
  1514. + #define L_SYMBOLS    12
  1515. + #define L_DEBSYM    13
  1516. + #define L_TSIZE        9
  1517. + #define L_G_TSIZE    13
  1518. + 
  1519. + char *lnames_tab[] = {
  1520. +     "",
  1521. +     "",
  1522. +     "DGROUP",
  1523. +     "_TEXT",
  1524. +     "CODE",
  1525. +     "_DATA",
  1526. +     "DATA",
  1527. +     "CONST",
  1528. +     "_BSS",
  1529. +     "BSS",
  1530. +     "$$TYPES",
  1531. +     "DEBTYP",
  1532. +     "$$SYMBOLS",
  1533. +     "DEBSYM"
  1534. + };
  1535. + 
  1536. + struct segtable {
  1537. +     unsigned char attrib;
  1538. +     long length;
  1539. +     unsigned nameindex;
  1540. +     unsigned classindex;
  1541. + };
  1542. + 
  1543. + /* SEGDEF's */
  1544. + 
  1545. + static struct segtable segt[] = {
  1546. +     {0, NULL, 0, 0},
  1547. +     {SD_DWORD|SD_PUBLIC|SD_PGRES, 0, L_UTEXT, L_CODE},
  1548. +     {SD_DWORD|SD_PUBLIC|SD_PGRES, 0, L_UDATA, L_DATA},
  1549. +     {SD_DWORD|SD_PUBLIC|SD_PGRES, 0, L_CONST, L_CONST},
  1550. +     {SD_DWORD|SD_PUBLIC|SD_PGRES, 0, L_UBSS, L_BSS},
  1551. +     {SD_BYTE|SD_PGRES, 0, L_SYMBOLS, L_DEBSYM},
  1552. +     {SD_BYTE|SD_PGRES, 0, L_TYPES, L_DEBTYP}
  1553. + };
  1554. + 
  1555. + /* GRPDEF */
  1556. + 
  1557. + #define GRPTABSIZ 3
  1558. + 
  1559. + unsigned int group_tab[GRPTABSIZ] = {3, 4, 2};
  1560. + 
  1561. + /* COMENTs */
  1562. + 
  1563. + struct comment {
  1564. +     unsigned char class;
  1565. +     unsigned char count;
  1566. +     unsigned char *data;
  1567. + };
  1568. + 
  1569. + #define NUMFIXEDCOMMENTS 4
  1570. + 
  1571. + static unsigned char gas_comment[] = "gas-1.38.1a";
  1572. + static unsigned char lib_comment[] = "SLIBCE";
  1573. + static unsigned char model_comment[] = "3s";
  1574. + static unsigned char msext_comment[] = {1, 0x43, 0x56};
  1575. + 
  1576. + struct comment fix_cmnt[NUMFIXEDCOMMENTS] = {
  1577. +     {0, 8, gas_comment},
  1578. +     {0x9f, 6, lib_comment},
  1579. +     {0x9d, 2, model_comment},
  1580. +     {0xa1, 3, msext_comment}
  1581. + };
  1582. + 
  1583. + void omf_initialize_a_out(name, text_size, data_size, bss_size, const_size,
  1584. +               gdb, syms_size, str_size)
  1585. + unsigned char *name;
  1586. + long text_size, data_size, bss_size, const_size;
  1587. + int gdb;
  1588. + long syms_size, str_size;
  1589. + {
  1590. +     int i;
  1591. + 
  1592. +     omf_theadr(name);
  1593. + 
  1594. +     /* static comments */
  1595. + 
  1596. +     for (i = 0; i < NUMFIXEDCOMMENTS; i++)
  1597. +       omf_coment(fix_cmnt[i].data, fix_cmnt[i].count, fix_cmnt[i].class);
  1598. + 
  1599. +     /* LNAMES */
  1600. + 
  1601. +     omf_start_lnames();
  1602. +     for (i = 1; i <= (gdb ? L_G_TSIZE : L_TSIZE); i++)
  1603. +         omf_lnames(lnames_tab[i]);
  1604. +     omf_end_lnames();
  1605. + 
  1606. +     /* SEGDEFS */
  1607. + 
  1608. +     segt[SDEF_TEXT].length = text_size;
  1609. +     segt[SDEF_DATA].length = data_size;
  1610. +     segt[SDEF_BSS].length = bss_size;
  1611. +     segt[SDEF_CONST].length = const_size;
  1612. +     if (gdb)
  1613. +     {
  1614. +         segt[SDEF_SYMBOLS].length = syms_size;
  1615. +         segt[SDEF_TYPES].length = str_size;
  1616. +     }
  1617. +     for (i = 1; i <= (gdb ? SDEF_G_SIZE : SDEF_SIZE); i++)
  1618. +         omf_segdef(I386, segt[i].attrib, 0, 0L, segt[i].length,
  1619. +                segt[i].nameindex, segt[i].classindex);
  1620. +     /* DGROUP */
  1621. + 
  1622. +     omf_start_grpdef(L_DGROUP);
  1623. +     for (i = 0; i < GRPTABSIZ; i++)
  1624. +         omf_grpdef(group_tab[i]);
  1625. +     omf_end_grpdef();
  1626. + }
  1627. *** gas-1.38/xenixomf.h
  1628. --- xenixomf.h    Wed Jul 10 09:02:21 1991
  1629. ***************
  1630. *** 0 ****
  1631. --- 1,140 ----
  1632. + 
  1633. + /* Defines to map a.out definitions to OMF style definitions
  1634. +  */
  1635. + #define    PUBLICDATA    (N_DATA|N_EXT)
  1636. + #define    PUBLICTEXT    (N_TEXT|N_EXT)
  1637. + #define    PUBLICABS    (N_ABS|N_EXT)
  1638. + #define COMMDEF(x)    ((x) == (N_UNDF|N_EXT))
  1639. + #define PRIVDATA    (N_DATA)
  1640. + #define PRIVTEXT    (N_TEXT)
  1641. + #define PRIVBSS        (N_BSS)
  1642. + #define EXTERNAL    (N_UNDF)
  1643. + #define PUBLIC(x)    ((x)==PUBLICDATA || (x)==PUBLICTEXT || (x)==PUBLICABS)
  1644. + #define EXTDEF(x)    ((x)==EXTERNAL || COMMDEF(x))
  1645. + #define PRIVATE(x)    ((x)==PRIVDATA || (x)==PRIVTEXT || (x)==PRIVBSS)
  1646. + 
  1647. + 
  1648. + #define MTHEADR        0x80    /* module header */
  1649. + #define MCOMENT        0x88    /* comment */
  1650. + #define MMODEND        0x8a    /* module end */
  1651. + #define M386END        0x8b    /* 32 bit module end */
  1652. + #define MEXTDEF        0x8c    /* external definition */
  1653. + #define MTYPDEF        0x8e    /* type definition */
  1654. + #define MPUBDEF        0x90    /* public definition */
  1655. + #define MPUB386        0x91    /* 32 bit public definition */
  1656. + #define MLINNUM        0x94    /* source line number */
  1657. + #define MLIN386        0x95    /* 32 bit source line number */
  1658. + #define MLNAMES        0x96    /* name list */
  1659. + #define MSEGDEF        0x98    /* segment definition */
  1660. + #define MSEG386        0x99    /* 32 bit segment definition */
  1661. + #define MGRPDEF        0x9a    /* group definition */
  1662. + #define MFIXUPP        0x9c    /* fix up previous data image */
  1663. + #define MFIX386        0x9d    /* fix up previous 32 bit data image */
  1664. + #define MLEDATA        0xa0    /* logical data image */
  1665. + #define MLED386        0xa1    /* 32 bit logical data image */
  1666. + #define    MCOMDEF        0xb0    /* communal names definition */
  1667. + 
  1668. + /* The maximum length of an identifier.
  1669. +  */
  1670. + 
  1671. + #define OMFNAMELENGTH    127
  1672. + 
  1673. + /* alignment required
  1674. +  */
  1675. + 
  1676. + #define SD_ABS        0x00        /* absolute */
  1677. + #define SD_BYTE        0x20        /* byte */
  1678. + #define SD_WORD        0x40        /* word */
  1679. + #define SD_PARA        0x60        /* paragraph */
  1680. + #define SD_PAGE        0x80        /* page */
  1681. + #define SD_DWORD    0xa0        /* double word */
  1682. + #define SD_LTL        0xc0        /* load-time locatable */
  1683. + #define SD_ALIGN    0xe0        /* alignment mask */
  1684. + #define SD_ASHIFT    5        /* alignment shift */
  1685. + 
  1686. + /* segment combine classes */
  1687. + 
  1688. + #define SD_PRIV        0x00        /* private, can't be combined */
  1689. + #define SD_HCOMM    0x04        /* common, place in high mem */
  1690. + #define SD_PUBLIC    0x08        /* public, sequential */
  1691. + #define SD_BAD        0x0c        /* undefined */
  1692. + #define SD_C4        0x10        /* not used */
  1693. + #define SD_STACK    0x14        /* stack segment */
  1694. + #define SD_COMM        0x18        /* common segment */
  1695. + #define SD_RCOMM    0x1c        /* not used, reverse common segment */
  1696. + #define SD_COMBO    0x1c        /* combine mask */
  1697. + #define SD_CSHIFT    2        /* combine shift */
  1698. + #define SD_PGRES    0x01        /* page resident */
  1699. + #define SD_64K        0x02        /* segment size is exactly 64k */
  1700. + 
  1701. + /* BSSDEF record definitions
  1702. +  */
  1703. + 
  1704. + #define    TD_CNEAR    0x62        /* near .comm variable */
  1705. + #define    TD_CFAR        0x61        /* far .comm variable */
  1706. + 
  1707. + /* COMENT record definitions
  1708. +  */
  1709. + 
  1710. + #define     CMT_PURGE    0x80        /* comment can be purged */
  1711. + #define  CMT_LIST    0x40        /* don't list when listing comments */
  1712. + 
  1713. + /* FIXUP record definitions
  1714. +  */
  1715. + 
  1716. + #define  FIX_FIXUP    0x80        /* fixup is a fixup (else thread def) */
  1717. + #define  TRD_FRAME    0x40        /* thread def for a frame (else tgt) */
  1718. + #define  TRD_MTHDSHFT    2        /* frame / target method shift */
  1719. + #define  TRD_MTHDMSK    0x1c        /* frame / target method mask */
  1720. + #define  TRD_THRED    0x03        /* thread number mask */
  1721. + 
  1722. + /* Target method defines.  0 - 3 are primary, they include an offset, while 
  1723. +  * 4 - 7 or secondary, the offset 0 and not specified.
  1724. +  */
  1725. + 
  1726. + #define  TGT_SI        0        /* target is Segment Index(N) + M */
  1727. + #define  TGT_GI        1        /* target is Group Index(N) + M */
  1728. + #define  TGT_EI        2        /* target is External Index(N) + M */
  1729. + #define  TGT_ABS    3        /* target is absolute frame N + N */
  1730. + #define  TGT_SI_0    4        /* target is Segment Index(N) + 0 */
  1731. + #define  TGT_GI_0    5        /* target is Group Index(N) + 0 */
  1732. + #define  TGT_EI_0    6        /* target is External Index(N) + 0 */
  1733. + #define  TGT_ABS_0    7        /* target is Absolute Segmnent N + 0 */
  1734. + 
  1735. + /* Frame fixup method
  1736. +  */
  1737. + 
  1738. + #define  FRM_SI        0        /* Frame is Segment index(N) */
  1739. + #define  FRM_GI        1        /* Frame is Group index(N) */
  1740. + #define  FRM_EI        2        /* Frame is External index(N) */
  1741. + #define  FRM_ABS    3        /* Frame is Absolute frame(N) */
  1742. + #define  FRM_LOC    4        /* Frame is LSEG of LOCATION */
  1743. + #define  FRM_TRGT    5        /* Frame is the frame of the target */
  1744. + 
  1745. + /* FIXUP fixdat field definitions
  1746. +  */
  1747. + 
  1748. + #define  FIX_SEG    0x4000        /* Fixup is seg relative (else self) */
  1749. + #define  FIX_24BIT    0x2000        /* Fixup has 24b tgt disp (NOT USED) */
  1750. + #define  FIX_LOCMSK    0x3c00        /* Fixup location type mask */
  1751. + #define  FIX_LOCSHFT    10        /* Fixup location type shift */
  1752. + #define  FIX_DATAOFF    0x3ff        /* location in prev data rec of fixup */
  1753. + #define  FIXDAT_FTHRD    0x80        /* Fixup frame by thread else direct */
  1754. + #define  FIXDAT_FRAME    0x70        /* Frame thread or method mask */
  1755. + #define  FIXDAT_FRSHFT    4        /* Frame thread or method shift */
  1756. + #define  FIXDAT_TTHRD    0x08        /* Fixup target by thread else direct */
  1757. + #define  FIXDAT_TSCND    0x04        /* Primary or secondary target method */
  1758. + #define  FIXDAT_TRGT    0x03        /* Target thread or method mask */
  1759. + 
  1760. + /* Location type definitions
  1761. +  */
  1762. + 
  1763. + #define  LOC_LOBYTE    0        /* low 8 bits */
  1764. + #define  LOC_OFFSET    1        /* 16 bit offset */
  1765. + #define  LOC_BASE    2        /* 16 bit frame number */
  1766. + #define  LOC_POINTER    3        /* 32 bit pointer */
  1767. + #define  LOC_HIBTE    4        /* second 8 bits */
  1768. + #define  LOC_OFFSETL    5        /* 16 bit offset (liner resolved) */
  1769. + #define  LOC_OFFSET32    9        /* 32 bit offset */
  1770. + #define  LOC_POINTER48    11        /* 48 bit pointer */
  1771. + #define  LOC_OFFSETL32    13        /* 32 bit offset (liner resolved) */
  1772.  
  1773.