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