home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / gnustuff / tos / updates / update29.zoo / util / diffs
Encoding:
Text File  |  1993-03-28  |  71.7 KB  |  2,891 lines
  1. ===================================================================
  2. RCS file: /net/acae127/home/bammi/etc/src/master/atari/cross-util/Changelog,v
  3. retrieving revision 1.36
  4. diff -c -r1.36 Changelog
  5. *** 1.36    1992/11/08 00:29:27
  6. --- Changelog    1993/03/29 03:40:52
  7. ***************
  8. *** 391,393 ****
  9. --- 391,460 ----
  10.       add -fshare flag for sharex text (mint 0.96 and up).
  11.   
  12.   ----------------------------- Patchlevel 33 --------------------------------
  13. + 
  14. +     REMOVE the following files from this (utils) directory
  15. +     they have been moved to the include directory
  16. + 
  17. +     rm gnu-ar.h
  18. +     rm gnu-out.h
  19. +     rm stab.def
  20. +     rm stab.h
  21. + 
  22. + 
  23. + 
  24. + cnm.c: andreas
  25. +     New flag -u, print symbols unsorted
  26. +     Cleanups
  27. + 
  28. + cplusdem.c:: andreas
  29. +     Cleanups to sync up with Gnu
  30. + 
  31. + stab.def, stab.h:: andreas
  32. +     Cleanups to sync up with Gnu *********** NOTE moved to <include>
  33. + 
  34. + printstk.c  fixstk.c: andreas
  35. +     Allow more than one file name argument
  36. +     
  37. + strip.c:: andreas
  38. +     Preserve the file mode and long symbols,
  39. +      keep __stksize by default, new flag -a to strip
  40. +      really all symbols
  41. + 
  42. +     ****************************
  43. +     * NOTE: new flag -a        *
  44. +     ****************************
  45. + 
  46. + ld.c sym-ld.c:
  47. + 
  48. +     - Many cleanups
  49. +     - All large stack requirements removed
  50. +     [ allocas turned into xmalloc/frees should be much more
  51. +       MiNT freindlier!]
  52. +     - defaults changed! ************** NOTE *****************
  53. +     default prgflags == 7 now    /* fastload and TT ram */
  54. +     default symbol table type == gst_format symbols
  55. + 
  56. +     - new options    ******************* NEW OPTIONS**************
  57. +      -f load_flags
  58. +      -h heap size
  59. + 
  60. + nm.c:: andreas
  61. +     - turn alloca()s into xmalloc()s
  62. + 
  63. + printstk.c:: andreas
  64. +     cleanup
  65. +     make it handle long symbols properly
  66. + 
  67. + size68.c:: andreas
  68. +     cleanup
  69. + 
  70. + fixstk.c:: ++jrb
  71. +     was missing *argv in usage message
  72. + 
  73. + 
  74. + stab.def, stab.h:: ++jrb
  75. +     removed from util subdir. use the one in the include
  76. +     directory. the one in include has been brought upto date with
  77. +     all the cygnus changes.
  78. + 
  79. + ----------------------------- Patchlevel 35 --------------------------------
  80. ===================================================================
  81. RCS file: /net/acae127/home/bammi/etc/src/master/atari/cross-util/PatchLev.h,v
  82. retrieving revision 1.31
  83. diff -c -r1.31 PatchLev.h
  84. *** 1.31    1992/11/08 00:29:27
  85. --- PatchLev.h    1993/03/29 03:40:54
  86. ***************
  87. *** 1,4 ****
  88. ! #define PatchLevel "33"
  89.   
  90.   /*
  91.    *    the Patch Level above is to identify the version
  92. --- 1,4 ----
  93. ! #define PatchLevel "35"
  94.   
  95.   /*
  96.    *    the Patch Level above is to identify the version
  97. ===================================================================
  98. RCS file: /net/acae127/home/bammi/etc/src/master/atari/cross-util/cnm.c,v
  99. retrieving revision 1.8
  100. diff -c -r1.8 cnm.c
  101. *** 1.8    1992/10/11 02:39:24
  102. --- cnm.c    1993/03/29 03:40:56
  103. ***************
  104. *** 35,40 ****
  105. --- 35,41 ----
  106.   #include <compiler.h>
  107.   #include <stdio.h>
  108.   #include <st-out.h>
  109. + #include <stdlib.h>
  110.   
  111.   #if __STDC__
  112.   #include <stdlib.h>
  113. ***************
  114. *** 94,99 ****
  115. --- 95,101 ----
  116.   
  117.   
  118.   int gflag;
  119. + int uflag;
  120.   
  121.   int main(argc, argv)
  122.   int argc;
  123. ***************
  124. *** 102,113 ****
  125.       int c, status = 0;
  126.       extern char *optarg;
  127.       extern int optind;
  128. !     while ((c = getopt(argc, argv, "g")) != -1)
  129.       switch (c)
  130.       {
  131.         case 'g':
  132.           gflag = 1;
  133.           break;
  134.         case '?':
  135.           usage();
  136.       }
  137. --- 104,118 ----
  138.       int c, status = 0;
  139.       extern char *optarg;
  140.       extern int optind;
  141. !     while ((c = getopt(argc, argv, "gu")) != -1)
  142.       switch (c)
  143.       {
  144.         case 'g':
  145.           gflag = 1;
  146.           break;
  147. +       case 'u':
  148. +         uflag = 1;
  149. +         break;
  150.         case '?':
  151.           usage();
  152.       }
  153. ***************
  154. *** 123,129 ****
  155.   int  cmp(s1, s2)
  156.   struct xsym *s1, *s2;
  157.   {
  158. !     return(s1->value - s2->value);
  159.   }
  160.   
  161.   int doname(s, many)
  162. --- 128,135 ----
  163.   int  cmp(s1, s2)
  164.   struct xsym *s1, *s2;
  165.   {
  166. !   long diff = s1->value - s2->value;
  167. !   return (diff > 0) - (diff < 0);
  168.   }
  169.   
  170.   int doname(s, many)
  171. ***************
  172. *** 183,189 ****
  173.       }
  174.       fclose(fd);
  175.       printf("%ld %s symbol(s)\n", i, (gflag ? "global ": ""));
  176. !     qsort(syms, i, sizeof(struct xsym), cmp);
  177.       while (i--)
  178.       {
  179.           dosym(syms);
  180. --- 189,196 ----
  181.       }
  182.       fclose(fd);
  183.       printf("%ld %s symbol(s)\n", i, (gflag ? "global ": ""));
  184. !     if (!uflag)
  185. !       qsort(syms, i, sizeof(struct xsym), cmp);
  186.       while (i--)
  187.       {
  188.           dosym(syms);
  189. ===================================================================
  190. RCS file: /net/acae127/home/bammi/etc/src/master/atari/cross-util/cplusdem.c,v
  191. retrieving revision 1.4
  192. diff -c -r1.4 cplusdem.c
  193. *** 1.4    1992/06/11 17:45:54
  194. --- cplusdem.c    1993/03/29 03:40:58
  195. ***************
  196. *** 148,154 ****
  197.     "co", "~",            /* ansi */
  198.     "call", "()",            /* old */
  199.     "cl", "()",            /* ansi */
  200. -   "cond", "?:",            /* old */
  201.     "alshift", "<<",        /* old */
  202.     "ls", "<<",            /* ansi */
  203.     "als", "<<=",            /* ansi */
  204. --- 148,153 ----
  205. ***************
  206. *** 235,240 ****
  207. --- 234,241 ----
  208.   {
  209.     int n = 0, success = 1;;
  210.     
  211. +   if (!isdigit (**type))
  212. +     return 0;
  213.     do
  214.       {
  215.         n *= 10;
  216. ***************
  217. *** 288,301 ****
  218.         /* virtual table "_vt$"  */
  219.         else if (type[0] == '_' && type[1] == 'v' && type[2] == 't' && type[3] == CPLUS_MARKER)
  220.       {
  221. !       int n = strlen (type + 4) + 14 + 1;
  222. !       char *tem = (char *) xmalloc (n);
  223. !       strcpy (tem, type + 4);
  224. !       strcat (tem, " virtual table");
  225. !       return tem;
  226.       }
  227.         /* static data member */
  228. !       else if (type[0] == '_' && type[1] != '_' && (strchr (type, CPLUS_MARKER) != NULL))
  229.       {
  230.         static_type = 1;
  231.         p = type + 1;
  232. --- 289,327 ----
  233.         /* virtual table "_vt$"  */
  234.         else if (type[0] == '_' && type[1] == 'v' && type[2] == 't' && type[3] == CPLUS_MARKER)
  235.       {
  236. !       if (isdigit (type[4]))
  237. !         {
  238. !           int n;
  239. !           string_init (&decl);
  240. !           type += 4;
  241. !           while (get_simple_count (&type, &n))
  242. !         {
  243. !           string_appendn (&decl, type, n);
  244. !           type += n;
  245. !           if (*type == '\0')
  246. !             {
  247. !               string_appendn (&decl, " virtual table", 15);
  248. !               return decl.b;
  249. !             }
  250. !           if (*type++ != CPLUS_MARKER)
  251. !             break;
  252. !           string_append (&decl, "::");
  253. !         }
  254. !           string_delete (&decl);
  255. !           return NULL;
  256. !         }
  257. !       else
  258. !         {
  259. !           int n = strlen (type + 4) + 14 + 1;
  260. !           char *tem = (char *) xmalloc (n);
  261. !           strcpy (tem, type + 4);
  262. !           strcat (tem, " virtual table");
  263. !           return tem;
  264. !         }
  265.       }
  266.         /* static data member */
  267. !       else if (type[0] == '_' && strchr ("0123456789Qt", type[1]) != NULL
  268. !            && strchr (type, CPLUS_MARKER) != NULL)
  269.       {
  270.         static_type = 1;
  271.         p = type + 1;
  272. ***************
  273. *** 345,351 ****
  274.     else
  275.       {
  276.         string_appendn (&decl, type, p - type);
  277. !       decl.p[0] = '0';
  278.         munge_function_name (&decl);
  279.         p += 2;
  280.       }
  281. --- 371,377 ----
  282.     else
  283.       {
  284.         string_appendn (&decl, type, p - type);
  285. !       decl.p[0] = '\0';
  286.         munge_function_name (&decl);
  287.         p += 2;
  288.       }
  289. ***************
  290. *** 451,456 ****
  291. --- 477,484 ----
  292.           string_delete (&trawname);
  293.           break;
  294.         }
  295. +     if (tname.p[-1] == '>')
  296. +       string_append (&tname, " ");
  297.       string_append (&tname, ">::");
  298.       if (destructor)
  299.         string_append(&tname, "~");
  300. ***************
  301. *** 556,573 ****
  302.         int member;
  303.         switch (**type)
  304.       {
  305. -     case 'Q':
  306. -       n = (*type)[1] - '0';
  307. -       if (n < 0 || n > 9)
  308. -         {
  309. -           success = 0;
  310. -           break;
  311. -         }
  312. -       *type += 2;
  313. -       while (n-- > 0)
  314. -         do_type (type, result);
  315. -       break;
  316. - 
  317.       case 'P':
  318.         *type += 1;
  319.         string_prepend (&decl, "*");
  320. --- 584,589 ----
  321. ***************
  322. *** 610,630 ****
  323.   
  324.           member = **type == 'M';
  325.           *type += 1;
  326. !         if (!isdigit (**type))
  327. !           {
  328. !         success = 0;
  329. !         break;
  330. !           }
  331. !         n = 0;
  332. !         do
  333.             {
  334. -         n *= 10;
  335. -         n += **type - '0';
  336. -         *type += 1;
  337. -           } 
  338. -         while (isdigit (**type));
  339. -         if (strlen (*type) < n)
  340. -           {
  341.           success = 0;
  342.           break;
  343.             }
  344. --- 626,633 ----
  345.   
  346.           member = **type == 'M';
  347.           *type += 1;
  348. !         if (!get_simple_count (type, &n))
  349.             {
  350.           success = 0;
  351.           break;
  352.             }
  353. ***************
  354. *** 747,752 ****
  355. --- 750,763 ----
  356.           *non_empty = 1;
  357.         string_append (result, "unsigned");
  358.         break;
  359. +     case 'S':
  360. +       *type += 1;
  361. +       if (*non_empty)
  362. +         string_append (result, " ");
  363. +       else
  364. +         *non_empty = 1;
  365. +       string_append (result, "signed");
  366. +       break;
  367.       case 'V':
  368.         *type += 1;
  369.         if (*non_empty)
  370. ***************
  371. *** 813,818 ****
  372. --- 824,835 ----
  373.       string_append (result, " ");
  374.         string_append (result, "char");
  375.         break;
  376. +     case 'w':
  377. +       *type += 1;
  378. +       if (*non_empty)
  379. +     string_append (result, " ");
  380. +       string_append (result, "wchar_t");
  381. +       break;
  382.       case 'r':
  383.         *type += 1;
  384.         if (*non_empty)
  385. ***************
  386. *** 883,890 ****
  387.         if (!do_template_args (type, result))
  388.       success = 0;
  389.         else
  390. !     string_append (result, ">");
  391.         break;
  392.       default:
  393.         success = 0;
  394.         break;
  395. --- 900,945 ----
  396.         if (!do_template_args (type, result))
  397.       success = 0;
  398.         else
  399. !     {
  400. !       if (result->p[-1] == '>')
  401. !         string_append (result, " ");
  402. !       string_append (result, ">");
  403. !     }
  404. !       break;
  405. !     case 'Q':
  406. !       n = (*type)[1] - '0';
  407. !       if (n < 0 || n > 9)
  408. !     {
  409. !       success = 0;
  410. !       break;
  411. !     }
  412. !       *type += 2;
  413. !       if (n > 0)
  414. !     {
  415. !       string temp;
  416. !       if (!do_type (type, &temp))
  417. !         {
  418. !           success = 0;
  419. !           break;
  420. !         }
  421. !       if (*non_empty)
  422. !         string_append (result, " ");
  423. !       string_appends (result, &temp);
  424. !       string_delete (&temp);
  425. !       while (--n > 0)
  426. !         {
  427. !           if (!do_type (type, &temp))
  428. !         {
  429. !           success = 0;
  430. !           break;
  431. !         }
  432. !           string_append (result, "::");
  433. !           string_appends (result, &temp);
  434. !           string_delete (&temp);
  435. !         }
  436. !     }
  437.         break;
  438. +       
  439.       default:
  440.         success = 0;
  441.         break;
  442. ***************
  443. *** 916,922 ****
  444.       {
  445.         *type += 1;
  446.   
  447. !       success = do_type (type, &temp);
  448.         if (success)
  449.           string_appends (result, &temp);
  450.         string_delete(&temp);
  451. --- 971,977 ----
  452.       {
  453.         *type += 1;
  454.   
  455. !       success = do_arg (type, &temp);
  456.         if (success)
  457.           string_appends (result, &temp);
  458.         string_delete(&temp);
  459. ***************
  460. *** 932,938 ****
  461.         int is_integral = 0;
  462.         int done = 0;
  463.   
  464. !       success = do_type (type, &temp);
  465.         if (success)
  466.           string_appends (result, &temp);
  467.         string_delete(&temp);
  468. --- 987,993 ----
  469.         int is_integral = 0;
  470.         int done = 0;
  471.   
  472. !       success = do_arg (type, &temp);
  473.         if (success)
  474.           string_appends (result, &temp);
  475.         string_delete(&temp);
  476. ***************
  477. *** 967,972 ****
  478. --- 1022,1028 ----
  479.           case 'i':    /* int */
  480.           case 's':    /* short */
  481.           case 'c':    /* char */
  482. +         case 'w': /* wchar_t */
  483.             done = is_integral = 1;
  484.             break;
  485.           case 'r':    /* long double */
  486. ===================================================================
  487. RCS file: /net/acae127/home/bammi/etc/src/master/atari/cross-util/fixstk.c,v
  488. retrieving revision 1.6
  489. diff -c -r1.6 fixstk.c
  490. *** 1.6    1992/07/21 14:52:06
  491. --- fixstk.c    1993/03/29 03:40:59
  492. ***************
  493. *** 38,43 ****
  494. --- 38,45 ----
  495.   # define SYM_OFFSET   (sizeof(short) + (3*sizeof(long)))
  496.   #endif
  497.   
  498. + int error = 0;
  499. + long newstksize;
  500.   
  501.   static char *sym_names[] = { "__stksize", "__initial_stack" };
  502.   
  503. ***************
  504. *** 48,56 ****
  505.   {
  506.       struct aexec head;
  507.       struct asym  sym;
  508. -     int found;
  509.       int    all = 0;
  510.       int index = 1;
  511.       
  512.   #ifndef WORD_ALIGNED
  513.       if(read(fd, &head, sizeof(head)) != sizeof(head))
  514. --- 50,62 ----
  515.   {
  516.       struct aexec head;
  517.       struct asym  sym;
  518.       int    all = 0;
  519.       int index = 1;
  520. + #ifndef WORD_ALIGNED
  521. +     char extension[sizeof (struct asym)];
  522. + #else
  523. +     char extension[SIZEOF_ASYM];
  524. + #endif
  525.       
  526.   #ifndef WORD_ALIGNED
  527.       if(read(fd, &head, sizeof(head)) != sizeof(head))
  528. ***************
  529. *** 59,75 ****
  530.   #endif
  531.       {
  532.       perror(fn);
  533. !     exit(2);
  534.       }
  535.       if(head.a_magic != CMAGIC)
  536.       {
  537. !     fprintf(stderr,"Invalid magic number %x\n", head.a_magic);
  538. !     exit(3);
  539.       }
  540.       if(head.a_syms == 0)
  541.       {
  542.       fprintf(stderr,"%s: no symbol table\n", fn);
  543. !     exit(4);
  544.       }
  545.       if(lseek(fd, head.a_text+head.a_data, 1) != 
  546.   #ifndef WORD_ALIGNED
  547. --- 65,81 ----
  548.   #endif
  549.       {
  550.       perror(fn);
  551. !     return -1;
  552.       }
  553.       if(head.a_magic != CMAGIC)
  554.       {
  555. !     fprintf(stderr,"%s: invalid magic number %x\n", fn, head.a_magic);
  556. !     return -1;
  557.       }
  558.       if(head.a_syms == 0)
  559.       {
  560.       fprintf(stderr,"%s: no symbol table\n", fn);
  561. !     return -1;
  562.       }
  563.       if(lseek(fd, head.a_text+head.a_data, 1) != 
  564.   #ifndef WORD_ALIGNED
  565. ***************
  566. *** 79,85 ****
  567.   #endif
  568.       {
  569.       perror(fn);
  570. !     exit(5);
  571.       }
  572.       for(;;)
  573.       {
  574. --- 85,91 ----
  575.   #endif
  576.       {
  577.       perror(fn);
  578. !     return -1;
  579.       }
  580.       for(;;)
  581.       {
  582. ***************
  583. *** 89,111 ****
  584.       if(index && read_sym(fd, &sym))
  585.   #endif
  586.       {
  587. !         fprintf(stderr, "symbol _stksize not found\n");
  588. !         exit(6);
  589.       }
  590.       /* after symbol read check first for _stksize */
  591.       index ^= 1;
  592.       if (strncmp(sym_names[index], sym.a_name, 8) == 0)
  593.       {
  594. !         if ((found = (sym.a_type & A_DATA)) || all++)
  595. !         break;
  596.       }
  597.       }
  598.       
  599. -     if(!found)
  600. -     {
  601. -     fprintf(stderr, "symbol _stksize is undefined\n");
  602. -     exit(9);
  603. -     }
  604.       *what = index;
  605.   #ifndef WORD_ALIGNED
  606.       return sym.a_value + sizeof(head);
  607. --- 95,126 ----
  608.       if(index && read_sym(fd, &sym))
  609.   #endif
  610.       {
  611. !         fprintf(stderr, "%s: symbol _stksize not found\n", fn);
  612. !         return -1;
  613.       }
  614. +     if (index && (sym.a_type & A_LNAM) == A_LNAM)
  615. +       if (read (fd, extension, sizeof (extension)) != sizeof (extension))
  616. +         {
  617. +           fprintf (stderr, "%s: symbol _stksize not found\n", fn);
  618. +           return -1;
  619. +         }
  620.       /* after symbol read check first for _stksize */
  621.       index ^= 1;
  622.       if (strncmp(sym_names[index], sym.a_name, 8) == 0)
  623.       {
  624. !       if ((sym.a_type & A_LNAM) == A_LNAM
  625. !           && strncmp (sym_names[index] + 8, extension, sizeof (extension)))
  626. !         continue;
  627. !       if (sym.a_type & A_DATA)
  628. !         break;
  629. !       if (all++)
  630. !         {
  631. !           fprintf (stderr, "%s: symbol _stksize is undefined\n", fn);
  632. !           return -1;
  633. !         }
  634.       }
  635.       }
  636.       
  637.       *what = index;
  638.   #ifndef WORD_ALIGNED
  639.       return sym.a_value + sizeof(head);
  640. ***************
  641. *** 141,177 ****
  642.   int argc;
  643.   char **argv;
  644.   {
  645. !     int fd;
  646. !     int what;
  647. !     long newstksize, stksize, offset;
  648. !     char sizestr[16], fn[FILENAME_MAX];
  649. !     
  650. !     if(argc < 2)
  651.       {
  652. !     fprintf(stderr, "usage: fixstk size [<filename>]\n");
  653. !     exit(1);
  654.       }
  655. ! 
  656. !     strcpy(sizestr, *++argv);
  657.   
  658. !     if(argc > 2)
  659. !     (void) strcpy(fn, *++argv);
  660. !     else
  661. !     (void) strcpy(fn, "gcc-cc1.ttp");
  662.   
  663.       if((fd = open(fn, 2)) < 0)
  664.       {
  665.       perror(fn);
  666. !     exit(1);
  667.       }
  668.       
  669. -     newstksize = calc_newsize(sizestr);
  670.       offset = find_offset(fd, fn, &what);
  671.       if(lseek(fd, offset, 0) != offset)
  672.       {
  673.       perror(fn);
  674.       close(fd);
  675. !     exit(7);
  676.       }
  677.       read(fd, &stksize, sizeof(long));
  678.       printf("%s: %s was %ld (%dK)\n",
  679. --- 156,199 ----
  680.   int argc;
  681.   char **argv;
  682.   {
  683. !   if (argc < 3)
  684.       {
  685. !       fprintf (stderr, "Usage: %s size file...\n", *argv);
  686. !       exit (1);
  687.       }
  688. !   newstksize = calc_newsize (*++argv);
  689. !   --argc;
  690. !   while (--argc)
  691. !     error |= fix_stack (*++argv);
  692. !   exit (error);
  693. ! }
  694.   
  695. ! int
  696. ! fix_stack (fn)
  697. !      char *fn;
  698. ! {
  699. !     int fd;
  700. !     int what;
  701. !     long stksize, offset;
  702.   
  703.       if((fd = open(fn, 2)) < 0)
  704.       {
  705.       perror(fn);
  706. !     return 1;
  707.       }
  708.       
  709.       offset = find_offset(fd, fn, &what);
  710. +     if (offset < 0)
  711. +       {
  712. +     close (fd);
  713. +     return 1;
  714. +       }
  715. + 
  716.       if(lseek(fd, offset, 0) != offset)
  717.       {
  718.       perror(fn);
  719.       close(fd);
  720. !     return 1;
  721.       }
  722.       read(fd, &stksize, sizeof(long));
  723.       printf("%s: %s was %ld (%dK)\n",
  724. ***************
  725. *** 183,189 ****
  726.       {
  727.       perror(fn);
  728.       close(fd);
  729. !     exit(8);
  730.       }
  731.       
  732.       lseek(fd, -((long)sizeof(long)), 1);
  733. --- 205,211 ----
  734.       {
  735.       perror(fn);
  736.       close(fd);
  737. !     return 1;
  738.       }
  739.       
  740.       lseek(fd, -((long)sizeof(long)), 1);
  741. ***************
  742. *** 191,197 ****
  743.       read(fd, &stksize, sizeof(long));
  744.       printf("%s: %s now is %ld (%dK)\n",
  745.            fn, sym_names[what] + 1, stksize, (int)(stksize/1024));
  746. !     return close(fd);
  747.   }
  748.   
  749.   #ifdef WORD_ALIGNED
  750. --- 213,219 ----
  751.       read(fd, &stksize, sizeof(long));
  752.       printf("%s: %s now is %ld (%dK)\n",
  753.            fn, sym_names[what] + 1, stksize, (int)(stksize/1024));
  754. !     return close(fd) != 0;
  755.   }
  756.   
  757.   #ifdef WORD_ALIGNED
  758. ===================================================================
  759. RCS file: /net/acae127/home/bammi/etc/src/master/atari/cross-util/ld.c,v
  760. retrieving revision 1.41
  761. diff -c -r1.41 ld.c
  762. *** 1.41    1992/11/08 00:29:27
  763. --- ld.c    1993/03/29 03:41:02
  764. ***************
  765. *** 132,142 ****
  766.   /* Determine whether we should attempt to handle (minimally)
  767.      N_BINCL and N_EINCL.  */
  768.   
  769. - #if (!(defined(atarist) || defined(atariminix) || defined(CROSSATARI)))
  770.   #if defined (__GNU_STAB__) || defined (N_BINCL)
  771.   #define HAVE_SUN_STABS
  772.   #endif
  773. - #endif
  774.   
  775.   #if (defined(CROSSATARI) || defined(atarist) || defined(atariminix))
  776.   /* stuff used when emitting reloc info here */
  777. --- 132,140 ----
  778. ***************
  779. *** 151,160 ****
  780. --- 149,160 ----
  781.   int rbuf_size = 0;        /* how many bytes are in there now */
  782.   long rbuf_last_pc = -1;        /* last rel pc; -1 means none yet */
  783.   
  784. + #if 0                /* all big alloca's changed to xmalloc */
  785.   #ifdef atarist        /* and a stack */
  786.   long _stksize = -1L;
  787.   #endif
  788.   #endif
  789. + #endif
  790.   
  791.   #ifdef min
  792.   #undef min
  793. ***************
  794. *** 259,265 ****
  795.   #ifdef i386
  796.   #define INITIALIZE_HEADER outheader.a_machtype = M_386
  797.   #endif
  798. ! #endif /* CROSSATARAI */
  799.   
  800.   #ifdef is68k
  801.   /* This enables code to take care of an ugly hack in the ISI OS.
  802. --- 259,265 ----
  803.   #ifdef i386
  804.   #define INITIALIZE_HEADER outheader.a_machtype = M_386
  805.   #endif
  806. ! #endif /* CROSSATARI */
  807.   
  808.   #ifdef is68k
  809.   /* This enables code to take care of an ugly hack in the ISI OS.
  810. ***************
  811. *** 447,453 ****
  812.   
  813.      The address of the set is made into an N_SETV symbol
  814.      whose name is the same as the name of the set.
  815. !    This symbol acts like a N_DATA global symbol
  816.      in that it can satisfy undefined external references.
  817.   
  818.      For the purposes of determining whether or not to load in a library
  819. --- 447,453 ----
  820.   
  821.      The address of the set is made into an N_SETV symbol
  822.      whose name is the same as the name of the set.
  823. !    This symbol acts like a N_TEXT global symbol
  824.      in that it can satisfy undefined external references.
  825.   
  826.      For the purposes of determining whether or not to load in a library
  827. ***************
  828. *** 890,895 ****
  829. --- 890,901 ----
  830.   void do_write_minix_out();
  831.   #endif
  832.   
  833. + #if defined (atarist) || defined (CROSSATARI)
  834. + /* atari special, specify load flags and head size */
  835. + int atari_load_flags;
  836. + int atari_heap_size;
  837. + #endif
  838. + 
  839.   /* Standard directories to search for files specified by -l.  */
  840.   #ifdef atarist
  841.   char *standard_search_dirs[] = {"\\gnu\\lib", "\\gnu"};
  842. ***************
  843. *** 1096,1106 ****
  844.     /* Initialize the data about options.  */
  845.   
  846.   #if defined(atarist) || defined(CROSSATARI)
  847. !   gst_symboltable = 0;
  848.     gst_symbols = 0;
  849.   #endif
  850.     specified_data_size = 0;
  851.     strip_symbols = STRIP_NONE;
  852.     trace_files = 0;
  853.     discard_locals = DISCARD_NONE;
  854.     entry_symbol = 0;
  855. --- 1102,1118 ----
  856.     /* Initialize the data about options.  */
  857.   
  858.   #if defined(atarist) || defined(CROSSATARI)
  859. !   gst_symboltable = 1;
  860.     gst_symbols = 0;
  861. +   atari_load_flags = 7;        /* fastload / tt ram is the default */
  862. +   atari_heap_size = 0;
  863.   #endif
  864.     specified_data_size = 0;
  865. + #ifdef atarist
  866. +   strip_symbols = STRIP_DEBUGGER;
  867. + #else
  868.     strip_symbols = STRIP_NONE;
  869. + #endif
  870.     trace_files = 0;
  871.     discard_locals = DISCARD_NONE;
  872.     entry_symbol = 0;
  873. ***************
  874. *** 1164,1174 ****
  875.     outheader.a_magic = magic;
  876.   #endif
  877.   
  878. - #if (!(defined(CROSSATARI) || defined(atarist) || defined(atariminix)))
  879.   #ifdef INITIALIZE_HEADER
  880.     INITIALIZE_HEADER;
  881.   #endif
  882. - #endif
  883.   
  884.   #if (defined(CROSSATARI) || defined(atarist) || defined(atariminix))
  885.     text_size = sizeof (struct aexec);
  886. --- 1176,1184 ----
  887. ***************
  888. *** 1255,1260 ****
  889. --- 1265,1274 ----
  890.       case 'o':
  891.       case 'u':
  892.       case 'y':
  893. + #if defined (atarist) || defined (CROSSATARI)
  894. +     case 'f':
  895. +     case 'h':
  896. + #endif
  897.         if (arg[2])
  898.       return 1;
  899.         return 2;
  900. ***************
  901. *** 1618,1623 ****
  902. --- 1632,1653 ----
  903.       case 'G':
  904.         gst_symboltable = 1;
  905.         return;
  906. + 
  907. +     case 'f':
  908. +       atari_load_flags = parse (arg, "%i", "invalid argument to -f");
  909. +       return;
  910. + 
  911. +     case 'h':
  912. +       {
  913. +     int heapsize_specified = parse (arg, "%i", "invalid argument to -h");
  914. +     if (heapsize_specified >= 0 && heapsize_specified < 16)
  915. +       atari_heap_size = heapsize_specified;
  916. +     else if (heapsize_specified >= 128 && heapsize_specified <= 16 * 128)
  917. +       atari_heap_size = (heapsize_specified - 128) / 128;
  918. +     else
  919. +       fatal ("invalid heap size", 0);
  920. +       }
  921. +       return;
  922.   #endif
  923.   
  924.       case 'l':
  925. ***************
  926. *** 2113,2121 ****
  927.     if (!N_BADMAG (*((struct exec *)&magicnum)))
  928.       {
  929.         read_entry_symbols (desc, entry);
  930. !       entry->strings = (char *) alloca (entry->string_size);
  931.         read_entry_strings (desc, entry);
  932.         enter_file_symbols (entry);
  933.         entry->strings = 0;
  934.       }
  935.     else
  936. --- 2143,2152 ----
  937.     if (!N_BADMAG (*((struct exec *)&magicnum)))
  938.       {
  939.         read_entry_symbols (desc, entry);
  940. !       entry->strings = (char *) xmalloc (entry->string_size);
  941.         read_entry_strings (desc, entry);
  942.         enter_file_symbols (entry);
  943. +       free (entry->strings);
  944.         entry->strings = 0;
  945.       }
  946.     else
  947. ***************
  948. *** 2697,2703 ****
  949.                + symdef_base[i].symbol_name_string_index,
  950.                entry->filename);
  951.           read_entry_symbols (desc, subentry);
  952. !         subentry->strings = (char *) malloc (subentry->string_size);
  953.           read_entry_strings (desc, subentry);
  954.   
  955.           /* Now scan the symbol table and decide whether to load.  */
  956. --- 2728,2734 ----
  957.                + symdef_base[i].symbol_name_string_index,
  958.                entry->filename);
  959.           read_entry_symbols (desc, subentry);
  960. !         subentry->strings = (char *) xmalloc (subentry->string_size);
  961.           read_entry_strings (desc, subentry);
  962.   
  963.           /* Now scan the symbol table and decide whether to load.  */
  964. ***************
  965. *** 2764,2775 ****
  966.         if (!subentry) return;
  967.   
  968.         read_entry_symbols (desc, subentry);
  969. !       subentry->strings = (char *) alloca (subentry->string_size);
  970.         read_entry_strings (desc, subentry);
  971.   
  972.         if (!subfile_wanted_p (subentry))
  973.       {
  974.         free (subentry->symbols);
  975.         free (subentry);
  976.       }
  977.         else
  978. --- 2795,2807 ----
  979.         if (!subentry) return;
  980.   
  981.         read_entry_symbols (desc, subentry);
  982. !       subentry->strings = (char *) xmalloc (subentry->string_size);
  983.         read_entry_strings (desc, subentry);
  984.   
  985.         if (!subfile_wanted_p (subentry))
  986.       {
  987.         free (subentry->symbols);
  988. +       free (subentry->strings);
  989.         free (subentry);
  990.       }
  991.         else
  992. ***************
  993. *** 2781,2787 ****
  994.         else
  995.               entry->subfiles = subentry;
  996.         prev = subentry;
  997. !           subentry->strings = 0; /* Since space will dissapear on return */
  998.       }
  999.   
  1000.         this_subfile_offset += member_length + sizeof (struct ar_hdr);
  1001. --- 2813,2820 ----
  1002.         else
  1003.               entry->subfiles = subentry;
  1004.         prev = subentry;
  1005. !       free (subentry->strings);
  1006. !           subentry->strings = 0;
  1007.       }
  1008.   
  1009.         this_subfile_offset += member_length + sizeof (struct ar_hdr);
  1010. ***************
  1011. *** 3073,3079 ****
  1012. --- 3106,3116 ----
  1013.           {
  1014.             if (!relocatable_output || force_common_definition)
  1015.           {
  1016. + #ifdef atarist
  1017. +           com = (com + sizeof (short) - 1) & (- sizeof (short));
  1018. + #else
  1019.             com = (com + sizeof (int) - 1) & (- sizeof (int));
  1020. + #endif
  1021.   
  1022.             sp->value = data_start + data_size + bss_size;
  1023.             sp->defined = N_BSS | N_EXT;
  1024. ***************
  1025. *** 3133,3138 ****
  1026. --- 3170,3176 ----
  1027.   
  1028.     /* Figure the data_pad now, so that it overlaps with the bss addresses.  */
  1029.   
  1030. + #if (!(defined(CROSSATARI) || defined(atarist) || defined(atariminix)))
  1031.     if (specified_data_size && specified_data_size > data_size)
  1032.       data_pad = specified_data_size - data_size;
  1033.   
  1034. ***************
  1035. *** 3144,3149 ****
  1036. --- 3182,3188 ----
  1037.     if (bss_size < 0) bss_size = 0;
  1038.   
  1039.     data_size += data_pad;
  1040. + #endif
  1041.   }
  1042.   
  1043.   /* Accumulate the section sizes of input file ENTRY
  1044. ***************
  1045. *** 3212,3222 ****
  1046.       switch (type)
  1047.         {
  1048.         case N_TEXT:
  1049.         case N_SETT:
  1050.           p->n_value += entry->text_start_address;
  1051.           break;
  1052.         case N_DATA:
  1053. -       case N_SETV:
  1054.         case N_SETD:
  1055.           /* A symbol whose value is in the data section
  1056.              is present in the input file as if the data section
  1057. --- 3251,3261 ----
  1058.       switch (type)
  1059.         {
  1060.         case N_TEXT:
  1061. +       case N_SETV:
  1062.         case N_SETT:
  1063.           p->n_value += entry->text_start_address;
  1064.           break;
  1065.         case N_DATA:
  1066.         case N_SETD:
  1067.           /* A symbol whose value is in the data section
  1068.              is present in the input file as if the data section
  1069. ***************
  1070. *** 3297,3303 ****
  1071.   {
  1072.     register struct nlist *p, *end = entry->symbols + entry->header.a_syms / sizeof (struct nlist);
  1073.   
  1074. !   entry->strings = (char *) alloca (entry->string_size);
  1075.     read_entry_strings (file_open (entry), entry);
  1076.   
  1077.     fprintf (outfile, "\nLocal symbols of ");
  1078. --- 3336,3342 ----
  1079.   {
  1080.     register struct nlist *p, *end = entry->symbols + entry->header.a_syms / sizeof (struct nlist);
  1081.   
  1082. !   entry->strings = (char *) xmalloc (entry->string_size);
  1083.     read_entry_strings (file_open (entry), entry);
  1084.   
  1085.     fprintf (outfile, "\nLocal symbols of ");
  1086. ***************
  1087. *** 3319,3324 ****
  1088. --- 3358,3364 ----
  1089.       free(nm);
  1090.         }
  1091.   
  1092. +   free (entry->strings);
  1093.     entry->strings = 0;        /* All done with them.  */
  1094.   }
  1095.   
  1096. ***************
  1097. *** 3361,3367 ****
  1098.       {
  1099.         FILE *desc;
  1100.   
  1101. !       entry->strings = (char *) alloca (entry->string_size);
  1102.         desc = file_open (entry);
  1103.         read_entry_strings (desc, entry);
  1104.       }
  1105. --- 3401,3407 ----
  1106.       {
  1107.         FILE *desc;
  1108.   
  1109. !       entry->strings = (char *) xmalloc (entry->string_size);
  1110.         desc = file_open (entry);
  1111.         read_entry_strings (desc, entry);
  1112.       }
  1113. ***************
  1114. *** 3573,3578 ****
  1115. --- 3613,3619 ----
  1116.         }
  1117.     }
  1118.   
  1119. +   free (entry->strings);
  1120.     entry->strings = 0;
  1121.   }
  1122.   /*
  1123. ***************
  1124. *** 3969,3977 ****
  1125.   #else 
  1126.     /* TOS */
  1127.     outheader.a_AZero1 = 0;        /* good a place as any to do this */
  1128. !   outheader.a_ldflgs = 0;        /* fastload is NOT the default */
  1129.     if (magic == NMAGIC)
  1130. !     outheader.a_ldflgs = F_SHTEXT;    /* sharable text */
  1131.     outheader.a_isreloc = ISRELOCINFO;    /* means reloc present (!) */
  1132.   #endif
  1133.   #endif
  1134. --- 4010,4018 ----
  1135.   #else 
  1136.     /* TOS */
  1137.     outheader.a_AZero1 = 0;        /* good a place as any to do this */
  1138. !   outheader.a_ldflgs = atari_load_flags | (atari_heap_size << 28);
  1139.     if (magic == NMAGIC)
  1140. !     outheader.a_ldflgs |= F_SHTEXT;    /* sharable text */
  1141.     outheader.a_isreloc = ISRELOCINFO;    /* means reloc present (!) */
  1142.   #endif
  1143.   #endif
  1144. ***************
  1145. *** 4036,4046 ****
  1146.       }
  1147.   #endif
  1148.   
  1149. - #if (!(defined(CROSSATARI) || defined(atarist) || defined(atariminix)))
  1150.   #ifdef INITIALIZE_HEADER
  1151.     INITIALIZE_HEADER;
  1152.   #endif
  1153. - #endif
  1154.   
  1155.     if (strip_symbols == STRIP_ALL)
  1156.       nsyms = 0;
  1157. --- 4077,4085 ----
  1158. ***************
  1159. *** 4176,4182 ****
  1160. --- 4215,4223 ----
  1161.     if (trace_files)
  1162.       fprintf (stderr, "\n");
  1163.   
  1164. + #if (!(defined(CROSSATARI) || defined(atarist) || defined(atariminix)))
  1165.     padfile (text_pad, outdesc);
  1166. + #endif
  1167.   }
  1168.   
  1169.   int
  1170. ***************
  1171. *** 4253,4259 ****
  1172.   
  1173.     /* Allocate space for the file's text section */
  1174.   
  1175. !   bytes = (char *) alloca (entry->header.a_text);
  1176.   
  1177.     /* Deal with relocation information however is appropriate */
  1178.   
  1179. --- 4294,4300 ----
  1180.   
  1181.     /* Allocate space for the file's text section */
  1182.   
  1183. !   bytes = (char *) xmalloc (entry->header.a_text);
  1184.   
  1185.     /* Deal with relocation information however is appropriate */
  1186.   
  1187. ***************
  1188. *** 4290,4295 ****
  1189. --- 4331,4339 ----
  1190.     /* Write the relocated text to the output file.  */
  1191.   
  1192.     mywrite (bytes, 1, entry->header.a_text, outdesc);
  1193. + 
  1194. +   /* Free the space for the text segment.  */
  1195. +   free (bytes);
  1196.   }
  1197.   
  1198.   /* Relocate the data segment of each input file
  1199. ***************
  1200. *** 4307,4313 ****
  1201. --- 4351,4359 ----
  1202.     if (trace_files)
  1203.       fprintf (stderr, "\n");
  1204.   
  1205. + #if (!(defined(CROSSATARI) || defined(atarist) || defined(atariminix)))
  1206.     padfile (data_pad, outdesc);
  1207. + #endif
  1208.   }
  1209.   
  1210.   /* Read the data segment contents of ENTRY, relocate them,
  1211. ***************
  1212. *** 4328,4334 ****
  1213.   
  1214.     desc = file_open (entry);
  1215.   
  1216. !   bytes = (char *) alloca (entry->header.a_data);
  1217.   
  1218.     if (entry->datarel) reloc = entry->datarel;
  1219.   #if (defined(CROSSATARI) || defined(atarist) || defined(atariminix))
  1220. --- 4374,4380 ----
  1221.   
  1222.     desc = file_open (entry);
  1223.   
  1224. !   bytes = (char *) xmalloc (entry->header.a_data);
  1225.   
  1226.     if (entry->datarel) reloc = entry->datarel;
  1227.   #if (defined(CROSSATARI) || defined(atarist) || defined(atariminix))
  1228. ***************
  1229. *** 4359,4364 ****
  1230. --- 4405,4412 ----
  1231.                 entry, 0);
  1232.   
  1233.     mywrite (bytes, 1, entry->header.a_data, outdesc);
  1234. + 
  1235. +   free (bytes);
  1236.   }
  1237.   
  1238.   static symbol *
  1239. ***************
  1240. *** 4431,4436 ****
  1241. --- 4479,4485 ----
  1242.     int data_relocation = entry->data_start_address - entry->header.a_text;
  1243.     int bss_relocation
  1244.       = entry->bss_start_address - entry->header.a_text - entry->header.a_data;
  1245. +   int text_overflow = entry->header.a_text & ~65535;
  1246.   
  1247.     for (; p < end; p++)
  1248.       {
  1249. ***************
  1250. *** 4535,4541 ****
  1251.           if (RELOC_PCREL_P(p)||RELOC_EXTERN_P(p))
  1252.             word = *(short *) (data + addr);
  1253.           else
  1254. !           word = *(unsigned short *) (data + addr);
  1255.   #ifdef BYTE_SWAP
  1256.           word = SWAP2(word);
  1257.   #endif
  1258. --- 4584,4590 ----
  1259.           if (RELOC_PCREL_P(p)||RELOC_EXTERN_P(p))
  1260.             word = *(short *) (data + addr);
  1261.           else
  1262. !           word = *(unsigned short *) (data + addr) + text_overflow;
  1263.   #ifdef BYTE_SWAP
  1264.           word = SWAP2(word);
  1265.   #endif
  1266. ***************
  1267. *** 4544,4550 ****
  1268.         if (relocation > 32767 || relocation < -32768) {
  1269.           if (!RELOC_EXTERN_P(p))
  1270.             if (!entry->strings) {
  1271. !         entry->strings = (char *) alloca (entry->string_size);
  1272.           read_entry_strings (file_open (entry), entry);
  1273.             }
  1274.           error ("fatal error: relocation out of range for %s in %s",
  1275. --- 4593,4599 ----
  1276.         if (relocation > 32767 || relocation < -32768) {
  1277.           if (!RELOC_EXTERN_P(p))
  1278.             if (!entry->strings) {
  1279. !         entry->strings = (char *) xmalloc (entry->string_size);
  1280.           read_entry_strings (file_open (entry), entry);
  1281.             }
  1282.           error ("fatal error: relocation out of range for %s in %s",
  1283. ***************
  1284. *** 4586,4592 ****
  1285.         if (pure_text && relocation > text_size+text_start) {
  1286.           if (!RELOC_EXTERN_P(p))
  1287.             if (!entry->strings) {
  1288. !         entry->strings = (char *) alloca (entry->string_size);
  1289.           read_entry_strings (file_open (entry), entry);
  1290.             }
  1291.           error ("absolute reference to %s from pure-text in %s",
  1292. --- 4635,4641 ----
  1293.         if (pure_text && relocation > text_size+text_start) {
  1294.           if (!RELOC_EXTERN_P(p))
  1295.             if (!entry->strings) {
  1296. !         entry->strings = (char *) xmalloc (entry->string_size);
  1297.           read_entry_strings (file_open (entry), entry);
  1298.             }
  1299.           error ("absolute reference to %s from pure-text in %s",
  1300. ***************
  1301. *** 4629,4634 ****
  1302. --- 4678,4685 ----
  1303.   }
  1304.   #endif /* BYTE_SWAP */
  1305.       }
  1306. +     if (entry->strings)
  1307. +       free (entry->strings);
  1308.       entry->strings = 0;
  1309.   }
  1310.   
  1311. ***************
  1312. *** 4777,4782 ****
  1313. --- 4828,4834 ----
  1314.       reloc_less_p);
  1315.     for (reloc_num = n_relocs - 1 ; reloc_num >= 0 ; reloc_num-- )
  1316.       if ((entry->textrel[reloc_num].r_length == 2) &&
  1317. +         !entry->textrel[reloc_num].r_pcrel &&
  1318.         !emit_atari_reloc(entry->textrel[reloc_num].r_address + text_base))
  1319.           fprintf(stderr, "  while processing text rel %d/%d of entry %s\n",
  1320.           reloc_num, n_relocs, entry->filename);
  1321. ***************
  1322. *** 4792,4797 ****
  1323. --- 4844,4851 ----
  1324.     qsort(entry->datarel, n_relocs, sizeof (struct relocation_info), 
  1325.       reloc_less_p);
  1326.     for (reloc_num = n_relocs - 1 ; reloc_num >= 0 ; reloc_num-- )
  1327. +     if (entry->datarel[reloc_num].r_length == 2
  1328. +     && !entry->datarel[reloc_num].r_pcrel)
  1329.       if (!emit_atari_reloc(entry->datarel[reloc_num].r_address + data_base))
  1330.           fprintf(stderr, "  while processing data rel %d/%d of entry %s\n",
  1331.           reloc_num, n_relocs, entry->filename);
  1332. ***************
  1333. *** 4942,4960 ****
  1334.       case N_UNDF: sym.a_type = A_UNDF; break;
  1335.       case N_ABS:  sym.a_type = A_EQU; break; /* ??? */
  1336.           case N_SETT:
  1337. -     case N_TEXT: sym.a_type = A_TEXT; break;
  1338.           case N_SETV:
  1339.           case N_SETD:
  1340.       case N_DATA: sym.a_type = A_DATA; break;
  1341.           case N_SETB:
  1342.       case N_BSS:  sym.a_type = A_BSS; break;
  1343.           case N_ATARI_FILENAME: sym.a_type = A_TFILE; break;
  1344. !     default: /* fake it */
  1345. !           sym.a_type = A_UNDF;
  1346. !       bzero(sym.a_name, sizeof(sym.a_name));
  1347. !       strncpy(sym.a_name, str, sizeof(sym.a_name));
  1348. !       i = 0;
  1349. !       goto fake_out;
  1350.   
  1351.   /* figure out rest of this later */
  1352.       }
  1353. --- 4996,5009 ----
  1354.       case N_UNDF: sym.a_type = A_UNDF; break;
  1355.       case N_ABS:  sym.a_type = A_EQU; break; /* ??? */
  1356.           case N_SETT:
  1357.           case N_SETV:
  1358. +     case N_TEXT: sym.a_type = A_TEXT; break;
  1359.           case N_SETD:
  1360.       case N_DATA: sym.a_type = A_DATA; break;
  1361.           case N_SETB:
  1362.       case N_BSS:  sym.a_type = A_BSS; break;
  1363.           case N_ATARI_FILENAME: sym.a_type = A_TFILE; break;
  1364. !     default:     sym.a_type = A_UNDF; break;
  1365.   
  1366.   /* figure out rest of this later */
  1367.       }
  1368. ***************
  1369. *** 5010,5016 ****
  1370.   
  1371.     /* Read the file's string table.  */
  1372.   
  1373. !   entry->strings = (char *) alloca (entry->string_size);
  1374.     read_entry_strings (file_open (entry), entry);
  1375.   
  1376.     /* Generate a local symbol for the start of this file's text.  */
  1377. --- 5059,5065 ----
  1378.   
  1379.     /* Read the file's string table.  */
  1380.   
  1381. !   entry->strings = (char *) xmalloc (entry->string_size);
  1382.     read_entry_strings (file_open (entry), entry);
  1383.   
  1384.     /* Generate a local symbol for the start of this file's text.  */
  1385. ***************
  1386. *** 5035,5045 ****
  1387.       {
  1388.         register int type = p->n_type;
  1389.         register int write = 0;
  1390. -       int is_a_set_ele;
  1391.   
  1392.         /* WRITE gets 1 for a non-global symbol that should be written.  */
  1393.   
  1394. !       if ((is_a_set_ele = SET_ELEMENT_P (type))) /* This occurs even if global.  These */
  1395.                   /* types of symbols are never written */
  1396.                   /* globally, though they are stored */
  1397.                   /* globally.  */
  1398. --- 5084,5093 ----
  1399.       {
  1400.         register int type = p->n_type;
  1401.         register int write = 0;
  1402.   
  1403.         /* WRITE gets 1 for a non-global symbol that should be written.  */
  1404.   
  1405. !       if (SET_ELEMENT_P (type)) /* This occurs even if global.  These */
  1406.                   /* types of symbols are never written */
  1407.                   /* globally, though they are stored */
  1408.                   /* globally.  */
  1409. ***************
  1410. *** 5058,5073 ****
  1411.         /* If this symbol has a name, write it */
  1412.   
  1413.         if (p->n_un.n_strx)
  1414. !         {
  1415. !         write_atari_sym(p, ((is_a_set_ele)?
  1416. !         ((symbol *) p->n_un.n_name)->name : p->n_un.n_strx + entry->strings));
  1417. ! #if 0
  1418. !              "SET_ELEMENT" : p->n_un.n_strx + entry->strings));
  1419. ! #endif
  1420. !         (*syms_written_addr)++;
  1421. !         }
  1422.       }
  1423.       }
  1424.     entry->strings = NULL;  
  1425.   }
  1426.   
  1427. --- 5106,5120 ----
  1428.         /* If this symbol has a name, write it */
  1429.   
  1430.         if (p->n_un.n_strx)
  1431. !         write_atari_sym(p, (SET_ELEMENT_P (type)
  1432. !                 ? ((symbol *) p->n_un.n_name)->name
  1433. !                 : p->n_un.n_strx + entry->strings));
  1434. !       else
  1435. !         write_atari_sym (p, "DBXSYM");
  1436. !       (*syms_written_addr)++;
  1437.       }
  1438.       }
  1439. +   free (entry->strings);
  1440.     entry->strings = NULL;  
  1441.   }
  1442.   
  1443. ***************
  1444. *** 5081,5086 ****
  1445. --- 5128,5134 ----
  1446.       return;
  1447.   
  1448.     each_file(write_atari_syms, &n_syms_written);
  1449. +   file_close ();
  1450.   
  1451.     /* Now write out the global symbols.  */
  1452.   
  1453. ***************
  1454. *** 5145,5171 ****
  1455.           n_syms_written++;
  1456.         }
  1457.         }
  1458. -   /* this is really stretching it, but we have to fake it */
  1459. -   if(n_syms_written < nsyms)
  1460. -   {
  1461. -       struct nlist nl;
  1462.   
  1463. -       nl.n_value = 0;
  1464. -       nl.n_type = (0x7ffff & N_TYPE); /* make sure it falls into the default */
  1465. -                       /* case in write_atari_sym() */
  1466. -       
  1467. -       while(n_syms_written < nsyms)
  1468. -       {
  1469. - #ifdef BYTE_SWAP
  1470. - nl.n_un.n_strx    = SWAP4(nl.n_un.n_strx);
  1471. - nl.n_desc        = SWAP2(nl.n_desc);
  1472. - nl.n_value      = SWAP4(nl.n_value);
  1473. - #endif
  1474. -       write_atari_sym(&nl, "FAKEEAKF");
  1475. -       n_syms_written++;
  1476. -       }
  1477. -       
  1478. -   }
  1479.     if (n_syms_written != nsyms)
  1480.       fprintf(stderr, "Bogon alert!  wrote %d syms, expected to write %d\n",
  1481.                n_syms_written, nsyms);
  1482. --- 5193,5199 ----
  1483. ***************
  1484. *** 5225,5231 ****
  1485.   
  1486.     /* Read the file's string table.  */
  1487.   
  1488. !   entry->strings = (char *) alloca (entry->string_size);
  1489.     read_entry_strings (file_open (entry), entry);
  1490.   
  1491.     /* Generate a local symbol for the start of this file's text.  */
  1492. --- 5253,5259 ----
  1493.   
  1494.     /* Read the file's string table.  */
  1495.   
  1496. !   entry->strings = (char *) xmalloc (entry->string_size);
  1497.     read_entry_strings (file_open (entry), entry);
  1498.   
  1499.     /* Generate a local symbol for the start of this file's text.  */
  1500. ***************
  1501. *** 5274,5279 ****
  1502. --- 5302,5308 ----
  1503.           }
  1504.       }
  1505.       }
  1506. +   free (entry->strings);
  1507.     entry->strings = NULL;  
  1508.   }
  1509.   
  1510. ***************
  1511. *** 5441,5450 ****
  1512.        extra struct for each indirect symbol to hold the extra reference
  1513.        following. */
  1514.     struct nlist *buf
  1515. !     = (struct nlist *) alloca ((defined_global_sym_count
  1516. !                 + undefined_global_sym_count
  1517. !                 + global_indirect_count)
  1518. !                    * sizeof (struct nlist));
  1519.     /* Pointer for storing into BUF.  */
  1520.     register struct nlist *bufp = buf;
  1521.   
  1522. --- 5470,5479 ----
  1523.        extra struct for each indirect symbol to hold the extra reference
  1524.        following. */
  1525.     struct nlist *buf
  1526. !     = (struct nlist *) xmalloc ((defined_global_sym_count
  1527. !                  + undefined_global_sym_count
  1528. !                  + global_indirect_count)
  1529. !                 * sizeof (struct nlist));
  1530.     /* Pointer for storing into BUF.  */
  1531.     register struct nlist *bufp = buf;
  1532.   
  1533. ***************
  1534. *** 5457,5463 ****
  1535.     string_table_len = strtab_size;
  1536.   
  1537.     if (strip_symbols == STRIP_ALL)
  1538. !     return;
  1539.   
  1540.     /* Write the local symbols defined by the various files.  */
  1541.   
  1542. --- 5486,5495 ----
  1543.     string_table_len = strtab_size;
  1544.   
  1545.     if (strip_symbols == STRIP_ALL)
  1546. !     {
  1547. !       free (buf);
  1548. !       return;
  1549. !     }
  1550.   
  1551.     /* Write the local symbols defined by the various files.  */
  1552.   
  1553. ***************
  1554. *** 5470,5479 ****
  1555.        table from the global symbols written so far.  This must include
  1556.        extra space for the references following indirect outputs. */
  1557.   
  1558. !   strtab_vector = (char **) alloca ((num_hash_tab_syms
  1559. !                      + global_indirect_count) * sizeof (char *));
  1560. !   strtab_lens = (int *) alloca ((num_hash_tab_syms
  1561. !                  + global_indirect_count) * sizeof (int));
  1562.     strtab_index = 0;
  1563.   
  1564.     /* Scan the symbol hash table, bucket by bucket.  */
  1565. --- 5502,5511 ----
  1566.        table from the global symbols written so far.  This must include
  1567.        extra space for the references following indirect outputs. */
  1568.   
  1569. !   strtab_vector = (char **) xmalloc ((num_hash_tab_syms
  1570. !                       + global_indirect_count) * sizeof (char *));
  1571. !   strtab_lens = (int *) xmalloc ((num_hash_tab_syms
  1572. !                   + global_indirect_count) * sizeof (int));
  1573.     strtab_index = 0;
  1574.   
  1575.     /* Scan the symbol hash table, bucket by bucket.  */
  1576. ***************
  1577. *** 5573,5578 ****
  1578. --- 5605,5616 ----
  1579.     /* Write the strings for the global symbols.  */
  1580.   
  1581.     write_string_table ();
  1582. + 
  1583. +   /* Free the buffers.  */
  1584. + 
  1585. +   free (strtab_lens);
  1586. +   free (strtab_vector);
  1587. +   free (buf);
  1588.   }
  1589.   
  1590.   /* Write the local and debugger symbols of file ENTRY.
  1591. ***************
  1592. *** 5592,5598 ****
  1593.     /* Buffer to accumulate all the syms before writing them.
  1594.        It has one extra slot for the local symbol we generate here.  */
  1595.     struct nlist *buf
  1596. !     = (struct nlist *) alloca (entry->header.a_syms + sizeof (struct nlist));
  1597.     register struct nlist *bufp = buf;
  1598.   
  1599.     /* Upper bound on number of syms to be written here.  */
  1600. --- 5630,5636 ----
  1601.     /* Buffer to accumulate all the syms before writing them.
  1602.        It has one extra slot for the local symbol we generate here.  */
  1603.     struct nlist *buf
  1604. !     = (struct nlist *) xmalloc (entry->header.a_syms + sizeof (struct nlist));
  1605.     register struct nlist *bufp = buf;
  1606.   
  1607.     /* Upper bound on number of syms to be written here.  */
  1608. ***************
  1609. *** 5601,5608 ****
  1610.     /* Make tables that record, for each symbol, its name and its name's length.
  1611.        The elements are filled in by `assign_string_table_index'.  */
  1612.   
  1613. !   strtab_vector = (char **) alloca (max_syms * sizeof (char *));
  1614. !   strtab_lens = (int *) alloca (max_syms * sizeof (int));
  1615.     strtab_index = 0;
  1616.   
  1617.     /* Generate a local symbol for the start of this file's text.  */
  1618. --- 5639,5646 ----
  1619.     /* Make tables that record, for each symbol, its name and its name's length.
  1620.        The elements are filled in by `assign_string_table_index'.  */
  1621.   
  1622. !   strtab_vector = (char **) xmalloc (max_syms * sizeof (char *));
  1623. !   strtab_lens = (int *) xmalloc (max_syms * sizeof (int));
  1624.     strtab_index = 0;
  1625.   
  1626.     /* Generate a local symbol for the start of this file's text.  */
  1627. ***************
  1628. *** 5623,5629 ****
  1629.   
  1630.     /* Read the file's string table.  */
  1631.   
  1632. !   entry->strings = (char *) alloca (entry->string_size);
  1633.     read_entry_strings (file_open (entry), entry);
  1634.   
  1635.     for (; p < end; p++)
  1636. --- 5661,5667 ----
  1637.   
  1638.     /* Read the file's string table.  */
  1639.   
  1640. !   entry->strings = (char *) xmalloc (entry->string_size);
  1641.     read_entry_strings (file_open (entry), entry);
  1642.   
  1643.     for (; p < end; p++)
  1644. ***************
  1645. *** 5685,5695 ****
  1646.        using the data in vectors `strtab_vector' and `strtab_lens'.  */
  1647.   
  1648.     write_string_table ();
  1649. !   entry->strings = 0;        /* Since it will dissapear anyway.  */
  1650.   }
  1651.   #endif            /* not atari st */
  1652.   
  1653.   
  1654.   /* Copy any GDB symbol segments from the input files to the output file.
  1655.      The contents of the symbol segment is copied without change
  1656.      except that we store some information into the beginning of it.  */
  1657. --- 5723,5740 ----
  1658.        using the data in vectors `strtab_vector' and `strtab_lens'.  */
  1659.   
  1660.     write_string_table ();
  1661. ! 
  1662. !   /* Free all buffers.  */
  1663. !   free (entry->strings);
  1664. !   entry->strings = 0;
  1665. !   free (strtab_lens);
  1666. !   free (strtab_vector);
  1667. !   free (buf);
  1668.   }
  1669.   #endif            /* not atari st */
  1670.   
  1671.   
  1672. + #if (!(defined(CROSSATARI) || defined(atarist) || defined(atariminix)))
  1673.   /* Copy any GDB symbol segments from the input files to the output file.
  1674.      The contents of the symbol segment is copied without change
  1675.      except that we store some information into the beginning of it.  */
  1676. ***************
  1677. *** 5706,5713 ****
  1678.   write_file_symseg (entry)
  1679.        struct file_entry *entry;
  1680.   {
  1681. -   /* this appears to be completely wrong for ST */
  1682. - #if (!(defined(CROSSATARI) || defined(atarist) || defined(atariminix)))
  1683.     char buffer[4096];
  1684.     struct symbol_root root;
  1685.     FILE *indesc;
  1686. --- 5751,5756 ----
  1687. ***************
  1688. *** 5769,5776 ****
  1689.       }
  1690.   
  1691.     file_close ();
  1692. - #endif
  1693.   }
  1694.   
  1695.   /* Create the symbol table entries for `etext', `edata' and `end'.  */
  1696.   
  1697. --- 5812,5819 ----
  1698.       }
  1699.   
  1700.     file_close ();
  1701.   }
  1702. + #endif /* not atari */
  1703.   
  1704.   /* Create the symbol table entries for `etext', `edata' and `end'.  */
  1705.   
  1706. ***************
  1707. *** 5996,6001 ****
  1708. --- 6039,6045 ----
  1709.     }
  1710.   }
  1711.   
  1712. + #if (!(defined(CROSSATARI) || defined(atarist) || defined(atariminix)))
  1713.   /* Output PADDING zero-bytes to descriptor OUTDESC.
  1714.      PADDING may be negative; in that case, do nothing.  */
  1715.   
  1716. ***************
  1717. *** 6004,6011 ****
  1718.        int padding;
  1719.        FILE *outdesc;
  1720.   {
  1721. -     /* not round here, you don't... */
  1722. - #if (!(defined(CROSSATARI) || defined(atarist) || defined(atariminix)))
  1723.     register char *buf;
  1724.     if (padding <= 0)
  1725.       return;
  1726. --- 6048,6053 ----
  1727. ***************
  1728. *** 6013,6020 ****
  1729.     buf = (char *) alloca (padding);
  1730.     bzero (buf, padding);
  1731.     mywrite (buf, padding, 1, outdesc);
  1732. - #endif
  1733.   }
  1734.   
  1735.   /* Return a newly-allocated string
  1736.      whose contents concatenate the strings S1, S2, S3.  */
  1737. --- 6055,6062 ----
  1738.     buf = (char *) alloca (padding);
  1739.     bzero (buf, padding);
  1740.     mywrite (buf, padding, 1, outdesc);
  1741.   }
  1742. + #endif /* not atari */
  1743.   
  1744.   /* Return a newly-allocated string
  1745.      whose contents concatenate the strings S1, S2, S3.  */
  1746. ***************
  1747. *** 6176,6182 ****
  1748.   
  1749.     /* Read the file's string table.  */
  1750.   
  1751. !   entry->strings = (char *) alloca (entry->string_size);
  1752.     read_entry_strings (file_open (entry), entry);
  1753.   
  1754.     /* Generate a local symbol for the start of this file's text.  */
  1755. --- 6218,6224 ----
  1756.   
  1757.     /* Read the file's string table.  */
  1758.   
  1759. !   entry->strings = (char *) xmalloc (entry->string_size);
  1760.     read_entry_strings (file_open (entry), entry);
  1761.   
  1762.     /* Generate a local symbol for the start of this file's text.  */
  1763. ***************
  1764. *** 6221,6226 ****
  1765. --- 6263,6269 ----
  1766.           }
  1767.       }
  1768.       }
  1769. +   free (entry->strings);
  1770.     entry->strings = NULL;  
  1771.   }
  1772.   
  1773. ===================================================================
  1774. RCS file: /net/acae127/home/bammi/etc/src/master/atari/cross-util/nm.c,v
  1775. retrieving revision 1.10
  1776. diff -c -r1.10 nm.c
  1777. *** 1.10    1992/03/22 21:44:03
  1778. --- nm.c    1993/03/29 03:41:06
  1779. ***************
  1780. *** 146,154 ****
  1781. --- 146,156 ----
  1782.   
  1783.   /* If compiled with GNU C, use the built-in alloca */
  1784.   #ifdef __GNUC__
  1785. + #ifndef alloca
  1786.   #    define alloca __builtin_alloca
  1787.   #endif
  1788.   
  1789. + #else
  1790.   /*
  1791.    * Alloca include.
  1792.    */
  1793. ***************
  1794. *** 158,163 ****
  1795. --- 160,166 ----
  1796.   #endif
  1797.   #include "alloca.h"
  1798.   #endif
  1799. + #endif /* __GNUC__ */
  1800.   
  1801.   /* Name of this program.  */
  1802.   
  1803. ***************
  1804. *** 792,797 ****
  1805. --- 795,806 ----
  1806.           case N_LENG:
  1807.             s = "LENG";
  1808.             break;
  1809. +         case N_BINCL:
  1810. +           s = "BINCL";
  1811. +           break;
  1812. +         case N_EINCL:
  1813. +           s = "EINCL";
  1814. +           break;
  1815.           default:
  1816.             s = "";
  1817.           }
  1818. ***************
  1819. *** 849,883 ****
  1820.       }
  1821.   
  1822.     nsymdefs = symdef_size / sizeof (struct symdef);
  1823. !   symdefs = (struct symdef *) alloca (symdef_size);
  1824.     if (symdef_size != read (desc, symdefs, symdef_size))
  1825.       {
  1826.         error_with_file ("premature eof in ");
  1827.         return;
  1828.       }
  1829.   
  1830. !   if (stringsize < 0)
  1831.       {
  1832. !       error_with_file ("invalid size value in ");
  1833.         return;
  1834.       }
  1835.   
  1836. !   if (sizeof stringsize != read (desc, &stringsize, sizeof stringsize))
  1837.       {
  1838. !       error_with_file ("premature eof in ");
  1839.         return;
  1840.       }
  1841.   
  1842. !   strings = (char *) alloca (stringsize);
  1843.     if (stringsize != read (desc, strings, stringsize))
  1844.       {
  1845.         error_with_file ("premature eof in ");
  1846.         return;
  1847.       }
  1848.   
  1849.     if (stringsize + symdef_size + sizeof stringsize + sizeof symdef_size != member_length)
  1850.       {
  1851.         error_with_file ("size of data isn't what the data calls for in ");
  1852.         return;
  1853.       }
  1854.   
  1855. --- 858,899 ----
  1856.       }
  1857.   
  1858.     nsymdefs = symdef_size / sizeof (struct symdef);
  1859. !   symdefs = (struct symdef *) xmalloc (symdef_size);
  1860.     if (symdef_size != read (desc, symdefs, symdef_size))
  1861.       {
  1862.         error_with_file ("premature eof in ");
  1863. +       free (symdefs);
  1864.         return;
  1865.       }
  1866.   
  1867. !   if (sizeof stringsize != read (desc, &stringsize, sizeof stringsize))
  1868.       {
  1869. !       error_with_file ("premature eof in ");
  1870. !       free (symdefs);
  1871.         return;
  1872.       }
  1873.   
  1874. !   if (stringsize < 0)
  1875.       {
  1876. !       error_with_file ("invalid size value in ");
  1877. !       free (symdefs);
  1878.         return;
  1879.       }
  1880.   
  1881. !   strings = (char *) xmalloc (stringsize);
  1882.     if (stringsize != read (desc, strings, stringsize))
  1883.       {
  1884.         error_with_file ("premature eof in ");
  1885. +       free (symdefs);
  1886. +       free (strings);
  1887.         return;
  1888.       }
  1889.   
  1890.     if (stringsize + symdef_size + sizeof stringsize + sizeof symdef_size != member_length)
  1891.       {
  1892.         error_with_file ("size of data isn't what the data calls for in ");
  1893. +       free (symdefs);
  1894. +       free (strings);
  1895.         return;
  1896.       }
  1897.   
  1898. ***************
  1899. *** 890,895 ****
  1900. --- 906,913 ----
  1901.         if (symdefs[i].stringoffset < 0 || symdefs[i].stringoffset >= stringsize)
  1902.       {
  1903.         error_with_file ("invalid entry in ");
  1904. +       free (symdefs);
  1905. +       free (strings);
  1906.         return;
  1907.       }
  1908.         if (member_offset != symdefs[i].offset)
  1909. ***************
  1910. *** 904,909 ****
  1911. --- 922,929 ----
  1912.       }
  1913.         printf ("%s in %s\n", symdefs[i].stringoffset + strings, member_name);
  1914.       }
  1915. +   free (symdefs);
  1916. +   free (strings);
  1917.   }
  1918.   
  1919.   /* Report a fatal error.
  1920. ===================================================================
  1921. RCS file: /net/acae127/home/bammi/etc/src/master/atari/cross-util/printstk.c,v
  1922. retrieving revision 1.6
  1923. diff -c -r1.6 printstk.c
  1924. *** 1.6    1992/07/21 14:52:06
  1925. --- printstk.c    1993/03/29 03:41:07
  1926. ***************
  1927. *** 33,38 ****
  1928. --- 33,40 ----
  1929.   # define SYM_OFFSET   (sizeof(short) + (3*sizeof(long)))
  1930.   #endif
  1931.   
  1932. + int error = 0;
  1933. + 
  1934.   static char *sym_names[] = { "__stksize", "__initial_stack" };
  1935.   
  1936.   long find_offset (fd, fn, what)
  1937. ***************
  1938. *** 42,50 ****
  1939.   {
  1940.       struct aexec head;
  1941.       struct asym  sym;
  1942. -     int found;
  1943.       int    all = 0;
  1944.       int index = 1;
  1945.       
  1946.   #ifndef WORD_ALIGNED
  1947.       if(read(fd, &head, sizeof(head)) != sizeof(head))
  1948. --- 44,56 ----
  1949.   {
  1950.       struct aexec head;
  1951.       struct asym  sym;
  1952.       int    all = 0;
  1953.       int index = 1;
  1954. + #ifndef WORD_ALIGNED
  1955. +     char extension[sizeof (struct asym)];
  1956. + #else
  1957. +     char extension[SIZEOF_ASYM];
  1958. + #endif
  1959.       
  1960.   #ifndef WORD_ALIGNED
  1961.       if(read(fd, &head, sizeof(head)) != sizeof(head))
  1962. ***************
  1963. *** 53,69 ****
  1964.   #endif
  1965.       {
  1966.       perror(fn);
  1967. !     exit(2);
  1968.       }
  1969.       if(head.a_magic != CMAGIC)
  1970.       {
  1971. !     fprintf(stderr,"Invalid magic number %x\n", head.a_magic);
  1972. !     exit(3);
  1973.       }
  1974.       if(head.a_syms == 0)
  1975.       {
  1976.       fprintf(stderr,"%s: no symbol table\n", fn);
  1977. !     exit(4);
  1978.       }
  1979.       if(lseek(fd, head.a_text+head.a_data, 1) != 
  1980.   #ifndef WORD_ALIGNED
  1981. --- 59,75 ----
  1982.   #endif
  1983.       {
  1984.       perror(fn);
  1985. !     return -1;
  1986.       }
  1987.       if(head.a_magic != CMAGIC)
  1988.       {
  1989. !     fprintf(stderr,"%s: invalid magic number %x\n", fn, head.a_magic);
  1990. !     return -1;
  1991.       }
  1992.       if(head.a_syms == 0)
  1993.       {
  1994.       fprintf(stderr,"%s: no symbol table\n", fn);
  1995. !     return -1;
  1996.       }
  1997.       if(lseek(fd, head.a_text+head.a_data, 1) != 
  1998.   #ifndef WORD_ALIGNED
  1999. ***************
  2000. *** 73,79 ****
  2001.   #endif
  2002.       {
  2003.       perror(fn);
  2004. !     exit(5);
  2005.       }
  2006.       for(;;)
  2007.       {
  2008. --- 79,85 ----
  2009.   #endif
  2010.       {
  2011.       perror(fn);
  2012. !     return -1;
  2013.       }
  2014.       for(;;)
  2015.       {
  2016. ***************
  2017. *** 83,105 ****
  2018.       if(index && read_sym(fd, &sym))
  2019.   #endif
  2020.       {
  2021. !         fprintf(stderr, "symbol _stksize not found\n");
  2022. !         exit(6);
  2023.       }
  2024.       /* after symbol read check first for _stksize */
  2025.       index ^= 1;
  2026.       if (strncmp(sym_names[index], sym.a_name, 8) == 0)
  2027.       {
  2028. !         if ((found = (sym.a_type & A_DATA)) || all++)
  2029. !         break;
  2030.       }
  2031.       }
  2032.       
  2033. -     if(!found)
  2034. -     {
  2035. -     fprintf(stderr, "symbol _stksize is undefined\n");
  2036. -     exit(9);
  2037. -     }
  2038.       *what = index;
  2039.   #ifndef WORD_ALIGNED
  2040.       return sym.a_value + sizeof(head);
  2041. --- 89,120 ----
  2042.       if(index && read_sym(fd, &sym))
  2043.   #endif
  2044.       {
  2045. !         fprintf(stderr, "%s: symbol _stksize not found\n", fn);
  2046. !         return -1;
  2047.       }
  2048. +     if (index && (sym.a_type & A_LNAM) == A_LNAM)
  2049. +       if (read (fd, extension, sizeof (extension)) != sizeof (extension))
  2050. +         {
  2051. +           fprintf (stderr, "%s: symbol _stksize not found\n", fn);
  2052. +           return -1;
  2053. +         }
  2054.       /* after symbol read check first for _stksize */
  2055.       index ^= 1;
  2056.       if (strncmp(sym_names[index], sym.a_name, 8) == 0)
  2057.       {
  2058. !       if ((sym.a_type & A_LNAM) == A_LNAM
  2059. !           && strncmp (sym_names[index] + 8, extension, sizeof (extension)))
  2060. !         continue;
  2061. !       if (sym.a_type & A_DATA)
  2062. !         break;
  2063. !       if (all++)
  2064. !         {
  2065. !           fprintf (stderr, "%s: symbol _stksize is undefined\n", fn);
  2066. !           return -1;
  2067. !         }
  2068.       }
  2069.       }
  2070.       
  2071.       *what = index;
  2072.   #ifndef WORD_ALIGNED
  2073.       return sym.a_value + sizeof(head);
  2074. ***************
  2075. *** 112,145 ****
  2076.   int argc;
  2077.   char **argv;
  2078.   {
  2079.       int fd;
  2080.       int what;
  2081.       long stksize, offset;
  2082. -     char fn[FILENAME_MAX];
  2083.       
  2084. -     if(argc > 1)
  2085. -     (void) strcpy(fn, *++argv);
  2086. -     else
  2087. -     (void) strcpy(fn, "gcc-cc1.ttp");
  2088. -     
  2089.       if((fd = open(fn, 0)) < 0)
  2090.       {
  2091.       perror(fn);
  2092. !     exit(1);
  2093.       }
  2094.       
  2095.       offset = find_offset(fd, fn, &what);
  2096. !     
  2097.       if(lseek(fd, offset, 0) != offset)
  2098.       {
  2099.       perror(fn);
  2100. !     exit(7);
  2101.       }
  2102.       read(fd, &stksize, sizeof(long));
  2103.       printf("%s: %s is %ld (%dK)\n",
  2104.            fn, sym_names[what] + 1, stksize, (int)(stksize/1024));
  2105.       
  2106. !     return close(fd);
  2107.   }
  2108.   
  2109.   #ifdef WORD_ALIGNED
  2110. --- 127,169 ----
  2111.   int argc;
  2112.   char **argv;
  2113.   {
  2114. +   while (--argc)
  2115. +     error |= print_stack (*++argv);
  2116. +   exit (error);
  2117. + }
  2118. + 
  2119. + int
  2120. + print_stack (fn)
  2121. +      char *fn;
  2122. + {
  2123.       int fd;
  2124.       int what;
  2125.       long stksize, offset;
  2126.       
  2127.       if((fd = open(fn, 0)) < 0)
  2128.       {
  2129.       perror(fn);
  2130. !     return 1;
  2131.       }
  2132.       
  2133.       offset = find_offset(fd, fn, &what);
  2134. !     if (offset < 0)
  2135. !       {
  2136. !     close (fd);
  2137. !     return 1;
  2138. !       }
  2139. ! 
  2140.       if(lseek(fd, offset, 0) != offset)
  2141.       {
  2142.       perror(fn);
  2143. !     close (fd);
  2144. !     return 1;
  2145.       }
  2146.       read(fd, &stksize, sizeof(long));
  2147.       printf("%s: %s is %ld (%dK)\n",
  2148.            fn, sym_names[what] + 1, stksize, (int)(stksize/1024));
  2149.       
  2150. !     return close(fd) != 0;
  2151.   }
  2152.   
  2153.   #ifdef WORD_ALIGNED
  2154. ===================================================================
  2155. RCS file: /net/acae127/home/bammi/etc/src/master/atari/cross-util/size68.c,v
  2156. retrieving revision 1.6
  2157. diff -c -r1.6 size68.c
  2158. *** 1.6    1992/01/14 19:45:23
  2159. --- size68.c    1993/03/29 03:41:09
  2160. ***************
  2161. *** 23,31 ****
  2162.   int argc;
  2163.   char **argv;
  2164.   {
  2165. - #ifdef atarist
  2166. -     _binmode(1);
  2167. - #endif
  2168.       while(--argc > 0)
  2169.           showfile(*++argv);
  2170.       return 0;
  2171. --- 23,28 ----
  2172. ***************
  2173. *** 37,43 ****
  2174.       register FILE *fp;
  2175.       struct aexec h;
  2176.       
  2177. !     if((fp = fopen(name, "r")) == (FILE *)NULL)
  2178.       {
  2179.           perror(name);
  2180.           exit(1);
  2181. --- 34,40 ----
  2182.       register FILE *fp;
  2183.       struct aexec h;
  2184.       
  2185. !     if((fp = fopen(name, "rb")) == (FILE *)NULL)
  2186.       {
  2187.           perror(name);
  2188.           exit(1);
  2189. ***************
  2190. *** 60,70 ****
  2191.       }
  2192.       printf("%s:\n\ttext size\t%ld\n\tdata size\t%ld\n\tbss size\t%ld\
  2193.   \n\tsymbol size\t%ld\n\tFile %s relocatable\n\
  2194. ! \n\t%s\n", name, h.a_text,
  2195.        h.a_data, h.a_bss, h.a_syms,
  2196.       (h.a_isreloc == ISRELOCINFO)? "is":"is not",
  2197. !     (h.a_AZero2 & 1)? "Only BSS cleared on startup" :
  2198. !              "BSS and high mem cleared on startup");
  2199.   }
  2200.   
  2201.   # ifdef WORD_ALIGNED
  2202. --- 57,66 ----
  2203.       }
  2204.       printf("%s:\n\ttext size\t%ld\n\tdata size\t%ld\n\tbss size\t%ld\
  2205.   \n\tsymbol size\t%ld\n\tFile %s relocatable\n\
  2206. ! \t%s cleared on startup\n\n", name, h.a_text,
  2207.        h.a_data, h.a_bss, h.a_syms,
  2208.       (h.a_isreloc == ISRELOCINFO)? "is":"is not",
  2209. !     (h.a_AZero2 & 1)? "Only BSS" : "BSS and high mem");
  2210.   }
  2211.   
  2212.   # ifdef WORD_ALIGNED
  2213. ===================================================================
  2214. RCS file: /net/acae127/home/bammi/etc/src/master/atari/cross-util/strip.c,v
  2215. retrieving revision 1.7
  2216. diff -c -r1.7 strip.c
  2217. *** 1.7    1992/08/14 17:24:38
  2218. --- strip.c    1993/03/29 03:41:10
  2219. ***************
  2220. *** 31,41 ****
  2221.    */
  2222.   
  2223.   #include <stdio.h>
  2224.   #ifdef atarist
  2225.   #ifdef __GNUC__
  2226.   #  include <stddef.h>
  2227.   #  include <memory.h>
  2228. ! #  include <unixlib.h>
  2229.   #else
  2230.   #include <malloc.h>
  2231.   extern long lread();
  2232. --- 31,42 ----
  2233.    */
  2234.   
  2235.   #include <stdio.h>
  2236. + #include <stat.h>
  2237.   #ifdef atarist
  2238.   #ifdef __GNUC__
  2239.   #  include <stddef.h>
  2240.   #  include <memory.h>
  2241. ! #  include <unistd.h>
  2242.   #else
  2243.   #include <malloc.h>
  2244.   extern long lread();
  2245. ***************
  2246. *** 51,56 ****
  2247. --- 52,59 ----
  2248.      extern char *malloc(), *realloc();
  2249.   #else
  2250.   #  include <string.h>
  2251. + #  define lwrite _write
  2252. + #  define lread _read
  2253.   #endif
  2254.   
  2255.   #include <fcntl.h>
  2256. ***************
  2257. *** 66,75 ****
  2258.   typedef char    symstr_t[GST_SYMLEN];
  2259.   symstr_t        stklist[] = {"__stksize", "__initial_stack"};
  2260.   
  2261. - #ifdef atarist
  2262. - long            _stksize = 1L;
  2263. - #endif
  2264. - 
  2265.   #ifndef __PROTO
  2266.   #  if __STDC__ || __cplusplus
  2267.   #   define __PROTO(s) s
  2268. --- 69,74 ----
  2269. ***************
  2270. *** 100,107 ****
  2271.       int             status = 0;
  2272.       int             flag = -1;
  2273.       int             cuttrail = 0;
  2274. !     symstr_t       *nmlist = (symstr_t *) 0;
  2275. !     select_fp       select=(select_fp)NULL;
  2276.   #ifdef atarist
  2277.       char           *tmpdir;
  2278.       register int    l;
  2279. --- 99,106 ----
  2280.       int             status = 0;
  2281.       int             flag = -1;
  2282.       int             cuttrail = 0;
  2283. !     symstr_t       *nmlist = stklist;
  2284. !     select_fp       select = sel_listed;
  2285.   #ifdef atarist
  2286.       char           *tmpdir;
  2287.       register int    l;
  2288. ***************
  2289. *** 126,131 ****
  2290. --- 125,133 ----
  2291.               nmlist = stklist;
  2292.           select = sel_listed;
  2293.           break;
  2294. +         case 'a':
  2295. +         select = 0;
  2296. +         break;
  2297.           case 'l':
  2298.           (*argv)++;
  2299.           if ('\0' == **argv) {
  2300. ***************
  2301. *** 151,167 ****
  2302.   
  2303.   #ifdef __GNUC__
  2304.   #ifdef atarist
  2305. -     tmpname[0] = '\0';
  2306.       if ((tmpdir = getenv ("TEMP")) != NULL) {
  2307.       strcpy (tmpname, tmpdir);
  2308.       l = (int) strlen (tmpname) - 1;
  2309. !     if (tmpname[l] == '\\')
  2310.           tmpname[l] = '\0';
  2311.       }
  2312. !     strcat (tmpname, "\\STXXXXXX");
  2313. ! #else
  2314. !     strcpy (tmpname, "/tmp/STXXXXXX");
  2315.   #endif
  2316.   
  2317.       mktemp (tmpname);
  2318.   #else /* not __GNUC__ */
  2319. --- 153,168 ----
  2320.   
  2321.   #ifdef __GNUC__
  2322.   #ifdef atarist
  2323.       if ((tmpdir = getenv ("TEMP")) != NULL) {
  2324.       strcpy (tmpname, tmpdir);
  2325.       l = (int) strlen (tmpname) - 1;
  2326. !     if (tmpname[l] == '\\' || tmpname[l] == '/')
  2327.           tmpname[l] = '\0';
  2328. +     strcat (tmpname, "/STXXXXXX");
  2329.       }
  2330. !     else
  2331.   #endif
  2332. +     strcpy (tmpname, "/tmp/STXXXXXX");
  2333.   
  2334.       mktemp (tmpname);
  2335.   #else /* not __GNUC__ */
  2336. ***************
  2337. *** 197,203 ****
  2338.       char           *s;
  2339.   {
  2340.       report (s);
  2341. !     report ("Usage: strip {-k | -l names | -g} [-t] files ...\n");
  2342.       exit (1);
  2343.   }
  2344.   
  2345. --- 198,204 ----
  2346.       char           *s;
  2347.   {
  2348.       report (s);
  2349. !     report ("Usage: strip {-k | -l names | -g | -a} [-t] files ...\n");
  2350.       exit (1);
  2351.   }
  2352.   
  2353. ***************
  2354. *** 275,280 ****
  2355. --- 276,282 ----
  2356.       register long   count, rbytes, sbytes;
  2357.       long            lbytes, swap_lbytes;
  2358.       struct aexec    ahead;
  2359. +     struct stat        statb;
  2360.   
  2361.       if ((fd = open (name, O_RDONLY, 0666)) < 0) {
  2362.       perror (name);
  2363. ***************
  2364. *** 372,379 ****
  2365.       }
  2366.       close (tfd);
  2367.       close (fd);
  2368.       if (rename(tmpname, name) == 0) return 0; /* try to rename it */
  2369. !     if ((fd = open (name, O_WRONLY | O_TRUNC | O_CREAT, 0666)) < 0) {
  2370.       perror (name);
  2371.       return 0x1000;
  2372.       }
  2373. --- 374,383 ----
  2374.       }
  2375.       close (tfd);
  2376.       close (fd);
  2377. +     if (stat (name, &statb) < 0)
  2378. +       statb.st_mode = 0666;
  2379.       if (rename(tmpname, name) == 0) return 0; /* try to rename it */
  2380. !     if ((fd = open (name, O_WRONLY | O_TRUNC | O_CREAT, statb.st_mode)) < 0) {
  2381.       perror (name);
  2382.       return 0x1000;
  2383.       }
  2384. ===================================================================
  2385. RCS file: /net/acae127/home/bammi/etc/src/master/atari/cross-util/sym-ld.c,v
  2386. retrieving revision 1.22
  2387. diff -c -r1.22 sym-ld.c
  2388. *** 1.22    1992/10/11 02:39:24
  2389. --- sym-ld.c    1993/03/29 03:41:12
  2390. ***************
  2391. *** 129,137 ****
  2392. --- 129,139 ----
  2393.   #endif
  2394.   #endif
  2395.   
  2396. + #if 0                /* all big alloca's eliminated */
  2397.   #ifdef atarist        /* and a stack */
  2398.   long _stksize = -1L;
  2399.   #endif
  2400. + #endif
  2401.   
  2402.   #ifdef min
  2403.   #undef min
  2404. ***************
  2405. *** 419,425 ****
  2406.   
  2407.      The address of the set is made into an N_SETV symbol
  2408.      whose name is the same as the name of the set.
  2409. !    This symbol acts like a N_DATA global symbol
  2410.      in that it can satisfy undefined external references.
  2411.   
  2412.      For the purposes of determining whether or not to load in a library
  2413. --- 421,427 ----
  2414.   
  2415.      The address of the set is made into an N_SETV symbol
  2416.      whose name is the same as the name of the set.
  2417. !    This symbol acts like a N_TEXT global symbol
  2418.      in that it can satisfy undefined external references.
  2419.   
  2420.      For the purposes of determining whether or not to load in a library
  2421. ***************
  2422. *** 996,1006 ****
  2423.   
  2424.     outheader.a_info = magic;
  2425.   
  2426. - #if (!(defined(CROSSATARI) || defined(atarist) || defined(atariminix)))
  2427.   #ifdef INITIALIZE_HEADER
  2428.     INITIALIZE_HEADER;
  2429.   #endif
  2430. - #endif
  2431.   
  2432.     text_size = sizeof (struct exec);
  2433.   #ifdef COFF_ENCAPSULATE
  2434. --- 998,1006 ----
  2435. ***************
  2436. *** 1870,1878 ****
  2437.     if (!N_BADMAG (*((struct exec *)&magicnum)))
  2438.       {
  2439.         read_entry_symbols (desc, entry);
  2440. !       entry->strings = (char *) alloca (entry->string_size);
  2441.         read_entry_strings (desc, entry);
  2442.         enter_file_symbols (entry);
  2443.         entry->strings = 0;
  2444.       }
  2445.     else
  2446. --- 1870,1879 ----
  2447.     if (!N_BADMAG (*((struct exec *)&magicnum)))
  2448.       {
  2449.         read_entry_symbols (desc, entry);
  2450. !       entry->strings = (char *) xmalloc (entry->string_size);
  2451.         read_entry_strings (desc, entry);
  2452.         enter_file_symbols (entry);
  2453. +       free (entry->strings);
  2454.         entry->strings = 0;
  2455.       }
  2456.     else
  2457. ***************
  2458. *** 2405,2411 ****
  2459.                + symdef_base[i].symbol_name_string_index,
  2460.                entry->filename);
  2461.           read_entry_symbols (desc, subentry);
  2462. !         subentry->strings = (char *) malloc (subentry->string_size);
  2463.           read_entry_strings (desc, subentry);
  2464.   
  2465.           /* Now scan the symbol table and decide whether to load.  */
  2466. --- 2406,2412 ----
  2467.                + symdef_base[i].symbol_name_string_index,
  2468.                entry->filename);
  2469.           read_entry_symbols (desc, subentry);
  2470. !         subentry->strings = (char *) xmalloc (subentry->string_size);
  2471.           read_entry_strings (desc, subentry);
  2472.   
  2473.           /* Now scan the symbol table and decide whether to load.  */
  2474. ***************
  2475. *** 2472,2483 ****
  2476.         if (!subentry) return;
  2477.   
  2478.         read_entry_symbols (desc, subentry);
  2479. !       subentry->strings = (char *) alloca (subentry->string_size);
  2480.         read_entry_strings (desc, subentry);
  2481.   
  2482.         if (!subfile_wanted_p (subentry))
  2483.       {
  2484.         free (subentry->symbols);
  2485.         free (subentry);
  2486.       }
  2487.         else
  2488. --- 2473,2485 ----
  2489.         if (!subentry) return;
  2490.   
  2491.         read_entry_symbols (desc, subentry);
  2492. !       subentry->strings = (char *) xmalloc (subentry->string_size);
  2493.         read_entry_strings (desc, subentry);
  2494.   
  2495.         if (!subfile_wanted_p (subentry))
  2496.       {
  2497.         free (subentry->symbols);
  2498. +       free (subentry->strings);
  2499.         free (subentry);
  2500.       }
  2501.         else
  2502. ***************
  2503. *** 2743,2749 ****
  2504. --- 2745,2755 ----
  2505.           {
  2506.             if (!relocatable_output || force_common_definition)
  2507.           {
  2508. + #ifdef atarist
  2509. +           com = (com + sizeof (short) - 1) & (- sizeof (short));
  2510. + #else
  2511.             com = (com + sizeof (int) - 1) & (- sizeof (int));
  2512. + #endif
  2513.   
  2514.             sp->value = data_start + data_size + bss_size;
  2515.             sp->defined = N_BSS | N_EXT;
  2516. ***************
  2517. *** 2867,2877 ****
  2518.       switch (type)
  2519.         {
  2520.         case N_TEXT:
  2521.         case N_SETT:
  2522.           p->n_value += entry->text_start_address;
  2523.           break;
  2524.         case N_DATA:
  2525. -       case N_SETV:
  2526.         case N_SETD:
  2527.           /* A symbol whose value is in the data section
  2528.              is present in the input file as if the data section
  2529. --- 2873,2883 ----
  2530.       switch (type)
  2531.         {
  2532.         case N_TEXT:
  2533. +       case N_SETV:
  2534.         case N_SETT:
  2535.           p->n_value += entry->text_start_address;
  2536.           break;
  2537.         case N_DATA:
  2538.         case N_SETD:
  2539.           /* A symbol whose value is in the data section
  2540.              is present in the input file as if the data section
  2541. ***************
  2542. *** 2952,2958 ****
  2543.   {
  2544.     register struct nlist *p, *end = entry->symbols + entry->header.a_syms / sizeof (struct nlist);
  2545.   
  2546. !   entry->strings = (char *) alloca (entry->string_size);
  2547.     read_entry_strings (file_open (entry), entry);
  2548.   
  2549.     fprintf (outfile, "\nLocal symbols of ");
  2550. --- 2958,2964 ----
  2551.   {
  2552.     register struct nlist *p, *end = entry->symbols + entry->header.a_syms / sizeof (struct nlist);
  2553.   
  2554. !   entry->strings = (char *) xmalloc (entry->string_size);
  2555.     read_entry_strings (file_open (entry), entry);
  2556.   
  2557.     fprintf (outfile, "\nLocal symbols of ");
  2558. ***************
  2559. *** 2974,2979 ****
  2560. --- 2980,2986 ----
  2561.       free(nm);
  2562.         }
  2563.   
  2564. +   free (entry->strings);
  2565.     entry->strings = 0;        /* All done with them.  */
  2566.   }
  2567.   
  2568. ***************
  2569. *** 3027,3033 ****
  2570.       {
  2571.         int desc;
  2572.   
  2573. !       entry->strings = (char *) alloca (entry->string_size);
  2574.         desc = file_open (entry);
  2575.         read_entry_strings (desc, entry);
  2576.       }
  2577. --- 3034,3040 ----
  2578.       {
  2579.         int desc;
  2580.   
  2581. !       entry->strings = (char *) xmalloc (entry->string_size);
  2582.         desc = file_open (entry);
  2583.         read_entry_strings (desc, entry);
  2584.       }
  2585. ***************
  2586. *** 3240,3245 ****
  2587. --- 3247,3253 ----
  2588.         }
  2589.     }
  2590.   
  2591. +   free (entry->strings);
  2592.     entry->strings = 0;
  2593.   }
  2594.   /*
  2595. ***************
  2596. *** 3540,3546 ****
  2597.   
  2598.     filemode = statbuf.st_mode;
  2599.   
  2600. ! #ifndef atarist
  2601.     chmod (output_filename, filemode & ~0111);
  2602.   #endif
  2603.   
  2604. --- 3548,3554 ----
  2605.   
  2606.     filemode = statbuf.st_mode;
  2607.   
  2608. ! #if !(defined(CROSSATARI) || defined(atarist) || defined(atariminix))
  2609.     chmod (output_filename, filemode & ~0111);
  2610.   #endif
  2611.   
  2612. ***************
  2613. *** 3566,3572 ****
  2614.   
  2615.     close (outdesc);
  2616.   
  2617. ! #ifndef atarist
  2618.     chmod (output_filename, filemode | 0111);
  2619.   #endif
  2620.   }
  2621. --- 3574,3580 ----
  2622.   
  2623.     close (outdesc);
  2624.   
  2625. ! #if !(defined(CROSSATARI) || defined(atarist) || defined(atariminix))
  2626.     chmod (output_filename, filemode | 0111);
  2627.   #endif
  2628.   }
  2629. ***************
  2630. *** 3648,3658 ****
  2631.       }
  2632.   #endif
  2633.   
  2634. - #if (!(defined(CROSSATARI) || defined(atarist) || defined(atariminix)))
  2635.   #ifdef INITIALIZE_HEADER
  2636.     INITIALIZE_HEADER;
  2637.   #endif
  2638. - #endif
  2639.   
  2640.     if (strip_symbols == STRIP_ALL)
  2641.       nsyms = 0;
  2642. --- 3656,3664 ----
  2643. ***************
  2644. *** 3810,3816 ****
  2645.   
  2646.     /* Allocate space for the file's text section */
  2647.   
  2648. !   bytes = (char *) alloca (entry->header.a_text);
  2649.   
  2650.     /* Deal with relocation information however is appropriate */
  2651.   
  2652. --- 3816,3822 ----
  2653.   
  2654.     /* Allocate space for the file's text section */
  2655.   
  2656. !   bytes = (char *) xmalloc (entry->header.a_text);
  2657.   
  2658.     /* Deal with relocation information however is appropriate */
  2659.   
  2660. ***************
  2661. *** 3822,3828 ****
  2662.       }
  2663.     else
  2664.       {
  2665. !       reloc = (struct relocation_info *) alloca (entry->header.a_trsize);
  2666.         lseek (desc, text_offset (entry) + entry->header.a_text + entry->header.a_data, 0);
  2667.         if (entry->header.a_trsize != read (desc, reloc, entry->header.a_trsize))
  2668.       fatal_with_file ("premature eof in text relocation of ", entry);
  2669. --- 3828,3834 ----
  2670.       }
  2671.     else
  2672.       {
  2673. !       reloc = (struct relocation_info *) xmalloc (entry->header.a_trsize);
  2674.         lseek (desc, text_offset (entry) + entry->header.a_text + entry->header.a_data, 0);
  2675.         if (entry->header.a_trsize != read (desc, reloc, entry->header.a_trsize))
  2676.       fatal_with_file ("premature eof in text relocation of ", entry);
  2677. ***************
  2678. *** 3843,3848 ****
  2679. --- 3849,3858 ----
  2680.     /* Write the relocated text to the output file.  */
  2681.   
  2682.     mywrite (bytes, 1, entry->header.a_text, outdesc);
  2683. + 
  2684. +   if (!entry->textrel)
  2685. +     free (reloc);
  2686. +   free (bytes);
  2687.   }
  2688.   
  2689.   /* Relocate the data segment of each input file
  2690. ***************
  2691. *** 3881,3887 ****
  2692.   
  2693.     desc = file_open (entry);
  2694.   
  2695. !   bytes = (char *) alloca (entry->header.a_data);
  2696.   
  2697.     if (entry->datarel) reloc = entry->datarel;
  2698.     else if (relocatable_output)    /* Will need this again */
  2699. --- 3891,3897 ----
  2700.   
  2701.     desc = file_open (entry);
  2702.   
  2703. !   bytes = (char *) xmalloc (entry->header.a_data);
  2704.   
  2705.     if (entry->datarel) reloc = entry->datarel;
  2706.     else if (relocatable_output)    /* Will need this again */
  2707. ***************
  2708. *** 3891,3897 ****
  2709.       }
  2710.     else
  2711.       {
  2712. !       reloc = (struct relocation_info *) alloca (entry->header.a_drsize);
  2713.         lseek (desc, text_offset (entry) + entry->header.a_text
  2714.            + entry->header.a_data + entry->header.a_trsize,
  2715.            0);
  2716. --- 3901,3907 ----
  2717.       }
  2718.     else
  2719.       {
  2720. !       reloc = (struct relocation_info *) xmalloc (entry->header.a_drsize);
  2721.         lseek (desc, text_offset (entry) + entry->header.a_text
  2722.            + entry->header.a_data + entry->header.a_trsize,
  2723.            0);
  2724. ***************
  2725. *** 3907,3912 ****
  2726. --- 3917,3926 ----
  2727.                 entry->header.a_data, reloc, entry->header.a_drsize, entry);
  2728.   
  2729.     mywrite (bytes, 1, entry->header.a_data, outdesc);
  2730. + 
  2731. +   if (!entry->datarel)
  2732. +     free (reloc);
  2733. +   free (bytes);
  2734.   }
  2735.   
  2736.   /* Relocate ENTRY's text or data section contents.
  2737. ***************
  2738. *** 4290,4299 ****
  2739.        extra struct for each indirect symbol to hold the extra reference
  2740.        following. */
  2741.     struct nlist *buf
  2742. !     = (struct nlist *) alloca ((defined_global_sym_count
  2743. !                 + undefined_global_sym_count
  2744. !                 + global_indirect_count)
  2745. !                    * sizeof (struct nlist));
  2746.     /* Pointer for storing into BUF.  */
  2747.     register struct nlist *bufp = buf;
  2748.   
  2749. --- 4304,4313 ----
  2750.        extra struct for each indirect symbol to hold the extra reference
  2751.        following. */
  2752.     struct nlist *buf
  2753. !     = (struct nlist *) xmalloc ((defined_global_sym_count
  2754. !                  + undefined_global_sym_count
  2755. !                  + global_indirect_count)
  2756. !                 * sizeof (struct nlist));
  2757.     /* Pointer for storing into BUF.  */
  2758.     register struct nlist *bufp = buf;
  2759.   
  2760. ***************
  2761. *** 4306,4312 ****
  2762.     string_table_len = strtab_size;
  2763.   
  2764.     if (strip_symbols == STRIP_ALL)
  2765. !     return;
  2766.   
  2767.     /* Write the local symbols defined by the various files.  */
  2768.   
  2769. --- 4320,4329 ----
  2770.     string_table_len = strtab_size;
  2771.   
  2772.     if (strip_symbols == STRIP_ALL)
  2773. !     {
  2774. !       free (buf);
  2775. !       return;
  2776. !     }
  2777.   
  2778.     /* Write the local symbols defined by the various files.  */
  2779.   
  2780. ***************
  2781. *** 4319,4328 ****
  2782.        table from the global symbols written so far.  This must include
  2783.        extra space for the references following indirect outputs. */
  2784.   
  2785. !   strtab_vector = (char **) alloca ((num_hash_tab_syms
  2786. !                      + global_indirect_count) * sizeof (char *));
  2787. !   strtab_lens = (int *) alloca ((num_hash_tab_syms
  2788. !                  + global_indirect_count) * sizeof (int));
  2789.     strtab_index = 0;
  2790.   
  2791.     /* Scan the symbol hash table, bucket by bucket.  */
  2792. --- 4336,4345 ----
  2793.        table from the global symbols written so far.  This must include
  2794.        extra space for the references following indirect outputs. */
  2795.   
  2796. !   strtab_vector = (char **) xmalloc ((num_hash_tab_syms
  2797. !                       + global_indirect_count) * sizeof (char *));
  2798. !   strtab_lens = (int *) xmalloc ((num_hash_tab_syms
  2799. !                   + global_indirect_count) * sizeof (int));
  2800.     strtab_index = 0;
  2801.   
  2802.     /* Scan the symbol hash table, bucket by bucket.  */
  2803. ***************
  2804. *** 4436,4441 ****
  2805. --- 4453,4462 ----
  2806.     /* Write the strings for the global symbols.  */
  2807.   
  2808.     write_string_table ();
  2809. + 
  2810. +   free (strtab_lens);
  2811. +   free (strtab_vector);
  2812. +   free (buf);
  2813.   }
  2814.   
  2815.   /* Write the local and debugger symbols of file ENTRY.
  2816. ***************
  2817. *** 4455,4461 ****
  2818.     /* Buffer to accumulate all the syms before writing them.
  2819.        It has one extra slot for the local symbol we generate here.  */
  2820.     struct nlist *buf
  2821. !     = (struct nlist *) alloca (entry->header.a_syms + sizeof (struct nlist));
  2822.     register struct nlist *bufp = buf;
  2823.   
  2824.     /* Upper bound on number of syms to be written here.  */
  2825. --- 4476,4482 ----
  2826.     /* Buffer to accumulate all the syms before writing them.
  2827.        It has one extra slot for the local symbol we generate here.  */
  2828.     struct nlist *buf
  2829. !     = (struct nlist *) xmalloc (entry->header.a_syms + sizeof (struct nlist));
  2830.     register struct nlist *bufp = buf;
  2831.   
  2832.     /* Upper bound on number of syms to be written here.  */
  2833. ***************
  2834. *** 4464,4471 ****
  2835.     /* Make tables that record, for each symbol, its name and its name's length.
  2836.        The elements are filled in by `assign_string_table_index'.  */
  2837.   
  2838. !   strtab_vector = (char **) alloca (max_syms * sizeof (char *));
  2839. !   strtab_lens = (int *) alloca (max_syms * sizeof (int));
  2840.     strtab_index = 0;
  2841.   
  2842.     /* Generate a local symbol for the start of this file's text.  */
  2843. --- 4485,4492 ----
  2844.     /* Make tables that record, for each symbol, its name and its name's length.
  2845.        The elements are filled in by `assign_string_table_index'.  */
  2846.   
  2847. !   strtab_vector = (char **) xmalloc (max_syms * sizeof (char *));
  2848. !   strtab_lens = (int *) xmalloc (max_syms * sizeof (int));
  2849.     strtab_index = 0;
  2850.   
  2851.     /* Generate a local symbol for the start of this file's text.  */
  2852. ***************
  2853. *** 4486,4492 ****
  2854.   
  2855.     /* Read the file's string table.  */
  2856.   
  2857. !   entry->strings = (char *) alloca (entry->string_size);
  2858.     read_entry_strings (file_open (entry), entry);
  2859.   
  2860.     for (; p < end; p++)
  2861. --- 4507,4513 ----
  2862.   
  2863.     /* Read the file's string table.  */
  2864.   
  2865. !   entry->strings = (char *) xmalloc (entry->string_size);
  2866.     read_entry_strings (file_open (entry), entry);
  2867.   
  2868.     for (; p < end; p++)
  2869. ***************
  2870. *** 4563,4569 ****
  2871.        using the data in vectors `strtab_vector' and `strtab_lens'.  */
  2872.   
  2873.     write_string_table ();
  2874. !   entry->strings = 0;        /* Since it will dissapear anyway.  */
  2875.   }
  2876.   
  2877.   /* Copy any GDB symbol segments from the input files to the output file.
  2878. --- 4584,4595 ----
  2879.        using the data in vectors `strtab_vector' and `strtab_lens'.  */
  2880.   
  2881.     write_string_table ();
  2882. ! 
  2883. !   free (entry->strings);
  2884. !   entry->strings = 0;
  2885. !   free (strtab_lens);
  2886. !   free (strtab_vector);
  2887. !   free (buf);
  2888.   }
  2889.   
  2890.   /* Copy any GDB symbol segments from the input files to the output file.
  2891.