![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gas-1.37-coff-new CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GNU Assembler] / gas|
Return to gas-1.37-coff-new CVS log | Up to [GNU Assembler] / gas |
1.1 ! root 1: *** /dev/null Wed Nov 7 08:15:02 1990 ! 2: --- Makefile.new Wed Nov 7 08:03:16 1990 ! 3: *************** ! 4: *** 0 **** ! 5: --- 1,203 ---- ! 6: + # Makefile for GAS. ! 7: + # Copyright (C) 1989, Free Software Foundation ! 8: + # ! 9: + # This file is part of GAS, the GNU Assembler. ! 10: + # ! 11: + # GAS is free software; you can redistribute it and/or modify ! 12: + # it under the terms of the GNU General Public License as published by ! 13: + # the Free Software Foundation; either version 1, or (at your option) ! 14: + # any later version. ! 15: + # ! 16: + # GAS is distributed in the hope that it will be useful, ! 17: + # but WITHOUT ANY WARRANTY; without even the implied warranty of ! 18: + # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ! 19: + # GNU General Public License for more details. ! 20: + # ! 21: + # You should have received a copy of the GNU General Public License ! 22: + # along with GAS; see the file COPYING. If not, write to ! 23: + # the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. ! 24: + ! 25: + BINDIR = /usr/local/bin ! 26: + ! 27: + BINARY = gas ! 28: + ! 29: + # ! 30: + # Add these flags to XCFLAGS below for specific use. ! 31: + # ! 32: + # If you machine does not have vfprintf, but does have _doprnt(), ! 33: + # -DNO_VARARGS ! 34: + # ! 35: + # If the return-type of a signal-hander is void (instead of int), ! 36: + # -DSIGTY ! 37: + # ! 38: + # To include the mc68851 mmu coprocessor instructions in the 68020 assembler, ! 39: + # -Dm68851 ! 40: + # ! 41: + # If you want the 80386 assembler to correctly handle fsub/fsubr and fdiv/fdivr ! 42: + # opcodes (unlike most 80386 assemblers) ! 43: + # -DNON_BROKEN_WORDS ! 44: + # ! 45: + XCFLAGS = ! 46: + ! 47: + # Your favorite compiler ! 48: + CC = gcc ! 49: + ! 50: + # Uncomment the following lines if you use USG ! 51: + ! 52: + INCLUDE_DIRS = -I. ! 53: + COFF_OBJECTS = stack.o ! 54: + CPPFLAGS = -DUSG ! 55: + CFLAGS = -g $(CPPFLAGS) $(XCFLAGS) ! 56: + LDFLAGS = ! 57: + #LOADLIBES = -lPW ! 58: + ! 59: + # Uncomment the following lines if you use BSD ! 60: + #INCLUDE_DIRS = -I. ! 61: + #CPPFLAGS = ! 62: + #CFLAGS = -g $(CPPFLAGS) $(XCFLAGS) ! 63: + #LDFLAGS = ! 64: + #LOADLIBES = ! 65: + ! 66: + CONFIG_FILES = \ ! 67: + machine.c machine.h atof.c oformat.c oformat.h opcode.h ! 68: + ! 69: + OBJECTS = \ ! 70: + as.o xrealloc.o xmalloc.o hash.o hex-value.o \ ! 71: + atof-generic.o append.o messages.o expr.o app.o \ ! 72: + frags.o input-file.o input-scrub.o output-file.o \ ! 73: + subsegs.o symbols.o version.o flonum-const.o flonum-copy.o \ ! 74: + flonum-mult.o strstr.o bignum-copy.o obstack.o write.o read.o \ ! 75: + oformat.o machine.o atof.o $(COFF_OBJECTS) ! 76: + ! 77: + SOURCES = $(OBJECTS:.o=.c) ! 78: + ! 79: + all : $(BINARY) ! 80: + ! 81: + install : all ! 82: + cp $(BINARY) $(BINDIR) ! 83: + ! 84: + clean : ! 85: + rm -f $(OBJECTS) ! 86: + ! 87: + clobber : clean ! 88: + rm -f $(BINARY) $(CONFIG_FILES) dependencies TAGS m68k.h ! 89: + ! 90: + $(BINARY) : $(OBJECTS) ! 91: + $(CC) -o $(BINARY) $(LDFLAGS) $(OBJECTS) $(LOADLIBES) ! 92: + ! 93: + TAGS : $(SOURCES) ! 94: + etags $(SOURCES) *.h ! 95: + ! 96: + CXREF : $(SOURCES) ! 97: + cxref -c $(INCLUDE_DIRS) $(SOURCES) ! 98: + ! 99: + stack.o: stack.c ! 100: + $(CC) $(CFLAGS) -c stack.c ! 101: + ! 102: + atof.o: \ ! 103: + flonum.h \ ! 104: + bignum.h ! 105: + oformat.o: \ ! 106: + as.h \ ! 107: + md.h \ ! 108: + aout.h \ ! 109: + a.out.gnu.h \ ! 110: + struc-symbol.h \ ! 111: + write.h \ ! 112: + append.h ! 113: + read.o: \ ! 114: + oformat.h \ ! 115: + a.out.gnu.h \ ! 116: + as.h \ ! 117: + read.h \ ! 118: + md.h \ ! 119: + hash.h \ ! 120: + obstack.h \ ! 121: + frags.h \ ! 122: + flonum.h \ ! 123: + bignum.h \ ! 124: + struc-symbol.h \ ! 125: + expr.h \ ! 126: + symbols.h \ ! 127: + sparc.h ! 128: + write.o: \ ! 129: + oformat.h \ ! 130: + a.out.gnu.h \ ! 131: + as.h \ ! 132: + md.h \ ! 133: + subsegs.h \ ! 134: + obstack.h \ ! 135: + struc-symbol.h \ ! 136: + write.h \ ! 137: + symbols.h \ ! 138: + append.h \ ! 139: + sparc.h ! 140: + obstack.o: \ ! 141: + obstack.h ! 142: + bignum-copy.o: \ ! 143: + bignum.h ! 144: + flonum-mult.o: \ ! 145: + flonum.h \ ! 146: + bignum.h ! 147: + flonum-copy.o: \ ! 148: + flonum.h \ ! 149: + bignum.h ! 150: + flonum-const.o: \ ! 151: + flonum.h \ ! 152: + bignum.h ! 153: + symbols.o: \ ! 154: + oformat.h \ ! 155: + a.out.gnu.h \ ! 156: + as.h \ ! 157: + hash.h \ ! 158: + obstack.h \ ! 159: + struc-symbol.h \ ! 160: + symbols.h \ ! 161: + frags.h ! 162: + subsegs.o: \ ! 163: + oformat.h \ ! 164: + a.out.gnu.h \ ! 165: + as.h \ ! 166: + subsegs.h \ ! 167: + obstack.h \ ! 168: + frags.h \ ! 169: + struc-symbol.h \ ! 170: + write.h ! 171: + input-scrub.o: \ ! 172: + as.h \ ! 173: + read.h \ ! 174: + input-file.h ! 175: + input-file.o: \ ! 176: + input-file.h ! 177: + frags.o: \ ! 178: + oformat.h \ ! 179: + a.out.gnu.h \ ! 180: + as.h \ ! 181: + subsegs.h \ ! 182: + obstack.h \ ! 183: + frags.h \ ! 184: + struc-symbol.h ! 185: + expr.o: \ ! 186: + oformat.h \ ! 187: + a.out.gnu.h \ ! 188: + as.h \ ! 189: + flonum.h \ ! 190: + bignum.h \ ! 191: + read.h \ ! 192: + struc-symbol.h \ ! 193: + expr.h \ ! 194: + obstack.h \ ! 195: + symbols.h ! 196: + messages.o: \ ! 197: + as.h ! 198: + atof-generic.o: \ ! 199: + flonum.h \ ! 200: + bignum.h ! 201: + hash.o: \ ! 202: + hash.h ! 203: + as.o: \ ! 204: + oformat.h \ ! 205: + a.out.gnu.h \ ! 206: + as.h \ ! 207: + struc-symbol.h \ ! 208: + write.h ! 209: *** /dev/null Wed Nov 7 08:15:02 1990 ! 210: --- README.coff Wed Nov 7 07:33:23 1990 ! 211: *************** ! 212: *** 0 **** ! 213: --- 1,79 ---- ! 214: + The coff patches intend to do the following : ! 215: + ! 216: + . Generate coff files very compatible with vanilla linker. ! 217: + . Understands coff debug directives. ! 218: + ! 219: + Here are the guidelines of the work I have done : ! 220: + ! 221: + . Encapsulate format dependent code in macros where it is possible. ! 222: + . Where not possible differenciate with #ifdef ! 223: + . try not to change the calling conventions of the existing functions. ! 224: + I made one exception : symbol_new. I would be pleased to hear about ! 225: + a better solution. (symbols.c) ! 226: + . Extend the use of N_TYPE_seg seg_N_TYPE tables so that segments can ! 227: + be manipulated without using their format dependent name. (subsegs.c) ! 228: + . Write a function to parse the .def debug directives ! 229: + . Write two small peaces of code to handle the .ln directive. ! 230: + . In write.c try to move all the cross compilation specifics (md_..) to ! 231: + format dependent files. ! 232: + . Encapsulate the data structures using generic types, macros calls. ! 233: + . Added too much code to resolve the complexity of the symbol table ! 234: + generated. Most of the code deals with debug stuff. ! 235: + . Create another makefile, shorter, cleaner. ! 236: + . Create a config.gas shell script to mimic the gcc,gdb... configuration ! 237: + mechanism. This reduce the complexity of the makefile. ! 238: + . Isolate the format dependent code in two files ! 239: + coff.c coff.h ! 240: + aout.c aout.h ! 241: + elf.c elf.h [ Not yet ;-] ! 242: + . added a little stack management routine for coff in file stack.c ! 243: + . isolate os specific flags in m- files ! 244: + ! 245: + If further development is planed on it is should solve the following problems : ! 246: + ! 247: + . Encapsulate DESC & OTHER tests in a macro call. I'm not aware ! 248: + of their exact semantics. ! 249: + . Clean up the seg_N_TYPE N_TYPE_seg naming scheme ! 250: + . Try to remove as much reference to segment dependent names as possible ! 251: + . Find a cleaner solution for symbol_new. ! 252: + . Report the modifications on vax, ns32k, sparc machine dependent files. ! 253: + To acheive this goal, search for \<N_, sy_, symbol_new and symbolS. ! 254: + . Allow an arbitrary number of segments (spare sections .ctor .dtor .bletch) ! 255: + . Find a way to extend the debug information without breaking sdb ! 256: + compatibility. Mainly intended for G++. ! 257: + . should it do something to generate shared libraries objects ? ! 258: + ! 259: + I have tested this code on the following processor/os. gcc-1.37.1 was ! 260: + used for all the tests. ! 261: + ! 262: + 386 SCO unix ODT ! 263: + gcc-1.37.1, gas, emacs-18.55 ! 264: + ! 265: + 386 Esix rev C ! 266: + gas-1.37/write.s ! 267: + ! 268: + 386 Ix 2.02 ! 269: + gas, all the X11R4 mit clients ! 270: + ! 271: + 386 CTIX 3.2 ! 272: + xsol (X11R4 solitary game), gas ! 273: + ! 274: + 68030 unisoft 1.3 ! 275: + the kernel (V.3.2) + tcp/ip extensions ! 276: + bash-1.05, bison-1.11, compress-4.0, cproto, shar-3.49, diff-1.14, ! 277: + dist-18.55, flex-2.3, gas-1.37, gcc-1.37.1, gdb-3.6, grep-1.5, ! 278: + kermit, make-3.58, makedep, patch, printf, makeinfo, g++-1.37.1, ! 279: + tar-1.08, texi2roff, uuencode, uutraf-1.2, libg++-1.37.2, groff-0.5 ! 280: + ! 281: + 68020 sunos 3.5 (no, not coff, just to be sure that I didn't ! 282: + introduce errors) ! 283: + gcc-1.37.1, gas, emacs-18.55, gdb-3.6, bison-1.11, diff-1.14, ! 284: + make-3.58, tar-1.08 ! 285: + ! 286: + 68030 sunos 4.0.3 (idem) ! 287: + gas ! 288: + ! 289: + I would be glad to hear about new experiences ! 290: + ! 291: + Loic ([email protected] or [email protected]) ! 292: + ! 293: *** /dev/null Wed Nov 7 08:15:02 1990 ! 294: --- aout.c Wed Nov 7 07:33:24 1990 ! 295: *************** ! 296: *** 0 **** ! 297: --- 1,146 ---- ! 298: + #include "as.h" ! 299: + #include "md.h" ! 300: + #include "aout.h" ! 301: + #include "struc-symbol.h" ! 302: + #include "write.h" ! 303: + #include "append.h" ! 304: + ! 305: + /* Relocation. */ ! 306: + ! 307: + /* ! 308: + * In: length of relocation (or of address) in chars: 1, 2 or 4. ! 309: + * Out: GNU LD relocation length code: 0, 1, or 2. ! 310: + */ ! 311: + ! 312: + static unsigned char ! 313: + ! 314: + nbytes_r_length [] = { ! 315: + 42, 0, 1, 42, 2 ! 316: + }; ! 317: + ! 318: + ! 319: + /* The sparc needs its own emit_relocations() */ ! 320: + #if !defined(SPARC) && !defined(I860) ! 321: + /* ! 322: + * emit_relocations() ! 323: + * ! 324: + * Crawl along a fixS chain. Emit the segment's relocations. ! 325: + */ ! 326: + void ! 327: + emit_relocations (fixP, segment_address_in_file) ! 328: + register fixS * fixP; /* Fixup chain for this segment. */ ! 329: + relax_addressT segment_address_in_file; ! 330: + { ! 331: + struct relocation_info ri; ! 332: + register symbolS * symbolP; ! 333: + ! 334: + /* JF this is for paranoia */ ! 335: + bzero((char *)&ri,sizeof(ri)); ! 336: + for ( ; fixP; fixP = fixP -> fx_next) ! 337: + { ! 338: + if (symbolP = fixP -> fx_addsy) ! 339: + { ! 340: + ! 341: + #ifdef NS32K ! 342: + /* These two 'cuz of NS32K */ ! 343: + ri . r_bsr = fixP -> fx_bsr; ! 344: + ri . r_disp = fixP -> fx_im_disp; ! 345: + #endif ! 346: + ! 347: + ri . r_length = nbytes_r_length [fixP -> fx_size]; ! 348: + ri . r_pcrel = fixP -> fx_pcrel; ! 349: + ri . r_address = fixP -> fx_frag -> fr_address ! 350: + + fixP -> fx_where ! 351: + - segment_address_in_file; ! 352: + if ((symbolP -> sy_type & N_TYPE) == N_UNDF) ! 353: + { ! 354: + ri . r_extern = 1; ! 355: + ri . r_symbolnum = symbolP -> sy_number; ! 356: + } ! 357: + else ! 358: + { ! 359: + ri . r_extern = 0; ! 360: + ri . r_symbolnum = symbolP -> sy_type & N_TYPE; ! 361: + } ! 362: + ! 363: + /* ! 364: + The 68k machines assign bit-fields from higher bits to ! 365: + lower bits ("left-to-right") within the int. VAXen assign ! 366: + bit-fields from lower bits to higher bits ("right-to-left"). ! 367: + Both handle multi-byte numbers in their usual fashion ! 368: + (Big-endian and little-endian stuff). ! 369: + Thus we need a machine dependent routine to make ! 370: + sure the structure is written out correctly. FUN! ! 371: + */ ! 372: + md_ri_to_chars((char *) &ri, ri); ! 373: + append (&next_object_file_charP, (char *)& ri, (unsigned long)sizeof(ri)); ! 374: + } ! 375: + } ! 376: + ! 377: + } ! 378: + #endif ! 379: + ! 380: + /* Aout file generation & utilities */ ! 381: + ! 382: + /* Convert a lvalue to machine dependent data */ ! 383: + #define MD(v) \ ! 384: + md_number_to_chars((char *)&header->v,header->v, sizeof(header->v)) ! 385: + ! 386: + void a_header_append(header, where) ! 387: + struct exec * header; ! 388: + char** where; ! 389: + { ! 390: + MD(a_text); ! 391: + MD(a_data); ! 392: + MD(a_bss); ! 393: + MD(a_trsize); ! 394: + MD(a_drsize); ! 395: + MD(a_syms); ! 396: + MD(a_info); ! 397: + MD(a_entry); ! 398: + #ifdef EXEC_MACHINE_TYPE ! 399: + MD(a_machtype); ! 400: + #endif /* EXEC_MACHINE_TYPE */ ! 401: + #ifdef EXEC_VERSION ! 402: + MD(a_version); ! 403: + #endif /* EXEC_VERSION */ ! 404: + append(where, (char *)header, sizeof(struct exec)); ! 405: + } ! 406: + ! 407: + #undef MD ! 408: + /* Convert a lvalue to machine dependent data */ ! 409: + #define MD(v) \ ! 410: + md_number_to_chars((char *)&symbolP->v,symbolP->v, sizeof(symbolP->v)) ! 411: + ! 412: + void a_symbol_append(symbolP, where) ! 413: + symbolS * symbolP; ! 414: + char** where; ! 415: + { ! 416: + MD(sy_strx); ! 417: + MD(sy_desc); ! 418: + MD(sy_value); ! 419: + append(where, (char *)&symbolP->sy_symbol, sizeof(symbol_type)); ! 420: + } ! 421: + ! 422: + void emit_symbols(symbol_rootP, where) ! 423: + symbolS * symbol_rootP; ! 424: + char** where; ! 425: + { ! 426: + symbolS * symbolP; ! 427: + /* ! 428: + * Emit all symbols left in the symbol chain. ! 429: + */ ! 430: + for(symbolP = symbol_rootP; symbolP; symbolP = symbolP -> sy_next) { ! 431: + /* Used to save the offset of the name. It is used to point ! 432: + to the string in memory but must be a file offset. */ ! 433: + register char * temp; ! 434: + ! 435: + temp = S_GET_NAME(symbolP); ! 436: + S_SET_OFFSET(symbolP, symbolP->sy_name_offset); ! 437: + /* Any symbol still undefined and is not a dbg symbol is made N_EXT. */ ! 438: + if (symbolP->sy_type == N_UNDF) ! 439: + S_SET_EXTERNAL(symbolP); ! 440: + SYMBOL_OUTPUT(symbolP, where); ! 441: + S_SET_NAME(symbolP,temp); ! 442: + } ! 443: + } ! 444: *** /dev/null Wed Nov 7 08:15:02 1990 ! 445: --- aout.h Wed Nov 7 07:33:25 1990 ! 446: *************** ! 447: *** 0 **** ! 448: --- 1,166 ---- ! 449: + #ifndef AOUT_H ! 450: + #define AOUT_H ! 451: + ! 452: + #include "machine.h" ! 453: + ! 454: + #ifndef VMS ! 455: + #include "a.out.gnu.h" /* Needed to define struct nlist. Sigh. */ ! 456: + #else ! 457: + #include "a_out.h" ! 458: + #endif ! 459: + ! 460: + /* Tag to validate a.out object file format processing */ ! 461: + #define aout ! 462: + ! 463: + /* RELOCATION INFORMATION */ ! 464: + ! 465: + #define relocation_type struct relocation_info /* Relocation table entry */ ! 466: + #define RELSZ sizeof(relocation_type) /* For coff compatibility */ ! 467: + ! 468: + /* SYMBOL TABLE */ ! 469: + /* Symbol table entry data type */ ! 470: + ! 471: + #define symbol_type struct nlist /* Symbol table entry */ ! 472: + ! 473: + /* If compiler generate leading underscores, remove them. */ ! 474: + ! 475: + #ifndef STRIP_UNDERSCORE ! 476: + #define STRIP_UNDERSCORE 0 ! 477: + #endif /* STRIP_UNDERSCORE */ ! 478: + ! 479: + /* Symbol table macros and constants */ ! 480: + ! 481: + /* ! 482: + * Macros to extract information from a symbol table entry. ! 483: + * This syntaxic indirection allows independence regarding a.out or coff. ! 484: + * The argument (s) of all these macros is a pointer to a symbol table entry. ! 485: + */ ! 486: + ! 487: + /* Predicates */ ! 488: + /* True if in text segment */ ! 489: + #define S_IS_TEXT(s) (((s)->sy_type & N_TYPE) == N_TEXT) ! 490: + /* True if in data segment */ ! 491: + #define S_IS_DATA(s) (((s)->sy_type & N_TYPE) == N_DATA) ! 492: + /* True if in bss segment */ ! 493: + #define S_IS_BSS(s) (((s)->sy_type & N_TYPE) == N_BSS) ! 494: + /* True if in abs segment */ ! 495: + #define S_IS_ABS(s) (((s)->sy_type & N_TYPE) == N_ABS) ! 496: + /* True if the symbol is external */ ! 497: + #define S_IS_EXTERNAL(s) ((s)->sy_type & N_EXT) ! 498: + /* True if symbol has been defined, ie is in N_{TEXT,DATA,BSS,ABS} or N_EXT */ ! 499: + #define S_IS_DEFINED(s) (((s)->sy_type & N_TYPE) != N_UNDF) ! 500: + /* True if a debug special symbol entry */ ! 501: + #define S_IS_DEBUG(s) ((s)->sy_type & N_STAB) ! 502: + /* True if a symbol is local symbol name */ ! 503: + /* A symbol name whose name begin with ^A is a gas internal pseudo symbol ! 504: + nameless symbols come from .stab directives. */ ! 505: + #define S_IS_LOCAL(s) (S_GET_NAME(s) && \ ! 506: + !S_IS_DEBUG(s) && \ ! 507: + (S_GET_NAME(s)[0] == '\001' || \ ! 508: + (S_LOCAL_NAME(s) && !flagseen['L']))) ! 509: + /* True if a symbol is not defined in this file */ ! 510: + #define S_IS_EXTERN(s) ((s)->sy_type & N_EXT) ! 511: + /* True if the symbol has been generated because of a .stabd directive */ ! 512: + #define S_IS_STABD(s) ((s)->sy_name == (char *)0) ! 513: + ! 514: + /* Accessors */ ! 515: + /* The value of the symbol */ ! 516: + #define S_GET_VALUE(s) ((s)->sy_value) ! 517: + /* The name of the symbol */ ! 518: + #define S_GET_NAME(s) ((s)->sy_name) ! 519: + /* The pointer to the string table */ ! 520: + #define S_GET_OFFSET(s) ((s)->sy_strx) ! 521: + /* The numeric value of the segment */ ! 522: + #define S_GET_SEGMENT(s) ((s)->sy_type & N_TYPE) ! 523: + /* The n_other expression value */ ! 524: + #define S_GET_OTHER(s) ((s)->sy_other) ! 525: + /* The n_desc expression value */ ! 526: + #define S_GET_DESC(s) ((s)->sy_desc) ! 527: + ! 528: + /* Modifiers */ ! 529: + /* Set the value of the symbol */ ! 530: + #define S_SET_VALUE(s,v) ((s)->sy_value = (v)) ! 531: + /* Assume that a symbol cannot be simultaneously in more than on segment */ ! 532: + /* Set the segment to text */ ! 533: + #define S_SET_TEXT(s) ((s)->sy_type &= ~N_TYPE,(s)->sy_type|=N_TEXT) ! 534: + /* Set the segment to data */ ! 535: + #define S_SET_DATA(s) ((s)->sy_type &= ~N_TYPE,(s)->sy_type|=N_DATA) ! 536: + /* Set the segment to bss */ ! 537: + #define S_SET_BSS(s) ((s)->sy_type &= ~N_TYPE,(s)->sy_type|=N_BSS) ! 538: + /* Set the segment to abs */ ! 539: + #define S_SET_ABS(s) ((s)->sy_type &= ~N_TYPE,(s)->sy_type|=N_ABS) ! 540: + /* The symbol is external */ ! 541: + #define S_SET_EXTERNAL(s) ((s)->sy_type |= N_EXT) ! 542: + /* The symbol is not external */ ! 543: + #define S_CLEAR_EXTERNAL(s) ((s)->sy_type &= ~N_EXT) ! 544: + /* Set the name of the symbol */ ! 545: + #define S_SET_NAME(s,v) ((s)->sy_name = v) ! 546: + /* Set the offset in the string table */ ! 547: + #define S_SET_OFFSET(s,v) ((s)->sy_strx = v) ! 548: + /* Set the n_other expression value */ ! 549: + #define S_SET_OTHER(s,v) ((s)->sy_other = (v)) ! 550: + /* Set the n_desc expression value */ ! 551: + #define S_SET_DESC(s,v) ((s)->sy_desc = (v)) ! 552: + ! 553: + /* File header macro and type definition */ ! 554: + ! 555: + #define H_GET_FILE_SIZE(h) (sizeof(struct exec) + \ ! 556: + H_GET_TEXT_SIZE(h) + H_GET_DATA_SIZE(h) + \ ! 557: + H_GET_SYMBOL_TABLE_SIZE(h) + \ ! 558: + H_GET_TEXT_RELOCATION_SIZE(h) + \ ! 559: + H_GET_DATA_RELOCATION_SIZE(h) + \ ! 560: + (h)->string_table_size) ! 561: + ! 562: + #define H_GET_TEXT_SIZE(h) ((h)->header.a_text) ! 563: + #define H_GET_DATA_SIZE(h) ((h)->header.a_data) ! 564: + #define H_GET_BSS_SIZE(h) ((h)->header.a_bss) ! 565: + #define H_GET_TEXT_RELOCATION_SIZE(h) ((h)->header.a_trsize) ! 566: + #define H_GET_DATA_RELOCATION_SIZE(h) ((h)->header.a_drsize) ! 567: + #define H_GET_SYMBOL_TABLE_SIZE(h) ((h)->header.a_syms) ! 568: + #define H_GET_MAGIC_NUMBER(h) ((h)->header.a_info) ! 569: + #define H_GET_ENTRY_POINT(h) ((h)->header.a_entry) ! 570: + #define H_GET_STRING_SIZE(h) ((h)->string_table_size) ! 571: + #ifdef EXEC_MACHINE_TYPE ! 572: + #define H_GET_MACHINE_TYPE(h) ((h)->header.a_machtype) ! 573: + #endif /* EXEC_MACHINE_TYPE */ ! 574: + #ifdef EXEC_VERSION ! 575: + #define H_GET_VERSION(h) ((h)->header.a_version) ! 576: + #endif /* EXEC_VERSION */ ! 577: + ! 578: + #define H_SET_TEXT_SIZE(h,v) ((h)->header.a_text = (v)) ! 579: + #define H_SET_DATA_SIZE(h,v) ((h)->header.a_data = (v)) ! 580: + #define H_SET_BSS_SIZE(h,v) ((h)->header.a_bss = (v)) ! 581: + #define H_SET_RELOCATION_SIZE(h,t,d) (H_SET_TEXT_RELOCATION_SIZE((h),(t)),\ ! 582: + H_SET_DATA_RELOCATION_SIZE((h),(d))) ! 583: + #define H_SET_TEXT_RELOCATION_SIZE(h,v) ((h)->header.a_trsize = (v)) ! 584: + #define H_SET_DATA_RELOCATION_SIZE(h,v) ((h)->header.a_drsize = (v)) ! 585: + #define H_SET_SYMBOL_TABLE_SIZE(h,v) ((h)->header.a_syms = (v) * \ ! 586: + sizeof(struct nlist)) ! 587: + #define H_SET_MAGIC_NUMBER(h,v) ((h)->header.a_info = (v)) ! 588: + #define H_SET_ENTRY_POINT(h,v) ((h)->header.a_entry = (v)) ! 589: + #define H_SET_STRING_SIZE(h,v) ((h)->string_table_size = (v)) ! 590: + #ifdef EXEC_MACHINE_TYPE ! 591: + #define H_SET_MACHINE_TYPE(h,v) ((h)->header.a_machtype = (v)) ! 592: + #endif /* EXEC_MACHINE_TYPE */ ! 593: + #ifdef EXEC_VERSION ! 594: + #define H_SET_VERSION(h,v) ((h)->header.a_version = (v)) ! 595: + #endif /* EXEC_VERSION */ ! 596: + ! 597: + /* Output the file(s) header(s) in a character array */ ! 598: + #define H_OUTPUT(h,where) a_header_append(&(h)->header,(where)) ! 599: + ! 600: + /* Output a symbol entry */ ! 601: + #define SYMBOL_OUTPUT(s,w) a_symbol_append((s), (w)) ! 602: + ! 603: + typedef struct { ! 604: + struct exec header; /* a.out header */ ! 605: + long int string_table_size; /* names + '\0' + sizeof(int) */ ! 606: + } object_headers; ! 607: + ! 608: + /* Format independent interface functions */ ! 609: + extern void emit_relocations(); ! 610: + extern void emit_symbols(); ! 611: + extern void a_header_append(); ! 612: + extern void a_symbol_append(); ! 613: + ! 614: + #endif /* AOUT_H */ ! 615: *** /dev/null Wed Nov 7 08:15:02 1990 ! 616: --- append.h Wed Nov 7 07:33:26 1990 ! 617: *************** ! 618: *** 0 **** ! 619: --- 1,1 ---- ! 620: + extern void append(); ! 621: *** /dev/null Wed Nov 7 08:15:02 1990 ! 622: --- coff.c Wed Nov 7 07:33:27 1990 ! 623: *************** ! 624: *** 0 **** ! 625: --- 1,364 ---- ! 626: + #include "oformat.h" ! 627: + #include "as.h" ! 628: + #include "md.h" ! 629: + #include "struc-symbol.h" ! 630: + #include "symbols.h" ! 631: + #include "write.h" ! 632: + ! 633: + /* Relocation. */ ! 634: + ! 635: + /* ! 636: + * emit_relocations() ! 637: + * ! 638: + * Crawl along a fixS chain. Emit the segment's relocations. ! 639: + */ ! 640: + ! 641: + void ! 642: + emit_relocations (fixP, segment_address_in_file) ! 643: + register fixS * fixP; /* Fixup chain for this segment. */ ! 644: + relax_addressT segment_address_in_file; ! 645: + { ! 646: + RELOC ri; ! 647: + register symbolS * symbolP; ! 648: + ! 649: + bzero((char *)&ri,sizeof(ri)); ! 650: + for ( ; fixP; fixP = fixP->fx_next) { ! 651: + if (symbolP = fixP->fx_addsy) { ! 652: + #if defined(PROCESSOR_68000) ! 653: + ri.r_type = (fixP->fx_pcrel ? ! 654: + ( fixP->fx_size == 1 ? R_PCRBYTE : ! 655: + fixP->fx_size == 2 ? R_PCRWORD : ! 656: + R_PCRLONG): ! 657: + ( fixP->fx_size == 1 ? R_RELBYTE : ! 658: + fixP->fx_size == 2 ? R_RELWORD : ! 659: + R_RELLONG)); ! 660: + #elif defined(PROCESSOR_i386) ! 661: + /* !!!! R_OFF8 & R_DIR16 are a vague guess, completly unested. */ ! 662: + ri.r_type = (fixP->fx_pcrel ? ! 663: + ( fixP->fx_size == 1 ? R_PCRBYTE : ! 664: + fixP->fx_size == 2 ? R_PCRWORD : ! 665: + R_PCRLONG): ! 666: + ( fixP->fx_size == 1 ? R_OFF8 : ! 667: + fixP->fx_size == 2 ? R_DIR16 : ! 668: + R_DIR32)); ! 669: + #else ! 670: + you lose ! 671: + #endif /* PROCESSOR_68000 || PROCESSOR_i386 */ ! 672: + ri.r_vaddr = fixP->fx_frag->fr_address + fixP->fx_where; ! 673: + /* If symbol associated to relocation entry is a bss symbol ! 674: + or undefined symbol just remember the index of the symbol. ! 675: + Otherwise store the index of the symbol describing the ! 676: + section the symbol belong to. This heuristic speeds up ld. ! 677: + */ ! 678: + /* Local symbols can generate relocation information. In case ! 679: + of structure return for instance. But they have no symbol ! 680: + number because they won't be emitted in the final object. ! 681: + In the case where they are in the BSS section, this leads ! 682: + to an incorrect r_symndx. ! 683: + Under bsd the loader do not care if the symbol reference is ! 684: + incorrect. But the SYS V ld complains about this. To avoid ! 685: + this we associate the symbol to the associated section, ! 686: + *even* if it is the BSS section. */ ! 687: + /* If someone can tell me why the other symbols of the bss ! 688: + section are not associated with the .bss section entry, ! 689: + I'd be gratefull. I guess that it has to do with the special ! 690: + nature of the .bss section. Or maybe this is because the ! 691: + bss symbols are declared in the common section and can ! 692: + be resized later. Can it break code some where ? */ ! 693: + ri.r_symndx = ! 694: + S_GET_SEGMENT(symbolP) == C_TEXT_SECTION ? dot_text_symbol->sy_number : ! 695: + S_GET_SEGMENT(symbolP) == C_DATA_SECTION ? dot_data_symbol->sy_number : ! 696: + (SF_GET_LOCAL(symbolP) ? dot_bss_symbol->sy_number : ! 697: + symbolP->sy_number); /* bss or undefined */ ! 698: + ! 699: + /* md_ri_to_chars((char *) &ri, ri); /* Last step : write md f */ ! 700: + append (&next_object_file_charP, ! 701: + (char *)& ri, ! 702: + (unsigned long)RELSZ); ! 703: + } ! 704: + } ! 705: + } ! 706: + ! 707: + /* Coff file generation & utilities */ ! 708: + ! 709: + /* Convert a lvalue to machine dependent data */ ! 710: + #define MD(s,v) \ ! 711: + md_number_to_chars((char *)&(s)->v,(s)->v, sizeof((s)->v)) ! 712: + ! 713: + void ! 714: + c_header_append(aouthdr, filehdr, where) ! 715: + AOUTHDR* aouthdr; ! 716: + FILHDR* filehdr; ! 717: + char** where; ! 718: + { ! 719: + /* Eventually swap bytes for cross compilation for file header */ ! 720: + MD(filehdr, f_magic); ! 721: + MD(filehdr, f_nscns); ! 722: + MD(filehdr, f_timdat); ! 723: + MD(filehdr, f_symptr); ! 724: + MD(filehdr, f_nsyms); ! 725: + MD(filehdr, f_opthdr); ! 726: + MD(filehdr, f_flags); ! 727: + append(where, (char *)filehdr, FILHSZ); ! 728: + ! 729: + /* Eventually swap bytes for cross compilation for a.out header */ ! 730: + MD(aouthdr, magic); ! 731: + MD(aouthdr, vstamp); ! 732: + MD(aouthdr, tsize); ! 733: + MD(aouthdr, dsize); ! 734: + MD(aouthdr, bsize); ! 735: + MD(aouthdr, entry); ! 736: + MD(aouthdr, text_start); ! 737: + MD(aouthdr, data_start); ! 738: + append(where, (char *)aouthdr, sizeof(struct aouthdr)); ! 739: + } ! 740: + ! 741: + /* ! 742: + * Beware ! If you cross compile to another ENDIAN machine, ! 743: + * the symbol table values will not be valid any more. ! 744: + */ ! 745: + ! 746: + void ! 747: + c_symbol_append(symbolP, where) ! 748: + symbolS * symbolP; ! 749: + char** where; ! 750: + { ! 751: + SYMENT *syment = &symbolP->sy_symbol; ! 752: + char numaux = syment->n_numaux; ! 753: + register AUXENT* auxP = &symbolP->sy_auxent; ! 754: + register unsigned short type = S_GET_DATA_TYPE(symbolP); ! 755: + ! 756: + MD(syment, n_value); ! 757: + MD(syment, n_scnum); ! 758: + MD(syment, n_type); ! 759: + MD(syment, n_sclass); ! 760: + MD(syment, n_numaux); ! 761: + append(where, (char *)syment, SYMESZ); ! 762: + ! 763: + /* Should do the following : if(.file entry) MD(..)... else ! 764: + if(static entry) MD(..) ! 765: + */ ! 766: + if(numaux == 1) { ! 767: + #if 0 /* This code has never been tested */ ! 768: + /* The most common case, x_sym entry. */ ! 769: + if((SF_GET(symbolP) & (SF_FILE | SF_STATICS)) == 0) { ! 770: + MD(auxP, x_sym.x_tagndx); ! 771: + if(ISFCN(type)) ! 772: + MD(auxP, x_sym.x_misc.x_fsize); ! 773: + else { ! 774: + MD(auxP, x_sym.x_misc.x_lnno); ! 775: + MD(auxP, x_sym.x_misc.x_size); ! 776: + } ! 777: + if(ISARY(type)) { ! 778: + register int index; ! 779: + for(index = 0; index < DIMNUM; index++) ! 780: + MD(auxP, x_sym.x_fcnary.x_ary.x_dimen[index]); ! 781: + } else { ! 782: + MD(auxP, x_sym.x_fcnary.x_fcn.x_lnnoptr); ! 783: + MD(auxP, x_sym.x_fcnary.x_fcn.x_endndx); ! 784: + } ! 785: + MD(auxP, x_sym.x_tvndx); ! 786: + } else if(SF_GET_FILE(symbolP)) /* .file */ ! 787: + ; ! 788: + else if(SF_GET_STATICS(symbolP)) { /* .text, .data, .bss symbols */ ! 789: + MD(auxP, x_scn.x_scnlen); ! 790: + MD(auxP, x_scn.x_nreloc); ! 791: + MD(auxP, x_scn.x_nlinno); ! 792: + } ! 793: + #endif /* 0 */ ! 794: + append(where, (char *)auxP, AUXESZ); ! 795: + } else if(numaux > 0) ! 796: + as_warn("more than one auxent for symbol"); ! 797: + ! 798: + return; ! 799: + } ! 800: + ! 801: + void ! 802: + c_section_header_append(header, where) ! 803: + SCNHDR* header; ! 804: + char** where; ! 805: + { ! 806: + MD(header, s_paddr); ! 807: + MD(header, s_vaddr); ! 808: + MD(header, s_size); ! 809: + MD(header, s_scnptr); ! 810: + MD(header, s_relptr); ! 811: + MD(header, s_lnnoptr); ! 812: + MD(header, s_nreloc); ! 813: + MD(header, s_nlnno); ! 814: + MD(header, s_flags); ! 815: + append(where, (char *)header, SCNHSZ); ! 816: + ! 817: + return; ! 818: + } ! 819: + ! 820: + ! 821: + void emit_symbols(symbol_rootP, where) ! 822: + symbolS * symbol_rootP; ! 823: + char** where; ! 824: + { ! 825: + symbolS * symbolP; ! 826: + /* ! 827: + * Emit all symbols left in the symbol chain. ! 828: + */ ! 829: + for(symbolP = symbol_rootP; symbolP; symbolP = symbolP -> sy_next) { ! 830: + /* Used to save the offset of the name. It is used to point ! 831: + to the string in memory but must be a file offset. */ ! 832: + register char * temp; ! 833: + ! 834: + temp = S_GET_NAME(symbolP); ! 835: + if (SF_GET_STRING(symbolP)) { ! 836: + S_SET_OFFSET(symbolP, symbolP->sy_name_offset); ! 837: + S_SET_ZEROES(symbolP, 0); ! 838: + } else { ! 839: + memset(symbolP->sy_name, '\0', SYMNMLEN); ! 840: + strncpy(symbolP->sy_name, temp, SYMNMLEN); ! 841: + } ! 842: + SYMBOL_OUTPUT(symbolP, where); ! 843: + S_SET_NAME(symbolP,temp); ! 844: + } ! 845: + } ! 846: + ! 847: + /* Merge a debug symbol containing debug information into a normal ! 848: + symbol. */ ! 849: + ! 850: + void ! 851: + c_symbol_merge(debug, normal) ! 852: + symbolS* debug; ! 853: + symbolS* normal; ! 854: + { ! 855: + S_SET_DATA_TYPE(normal, S_GET_DATA_TYPE(debug)); ! 856: + S_SET_STORAGE_CLASS(normal, S_GET_STORAGE_CLASS(debug)); ! 857: + S_SET_NUMBER_AUXILIARY(normal, S_GET_NUMBER_AUXILIARY(debug)); ! 858: + /* Move all the auxiliary information */ ! 859: + if(S_GET_NUMBER_AUXILIARY(debug)) ! 860: + memcpy((char*)&normal->sy_auxent, (char*)&debug->sy_auxent, ! 861: + AUXESZ); ! 862: + /* Move the debug flags. */ ! 863: + SF_SET_DEBUG_FIELD(normal, SF_GET_DEBUG_FIELD(debug)); ! 864: + } ! 865: + ! 866: + c_dot_file_symbol(filename) ! 867: + char* filename; ! 868: + { ! 869: + symbolS* symbolP; ! 870: + ! 871: + symbolP = symbol_new(".file", SEG_DEBUG, 0, ! 872: + C_FILE, &zero_address_frag); ! 873: + S_SET_NUMBER_AUXILIARY(symbolP, 1); ! 874: + SA_SET_FILE_FNAME(symbolP, filename); ! 875: + SF_SET_DEBUG(symbolP); ! 876: + ! 877: + /* Make sure that the symbol is first on the symbol chain */ ! 878: + if(symbol_rootP != symbolP) { ! 879: + symbol_lastP = symbol_lastP->sy_previous; ! 880: + DL_REMOVE(symbolP); ! 881: + DL_INSERT(symbolP, symbol_rootP); ! 882: + symbol_rootP = symbolP; ! 883: + } ! 884: + } ! 885: + /* ! 886: + * Build a 'section static' symbol. ! 887: + */ ! 888: + ! 889: + char* ! 890: + c_section_symbol(name, value, length, nreloc, nlnno) ! 891: + char* name; ! 892: + long value; ! 893: + long length; ! 894: + unsigned short nreloc; ! 895: + unsigned short nlnno; ! 896: + { ! 897: + symbolS* symbolP; ! 898: + ! 899: + symbolP = symbol_new(name, ! 900: + (name[1] == 't' ? SEG_TEXT : ! 901: + name[1] == 'd' ? SEG_DATA : ! 902: + SEG_BSS), ! 903: + value, ! 904: + C_STAT, ! 905: + &zero_address_frag); ! 906: + ! 907: + S_SET_NUMBER_AUXILIARY(symbolP, 1); ! 908: + ! 909: + SA_SET_SCN_SCNLEN(symbolP, length); ! 910: + SA_SET_SCN_NRELOC(symbolP, nreloc); ! 911: + SA_SET_SCN_NLINNO(symbolP, nlnno); ! 912: + ! 913: + SF_SET_STATICS(symbolP); ! 914: + ! 915: + return (char*)symbolP; ! 916: + } ! 917: + ! 918: + void ! 919: + c_section_header(header, name, core_address, size, ! 920: + data_ptr, reloc_ptr, lineno_ptr, ! 921: + reloc_number, lineno_number) ! 922: + SCNHDR* header; ! 923: + char* name; ! 924: + long core_address; ! 925: + long size; ! 926: + long data_ptr; ! 927: + long reloc_ptr; ! 928: + long lineno_ptr; ! 929: + long reloc_number; ! 930: + long lineno_number; ! 931: + { ! 932: + strncpy(header->s_name, name, 8); ! 933: + header->s_paddr = header->s_vaddr = core_address; ! 934: + header->s_size = size; ! 935: + header->s_scnptr = data_ptr; ! 936: + header->s_relptr = reloc_ptr; ! 937: + header->s_lnnoptr = lineno_ptr; ! 938: + header->s_nreloc = reloc_number; ! 939: + header->s_nlnno = lineno_number; ! 940: + header->s_flags = STYP_REG | ( name[1] == 't' ? STYP_TEXT : ! 941: + name[1] == 'd' ? STYP_DATA : ! 942: + name[1] == 'b' ? STYP_BSS : ! 943: + STYP_INFO ); ! 944: + return ; ! 945: + } ! 946: + ! 947: + /* Line number handling */ ! 948: + ! 949: + int text_lineno_number = 0; ! 950: + lineno* lineno_rootP = (lineno*)0; ! 951: + lineno* lineno_lastP = (lineno*)0; ! 952: + ! 953: + lineno* ! 954: + c_line_new(paddr, line_number, frag) ! 955: + long paddr; ! 956: + unsigned short line_number; ! 957: + fragS* frag; ! 958: + { ! 959: + lineno* new_line = (lineno*)xmalloc(sizeof(lineno)); ! 960: + ! 961: + new_line->line.l_addr.l_paddr = paddr; ! 962: + new_line->line.l_lnno = line_number; ! 963: + new_line->frag = (char*)frag; ! 964: + new_line->next = (lineno*)0; ! 965: + ! 966: + if(lineno_rootP == (lineno*)0) ! 967: + lineno_rootP = new_line; ! 968: + else ! 969: + lineno_lastP->next = new_line; ! 970: + lineno_lastP = new_line; ! 971: + } ! 972: + ! 973: + void ! 974: + emit_lineno(line, where) ! 975: + lineno* line; ! 976: + char** where; ! 977: + { ! 978: + register LINENO* line_entry; ! 979: + ! 980: + for(;line;line = line->next) { ! 981: + line_entry = &line->line; ! 982: + /* No matter which member of the union we process, they are ! 983: + both long. */ ! 984: + MD(line_entry, l_addr.l_paddr); ! 985: + MD(line_entry, l_lnno); ! 986: + append(where, (char *)line_entry, LINESZ); ! 987: + } ! 988: + return ; ! 989: + } ! 990: *** /dev/null Wed Nov 7 08:15:02 1990 ! 991: --- coff.h Wed Nov 7 07:33:28 1990 ! 992: *************** ! 993: *** 0 **** ! 994: --- 1,400 ---- ! 995: + #ifndef COFF_H ! 996: + #define COFF_H ! 997: + ! 998: + #include <filehdr.h> ! 999: + #include <aouthdr.h> ! 1000: + #include <scnhdr.h> ! 1001: + #include <storclass.h> ! 1002: + #include <linenum.h> ! 1003: + #include <syms.h> ! 1004: + #include <reloc.h> ! 1005: + ! 1006: + #include "machine.h" ! 1007: + #include "stack.h" ! 1008: + ! 1009: + /* Tag to validate coff object file format processing */ ! 1010: + #define coff ! 1011: + ! 1012: + /* Define some processor dependent values according to the processor we are ! 1013: + on. */ ! 1014: + #if defined(PROCESSOR_68000) ! 1015: + ! 1016: + #define BYTE_ORDERING F_AR32W /* See filehdr.h for more info. */ ! 1017: + #ifndef FILE_HEADER_MAGIC ! 1018: + #define FILE_HEADER_MAGIC MC68MAGIC /* ... */ ! 1019: + #endif /* FILE_HEADER_MAGIC */ ! 1020: + ! 1021: + #elif defined(PROCESSOR_i386) ! 1022: + ! 1023: + #define BYTE_ORDERING F_AR32WR /* See filehdr.h for more info. */ ! 1024: + #ifndef FILE_HEADER_MAGIC ! 1025: + #define FILE_HEADER_MAGIC I386MAGIC /* ... */ ! 1026: + #endif /* FILE_HEADER_MAGIC */ ! 1027: + ! 1028: + #elif ! 1029: + you lose ! 1030: + #endif ! 1031: + ! 1032: + /* Magic number of paged executable. */ ! 1033: + #define OMAGIC 0413 ! 1034: + ! 1035: + /* Add these definitions to have a consistent convention for all the ! 1036: + types used in COFF format. */ ! 1037: + #define AOUTHDR struct aouthdr ! 1038: + #define AOUTHDRSZ sizeof(AOUTHDR) ! 1039: + ! 1040: + /* RELOCATION INFORMATION */ ! 1041: + ! 1042: + #define relocation_type RELOC /* Relocation table entry */ ! 1043: + ! 1044: + /* SYMBOL TABLE */ ! 1045: + ! 1046: + /* Symbol table entry data type */ ! 1047: + ! 1048: + #define symbol_type SYMENT /* Symbol table entry */ ! 1049: + ! 1050: + /* If compiler generate leading underscores, remove them. */ ! 1051: + ! 1052: + #ifndef STRIP_UNDERSCORE ! 1053: + #define STRIP_UNDERSCORE 0 ! 1054: + #endif /* STRIP_UNDERSCORE */ ! 1055: + #define DO_NOT_STRIP 0 ! 1056: + #define DO_STRIP 1 ! 1057: + ! 1058: + /* Double linked list manipulations macros. */ ! 1059: + /* See struc-symbol.h for a definition of symbolS. */ ! 1060: + ! 1061: + /* Remove the argument from the list. */ ! 1062: + #define DL_REMOVE(p) \ ! 1063: + (((p)->sy_next && ((p)->sy_next->sy_previous = (p)->sy_previous)),\ ! 1064: + ((p)->sy_previous && ((p)->sy_previous->sy_next = (p)->sy_next))) ! 1065: + ! 1066: + /* Set the chain symbols to null. */ ! 1067: + #define DL_CLEAR(p) \ ! 1068: + ((p)->sy_next = (symbolS*)0, (p)->sy_previous = (symbolS*)0) ! 1069: + ! 1070: + /* Link symbol p after symbol w in the chain. */ ! 1071: + #define DL_APPEND(p,w) \ ! 1072: + (((w)->sy_next && ((w)->sy_next->sy_previous = (p))), \ ! 1073: + ((p)->sy_next = (w)->sy_next), \ ! 1074: + ((w)->sy_next = (p)), \ ! 1075: + ((p)->sy_previous = (w))) ! 1076: + ! 1077: + /* Link symbol p before symbol w in the chain. */ ! 1078: + #define DL_INSERT(p,w) \ ! 1079: + (((w)->sy_previous && ((w)->sy_previous->sy_next = (p))), \ ! 1080: + ((p)->sy_previous = (w)->sy_previous), \ ! 1081: + ((w)->sy_previous = (p)), \ ! 1082: + ((p)->sy_next = (w))) ! 1083: + ! 1084: + /* Symbol table macros and constants */ ! 1085: + ! 1086: + /* Possible and usefull section number in symbol table ! 1087: + * The values of TEXT, DATA and BSS may not be portable. ! 1088: + */ ! 1089: + ! 1090: + #define C_TEXT_SECTION 1 ! 1091: + #define C_DATA_SECTION 2 ! 1092: + #define C_BSS_SECTION 3 ! 1093: + #define C_ABS_SECTION N_ABS ! 1094: + #define C_UNDEF_SECTION N_UNDEF ! 1095: + #define C_DEBUG_SECTION N_DEBUG ! 1096: + #define C_NTV_SECTION N_TV ! 1097: + #define C_PTV_SECTION P_TV ! 1098: + ! 1099: + /* ! 1100: + * Macros to extract information from a symbol table entry. ! 1101: + * This syntaxic indirection allows independence regarding a.out or coff. ! 1102: + * The argument (s) of all these macros is a pointer to a symbol table entry. ! 1103: + */ ! 1104: + ! 1105: + /* Predicates */ ! 1106: + /* True if in text segment */ ! 1107: + #define S_IS_TEXT(s) ((s)->sy_scnum == C_TEXT_SECTION) ! 1108: + /* True if in data segment */ ! 1109: + #define S_IS_DATA(s) ((s)->sy_scnum == C_DATA_SECTION) ! 1110: + /* True if in bss segment */ ! 1111: + #define S_IS_BSS(s) ((s)->sy_scnum == C_BSS_SECTION) ! 1112: + /* True if in bss segment */ ! 1113: + #define S_IS_ABS(s) ((s)->sy_scnum == C_ABS_SECTION) ! 1114: + /* True if the symbol is external */ ! 1115: + #define S_IS_EXTERNAL(s) ((s)->sy_scnum == C_UNDEF_SECTION) ! 1116: + /* True if symbol has been defined, ie : ! 1117: + section > 0 (DATA, TEXT or BSS) ! 1118: + section == 0 and value > 0 (external bss symbol) */ ! 1119: + #define S_IS_DEFINED(s) ((s)->sy_scnum > C_UNDEF_SECTION || \ ! 1120: + ((s)->sy_scnum == C_UNDEF_SECTION && \ ! 1121: + (s)->sy_value > 0)) ! 1122: + /* True if a debug special symbol entry */ ! 1123: + #define S_IS_DEBUG(s) ((s)->sy_scnum == C_DEGUG_SECTION) ! 1124: + /* True if a symbol is local symbol name */ ! 1125: + /* A symbol name whose name begin with ^A is a gas internal pseudo symbol */ ! 1126: + #define S_IS_LOCAL(s) (S_GET_NAME(s)[0] == '\001' || \ ! 1127: + (S_LOCAL_NAME(s) && !flagseen['L'])) ! 1128: + /* True if a symbol is not defined in this file */ ! 1129: + #define S_IS_EXTERN(s) ((s)->sy_scnum == 0 && (s)->sy_value == 0) ! 1130: + /* ! 1131: + * True if a symbol can be multiply defined (bss symbols have this def ! 1132: + * though it is bad practice) ! 1133: + */ ! 1134: + #define S_IS_COMMON(s) ((s)->sy_scnum == 0 && (s)->sy_value != 0) ! 1135: + /* True if a symbol name is in the string table, i.e. its length is > 8. */ ! 1136: + #define S_IS_STRING(s) (strlen(S_GET_NAME(s)) > 8 ? 1 : 0) ! 1137: + ! 1138: + /* Accessors */ ! 1139: + /* The name of the symbol */ ! 1140: + #define S_GET_NAME(s) ((char*)(s)->sy_offset) ! 1141: + /* The pointer to the string table */ ! 1142: + #define S_GET_OFFSET(s) ((s)->sy_offset) ! 1143: + /* The zeroes if symbol name is longer than 8 chars */ ! 1144: + #define S_GET_ZEROES(s) ((s)->sy_zeroes) ! 1145: + /* The value of the symbol */ ! 1146: + #define S_GET_VALUE(s) ((s)->sy_value) ! 1147: + /* The numeric value of the segment */ ! 1148: + #define S_GET_SEGMENT(s) ((s)->sy_scnum) ! 1149: + /* The data type */ ! 1150: + #define S_GET_DATA_TYPE(s) ((s)->sy_type) ! 1151: + /* The storage class */ ! 1152: + #define S_GET_STORAGE_CLASS(s) ((s)->sy_sclass) ! 1153: + /* The number of auxiliary entries */ ! 1154: + #define S_GET_NUMBER_AUXILIARY(s) ((s)->sy_numaux) ! 1155: + ! 1156: + /* Modifiers */ ! 1157: + /* Set the name of the symbol */ ! 1158: + #define S_SET_NAME(s,v) ((s)->sy_offset = (unsigned long)(v)) ! 1159: + /* Set the offset of the symbol */ ! 1160: + #define S_SET_OFFSET(s,v) ((s)->sy_offset = (v)) ! 1161: + /* The zeroes if symbol name is longer than 8 chars */ ! 1162: + #define S_SET_ZEROES(s,v) ((s)->sy_zeroes = (v)) ! 1163: + /* Set the value of the symbol */ ! 1164: + #define S_SET_VALUE(s,v) ((s)->sy_value = (v)) ! 1165: + /* The numeric value of the segment */ ! 1166: + #define S_SET_SEGMENT(s,v) ((s)->sy_scnum = (v)) ! 1167: + /* The data type */ ! 1168: + #define S_SET_DATA_TYPE(s,v) ((s)->sy_type = (v)) ! 1169: + /* The storage class */ ! 1170: + #define S_SET_STORAGE_CLASS(s,v) ((s)->sy_sclass = (v)) ! 1171: + /* The number of auxiliary entries */ ! 1172: + #define S_SET_NUMBER_AUXILIARY(s,v) ((s)->sy_numaux = (v)) ! 1173: + ! 1174: + /* Additional modifiers */ ! 1175: + /* Assume that a symbol cannot be simultaneously in more than on segment */ ! 1176: + /* Set the segment to text */ ! 1177: + #define S_SET_TEXT(s) ((s)->sy_scnum = C_TEXT_SECTION) ! 1178: + /* Set the segment to data */ ! 1179: + #define S_SET_DATA(s) ((s)->sy_scnum = C_DATA_SECTION) ! 1180: + /* Set the segment to bss */ ! 1181: + #define S_SET_BSS(s) ((s)->sy_scnum = C_BSS_SECTION) ! 1182: + /* Set the segment to abs */ ! 1183: + #define S_SET_ABS(s) ((s)->sy_scnum = C_ABS_SECTION) ! 1184: + /* The symbol is external (does not mean undefined) */ ! 1185: + #define S_SET_EXTERNAL(s) S_SET_STORAGE_CLASS(s,C_EXT) ! 1186: + ! 1187: + /* Auxiliary entry macros. SA_ stands for symbol auxiliary */ ! 1188: + /* Omit the tv related fields */ ! 1189: + /* Accessors */ ! 1190: + #define SA_GET_SYM_TAGNDX(s) ((s)->sy_auxent.x_sym.x_tagndx) ! 1191: + #define SA_GET_SYM_LNNO(s) ((s)->sy_auxent.x_sym.x_misc.x_lnsz.x_lnno) ! 1192: + #define SA_GET_SYM_SIZE(s) ((s)->sy_auxent.x_sym.x_misc.x_lnsz.x_size) ! 1193: + #define SA_GET_SYM_FSIZE(s) ((s)->sy_auxent.x_sym.x_misc.x_fsize) ! 1194: + #define SA_GET_SYM_LNNOPTR(s) ((s)->sy_auxent.x_sym.x_fcnary.x_fcn.x_lnnoptr) ! 1195: + #define SA_GET_SYM_ENDNDX(s) ((s)->sy_auxent.x_sym.x_fcnary.x_fcn.x_endndx) ! 1196: + #define SA_GET_SYM_DIMEN(s,i) ((s)->sy_auxent.x_sym.x_fcnary.x_ary.x_dimen[(i)]) ! 1197: + #define SA_GET_FILE_FNAME(s) ((s)->sy_auxent.x_file.x_fname) ! 1198: + #define SA_GET_SCN_SCNLEN(s) ((s)->sy_auxent.x_scn.x_scnlen) ! 1199: + #define SA_GET_SCN_NRELOC(s) ((s)->sy_auxent.x_scn.x_nreloc) ! 1200: + #define SA_GET_SCN_NLINNO(s) ((s)->sy_auxent.x_scn.x_nlinno) ! 1201: + ! 1202: + /* Modifiers */ ! 1203: + #define SA_SET_SYM_TAGNDX(s,v) ((s)->sy_auxent.x_sym.x_tagndx=(v)) ! 1204: + #define SA_SET_SYM_LNNO(s,v) ((s)->sy_auxent.x_sym.x_misc.x_lnsz.x_lnno=(v)) ! 1205: + #define SA_SET_SYM_SIZE(s,v) ((s)->sy_auxent.x_sym.x_misc.x_lnsz.x_size=(v)) ! 1206: + #define SA_SET_SYM_FSIZE(s,v) ((s)->sy_auxent.x_sym.x_misc.x_fsize=(v)) ! 1207: + #define SA_SET_SYM_LNNOPTR(s,v) ((s)->sy_auxent.x_sym.x_fcnary.x_fcn.x_lnnoptr=(v)) ! 1208: + #define SA_SET_SYM_ENDNDX(s,v) ((s)->sy_auxent.x_sym.x_fcnary.x_fcn.x_endndx=(v)) ! 1209: + #define SA_SET_SYM_DIMEN(s,i,v) ((s)->sy_auxent.x_sym.x_fcnary.x_ary.x_dimen[(i)]=(v)) ! 1210: + #define SA_SET_FILE_FNAME(s,v) strncpy((s)->sy_auxent.x_file.x_fname,(v),FILNMLEN) ! 1211: + #define SA_SET_SCN_SCNLEN(s,v) ((s)->sy_auxent.x_scn.x_scnlen=(v)) ! 1212: + #define SA_SET_SCN_NRELOC(s,v) ((s)->sy_auxent.x_scn.x_nreloc=(v)) ! 1213: + #define SA_SET_SCN_NLINNO(s,v) ((s)->sy_auxent.x_scn.x_nlinno=(v)) ! 1214: + ! 1215: + /* Internal use only definitions. SF_ stands for symbol flags. */ ! 1216: + ! 1217: + /* These values can be assigned to sy_flags field of a symbolS */ ! 1218: + /* The first 16 bits are general purpose. The last 16 bits are debug info */ ! 1219: + ! 1220: + #define SF_STATICS 0x00000001 /* Mark the .text & all symbols */ ! 1221: + #define SF_DEFINED 0x00000002 /* Symbol is defined in this file */ ! 1222: + #define SF_STRING 0x00000004 /* Symbol name length > 8 */ ! 1223: + #define SF_LOCAL 0x00000008 /* Symbol must not be emitted */ ! 1224: + ! 1225: + #define SF_FUNCTION 0x00010000 /* The symbol is a function */ ! 1226: + #define SF_PROCESS 0x00020000 /* Process symbol before write */ ! 1227: + #define SF_TAGGED 0x00040000 /* Is associated with a tag */ ! 1228: + #define SF_TAG 0x00080000 /* Is a tag */ ! 1229: + #define SF_DEBUG 0x00100000 /* Is in debug or abs section */ ! 1230: + #define SF_GET_SEGMENT 0x00200000 /* Get the section of the forward ! 1231: + symbol. */ ! 1232: + ! 1233: + /* Masks */ ! 1234: + #define SF_NORMAL_MASK 0x0000ffff /* Non debug information */ ! 1235: + #define SF_DEBUG_MASK 0xffff0000 /* Debug information */ ! 1236: + ! 1237: + /* Accessors */ ! 1238: + #define SF_GET(s) ((s)->sy_flags) ! 1239: + #define SF_GET_NORMAL_FIELD(s) ((s)->sy_flags & SF_NORMAL_MASK) ! 1240: + #define SF_GET_DEBUG_FIELD(s) ((s)->sy_flags & SF_DEBUG_MASK) ! 1241: + #define SF_GET_FILE(s) ((s)->sy_flags & SF_FILE) ! 1242: + #define SF_GET_STATICS(s) ((s)->sy_flags & SF_STATICS) ! 1243: + #define SF_GET_DEFINED(s) ((s)->sy_flags & SF_DEFINED) ! 1244: + #define SF_GET_STRING(s) ((s)->sy_flags & SF_STRING) ! 1245: + #define SF_GET_LOCAL(s) ((s)->sy_flags & SF_LOCAL) ! 1246: + #define SF_GET_FUNCTION(s) ((s)->sy_flags & SF_FUNCTION) ! 1247: + #define SF_GET_PROCESS(s) ((s)->sy_flags & SF_PROCESS) ! 1248: + #define SF_GET_DEBUG(s) ((s)->sy_flags & SF_DEBUG) ! 1249: + #define SF_GET_TAGGED(s) ((s)->sy_flags & SF_TAGGED) ! 1250: + #define SF_GET_TAG(s) ((s)->sy_flags & SF_TAG) ! 1251: + #define SF_GET_GET_SEGMENT(s) ((s)->sy_flags & SF_GET_SEGMENT) ! 1252: + ! 1253: + /* Modifiers */ ! 1254: + #define SF_SET(s,v) ((s)->sy_flags = (v)) ! 1255: + #define SF_SET_NORMAL_FIELD(s,v)((s)->sy_flags |= ((v) & SF_NORMAL_MASK)) ! 1256: + #define SF_SET_DEBUG_FIELD(s,v) ((s)->sy_flags |= ((v) & SF_DEBUG_MASK)) ! 1257: + #define SF_SET_FILE(s) ((s)->sy_flags |= SF_FILE) ! 1258: + #define SF_SET_STATICS(s) ((s)->sy_flags |= SF_STATICS) ! 1259: + #define SF_SET_DEFINED(s) ((s)->sy_flags |= SF_DEFINED) ! 1260: + #define SF_SET_STRING(s) ((s)->sy_flags |= SF_STRING) ! 1261: + #define SF_SET_LOCAL(s) ((s)->sy_flags |= SF_LOCAL) ! 1262: + #define SF_SET_FUNCTION(s) ((s)->sy_flags |= SF_FUNCTION) ! 1263: + #define SF_SET_PROCESS(s) ((s)->sy_flags |= SF_PROCESS) ! 1264: + #define SF_SET_DEBUG(s) ((s)->sy_flags |= SF_DEBUG) ! 1265: + #define SF_SET_TAGGED(s) ((s)->sy_flags |= SF_TAGGED) ! 1266: + #define SF_SET_TAG(s) ((s)->sy_flags |= SF_TAG) ! 1267: + #define SF_SET_GET_SEGMENT(s) ((s)->sy_flags |= SF_GET_SEGMENT) ! 1268: + ! 1269: + /* File header macro and type definition */ ! 1270: + ! 1271: + /* ! 1272: + * File position calculators. Beware to use them when all the ! 1273: + * appropriate fields are set in the header. ! 1274: + */ ! 1275: + ! 1276: + #define H_GET_FILE_SIZE(h) \ ! 1277: + (long)(FILHSZ + AOUTHDRSZ + \ ! 1278: + H_GET_NUMBER_OF_SECTIONS(h) * SCNHSZ + \ ! 1279: + H_GET_TEXT_SIZE(h) + H_GET_DATA_SIZE(h) + \ ! 1280: + H_GET_RELOCATION_SIZE(h) + H_GET_LINENO_SIZE(h) + \ ! 1281: + H_GET_SYMBOL_TABLE_SIZE(h) * SYMESZ + \ ! 1282: + (h)->string_table_size) ! 1283: + #define H_GET_TEXT_FILE_OFFSET(h) \ ! 1284: + (long)(FILHSZ + AOUTHDRSZ + \ ! 1285: + H_GET_NUMBER_OF_SECTIONS(h) * SCNHSZ) ! 1286: + #define H_GET_DATA_FILE_OFFSET(h) \ ! 1287: + (long)(FILHSZ + AOUTHDRSZ + \ ! 1288: + H_GET_NUMBER_OF_SECTIONS(h) * SCNHSZ + \ ! 1289: + H_GET_TEXT_SIZE(h)) ! 1290: + #define H_GET_BSS_FILE_OFFSET(h) 0 ! 1291: + #define H_GET_RELOCATION_FILE_OFFSET(h) \ ! 1292: + (long)(FILHSZ + AOUTHDRSZ + \ ! 1293: + H_GET_NUMBER_OF_SECTIONS(h) * SCNHSZ + \ ! 1294: + H_GET_TEXT_SIZE(h) + H_GET_DATA_SIZE(h)) ! 1295: + #define H_GET_LINENO_FILE_OFFSET(h) \ ! 1296: + (long)(FILHSZ + AOUTHDRSZ + \ ! 1297: + H_GET_NUMBER_OF_SECTIONS(h) * SCNHSZ + \ ! 1298: + H_GET_TEXT_SIZE(h) + H_GET_DATA_SIZE(h) + \ ! 1299: + H_GET_RELOCATION_SIZE(h)) ! 1300: + #define H_GET_SYMBOL_TABLE_FILE_OFFSET(h) \ ! 1301: + (long)(FILHSZ + AOUTHDRSZ + \ ! 1302: + H_GET_NUMBER_OF_SECTIONS(h) * SCNHSZ + \ ! 1303: + H_GET_TEXT_SIZE(h) + H_GET_DATA_SIZE(h) + \ ! 1304: + H_GET_RELOCATION_SIZE(h) + H_GET_LINENO_SIZE(h)) ! 1305: + ! 1306: + /* Accessors */ ! 1307: + /* aouthdr */ ! 1308: + #define H_GET_MAGIC_NUMBER(h) ((h)->aouthdr.magic) ! 1309: + #define H_GET_VERSION_STAMP(h) ((h)->aouthdr.vstamp) ! 1310: + #define H_GET_TEXT_SIZE(h) ((h)->aouthdr.tsize) ! 1311: + #define H_GET_DATA_SIZE(h) ((h)->aouthdr.dsize) ! 1312: + #define H_GET_BSS_SIZE(h) ((h)->aouthdr.bsize) ! 1313: + #define H_GET_ENTRY_POINT(h) ((h)->aouthdr.entry) ! 1314: + #define H_GET_TEXT_START(h) ((h)->aouthdr.text_start) ! 1315: + #define H_GET_DATA_START(h) ((h)->aouthdr.data_start) ! 1316: + /* filehdr */ ! 1317: + #define H_GET_FILE_MAGIC_NUMBER(h) ((h)->filehdr.f_magic) ! 1318: + #define H_GET_NUMBER_OF_SECTIONS(h) ((h)->filehdr.f_nscns) ! 1319: + #define H_GET_TIME_STAMP(h) ((h)->filehdr.f_timdat) ! 1320: + #define H_GET_SYMBOL_TABLE_POINTER(h) ((h)->filehdr.f_symptr) ! 1321: + #define H_GET_SYMBOL_TABLE_SIZE(h) ((h)->filehdr.f_nsyms) ! 1322: + #define H_GET_SIZEOF_OPTIONAL_HEADER(h) ((h)->filehdr.f_opthdr) ! 1323: + #define H_GET_FLAGS(h) ((h)->filehdr.f_flags) ! 1324: + /* Extra fields to achieve bsd a.out compatibility and for convinience */ ! 1325: + #define H_GET_RELOCATION_SIZE(h) ((h)->relocation_size) ! 1326: + #define H_GET_STRING_SIZE(h) ((h)->string_table_size) ! 1327: + #define H_GET_LINENO_SIZE(h) ((h)->lineno_size) ! 1328: + ! 1329: + /* Modifiers */ ! 1330: + /* aouthdr */ ! 1331: + #define H_SET_MAGIC_NUMBER(h,v) ((h)->aouthdr.magic = (v)) ! 1332: + #define H_SET_VERSION_STAMP(h,v) ((h)->aouthdr.vstamp = (v)) ! 1333: + #define H_SET_TEXT_SIZE(h,v) ((h)->aouthdr.tsize = (v)) ! 1334: + #define H_SET_DATA_SIZE(h,v) ((h)->aouthdr.dsize = (v)) ! 1335: + #define H_SET_BSS_SIZE(h,v) ((h)->aouthdr.bsize = (v)) ! 1336: + #define H_SET_ENTRY_POINT(h,v) ((h)->aouthdr.entry = (v)) ! 1337: + #define H_SET_TEXT_START(h,v) ((h)->aouthdr.text_start = (v)) ! 1338: + #define H_SET_DATA_START(h,v) ((h)->aouthdr.data_start = (v)) ! 1339: + /* filehdr */ ! 1340: + #define H_SET_FILE_MAGIC_NUMBER(h,v) ((h)->filehdr.f_magic = (v)) ! 1341: + #define H_SET_NUMBER_OF_SECTIONS(h,v) ((h)->filehdr.f_nscns = (v)) ! 1342: + #define H_SET_TIME_STAMP(h,v) ((h)->filehdr.f_timdat = (v)) ! 1343: + #define H_SET_SYMBOL_TABLE_POINTER(h,v) ((h)->filehdr.f_symptr = (v)) ! 1344: + #define H_SET_SYMBOL_TABLE_SIZE(h,v) ((h)->filehdr.f_nsyms = (v)) ! 1345: + #define H_SET_SIZEOF_OPTIONAL_HEADER(h,v) ((h)->filehdr.f_opthdr = (v)) ! 1346: + #define H_SET_FLAGS(h,v) ((h)->filehdr.f_flags = (v)) ! 1347: + /* Extra fields to achieve bsd a.out compatibility and for convinience */ ! 1348: + #define H_SET_RELOCATION_SIZE(h,t,d) ((h)->relocation_size = (t)+(d)) ! 1349: + #define H_SET_STRING_SIZE(h,v) ((h)->string_table_size = (v)) ! 1350: + #define H_SET_LINENO_SIZE(h,v) ((h)->lineno_size = (v)) ! 1351: + ! 1352: + /* Output the file(s) header(s) in a character array */ ! 1353: + #define H_OUTPUT(h,where) c_header_append(&(h)->aouthdr, &(h)->filehdr,(where)) ! 1354: + ! 1355: + /* Output a symbol entry */ ! 1356: + #define SYMBOL_OUTPUT(s,w) c_symbol_append((s), (w)) ! 1357: + ! 1358: + typedef struct { ! 1359: + AOUTHDR aouthdr; /* a.out header */ ! 1360: + FILHDR filehdr; /* File header, not machine dep. */ ! 1361: + long int string_table_size; /* names + '\0' + sizeof(int) */ ! 1362: + long int relocation_size; /* Cumulated size of relocation ! 1363: + information for all sections in ! 1364: + bytes. */ ! 1365: + long int lineno_size; /* Size of the line number information ! 1366: + table in bytes */ ! 1367: + } object_headers; ! 1368: + ! 1369: + /* Format independent interface functions */ ! 1370: + extern void emit_relocations(); ! 1371: + extern void emit_symbols(); ! 1372: + extern void c_symbol_merge(); ! 1373: + extern void c_header_append(); ! 1374: + extern void c_symbol_append(); ! 1375: + extern void c_section_header_append(); ! 1376: + extern char* c_section_symbol(); ! 1377: + extern void c_section_header(); ! 1378: + ! 1379: + /* -------------- Line number handling ------- */ ! 1380: + extern int text_lineno_number; ! 1381: + ! 1382: + typedef struct internal_lineno { ! 1383: + LINENO line; /* The lineno structure itself */ ! 1384: + char* frag; /* Frag the line number is related to*/ ! 1385: + struct internal_lineno* next; /* Forward chain pointer */ ! 1386: + } lineno; ! 1387: + ! 1388: + extern lineno* c_new_file(); ! 1389: + extern void emit_lineno(); ! 1390: + extern lineno* lineno_rootP; ! 1391: + extern lineno* lineno_lastP; ! 1392: + #endif /* COFF_H */ ! 1393: + ! 1394: + ! 1395: *** /dev/null Wed Nov 7 08:15:02 1990 ! 1396: --- config.gas Wed Nov 7 07:33:29 1990 ! 1397: *************** ! 1398: *** 0 **** ! 1399: --- 1,70 ---- ! 1400: + # Set the appropriate links for machine dependent files ! 1401: + ! 1402: + # Chose one of ! 1403: + # ! 1404: + # i386 for 386 box running SCO unix (ODT), ! 1405: + # Esix rev C ! 1406: + # Ix 2.02 ! 1407: + # CTIX 3.2 ! 1408: + # ! 1409: + # sun-3 for sun3 running SunOs 3.5 ! 1410: + # SunOs 4.0.3 ! 1411: + # ! 1412: + # motorola-3600-unisoft-1.3 for Motorola 3600 running Unisoft 1.3 (V.3.2) ! 1413: + # microlec-2030-lectra-1 for Microlec 2030 running Lectra 1.1 ! 1414: + ! 1415: + case $1 in ! 1416: + default) ! 1417: + cp /dev/null dependencies ! 1418: + ln aout.h oformat.h ! 1419: + exit ! 1420: + ;; ! 1421: + sun-3) ! 1422: + [ -f m68k.h ] && rm -f m68k.h ! 1423: + ln m-sun3.h m68k.h ! 1424: + machine_file=m68k.c ! 1425: + atof_file=atof-ieee.c ! 1426: + machine_header=m-sun3.h ! 1427: + opcode_header=m68k-opcode.h ! 1428: + object_format=aout ! 1429: + ;; ! 1430: + motorola-3600-unisoft-1.3|microlec-2030-lectra-1.1) ! 1431: + [ -f m68k.h ] && rm -f m68k.h ! 1432: + ln m-sun3.h m68k.h ! 1433: + machine_file=m68k.c ! 1434: + atof_file=atof-ieee.c ! 1435: + machine_header=m-motor.h ! 1436: + opcode_header=m68k-opcode.h ! 1437: + object_format=coff ! 1438: + ;; ! 1439: + dpx2) ! 1440: + [ -f m68k.h ] && rm -f m68k.h ! 1441: + ln m-sun3.h m68k.h ! 1442: + machine_file=m68k.c ! 1443: + atof_file=atof-ieee.c ! 1444: + machine_header=m-dpx2.h ! 1445: + opcode_header=m68k-opcode.h ! 1446: + object_format=coff ! 1447: + ;; ! 1448: + i386) ! 1449: + [ -f m68k.h ] && rm -f m68k.h ! 1450: + machine_file=i386.c ! 1451: + atof_file=atof-ieee.c ! 1452: + machine_header=m-i386.h ! 1453: + opcode_header=i386-opcode.h ! 1454: + object_format=coff ! 1455: + ;; ! 1456: + *) ! 1457: + echo $1 not a known configuration ! 1458: + exit 1 ! 1459: + ;; ! 1460: + esac ! 1461: + ! 1462: + rm -f machine.c atof.c machine.h oformat.h oformat.c opcode.h ! 1463: + set -x ! 1464: + ln $machine_file machine.c ! 1465: + ln $atof_file atof.c ! 1466: + ln $machine_header machine.h ! 1467: + ln ${object_format}.c oformat.c ! 1468: + ln ${object_format}.h oformat.h ! 1469: + ln ${opcode_header} opcode.h ! 1470: *** /dev/null Wed Nov 7 08:15:02 1990 ! 1471: --- m-dpx2.h Wed Nov 7 07:33:29 1990 ! 1472: *************** ! 1473: *** 0 **** ! 1474: --- 1,14 ---- ! 1475: + /* Machine specific defines for the dpx2 machine */ ! 1476: + #define dpx2 ! 1477: + #define PROCESSOR_68000 ! 1478: + ! 1479: + /* Return true if s (a non null string pointer), points to a local variable ! 1480: + name. */ ! 1481: + #define S_LOCAL_NAME(s) (S_GET_NAME(s)[0] == 'L') ! 1482: + ! 1483: + /* Preserve leading underscore in symbol names. */ ! 1484: + #define STRIP_UNDERSCORE 0 ! 1485: + ! 1486: + /* The magic number is not the usual MC68MAGIC. */ ! 1487: + #define FILE_HEADER_MAGIC MC68KBCSMAGIC ! 1488: + ! 1489: *** /dev/null Wed Nov 7 08:15:02 1990 ! 1490: --- m-i386.h Wed Nov 7 07:33:30 1990 ! 1491: *************** ! 1492: *** 0 **** ! 1493: --- 1,10 ---- ! 1494: + /* Machine specific defines for the SCO Unix V.3.2 ODT */ ! 1495: + #define scounix ! 1496: + #define PROCESSOR_i386 ! 1497: + ! 1498: + /* Return true if s (a non null string pointer), points to a local variable ! 1499: + name. */ ! 1500: + #define S_LOCAL_NAME(s) (S_GET_NAME(s)[0] == '.' && S_GET_NAME(s)[1] == 'L') ! 1501: + ! 1502: + /* Compiler does not generate symbol names with a leading underscore. */ ! 1503: + #define STRIP_UNDERSCORE 0 ! 1504: *** /dev/null Wed Nov 7 08:15:02 1990 ! 1505: --- m-motor.h Wed Nov 7 07:33:30 1990 ! 1506: *************** ! 1507: *** 0 **** ! 1508: --- 1,10 ---- ! 1509: + /* Machine specific defines for the unisoft 680x0 V.3.2 version 1.3 */ ! 1510: + #define unisoft ! 1511: + #define PROCESSOR_68000 ! 1512: + ! 1513: + /* Return true if s (a non null string pointer), points to a local variable ! 1514: + name. */ ! 1515: + #define S_LOCAL_NAME(s) (S_GET_NAME(s)[0] == 'L') ! 1516: + ! 1517: + /* Remove leading underscore from the gcc generated symbol names */ ! 1518: + #define STRIP_UNDERSCORE 1 ! 1519: *** /dev/null Wed Nov 7 08:15:02 1990 ! 1520: --- stack.c Wed Nov 7 07:33:31 1990 ! 1521: *************** ! 1522: *** 0 **** ! 1523: --- 1,59 ---- ! 1524: + #include "stack.h" ! 1525: + ! 1526: + extern char* malloc(); ! 1527: + extern char* realloc(); ! 1528: + ! 1529: + stack* stack_init(chunk_size, element_size) ! 1530: + unsigned long chunk_size; ! 1531: + unsigned long element_size; ! 1532: + { ! 1533: + stack* st; ! 1534: + if((st = (stack*)malloc(sizeof(stack))) == (stack*)0) ! 1535: + return (stack*)0; ! 1536: + if((st->data = malloc(chunk_size)) == (char*)0) { ! 1537: + free(st); ! 1538: + return (stack*)0; ! 1539: + } ! 1540: + st->pointer = 0; ! 1541: + st->size = chunk_size; ! 1542: + st->chunk_size = chunk_size; ! 1543: + st->element_size = element_size; ! 1544: + return st; ! 1545: + } ! 1546: + ! 1547: + void stack_delete(st) ! 1548: + stack* st; ! 1549: + { ! 1550: + free(st->data); ! 1551: + free(st); ! 1552: + } ! 1553: + ! 1554: + char* stack_push(st, element) ! 1555: + stack* st; ! 1556: + char* element; ! 1557: + { ! 1558: + if(st->pointer + st->element_size >= st->size) { ! 1559: + st->size += st->chunk_size; ! 1560: + if((st->data = realloc(st->data, st->size)) == (char*)0) ! 1561: + return (char*)0; ! 1562: + } ! 1563: + memcpy(st->data + st->pointer, element, st->element_size); ! 1564: + st->pointer += st->element_size; ! 1565: + return st->data + st->pointer; ! 1566: + } ! 1567: + ! 1568: + char* stack_pop(st) ! 1569: + stack* st; ! 1570: + { ! 1571: + if((st->pointer -= st->element_size) < 0) { ! 1572: + st->pointer = 0; ! 1573: + return (char*)0; ! 1574: + } ! 1575: + return st->data + st->pointer; ! 1576: + } ! 1577: + ! 1578: + char* stack_top(st) ! 1579: + stack* st; ! 1580: + { ! 1581: + return st->data + st->pointer - st->element_size; ! 1582: + } ! 1583: *** /dev/null Wed Nov 7 08:15:02 1990 ! 1584: --- stack.h Wed Nov 7 07:33:31 1990 ! 1585: *************** ! 1586: *** 0 **** ! 1587: --- 1,13 ---- ! 1588: + typedef struct { ! 1589: + unsigned long chunk_size; ! 1590: + unsigned long element_size; ! 1591: + unsigned long size; ! 1592: + char* data; ! 1593: + unsigned long pointer; ! 1594: + } stack; ! 1595: + ! 1596: + extern stack* stack_init(); ! 1597: + extern void stack_delete(); ! 1598: + extern char* stack_push(); ! 1599: + extern char* stack_pop(); ! 1600: + extern char* stack_top(); ! 1601: *** /lasvegas/spare/usenet/work/gas-1.37.genuine/./as.c Thu Oct 11 18:26:17 1990 ! 1602: --- ./as.c Wed Nov 7 07:33:32 1990 ! 1603: *************** ! 1604: *** 38,43 **** ! 1605: --- 38,44 ---- ! 1606: #include <signal.h> ! 1607: ! 1608: #define COMMON ! 1609: + #include "oformat.h" ! 1610: #include "as.h" ! 1611: #include "struc-symbol.h" ! 1612: #include "write.h" ! 1613: *** /lasvegas/spare/usenet/work/gas-1.37.genuine/./as.h Thu Oct 11 18:26:18 1990 ! 1614: --- ./as.h Wed Nov 7 07:33:33 1990 ! 1615: *************** ! 1616: *** 162,170 **** ! 1617: /* Invented so we don't crash printing */ ! 1618: /* error message involving weird segment. */ ! 1619: SEG_BIG, /* Bigger than 32 bits constant. */ ! 1620: ! SEG_DIFFERENCE /* Mythical Segment: absolute difference. */ ! 1621: } segT; ! 1622: #define SEG_MAXIMUM_ORDINAL (SEG_DIFFERENCE) ! 1623: ! 1624: typedef unsigned char subsegT; ! 1625: ! 1626: --- 162,179 ---- ! 1627: /* Invented so we don't crash printing */ ! 1628: /* error message involving weird segment. */ ! 1629: SEG_BIG, /* Bigger than 32 bits constant. */ ! 1630: ! SEG_DIFFERENCE, /* Mythical Segment: absolute difference. */ ! 1631: ! #ifdef coff ! 1632: ! SEG_DEBUG, /* Debug segment */ ! 1633: ! SEG_NTV, /* Transfert vector preload segment */ ! 1634: ! SEG_PTV, /* Transfert vector postload segment */ ! 1635: ! #endif /* coff */ ! 1636: } segT; ! 1637: + #ifdef coff ! 1638: + #define SEG_MAXIMUM_ORDINAL (SEG_PTV) ! 1639: + #else /* coff */ ! 1640: #define SEG_MAXIMUM_ORDINAL (SEG_DIFFERENCE) ! 1641: + #endif /* coff */ ! 1642: ! 1643: typedef unsigned char subsegT; ! 1644: ! 1645: *************** ! 1646: *** 180,185 **** ! 1647: --- 189,211 ---- ! 1648: extern char *const seg_name[]; ! 1649: extern const int seg_N_TYPE[]; ! 1650: extern const segT N_TYPE_seg[]; ! 1651: + #ifdef coff ! 1652: + #define segment_name(v) (seg_name[(v)]) ! 1653: + /* Machine independent -> machine dependent */ ! 1654: + #define seg_SEG(v) (seg_N_TYPE[(v)]) ! 1655: + /* ! 1656: + * +4 shift the value of the mnemonics from -4, -3, -2, -1, 0, 1, 2, 3 ! 1657: + * to 0, 1, 2, 3, 4, 5, 6, 7 ! 1658: + */ ! 1659: + /* Machine dependent -> machine independent */ ! 1660: + #define SEG_seg(v) (N_TYPE_seg[(v) + 4]) ! 1661: + #else /* coff */ ! 1662: + #define segment_name(v) (seg_name[(v)]) ! 1663: + /* Machine independent -> machine dependent */ ! 1664: + #define seg_SEG(v) (seg_N_TYPE[(v)]) ! 1665: + /* Machine dependent -> machine independent */ ! 1666: + #define SEG_seg(v) (N_TYPE_seg[(v)]) ! 1667: + #endif /* coff */ ! 1668: void subsegs_begin(); ! 1669: void subseg_change(); ! 1670: void subseg_new(); ! 1671: *** /lasvegas/spare/usenet/work/gas-1.37.genuine/./expr.c Thu Oct 11 18:26:21 1990 ! 1672: --- ./expr.c Wed Nov 7 07:33:36 1990 ! 1673: *************** ! 1674: *** 25,30 **** ! 1675: --- 25,31 ---- ! 1676: */ ! 1677: ! 1678: #include <ctype.h> ! 1679: + #include "oformat.h" ! 1680: #include "as.h" ! 1681: #include "flonum.h" ! 1682: #include "read.h" ! 1683: *************** ! 1684: *** 84,90 **** ! 1685: { ! 1686: register char c; ! 1687: register char *name; /* points to name of symbol */ ! 1688: ! register struct symbol * symbolP; /* Points to symbol */ ! 1689: ! 1690: extern char hex_value[]; /* In hex_value.c */ ! 1691: char *local_label_name(); ! 1692: --- 85,91 ---- ! 1693: { ! 1694: register char c; ! 1695: register char *name; /* points to name of symbol */ ! 1696: ! register symbolS * symbolP; /* Points to symbol */ ! 1697: ! 1698: extern char hex_value[]; /* In hex_value.c */ ! 1699: char *local_label_name(); ! 1700: *************** ! 1701: *** 250,264 **** ! 1702: */ ! 1703: name = local_label_name ((int)number, 0); ! 1704: if ( (symbolP = symbol_table_lookup(name)) /* seen before */ ! 1705: ! && (symbolP -> sy_type & N_TYPE) != N_UNDF /* symbol is defined: OK */ ! 1706: ! ) ! 1707: { /* Expected path: symbol defined. */ ! 1708: /* Local labels are never absolute. Don't waste time checking absoluteness. */ ! 1709: ! know( (symbolP -> sy_type & N_TYPE) == N_DATA ! 1710: ! || (symbolP -> sy_type & N_TYPE) == N_TEXT ); ! 1711: expressionP -> X_add_symbol = symbolP; ! 1712: expressionP -> X_add_number = 0; ! 1713: ! expressionP -> X_seg = N_TYPE_seg [symbolP -> sy_type]; ! 1714: } ! 1715: else ! 1716: { /* Either not seen or not defined. */ ! 1717: --- 251,263 ---- ! 1718: */ ! 1719: name = local_label_name ((int)number, 0); ! 1720: if ( (symbolP = symbol_table_lookup(name)) /* seen before */ ! 1721: ! && (S_IS_DEFINED(symbolP))) ! 1722: { /* Expected path: symbol defined. */ ! 1723: /* Local labels are never absolute. Don't waste time checking absoluteness. */ ! 1724: ! know((S_IS_DATA(symbolP)) || S_IS_TEXT(symbolP)); ! 1725: expressionP -> X_add_symbol = symbolP; ! 1726: expressionP -> X_add_number = 0; ! 1727: ! expressionP -> X_seg = SEG_seg(S_GET_SEGMENT(symbolP)); ! 1728: } ! 1729: else ! 1730: { /* Either not seen or not defined. */ ! 1731: *************** ! 1732: *** 289,301 **** ! 1733: if ( symbolP = symbol_table_lookup( name )) ! 1734: { ! 1735: /* We have no need to check symbol properties. */ ! 1736: ! know( (symbolP -> sy_type & N_TYPE) == N_UNDF ! 1737: ! || (symbolP -> sy_type & N_TYPE) == N_DATA ! 1738: ! || (symbolP -> sy_type & N_TYPE) == N_TEXT); ! 1739: } ! 1740: else ! 1741: { ! 1742: ! symbolP = symbol_new (name, N_UNDF, 0,0,0, & zero_address_frag); ! 1743: symbol_table_insert (symbolP); ! 1744: } ! 1745: expressionP -> X_add_symbol = symbolP; ! 1746: --- 288,306 ---- ! 1747: if ( symbolP = symbol_table_lookup( name )) ! 1748: { ! 1749: /* We have no need to check symbol properties. */ ! 1750: ! know(!S_IS_DEFINED(symbolP) || ! 1751: ! S_IS_DATA(symbolP) || S_IS_TEXT(symbolP)); ! 1752: } ! 1753: else ! 1754: { ! 1755: ! #ifdef coff ! 1756: ! symbolP = symbol_new(name, SEG_UNKNOWN, ! 1757: ! 0, 0, ! 1758: ! &zero_address_frag); ! 1759: ! #else /* coff */ ! 1760: ! symbolP = symbol_new (name, N_UNDF, 0,0,0, ! 1761: ! & zero_address_frag); ! 1762: ! #endif /* coff */ ! 1763: symbol_table_insert (symbolP); ! 1764: } ! 1765: expressionP -> X_add_symbol = symbolP; ! 1766: *************** ! 1767: *** 358,369 **** ! 1768: JF: '.' is pseudo symbol with value of current location in current ! 1769: segment. . . ! 1770: */ ! 1771: symbolP = symbol_new("L0\001", ! 1772: ! (unsigned char)(seg_N_TYPE[(int)now_seg]), ! 1773: 0, ! 1774: 0, ! 1775: (valueT)(obstack_next_free(&frags)-frag_now->fr_literal), ! 1776: frag_now); ! 1777: expressionP->X_add_number=0; ! 1778: expressionP->X_add_symbol=symbolP; ! 1779: expressionP->X_seg = now_seg; ! 1780: --- 363,379 ---- ! 1781: JF: '.' is pseudo symbol with value of current location in current ! 1782: segment. . . ! 1783: */ ! 1784: + #ifdef coff ! 1785: + symbolP = symbol_new("L0\001", now_seg, (valueT)(obstack_next_free(&frags)- ! 1786: + frag_now->fr_literal), 0, frag_now); ! 1787: + #else /* coff */ ! 1788: symbolP = symbol_new("L0\001", ! 1789: ! (unsigned char)(seg_SEG((int)now_seg)), ! 1790: 0, ! 1791: 0, ! 1792: (valueT)(obstack_next_free(&frags)-frag_now->fr_literal), ! 1793: frag_now); ! 1794: + #endif /* coff */ ! 1795: expressionP->X_add_number=0; ! 1796: expressionP->X_add_symbol=symbolP; ! 1797: expressionP->X_seg = now_seg; ! 1798: *************** ! 1799: *** 384,390 **** ! 1800: */ ! 1801: register segT seg; ! 1802: ! 1803: ! seg = N_TYPE_seg [(int) symbolP -> sy_type & N_TYPE]; ! 1804: if ((expressionP -> X_seg = seg) == SEG_ABSOLUTE ) ! 1805: { ! 1806: expressionP -> X_add_number = symbolP -> sy_value; ! 1807: --- 394,400 ---- ! 1808: */ ! 1809: register segT seg; ! 1810: ! 1811: ! seg = SEG_seg((int)S_GET_SEGMENT(symbolP)); ! 1812: if ((expressionP -> X_seg = seg) == SEG_ABSOLUTE ) ! 1813: { ! 1814: expressionP -> X_add_number = symbolP -> sy_value; ! 1815: *************** ! 1816: *** 399,405 **** ! 1817: --- 409,419 ---- ! 1818: { ! 1819: expressionP -> X_add_symbol ! 1820: = symbolP ! 1821: + #ifdef coff ! 1822: + = symbol_new (name, SEG_UNKNOWN, 0, 0, &zero_address_frag); ! 1823: + #else /* coff */ ! 1824: = symbol_new (name, N_UNDF, 0,0,0, & zero_address_frag); ! 1825: + #endif /* coff */ ! 1826: ! 1827: expressionP -> X_add_number = 0; ! 1828: expressionP -> X_seg = SEG_UNKNOWN; ! 1829: *************** ! 1830: *** 554,579 **** ! 1831: ! 1832: static segT ! 1833: expr_part (symbol_1_PP, symbol_2_P) ! 1834: ! struct symbol ** symbol_1_PP; ! 1835: ! struct symbol * symbol_2_P; ! 1836: { ! 1837: segT return_value; ! 1838: ! 1839: know( (* symbol_1_PP) == NULL ! 1840: ! || ((* symbol_1_PP) -> sy_type & N_TYPE) == N_TEXT ! 1841: ! || ((* symbol_1_PP) -> sy_type & N_TYPE) == N_DATA ! 1842: ! || ((* symbol_1_PP) -> sy_type & N_TYPE) == N_BSS ! 1843: ! || ((* symbol_1_PP) -> sy_type & N_TYPE) == N_UNDF ! 1844: ); ! 1845: know( symbol_2_P == NULL ! 1846: ! || (symbol_2_P -> sy_type & N_TYPE) == N_TEXT ! 1847: ! || (symbol_2_P -> sy_type & N_TYPE) == N_DATA ! 1848: ! || (symbol_2_P -> sy_type & N_TYPE) == N_BSS ! 1849: ! || (symbol_2_P -> sy_type & N_TYPE) == N_UNDF ! 1850: ); ! 1851: if (* symbol_1_PP) ! 1852: { ! 1853: ! if (((* symbol_1_PP) -> sy_type & N_TYPE) == N_UNDF) ! 1854: { ! 1855: if (symbol_2_P) ! 1856: { ! 1857: --- 568,593 ---- ! 1858: ! 1859: static segT ! 1860: expr_part (symbol_1_PP, symbol_2_P) ! 1861: ! symbolS ** symbol_1_PP; ! 1862: ! symbolS * symbol_2_P; ! 1863: { ! 1864: segT return_value; ! 1865: ! 1866: know( (* symbol_1_PP) == NULL ! 1867: ! || (S_IS_TEXT(* symbol_1_PP)) ! 1868: ! || (S_IS_DATA(* symbol_1_PP)) ! 1869: ! || (S_IS_BSS(* symbol_1_PP)) ! 1870: ! || (!S_IS_DEFINED(* symbol_1_PP)) ! 1871: ); ! 1872: know( symbol_2_P == NULL ! 1873: ! || (S_IS_TEXT(symbol_2_P)) ! 1874: ! || (S_IS_DATA(symbol_2_P)) ! 1875: ! || (S_IS_BSS(symbol_2_P)) ! 1876: ! || (!S_IS_DEFINED(symbol_2_P)) ! 1877: ); ! 1878: if (* symbol_1_PP) ! 1879: { ! 1880: ! if (!S_IS_DEFINED(* symbol_1_PP)) ! 1881: { ! 1882: if (symbol_2_P) ! 1883: { ! 1884: *************** ! 1885: *** 582,588 **** ! 1886: } ! 1887: else ! 1888: { ! 1889: ! know( ((* symbol_1_PP) -> sy_type & N_TYPE) == N_UNDF) ! 1890: return_value = SEG_UNKNOWN; ! 1891: } ! 1892: } ! 1893: --- 596,602 ---- ! 1894: } ! 1895: else ! 1896: { ! 1897: ! know(!S_IS_DEFINED(* symbol_1_PP)); ! 1898: return_value = SEG_UNKNOWN; ! 1899: } ! 1900: } ! 1901: *************** ! 1902: *** 590,596 **** ! 1903: { ! 1904: if (symbol_2_P) ! 1905: { ! 1906: ! if ((symbol_2_P -> sy_type & N_TYPE) == N_UNDF) ! 1907: { ! 1908: * symbol_1_PP = NULL; ! 1909: return_value = SEG_PASS1; ! 1910: --- 604,610 ---- ! 1911: { ! 1912: if (symbol_2_P) ! 1913: { ! 1914: ! if (!S_IS_DEFINED(symbol_2_P)) ! 1915: { ! 1916: * symbol_1_PP = NULL; ! 1917: return_value = SEG_PASS1; ! 1918: *************** ! 1919: *** 599,605 **** ! 1920: { ! 1921: /* {seg1} - {seg2} */ ! 1922: as_warn( "Expression too complex, 2 symbols forgotten: \"%s\" \"%s\"", ! 1923: ! (* symbol_1_PP) -> sy_name, symbol_2_P -> sy_name ); ! 1924: * symbol_1_PP = NULL; ! 1925: return_value = SEG_ABSOLUTE; ! 1926: } ! 1927: --- 613,619 ---- ! 1928: { ! 1929: /* {seg1} - {seg2} */ ! 1930: as_warn( "Expression too complex, 2 symbols forgotten: \"%s\" \"%s\"", ! 1931: ! S_GET_NAME(* symbol_1_PP), S_GET_NAME(symbol_2_P)); ! 1932: * symbol_1_PP = NULL; ! 1933: return_value = SEG_ABSOLUTE; ! 1934: } ! 1935: *************** ! 1936: *** 606,612 **** ! 1937: } ! 1938: else ! 1939: { ! 1940: ! return_value = N_TYPE_seg [(* symbol_1_PP) -> sy_type & N_TYPE]; ! 1941: } ! 1942: } ! 1943: } ! 1944: --- 620,626 ---- ! 1945: } ! 1946: else ! 1947: { ! 1948: ! return_value = SEG_seg(S_GET_SEGMENT(* symbol_1_PP)); ! 1949: } ! 1950: } ! 1951: } ! 1952: *************** ! 1953: *** 615,621 **** ! 1954: if (symbol_2_P) ! 1955: { ! 1956: * symbol_1_PP = symbol_2_P; ! 1957: ! return_value = N_TYPE_seg [(symbol_2_P) -> sy_type & N_TYPE]; ! 1958: } ! 1959: else ! 1960: { ! 1961: --- 629,635 ---- ! 1962: if (symbol_2_P) ! 1963: { ! 1964: * symbol_1_PP = symbol_2_P; ! 1965: ! return_value = SEG_seg(S_GET_SEGMENT(symbol_2_P)); ! 1966: } ! 1967: else ! 1968: { ! 1969: *************** ! 1970: *** 631,637 **** ! 1971: || return_value == SEG_PASS1 ! 1972: ); ! 1973: know( (* symbol_1_PP) == NULL ! 1974: ! || ((* symbol_1_PP) -> sy_type & N_TYPE) == seg_N_TYPE [(int) return_value] ); ! 1975: return (return_value); ! 1976: } /* expr_part() */ ! 1977: ! 1978: --- 645,651 ---- ! 1979: || return_value == SEG_PASS1 ! 1980: ); ! 1981: know( (* symbol_1_PP) == NULL ! 1982: ! || (S_GET_SEGMENT(* symbol_1_PP) == seg_SEG((int) return_value) )); ! 1983: return (return_value); ! 1984: } /* expr_part() */ ! 1985: ! 1986: *************** ! 1987: *** 793,799 **** ! 1988: * does not cause any further inaccuracy. ! 1989: */ ! 1990: ! 1991: ! register struct symbol * symbolP; ! 1992: ! 1993: right . X_add_number = - right . X_add_number; ! 1994: symbolP = right . X_add_symbol; ! 1995: --- 807,813 ---- ! 1996: * does not cause any further inaccuracy. ! 1997: */ ! 1998: ! 1999: ! register symbolS * symbolP; ! 2000: ! 2001: right . X_add_number = - right . X_add_number; ! 2002: symbolP = right . X_add_symbol; ! 2003: *************** ! 2004: *** 859,866 **** ! 2005: know( resultP -> X_add_symbol ); ! 2006: know( resultP -> X_subtract_symbol ); ! 2007: as_warn("Expression too complex: forgetting %s - %s", ! 2008: ! resultP -> X_add_symbol -> sy_name, ! 2009: ! resultP -> X_subtract_symbol -> sy_name); ! 2010: resultP -> X_seg = SEG_ABSOLUTE; ! 2011: /* Clean_up_expression() will do the rest. */ ! 2012: } ! 2013: --- 873,880 ---- ! 2014: know( resultP -> X_add_symbol ); ! 2015: know( resultP -> X_subtract_symbol ); ! 2016: as_warn("Expression too complex: forgetting %s - %s", ! 2017: ! S_GET_NAME(resultP -> X_add_symbol), ! 2018: ! S_GET_NAME(resultP -> X_subtract_symbol)); ! 2019: resultP -> X_seg = SEG_ABSOLUTE; ! 2020: /* Clean_up_expression() will do the rest. */ ! 2021: } ! 2022: *** /lasvegas/spare/usenet/work/gas-1.37.genuine/./flonum-const.c Thu Oct 11 18:26:21 1990 ! 2023: --- ./flonum-const.c Wed Nov 7 07:33:37 1990 ! 2024: *************** ! 2025: *** 134,140 **** ! 2026: {X minus_11, X minus_11+29, X minus_11 + 29,-242, '+'}, ! 2027: }; ! 2028: ! 2029: ! FLONUM_TYPE flonum_positive_powers_of_ten [] = { ! 2030: {X zero, X zero, X zero, 0, '+'}, ! 2031: {X plus_1, X plus_1 + 0, X plus_1 + 0, 0, '+'}, ! 2032: {X plus_2, X plus_2 + 0, X plus_2 + 0, 0, '+'}, ! 2033: --- 134,140 ---- ! 2034: {X minus_11, X minus_11+29, X minus_11 + 29,-242, '+'}, ! 2035: }; ! 2036: ! 2037: ! const FLONUM_TYPE flonum_positive_powers_of_ten [] = { ! 2038: {X zero, X zero, X zero, 0, '+'}, ! 2039: {X plus_1, X plus_1 + 0, X plus_1 + 0, 0, '+'}, ! 2040: {X plus_2, X plus_2 + 0, X plus_2 + 0, 0, '+'}, ! 2041: *** /lasvegas/spare/usenet/work/gas-1.37.genuine/./frags.c Thu Aug 17 21:53:21 1989 ! 2042: --- ./frags.c Wed Nov 7 07:33:37 1990 ! 2043: *************** ! 2044: *** 17,22 **** ! 2045: --- 17,23 ---- ! 2046: along with GAS; see the file COPYING. If not, write to ! 2047: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ ! 2048: ! 2049: + #include "oformat.h" ! 2050: #include "as.h" ! 2051: #include "subsegs.h" ! 2052: #include "obstack.h" ! 2053: *** /lasvegas/spare/usenet/work/gas-1.37.genuine/./hash.c Thu Oct 18 18:43:36 1990 ! 2054: --- ./hash.c Wed Nov 7 07:33:39 1990 ! 2055: *************** ! 2056: *** 129,134 **** ! 2057: --- 129,137 ---- ! 2058: #define min(a, b) ((a) < (b) ? (a) : (b)) ! 2059: ! 2060: #include "hash.h" ! 2061: + ! 2062: + #define error as_fatal ! 2063: + ! 2064: char *xmalloc(); ! 2065: ! 2066: #define DELETED ((char *)1) /* guarenteed invalid address */ ! 2067: *** /lasvegas/spare/usenet/work/gas-1.37.genuine/./i386.c Mon Jul 9 20:49:54 1990 ! 2068: --- ./i386.c Wed Nov 7 07:33:42 1990 ! 2069: *************** ! 2070: *** 37,42 **** ! 2071: --- 37,43 ---- ! 2072: #define index strchr ! 2073: #endif ! 2074: ! 2075: + #include "oformat.h" ! 2076: #include "as.h" ! 2077: #include "read.h" ! 2078: #include "flonum.h" ! 2079: *************** ! 2080: *** 117,123 **** ! 2081: #define SIZE_FROM_RELAX_STATE(s) \ ! 2082: ( (((s) & 0x3) == BYTE ? 1 : (((s) & 0x3) == WORD ? 2 : 4)) ) ! 2083: ! 2084: ! relax_typeS md_relax_table[] = { ! 2085: /* ! 2086: The fields are: ! 2087: 1) most positive reach of this state, ! 2088: --- 118,124 ---- ! 2089: #define SIZE_FROM_RELAX_STATE(s) \ ! 2090: ( (((s) & 0x3) == BYTE ? 1 : (((s) & 0x3) == WORD ? 2 : 4)) ) ! 2091: ! 2092: ! const relax_typeS md_relax_table[] = { ! 2093: /* ! 2094: The fields are: ! 2095: 1) most positive reach of this state, ! 2096: *************** ! 2097: *** 162,177 **** ! 2098: input_line_pointer++; ! 2099: } ! 2100: ! 2101: ! pseudo_typeS md_pseudo_table[] = { ! 2102: { "ffloat", float_cons, 'f' }, ! 2103: { "dfloat", float_cons, 'd' }, ! 2104: { "tfloat", float_cons, 'x' }, ! 2105: { "value", cons, 2 }, ! 2106: { "ident", dummy, 0 }, /* ignore these directives */ ! 2107: { "def", dummy, 0 }, ! 2108: { "optim", dummy, 0 }, /* For sun386i cc */ ! 2109: { "version", dummy, 0 }, ! 2110: { "ln", dummy, 0 }, ! 2111: { 0, 0, 0 } ! 2112: }; ! 2113: ! 2114: --- 163,182 ---- ! 2115: input_line_pointer++; ! 2116: } ! 2117: ! 2118: ! const pseudo_typeS md_pseudo_table[] = { ! 2119: { "ffloat", float_cons, 'f' }, ! 2120: { "dfloat", float_cons, 'd' }, ! 2121: { "tfloat", float_cons, 'x' }, ! 2122: { "value", cons, 2 }, ! 2123: { "ident", dummy, 0 }, /* ignore these directives */ ! 2124: + #ifdef aout ! 2125: { "def", dummy, 0 }, ! 2126: + #endif /* aout */ ! 2127: { "optim", dummy, 0 }, /* For sun386i cc */ ! 2128: { "version", dummy, 0 }, ! 2129: + #ifdef aout ! 2130: { "ln", dummy, 0 }, ! 2131: + #endif /* aout */ ! 2132: { 0, 0, 0 } ! 2133: }; ! 2134: ! 2135: *************** ! 2136: *** 373,392 **** ! 2137: } ! 2138: } ! 2139: ! 2140: ! #define SYMBOL_TYPE(t) \ ! 2141: ! (((t&N_TYPE) == N_UNDF) ? "UNDEFINED" : \ ! 2142: ! (((t&N_TYPE) == N_ABS) ? "ABSOLUTE" : \ ! 2143: ! (((t&N_TYPE) == N_TEXT) ? "TEXT" : \ ! 2144: ! (((t&N_TYPE) == N_DATA) ? "DATA" : \ ! 2145: ! (((t&N_TYPE) == N_BSS) ? "BSS" : "Bad n_type!"))))) ! 2146: ! 2147: static void ps (s) ! 2148: symbolS *s; ! 2149: { ! 2150: fprintf (stdout, "%s type %s%s", ! 2151: ! s->sy_nlist.n_un.n_name, ! 2152: ! (s->sy_nlist.n_type&N_EXT) ? "EXTERNAL " : "", ! 2153: ! SYMBOL_TYPE (s->sy_nlist.n_type)); ! 2154: } ! 2155: ! 2156: struct type_name { ! 2157: --- 378,392 ---- ! 2158: } ! 2159: } ! 2160: ! 2161: ! #define SYMBOL_TYPE(t) segment_name(SEG_seg(t)) ! 2162: ! 2163: static void ps (s) ! 2164: symbolS *s; ! 2165: { ! 2166: fprintf (stdout, "%s type %s%s", ! 2167: ! S_GET_NAME(s), ! 2168: ! S_IS_EXTERNAL(s) ? "EXTERNAL " : "", ! 2169: ! SYMBOL_TYPE(S_GET_SEGMENT(s)) ! 2170: } ! 2171: ! 2172: struct type_name { ! 2173: *************** ! 2174: *** 1546,1552 **** ! 2175: int ! 2176: md_estimate_size_before_relax (fragP, segment_type) ! 2177: register fragS * fragP; ! 2178: ! register int segment_type; /* N_DATA or N_TEXT. */ ! 2179: { ! 2180: register uchar * opcode; ! 2181: register int old_fr_fix; ! 2182: --- 1546,1552 ---- ! 2183: int ! 2184: md_estimate_size_before_relax (fragP, segment_type) ! 2185: register fragS * fragP; ! 2186: ! register int segment_type; /* DATA or TEXT. */ ! 2187: { ! 2188: register uchar * opcode; ! 2189: register int old_fr_fix; ! 2190: *************** ! 2191: *** 1555,1561 **** ! 2192: opcode = (uchar *) fragP -> fr_opcode; ! 2193: /* We've already got fragP->fr_subtype right; all we have to do is check ! 2194: for un-relaxable symbols. */ ! 2195: ! if ((fragP -> fr_symbol -> sy_type & N_TYPE) != segment_type) { ! 2196: /* symbol is undefined in this segment */ ! 2197: switch (opcode[0]) { ! 2198: case JUMP_PC_RELATIVE: /* make jmp (0xeb) a dword displacement jump */ ! 2199: --- 1555,1561 ---- ! 2200: opcode = (uchar *) fragP -> fr_opcode; ! 2201: /* We've already got fragP->fr_subtype right; all we have to do is check ! 2202: for un-relaxable symbols. */ ! 2203: ! if (S_GET_SEGMENT(fragP->fr_symbol) != segment_type) { ! 2204: /* symbol is undefined in this segment */ ! 2205: switch (opcode[0]) { ! 2206: case JUMP_PC_RELATIVE: /* make jmp (0xeb) a dword displacement jump */ ! 2207: *************** ! 2208: *** 1608,1614 **** ! 2209: opcode = (uchar *) fragP -> fr_opcode; ! 2210: ! 2211: /* Address we want to reach in file space. */ ! 2212: ! target_address = fragP->fr_symbol->sy_value + fragP->fr_offset; ! 2213: ! 2214: /* Address opcode resides at in file space. */ ! 2215: opcode_address = fragP->fr_address + fragP->fr_fix; ! 2216: --- 1608,1614 ---- ! 2217: opcode = (uchar *) fragP -> fr_opcode; ! 2218: ! 2219: /* Address we want to reach in file space. */ ! 2220: ! target_address = S_GET_VALUE(fragP->fr_symbol) + fragP->fr_offset; ! 2221: ! 2222: /* Address opcode resides at in file space. */ ! 2223: opcode_address = fragP->fr_address + fragP->fr_fix; ! 2224: *************** ! 2225: *** 1687,1693 **** ! 2226: long offset; ! 2227: ! 2228: if (flagseen['m']) { ! 2229: ! offset = to_addr - to_symbol->sy_value; ! 2230: md_number_to_chars (ptr, 0xe9, 1); /* opcode for long jmp */ ! 2231: md_number_to_chars (ptr + 1, offset, 4); ! 2232: fix_new (frag, (ptr+1) - frag->fr_literal, 4, ! 2233: --- 1687,1693 ---- ! 2234: long offset; ! 2235: ! 2236: if (flagseen['m']) { ! 2237: ! offset = to_addr - S_GET_VALUE(to_symbol); ! 2238: md_number_to_chars (ptr, 0xe9, 1); /* opcode for long jmp */ ! 2239: md_number_to_chars (ptr + 1, offset, 4); ! 2240: fix_new (frag, (ptr+1) - frag->fr_literal, 4, ! 2241: *************** ! 2242: *** 1836,1841 **** ! 2243: --- 1836,1844 ---- ! 2244: return retval; ! 2245: } ! 2246: ! 2247: + /* Not needed for coff since relocation structure does not ! 2248: + contain bitfields. */ ! 2249: + #ifdef aout ! 2250: void md_ri_to_chars(ri_p, ri) ! 2251: struct relocation_info *ri_p, ri; ! 2252: { ! 2253: *************** ! 2254: *** 1852,1857 **** ! 2255: --- 1855,1861 ---- ! 2256: /* now put it back where you found it */ ! 2257: bcopy (the_bytes, (char *)ri_p, sizeof(struct relocation_info)); ! 2258: } ! 2259: + #endif /* aout */ ! 2260: ! 2261: ! 2262: #define MAX_LITTLENUMS 6 ! 2263: *** /lasvegas/spare/usenet/work/gas-1.37.genuine/./m-sun3.h Wed Mar 1 23:49:04 1989 ! 2264: --- ./m-sun3.h Wed Nov 7 07:33:43 1990 ! 2265: *************** ! 2266: *** 29,31 **** ! 2267: --- 29,41 ---- ! 2268: ! 2269: #define M_SUN 1 ! 2270: #define SUN_ASM_SYNTAX ! 2271: + ! 2272: + /* Return true if s (a non null string pointer), points to a local variable ! 2273: + name. */ ! 2274: + #define S_LOCAL_NAME(s) (S_GET_NAME(s)[0] == 'L') ! 2275: + ! 2276: + /* Could also be : ! 2277: + #define S_LOCAL_NAME(s) (S_GET_NAME(s)[0] == '.' && ! 2278: + S_GET_NAME(s)[1] == 'L' || ! 2279: + S_GET_NAME(s)[1] == '.') ! 2280: + */ ! 2281: *** /lasvegas/spare/usenet/work/gas-1.37.genuine/./m68k.c Tue Oct 16 16:38:51 1990 ! 2282: --- ./m68k.c Wed Nov 7 07:33:46 1990 ! 2283: *************** ! 2284: *** 21,26 **** ! 2285: --- 21,27 ---- ! 2286: #include <ctype.h> ! 2287: ! 2288: #include "m68k-opcode.h" ! 2289: + #include "oformat.h" ! 2290: #include "as.h" ! 2291: #include "obstack.h" ! 2292: #include "frags.h" ! 2293: *************** ! 2294: *** 2738,2744 **** ! 2295: know(fragP->fr_symbol); ! 2296: ! 2297: /* The displacement of the address, from current location. */ ! 2298: ! disp = (fragP->fr_symbol->sy_value + fragP->fr_offset) - object_address; ! 2299: ! 2300: switch(fragP->fr_subtype) { ! 2301: case TAB(BCC68000,BYTE): ! 2302: --- 2739,2745 ---- ! 2303: know(fragP->fr_symbol); ! 2304: ! 2305: /* The displacement of the address, from current location. */ ! 2306: ! disp = (S_GET_VALUE(fragP->fr_symbol) + fragP->fr_offset) - object_address; ! 2307: ! 2308: switch(fragP->fr_subtype) { ! 2309: case TAB(BCC68000,BYTE): ! 2310: *************** ! 2311: *** 2887,2893 **** ! 2312: /* handle SZ_UNDEF first, it can be changed to BYTE or SHORT */ ! 2313: switch(fragP->fr_subtype) { ! 2314: case TAB(BRANCH,SZ_UNDEF): ! 2315: ! if((fragP->fr_symbol->sy_type&N_TYPE)==segtype) { ! 2316: fragP->fr_subtype=TAB(TABTYPE(fragP->fr_subtype),BYTE); ! 2317: break; ! 2318: } else if(flagseen['m']) { ! 2319: --- 2888,2894 ---- ! 2320: /* handle SZ_UNDEF first, it can be changed to BYTE or SHORT */ ! 2321: switch(fragP->fr_subtype) { ! 2322: case TAB(BRANCH,SZ_UNDEF): ! 2323: ! if(S_GET_SEGMENT(fragP->fr_symbol)==segtype) { ! 2324: fragP->fr_subtype=TAB(TABTYPE(fragP->fr_subtype),BYTE); ! 2325: break; ! 2326: } else if(flagseen['m']) { ! 2327: *************** ! 2328: *** 2945,2951 **** ! 2329: break; ! 2330: ! 2331: case TAB(FBRANCH,SZ_UNDEF): ! 2332: ! if((fragP->fr_symbol->sy_type&N_TYPE)==segtype || flagseen['l']) { ! 2333: fragP->fr_subtype=TAB(FBRANCH,SHORT); ! 2334: fragP->fr_var+=2; ! 2335: } else { ! 2336: --- 2946,2952 ---- ! 2337: break; ! 2338: ! 2339: case TAB(FBRANCH,SZ_UNDEF): ! 2340: ! if(S_GET_SEGMENT(fragP->fr_symbol)==segtype || flagseen['l']) { ! 2341: fragP->fr_subtype=TAB(FBRANCH,SHORT); ! 2342: fragP->fr_var+=2; ! 2343: } else { ! 2344: *************** ! 2345: *** 2955,2961 **** ! 2346: break; ! 2347: ! 2348: case TAB(PCREL,SZ_UNDEF): ! 2349: ! if((fragP->fr_symbol->sy_type&N_TYPE)==segtype || flagseen['l']) { ! 2350: fragP->fr_subtype=TAB(PCREL,SHORT); ! 2351: fragP->fr_var+=2; ! 2352: } else { ! 2353: --- 2956,2962 ---- ! 2354: break; ! 2355: ! 2356: case TAB(PCREL,SZ_UNDEF): ! 2357: ! if(S_GET_SEGMENT(fragP->fr_symbol)==segtype || flagseen['l']) { ! 2358: fragP->fr_subtype=TAB(PCREL,SHORT); ! 2359: fragP->fr_var+=2; ! 2360: } else { ! 2361: *************** ! 2362: *** 2965,2971 **** ! 2363: break; ! 2364: ! 2365: case TAB(BCC68000,SZ_UNDEF): ! 2366: ! if((fragP->fr_symbol->sy_type&N_TYPE)==segtype) { ! 2367: fragP->fr_subtype=TAB(BCC68000,BYTE); ! 2368: break; ! 2369: } ! 2370: --- 2966,2972 ---- ! 2371: break; ! 2372: ! 2373: case TAB(BCC68000,SZ_UNDEF): ! 2374: ! if(S_GET_SEGMENT(fragP->fr_symbol)==segtype) { ! 2375: fragP->fr_subtype=TAB(BCC68000,BYTE); ! 2376: break; ! 2377: } ! 2378: *************** ! 2379: *** 2997,3003 **** ! 2380: break; ! 2381: ! 2382: case TAB(DBCC,SZ_UNDEF): ! 2383: ! if((fragP->fr_symbol->sy_type&N_TYPE)==segtype) { ! 2384: fragP->fr_subtype=TAB(DBCC,SHORT); ! 2385: fragP->fr_var+=2; ! 2386: break; ! 2387: --- 2998,3004 ---- ! 2388: break; ! 2389: ! 2390: case TAB(DBCC,SZ_UNDEF): ! 2391: ! if(S_GET_SEGMENT(fragP->fr_symbol)==segtype) { ! 2392: fragP->fr_subtype=TAB(DBCC,SHORT); ! 2393: fragP->fr_var+=2; ! 2394: break; ! 2395: *************** ! 2396: *** 3033,3039 **** ! 2397: break; ! 2398: ! 2399: case TAB(PCLEA,SZ_UNDEF): ! 2400: ! if((fragP->fr_symbol->sy_type&N_TYPE)==segtype || flagseen['l']) { ! 2401: fragP->fr_subtype=TAB(PCLEA,SHORT); ! 2402: fragP->fr_var+=2; ! 2403: } else { ! 2404: --- 3034,3040 ---- ! 2405: break; ! 2406: ! 2407: case TAB(PCLEA,SZ_UNDEF): ! 2408: ! if(S_GET_SEGMENT(fragP->fr_symbol)==segtype || flagseen['l']) { ! 2409: fragP->fr_subtype=TAB(PCLEA,SHORT); ! 2410: fragP->fr_var+=2; ! 2411: } else { ! 2412: *************** ! 2413: *** 3052,3058 **** ! 2414: case TAB(BRANCH,BYTE): ! 2415: /* We can't do a short jump to the next instruction, ! 2416: so we force word mode. */ ! 2417: ! if(fragP->fr_symbol && fragP->fr_symbol->sy_value==0 && ! 2418: fragP->fr_symbol->sy_frag==fragP->fr_next) { ! 2419: fragP->fr_subtype=TAB(TABTYPE(fragP->fr_subtype),SHORT); ! 2420: fragP->fr_var+=2; ! 2421: --- 3053,3059 ---- ! 2422: case TAB(BRANCH,BYTE): ! 2423: /* We can't do a short jump to the next instruction, ! 2424: so we force word mode. */ ! 2425: ! if(fragP->fr_symbol && S_GET_VALUE(fragP->fr_symbol)==0 && ! 2426: fragP->fr_symbol->sy_frag==fragP->fr_next) { ! 2427: fragP->fr_subtype=TAB(TABTYPE(fragP->fr_subtype),SHORT); ! 2428: fragP->fr_var+=2; ! 2429: *************** ! 2430: *** 3064,3069 **** ! 2431: --- 3065,3071 ---- ! 2432: return fragP->fr_var + fragP->fr_fix - old_fix; ! 2433: } ! 2434: ! 2435: + #ifdef aout ! 2436: /* the bit-field entries in the relocation_info struct plays hell ! 2437: with the byte-order problems of cross-assembly. So as a hack, ! 2438: I added this mach. dependent ri twiddler. Ugly, but it gets ! 2439: *************** ! 2440: *** 3089,3094 **** ! 2441: --- 3091,3097 ---- ! 2442: /* now put it back where you found it */ ! 2443: bcopy (the_bytes, (char *)ri_p, sizeof(struct relocation_info)); ! 2444: } ! 2445: + #endif /* aout */ ! 2446: ! 2447: #ifndef WORKING_DOT_WORD ! 2448: const int md_short_jump_size = 4; ! 2449: *************** ! 2450: *** 3121,3127 **** ! 2451: long offset; ! 2452: ! 2453: if(flagseen['m']) { ! 2454: ! offset=to_addr-to_symbol->sy_value; ! 2455: md_number_to_chars(ptr ,(long)0x4EF9,2); ! 2456: md_number_to_chars(ptr+2,(long)offset,4); ! 2457: fix_new(frag,(ptr+2)-frag->fr_literal,4,to_symbol,(symbolS *)0,(long int)0,0); ! 2458: --- 3124,3130 ---- ! 2459: long offset; ! 2460: ! 2461: if(flagseen['m']) { ! 2462: ! offset=to_addr-S_GET_VALUE(to_symbol); ! 2463: md_number_to_chars(ptr ,(long)0x4EF9,2); ! 2464: md_number_to_chars(ptr+2,(long)offset,4); ! 2465: fix_new(frag,(ptr+2)-frag->fr_literal,4,to_symbol,(symbolS *)0,(long int)0,0); ! 2466: *** /lasvegas/spare/usenet/work/gas-1.37.genuine/./read.c Thu Oct 18 22:01:12 1990 ! 2467: --- ./read.c Wed Nov 7 07:33:51 1990 ! 2468: *************** ! 2469: *** 35,40 **** ! 2470: --- 35,41 ---- ! 2471: #include <ctype.h> ! 2472: #include <sys/types.h> ! 2473: #include <sys/stat.h> ! 2474: + #include "oformat.h" ! 2475: #include "as.h" ! 2476: #include "read.h" ! 2477: #include "md.h" ! 2478: *************** ! 2479: *** 119,125 **** ! 2480: --- 120,131 ---- ! 2481: static int is_it_end_of_statement(); ! 2482: static void pobegin(); ! 2483: static void pseudo_set(); ! 2484: + #ifdef coff ! 2485: + static void def(); ! 2486: + static void line(); ! 2487: + #else /* coff */ ! 2488: static void stab(); ! 2489: + #endif /* coff */ ! 2490: static void stringer(); ! 2491: ! 2492: extern char line_comment_chars[]; ! 2493: *************** ! 2494: *** 135,140 **** ! 2495: --- 141,153 ---- ! 2496: static char *old_input; ! 2497: static char *old_limit; ! 2498: ! 2499: + #ifdef coff ! 2500: + static struct hash_control* tag_hash; ! 2501: + static void tag_init(); ! 2502: + static void tag_insert(); ! 2503: + static symbolS* tag_find(); ! 2504: + #endif /* coff */ ! 2505: + ! 2506: #ifndef WORKING_DOT_WORD ! 2507: struct broken_word *broken_words; ! 2508: int new_broken_words = 0; ! 2509: *************** ! 2510: *** 147,152 **** ! 2511: --- 160,168 ---- ! 2512: read_begin() ! 2513: { ! 2514: pobegin(); ! 2515: + #ifdef coff ! 2516: + tag_init(); ! 2517: + #endif /* coff */ ! 2518: obstack_begin( ¬es, 5000 ); ! 2519: #define BIGNUM_BEGIN_SIZE (16) ! 2520: bignum_low = xmalloc((long)BIGNUM_BEGIN_SIZE); ! 2521: *************** ! 2522: *** 159,166 **** ! 2523: po_hash = NULL; /* use before set up: NULL-> address error */ ! 2524: ! 2525: ! 2526: void s_abort(), s_align(), s_comm(), s_data(); ! 2527: ! void s_desc(), s_even(), s_file(), s_fill(); ! 2528: void s_globl(), s_lcomm(), s_line(), s_lsym(); ! 2529: void s_org(), s_set(), s_space(), s_text(); ! 2530: #ifdef VMS ! 2531: --- 175,185 ---- ! 2532: po_hash = NULL; /* use before set up: NULL-> address error */ ! 2533: ! 2534: ! 2535: + #ifdef aout ! 2536: + void s_desc(); ! 2537: + #endif /* aout */ ! 2538: void s_abort(), s_align(), s_comm(), s_data(); ! 2539: ! void s_even(), s_file(), s_fill(); ! 2540: void s_globl(), s_lcomm(), s_line(), s_lsym(); ! 2541: void s_org(), s_set(), s_space(), s_text(); ! 2542: #ifdef VMS ! 2543: *************** ! 2544: *** 192,198 **** ! 2545: --- 211,219 ---- ! 2546: { "const", s_const, 0 }, ! 2547: #endif ! 2548: { "data", s_data, 0 }, ! 2549: + #ifdef aout ! 2550: { "desc", s_desc, 0 }, ! 2551: + #endif /* aout */ ! 2552: { "double", float_cons, 'd' }, ! 2553: { "file", s_file, 0 }, ! 2554: { "fill", s_fill, 0 }, ! 2555: *************** ! 2556: *** 218,226 **** ! 2557: --- 239,252 ---- ! 2558: { "short", cons, 2 }, ! 2559: { "single", float_cons, 'f' }, ! 2560: { "space", s_space, 0 }, ! 2561: + #ifdef coff ! 2562: + { "def", def, 0 }, ! 2563: + { "ln", line, 0 }, ! 2564: + #else /* coff */ ! 2565: { "stabd", stab, 'd' }, ! 2566: { "stabn", stab, 'n' }, ! 2567: { "stabs", stab, 's' }, ! 2568: + #endif /* coff */ ! 2569: { "text", s_text, 0 }, ! 2570: #ifndef SPARC ! 2571: { "word", cons, 2 }, ! 2572: *************** ! 2573: *** 622,640 **** ! 2574: *p = 0; ! 2575: symbolP = symbol_find_or_make (name); ! 2576: *p = c; ! 2577: ! if ( (symbolP -> sy_type & N_TYPE) != N_UNDF || ! 2578: ! symbolP -> sy_other != 0 || symbolP -> sy_desc != 0) { ! 2579: as_warn( "Ignoring attempt to re-define symbol"); ! 2580: ignore_rest_of_line(); ! 2581: return; ! 2582: } ! 2583: ! if (symbolP -> sy_value) { ! 2584: ! if (symbolP -> sy_value != temp) ! 2585: as_warn( "Length of .comm \"%s\" is already %d. Not changed to %d.", ! 2586: ! symbolP -> sy_name, symbolP -> sy_value, temp); ! 2587: } else { ! 2588: ! symbolP -> sy_value = temp; ! 2589: ! symbolP -> sy_type |= N_EXT; ! 2590: } ! 2591: #ifdef VMS ! 2592: if(!temp) ! 2593: --- 648,671 ---- ! 2594: *p = 0; ! 2595: symbolP = symbol_find_or_make (name); ! 2596: *p = c; ! 2597: ! if (S_IS_DEFINED(symbolP) ! 2598: ! #ifdef aout ! 2599: ! || S_GET_OTHER(symbolP) != 0 || S_GET_DESC(symbolP) != 0 ! 2600: ! #endif /* aout */ ! 2601: ! ) { ! 2602: as_warn( "Ignoring attempt to re-define symbol"); ! 2603: ignore_rest_of_line(); ! 2604: return; ! 2605: } ! 2606: ! if (S_GET_VALUE(symbolP)) { ! 2607: ! if (S_GET_VALUE(symbolP) != temp) ! 2608: as_warn( "Length of .comm \"%s\" is already %d. Not changed to %d.", ! 2609: ! S_GET_NAME(symbolP), ! 2610: ! S_GET_VALUE(symbolP), ! 2611: ! temp); ! 2612: } else { ! 2613: ! S_SET_VALUE(symbolP, temp); ! 2614: ! S_SET_EXTERNAL(symbolP); ! 2615: } ! 2616: #ifdef VMS ! 2617: if(!temp) ! 2618: *************** ! 2619: *** 670,675 **** ! 2620: --- 701,707 ---- ! 2621: demand_empty_rest_of_line(); ! 2622: } ! 2623: ! 2624: + #ifdef aout ! 2625: void ! 2626: s_desc() ! 2627: { ! 2628: *************** ! 2629: *** 699,720 **** ! 2630: *p = 0; ! 2631: symbolP = symbol_find_or_make (name); ! 2632: *p = c; ! 2633: ! symbolP -> sy_desc = temp; ! 2634: } ! 2635: demand_empty_rest_of_line(); ! 2636: } ! 2637: ! 2638: void ! 2639: s_file() ! 2640: { ! 2641: ! register char *s; ! 2642: ! int length; ! 2643: ! ! 2644: ! /* Some assemblers tolerate immediately following '"' */ ! 2645: ! if ( s = demand_copy_string( & length ) ) { ! 2646: ! new_logical_line (s, -1); ! 2647: ! demand_empty_rest_of_line(); ! 2648: ! } ! 2649: } ! 2650: ! 2651: void ! 2652: --- 731,756 ---- ! 2653: *p = 0; ! 2654: symbolP = symbol_find_or_make (name); ! 2655: *p = c; ! 2656: ! S_SET_DESC(symbolP,temp); ! 2657: } ! 2658: demand_empty_rest_of_line(); ! 2659: } ! 2660: + #endif /* aout */ ! 2661: ! 2662: void ! 2663: s_file() ! 2664: { ! 2665: ! register char *s; ! 2666: ! int length; ! 2667: ! ! 2668: ! /* Some assemblers tolerate immediately following '"' */ ! 2669: ! if ( s = demand_copy_string( & length ) ) { ! 2670: ! new_logical_line (s, -1); ! 2671: ! demand_empty_rest_of_line(); ! 2672: ! } ! 2673: ! #ifdef coff ! 2674: ! c_dot_file_symbol(s); ! 2675: ! #endif /* coff */ ! 2676: } ! 2677: ! 2678: void ! 2679: *************** ! 2680: *** 897,903 **** ! 2681: symbolP = symbol_find_or_make (name); ! 2682: * input_line_pointer = c; ! 2683: SKIP_WHITESPACE(); ! 2684: ! symbolP -> sy_type |= N_EXT; ! 2685: if(c==',') { ! 2686: input_line_pointer++; ! 2687: SKIP_WHITESPACE(); ! 2688: --- 933,939 ---- ! 2689: symbolP = symbol_find_or_make (name); ! 2690: * input_line_pointer = c; ! 2691: SKIP_WHITESPACE(); ! 2692: ! S_SET_EXTERNAL(symbolP); ! 2693: if(c==',') { ! 2694: input_line_pointer++; ! 2695: SKIP_WHITESPACE(); ! 2696: *************** ! 2697: *** 936,954 **** ! 2698: *p = 0; ! 2699: symbolP = symbol_find_or_make (name); ! 2700: *p = c; ! 2701: ! if ( symbolP -> sy_other == 0 ! 2702: ! && symbolP -> sy_desc == 0 ! 2703: ! && ( ( symbolP -> sy_type == N_BSS ! 2704: ! && symbolP -> sy_value == local_bss_counter) ! 2705: ! || ( (symbolP -> sy_type & N_TYPE) == N_UNDF ! 2706: ! && symbolP -> sy_value == 0))) { ! 2707: ! symbolP -> sy_value = local_bss_counter; ! 2708: ! symbolP -> sy_type = N_BSS; ! 2709: symbolP -> sy_frag = & bss_address_frag; ! 2710: local_bss_counter += temp; ! 2711: } else ! 2712: as_warn( "Ignoring attempt to re-define symbol from %d. to %d.", ! 2713: ! symbolP -> sy_value, local_bss_counter ); ! 2714: demand_empty_rest_of_line(); ! 2715: } ! 2716: ! 2717: --- 972,998 ---- ! 2718: *p = 0; ! 2719: symbolP = symbol_find_or_make (name); ! 2720: *p = c; ! 2721: ! if ( ! 2722: ! #ifdef aout ! 2723: ! S_GET_OTHER(symbolP) == 0 && ! 2724: ! S_GET_DESC(symbolP) == 0 && ! 2725: ! #endif /* aout */ ! 2726: ! (S_IS_BSS(symbolP) && S_GET_VALUE(symbolP) == local_bss_counter) ! 2727: ! /* What S_GET_VALUE(symbolP) == 0 is supposed to mean (in aout case) ? ! 2728: ! In the coff case it clearly does not mean anything (the only case ! 2729: ! where a symbol is not defined is from an external declaration (extern a) ! 2730: ! and this kind of symbol have a 0 value. */ ! 2731: ! || (!S_IS_DEFINED(symbolP) && S_GET_VALUE(symbolP) == 0)) { ! 2732: ! S_SET_VALUE(symbolP,local_bss_counter); ! 2733: ! S_SET_BSS(symbolP); ! 2734: ! #ifdef coff ! 2735: ! S_SET_STORAGE_CLASS(symbolP, C_STAT); ! 2736: ! #endif /* coff */ ! 2737: symbolP -> sy_frag = & bss_address_frag; ! 2738: local_bss_counter += temp; ! 2739: } else ! 2740: as_warn( "Ignoring attempt to re-define symbol from %d. to %d.", ! 2741: ! S_GET_VALUE(symbolP), local_bss_counter ); ! 2742: demand_empty_rest_of_line(); ! 2743: } ! 2744: ! 2745: *************** ! 2746: *** 1001,1014 **** ! 2747: segment = expression (& exp); ! 2748: if ( segment != SEG_ABSOLUTE && segment != SEG_DATA && ! 2749: segment != SEG_TEXT && segment != SEG_BSS) { ! 2750: ! as_warn("Bad expression: %s", seg_name [(int)segment]); ! 2751: ignore_rest_of_line(); ! 2752: return; ! 2753: } ! 2754: know( segment == SEG_ABSOLUTE || segment == SEG_DATA || segment == SEG_TEXT || segment == SEG_BSS ); ! 2755: *p = 0; ! 2756: ! symbolP = symbol_new (name,(unsigned char)(seg_N_TYPE [(int) segment]), ! 2757: 0, 0, (valueT)(exp . X_add_number), & zero_address_frag); ! 2758: *p = c; ! 2759: demand_empty_rest_of_line(); ! 2760: } ! 2761: --- 1045,1063 ---- ! 2762: segment = expression (& exp); ! 2763: if ( segment != SEG_ABSOLUTE && segment != SEG_DATA && ! 2764: segment != SEG_TEXT && segment != SEG_BSS) { ! 2765: ! as_warn("Bad expression: %s", segment_name((int)segment)); ! 2766: ignore_rest_of_line(); ! 2767: return; ! 2768: } ! 2769: know( segment == SEG_ABSOLUTE || segment == SEG_DATA || segment == SEG_TEXT || segment == SEG_BSS ); ! 2770: *p = 0; ! 2771: ! #ifdef coff ! 2772: ! symbolP = symbol_new(name, segment, (valueT)(exp . X_add_number), ! 2773: ! 0, &zero_address_frag); ! 2774: ! #else /* coff */ ! 2775: ! symbolP = symbol_new (name,(unsigned char)(seg_SEG((int) segment)), ! 2776: 0, 0, (valueT)(exp . X_add_number), & zero_address_frag); ! 2777: + #endif /* coff */ ! 2778: *p = c; ! 2779: demand_empty_rest_of_line(); ! 2780: } ! 2781: *************** ! 2782: *** 1044,1050 **** ! 2783: if ( ! need_pass_2 ) { ! 2784: if (segment != now_seg && segment != SEG_ABSOLUTE) ! 2785: as_warn("Illegal segment \"%s\". Segment \"%s\" assumed.", ! 2786: ! seg_name [(int) segment], seg_name [(int) now_seg]); ! 2787: p = frag_var (rs_org, 1, 1, (relax_substateT)0, exp . X_add_symbol, ! 2788: exp . X_add_number, (char *)0); ! 2789: * p = temp_fill; ! 2790: --- 1093,1099 ---- ! 2791: if ( ! need_pass_2 ) { ! 2792: if (segment != now_seg && segment != SEG_ABSOLUTE) ! 2793: as_warn("Illegal segment \"%s\". Segment \"%s\" assumed.", ! 2794: ! segment_name((int) segment), segment_name((int) now_seg)); ! 2795: p = frag_var (rs_org, 1, 1, (relax_substateT)0, exp . X_add_symbol, ! 2796: exp . X_add_number, (char *)0); ! 2797: * p = temp_fill; ! 2798: *************** ! 2799: *** 1089,1095 **** ! 2800: if ( ! need_pass_2 ) { ! 2801: if (segment != now_seg && segment != SEG_ABSOLUTE) ! 2802: as_warn("Illegal segment \"%s\". Segment \"%s\" assumed.", ! 2803: ! seg_name [(int) segment], seg_name [(int) now_seg]); ! 2804: ptr = frag_var (rs_org, 1, 1, (relax_substateT)0, exp.X_add_symbol, ! 2805: exp.X_add_number, (char *)0); ! 2806: *ptr= 0; ! 2807: --- 1138,1145 ---- ! 2808: if ( ! need_pass_2 ) { ! 2809: if (segment != now_seg && segment != SEG_ABSOLUTE) ! 2810: as_warn("Illegal segment \"%s\". Segment \"%s\" assumed.", ! 2811: ! segment_name((int) segment), ! 2812: ! segment_name((int) now_seg)); ! 2813: ptr = frag_var (rs_org, 1, 1, (relax_substateT)0, exp.X_add_symbol, ! 2814: exp.X_add_number, (char *)0); ! 2815: *ptr= 0; ! 2816: *************** ! 2817: *** 1176,1181 **** ! 2818: --- 1226,1546 ---- ! 2819: know( is_end_of_line [input_line_pointer [-1]] ); ! 2820: } ! 2821: ! 2822: + #ifdef coff ! 2823: + /* ! 2824: + * Handle .ln directives. ! 2825: + */ ! 2826: + ! 2827: + static void ! 2828: + line(what) ! 2829: + int what; ! 2830: + { ! 2831: + c_line_new(obstack_next_free(&frags) - frag_now->fr_literal, ! 2832: + get_absolute_expression(), ! 2833: + frag_now); ! 2834: + demand_empty_rest_of_line(); ! 2835: + ! 2836: + return; ! 2837: + } ! 2838: + /* ! 2839: + * def() ! 2840: + * ! 2841: + * Handle .def directives. ! 2842: + * ! 2843: + * One would say : why can't we symbol_new if the symbol does not ! 2844: + * allready exists and fill it with debug information. Because of ! 2845: + * the C_EFCN special symbol. It would clobber the value of the ! 2846: + * function symbol before we have a chance to notice that it is ! 2847: + * a C_EFCN. And a second reason is that the code is more clear this ! 2848: + * way. (at least I think it is:-). ! 2849: + * ! 2850: + */ ! 2851: + ! 2852: + #define SKIP_SEMI_COLON() while(*input_line_pointer++ != ';') ! 2853: + #define SKIP_WHITESPACES() while(*input_line_pointer == ' ' || \ ! 2854: + *input_line_pointer == '\t') \ ! 2855: + input_line_pointer++; ! 2856: + ! 2857: + #define NEXT_DEF_DIRECTIVE() SKIP_SEMI_COLON(); SKIP_WHITESPACES() ! 2858: + #define equal !strcmp ! 2859: + #define MAX_DIRECTIVE 20 ! 2860: + ! 2861: + static void ! 2862: + def(what) ! 2863: + int what; ! 2864: + { ! 2865: + char name_end; /* Char after the end of name */ ! 2866: + symbolS* symbolP; /* Debug symbol just created */ ! 2867: + symbolS symbol; /* Temporary symbol to hold .def */ ! 2868: + char* symbol_name; /* Name of the debug symbol */ ! 2869: + char* symbol_name_copy; /* Temporary copy of the name */ ! 2870: + unsigned int symbol_name_length; /* */ ! 2871: + char* directiveP; /* Name of the pseudo opcode */ ! 2872: + char directive[MAX_DIRECTIVE]; /* Backup of the directive */ ! 2873: + char end = 0; /* If 1, stop parsing */ ! 2874: + ! 2875: + SKIP_WHITESPACES(); ! 2876: + ! 2877: + symbolP = &symbol; ! 2878: + memset((char*)symbolP, '\0', sizeof(symbolS)); ! 2879: + ! 2880: + symbol_name = input_line_pointer; ! 2881: + name_end = get_symbol_end(); ! 2882: + symbol_name_length = strlen(symbol_name); ! 2883: + symbol_name_copy = xmalloc(symbol_name_length + 1); ! 2884: + strcpy(symbol_name_copy, symbol_name); ! 2885: + ! 2886: + /* Initialize the new symbol */ ! 2887: + #if STRIP_UNDERSCORE ! 2888: + S_SET_NAME(symbolP, *symbol_name_copy == '_' ? symbol_name_copy + 1 : ! 2889: + symbol_name_copy); ! 2890: + #else /* STRIP_UNDERSCORE */ ! 2891: + S_SET_NAME(symbolP, symbol_name_copy); ! 2892: + #endif /* STRIP_UNDERSCORE */ ! 2893: + symbolP->sy_name_offset = ~0; ! 2894: + symbolP->sy_number = ~0; ! 2895: + symbolP->sy_frag = &zero_address_frag; ! 2896: + if(S_IS_STRING(symbolP)) ! 2897: + SF_SET_STRING(symbolP); ! 2898: + ! 2899: + *input_line_pointer = name_end; ! 2900: + ! 2901: + while(!end) { ! 2902: + NEXT_DEF_DIRECTIVE(); ! 2903: + directiveP = input_line_pointer; ! 2904: + name_end = get_symbol_end(); ! 2905: + strncpy(directive, directiveP, MAX_DIRECTIVE); ! 2906: + *input_line_pointer = name_end; ! 2907: + SKIP_WHITESPACES(); ! 2908: + switch(directive[1]) { ! 2909: + case 'd': ! 2910: + if(equal(directive, ".dim")) { ! 2911: + register int dim_index; ! 2912: + register int dimension; ! 2913: + ! 2914: + S_SET_NUMBER_AUXILIARY(symbolP, 1); ! 2915: + for(dim_index = 0; dim_index < DIMNUM; dim_index++) { ! 2916: + SKIP_WHITESPACES(); ! 2917: + SA_SET_SYM_DIMEN(symbolP, dim_index, ! 2918: + get_absolute_expression()); ! 2919: + switch(*input_line_pointer) { ! 2920: + case ',': ! 2921: + input_line_pointer++; ! 2922: + break; ! 2923: + default: ! 2924: + as_warn("badly formed .dim directive"); ! 2925: + case ';': ! 2926: + dim_index = DIMNUM; ! 2927: + break; ! 2928: + } ! 2929: + } ! 2930: + } else ! 2931: + as_warn("unknown debug directive : %s", directive); ! 2932: + break; ! 2933: + case 'e': ! 2934: + if(equal(directive, ".endef")) ! 2935: + end = 1; ! 2936: + else ! 2937: + as_warn("unknown debug directive : %s", directive); ! 2938: + break; ! 2939: + case 'l': ! 2940: + if(equal(directive, ".line")) { ! 2941: + S_SET_NUMBER_AUXILIARY(symbolP, 1); ! 2942: + SA_SET_SYM_LNNO(symbolP, get_absolute_expression()); ! 2943: + } else ! 2944: + as_warn("unknown debug directive : %s", directive); ! 2945: + break; ! 2946: + case 's': ! 2947: + if(equal(directive, ".size")) { ! 2948: + S_SET_NUMBER_AUXILIARY(symbolP, 1); ! 2949: + SA_SET_SYM_SIZE(symbolP, get_absolute_expression()); ! 2950: + } else if(equal(directive, ".scl")) ! 2951: + S_SET_STORAGE_CLASS(symbolP, get_absolute_expression()); ! 2952: + else ! 2953: + as_warn("unknown debug directive : %s", directive); ! 2954: + break; ! 2955: + case 't': ! 2956: + if(equal(directive, ".tag")) { ! 2957: + symbolS * tag_symbolP; ! 2958: + ! 2959: + S_SET_NUMBER_AUXILIARY(symbolP, 1); ! 2960: + symbol_name = input_line_pointer; ! 2961: + name_end = get_symbol_end(); ! 2962: + /* Assume that the symbol referred to by .tag is ! 2963: + always defined. */ ! 2964: + SA_SET_SYM_TAGNDX(symbolP, (long)tag_find(symbol_name)); ! 2965: + if(SA_GET_SYM_TAGNDX(symbolP) == 0L) ! 2966: + as_warn("tag not found for .tag %s", symbol_name); ! 2967: + SF_SET_TAGGED(symbolP); ! 2968: + *input_line_pointer = name_end; ! 2969: + } else if(equal(directive, ".type")) { ! 2970: + S_SET_DATA_TYPE(symbolP, get_absolute_expression()); ! 2971: + if(ISFCN(S_GET_DATA_TYPE(symbolP)) && ! 2972: + S_GET_STORAGE_CLASS(symbolP) != C_TPDEF) ! 2973: + SF_SET_FUNCTION(symbolP); ! 2974: + } else ! 2975: + as_warn("unknown debug directive : %s", directive); ! 2976: + break; ! 2977: + case 'v': ! 2978: + if(equal(directive, ".val")) { ! 2979: + if(is_name_beginner(*input_line_pointer)) { ! 2980: + symbol_name = input_line_pointer; ! 2981: + name_end = get_symbol_end(); ! 2982: + if(equal(symbol_name, ".")) { ! 2983: + symbolP->sy_frag = frag_now; ! 2984: + S_SET_VALUE(symbolP, obstack_next_free(&frags) - ! 2985: + frag_now->fr_literal); ! 2986: + /* If the .val is != from the .def (i.e. statics) */ ! 2987: + } else if(!equal(symbol_name_copy, symbol_name)) { ! 2988: + register symbolS* forwardP; ! 2989: + if(forwardP = symbol_find(symbol_name)) ! 2990: + symbolP->sy_forward = forwardP; ! 2991: + else { ! 2992: + /* Create a new undefined symbol. */ ! 2993: + symbolP->sy_forward = ! 2994: + symbol_new (symbol_name, SEG_UNKNOWN, ! 2995: + 0, 0, &zero_address_frag); ! 2996: + } ! 2997: + /* If the segment is undefined when the forward ! 2998: + reference is solved, then copy the segment id ! 2999: + from the forward symbol. */ ! 3000: + SF_SET_GET_SEGMENT(symbolP); ! 3001: + } ! 3002: + /* Otherwise, it is the name of a non debug symbol and its ! 3003: + value will be calculated later. */ ! 3004: + *input_line_pointer = name_end; ! 3005: + } else ! 3006: + S_SET_VALUE(symbolP, get_absolute_expression()); ! 3007: + } else ! 3008: + as_warn("unknown debug directive : %s", directive); ! 3009: + break; ! 3010: + default: ! 3011: + as_warn("unknown debug directive : %s", directive); ! 3012: + break; ! 3013: + } ! 3014: + } ! 3015: + demand_empty_rest_of_line(); ! 3016: + ! 3017: + /* Set the section number according to storage class. */ ! 3018: + switch(S_GET_STORAGE_CLASS(symbolP)) { ! 3019: + case C_STRTAG: case C_ENTAG: case C_UNTAG: ! 3020: + SF_SET_TAG(symbolP); ! 3021: + case C_FILE: ! 3022: + case C_TPDEF: ! 3023: + SF_SET_DEBUG(symbolP); ! 3024: + S_SET_SEGMENT(symbolP, C_DEBUG_SECTION); ! 3025: + break; ! 3026: + case C_EFCN: ! 3027: + SF_SET_LOCAL(symbolP); /* Do not emit this symbol. */ ! 3028: + case C_BLOCK: ! 3029: + SF_SET_PROCESS(symbolP); /* Will need processing before writing */ ! 3030: + case C_FCN: ! 3031: + S_SET_SEGMENT(symbolP, C_TEXT_SECTION); ! 3032: + break; ! 3033: + case C_AUTO: ! 3034: + case C_REG: ! 3035: + case C_MOS: case C_MOE: case C_MOU: ! 3036: + case C_ARG: ! 3037: + case C_REGPARM: ! 3038: + case C_FIELD: ! 3039: + case C_EOS: ! 3040: + SF_SET_DEBUG(symbolP); ! 3041: + S_SET_SEGMENT(symbolP, C_ABS_SECTION); ! 3042: + break; ! 3043: + case C_EXT: ! 3044: + case C_STAT: ! 3045: + /* Valid but set somewhere else (s_comm, s_lcomm, colon) */ ! 3046: + break; ! 3047: + case C_USTATIC: ! 3048: + case C_EXTDEF: ! 3049: + case C_LABEL: ! 3050: + case C_ULABEL: ! 3051: + as_warn("unexpected storage class %d", S_GET_STORAGE_CLASS(symbolP)); ! 3052: + break; ! 3053: + } ! 3054: + /* Now that we have build up a debug symbol, try to find if we should ! 3055: + merge with an existing symbol or not. */ ! 3056: + /* If symbol does not exist, or symbol is a end function mark, ! 3057: + or symbol is in debug or abs section, ! 3058: + insert it in the list of symbols. */ ! 3059: + if(S_GET_STORAGE_CLASS(symbolP) == C_EFCN || ! 3060: + S_GET_SEGMENT(symbolP) == C_DEBUG_SECTION || ! 3061: + S_GET_SEGMENT(symbolP) == C_ABS_SECTION || ! 3062: + (symbolP = symbol_find_base(S_GET_NAME(symbolP), DO_NOT_STRIP)) == ! 3063: + (symbolS*)0) { ! 3064: + ! 3065: + symbolP = (symbolS *)obstack_alloc(¬es, sizeof(symbolS)); ! 3066: + memcpy((char*)symbolP, &symbol, sizeof(symbolS)); ! 3067: + ! 3068: + DL_APPEND(symbolP, symbol_lastP); ! 3069: + symbol_lastP = symbolP; ! 3070: + ! 3071: + } else { ! 3072: + /* This symbol allready exists, merge the newly created symbol into ! 3073: + the old one. This is not mandatory. The linker can handle ! 3074: + duplicate symbols correctly. But I guess that it save a *lot* ! 3075: + of space if the assembly file defines a lot of symbols. */ ! 3076: + /* The debug entry (symbol) is merged into symbolP. */ ! 3077: + c_symbol_merge(&symbol, symbolP); ! 3078: + /* For the function, the symbol *must* be were the debug symbol ! 3079: + appear. Move the existing symbol to the current place. */ ! 3080: + if(SF_GET_FUNCTION(symbolP)) { ! 3081: + /* If it already is at the end of the symbol list, do nothing */ ! 3082: + if(symbolP != symbol_lastP) { ! 3083: + DL_REMOVE(symbolP); ! 3084: + DL_APPEND(symbolP, symbol_lastP); ! 3085: + symbol_lastP = symbolP; ! 3086: + } ! 3087: + } else ! 3088: + free(symbol_name_copy); ! 3089: + } ! 3090: + ! 3091: + /* If symbol is a {structure,union} tag, associate symbol to its name. */ ! 3092: + if(SF_GET_TAG(symbolP)) ! 3093: + tag_insert(S_GET_NAME(symbolP), symbolP); ! 3094: + ! 3095: + /* Create the line number entry pointing on the function being defined */ ! 3096: + if(SF_GET_FUNCTION(symbolP)) { ! 3097: + c_line_new((long)S_GET_NAME(symbolP), 0, &zero_address_frag); ! 3098: + SF_SET_PROCESS(symbolP); ! 3099: + } ! 3100: + } ! 3101: + ! 3102: + /* ! 3103: + * Maintain a list of the tagnames of the structres. ! 3104: + */ ! 3105: + ! 3106: + static void ! 3107: + tag_init() ! 3108: + { ! 3109: + tag_hash = hash_new(); ! 3110: + return ; ! 3111: + } ! 3112: + ! 3113: + static void ! 3114: + tag_insert(name, symbolP) ! 3115: + char* name; ! 3116: + symbolS* symbolP; ! 3117: + { ! 3118: + register char * error_string; ! 3119: + ! 3120: + if(*(error_string = hash_jam (tag_hash, name, (char *)symbolP))) { ! 3121: + as_fatal("Inserting \"%s\" into structure table failed: %s", ! 3122: + name, error_string); ! 3123: + } ! 3124: + return ; ! 3125: + } ! 3126: + ! 3127: + static symbolS* ! 3128: + tag_find(name) ! 3129: + char* name; ! 3130: + { ! 3131: + #if STRIP_UNDERSCORE ! 3132: + if(*name == '_') name++; ! 3133: + #endif /* STRIP_UNDERSCORE */ ! 3134: + return((symbolS*)hash_find(tag_hash, name)); ! 3135: + } ! 3136: + #else /* coff */ ! 3137: /* ! 3138: * stab() ! 3139: * ! 3140: *************** ! 3141: *** 1230,1237 **** ! 3142: symbolP = symbol_new (string, 0,0,0,0,(struct frag *)0); ! 3143: switch (what) { ! 3144: case 'd': ! 3145: ! symbolP->sy_name = NULL; /* .stabd feature. */ ! 3146: ! symbolP->sy_value = obstack_next_free(& frags) - frag_now->fr_literal; ! 3147: symbolP->sy_frag = frag_now; ! 3148: break; ! 3149: ! 3150: --- 1595,1603 ---- ! 3151: symbolP = symbol_new (string, 0,0,0,0,(struct frag *)0); ! 3152: switch (what) { ! 3153: case 'd': ! 3154: ! S_SET_NAME(symbolP,NULL); /* .stabd feature. */ ! 3155: ! S_SET_VALUE(symbolP,obstack_next_free(&frags) - ! 3156: ! frag_now->fr_literal); ! 3157: symbolP->sy_frag = frag_now; ! 3158: break; ! 3159: ! 3160: *************** ! 3161: *** 1257,1263 **** ! 3162: } ! 3163: if (! goof) { ! 3164: if (get_absolute_expression_and_terminator (& longint) == ',') ! 3165: ! symbolP->sy_other = longint; ! 3166: else { ! 3167: as_warn( "I want a comma after the n_other expression" ); ! 3168: goof = TRUE; ! 3169: --- 1623,1629 ---- ! 3170: } ! 3171: if (! goof) { ! 3172: if (get_absolute_expression_and_terminator (& longint) == ',') ! 3173: ! S_SET_OTHER(symbolP,longint); ! 3174: else { ! 3175: as_warn( "I want a comma after the n_other expression" ); ! 3176: goof = TRUE; ! 3177: *************** ! 3178: *** 1265,1271 **** ! 3179: } ! 3180: } ! 3181: if (! goof) { ! 3182: ! symbolP->sy_desc = get_absolute_expression (); ! 3183: if (what == 's' || what == 'n') { ! 3184: if (* input_line_pointer != ',') { ! 3185: as_warn( "I want a comma after the n_desc expression" ); ! 3186: --- 1631,1637 ---- ! 3187: } ! 3188: } ! 3189: if (! goof) { ! 3190: ! S_SET_DESC(symbolP, get_absolute_expression ()); ! 3191: if (what == 's' || what == 'n') { ! 3192: if (* input_line_pointer != ',') { ! 3193: as_warn( "I want a comma after the n_desc expression" ); ! 3194: *************** ! 3195: *** 1284,1289 **** ! 3196: --- 1650,1656 ---- ! 3197: else ! 3198: demand_empty_rest_of_line (); ! 3199: } ! 3200: + #endif /* coff */ ! 3201: ! 3202: /* ! 3203: * pseudo_set() ! 3204: *************** ! 3205: *** 1302,1311 **** ! 3206: { ! 3207: expressionS exp; ! 3208: register segT segment; ! 3209: int ext; ! 3210: ! 3211: know( symbolP ); /* NULL pointer is logic error. */ ! 3212: ! ext=(symbolP->sy_type&N_EXT); ! 3213: if ((segment = expression( & exp )) == SEG_NONE) ! 3214: { ! 3215: as_warn( "Missing expression: absolute 0 assumed" ); ! 3216: --- 1669,1682 ---- ! 3217: { ! 3218: expressionS exp; ! 3219: register segT segment; ! 3220: + #ifdef aout ! 3221: int ext; ! 3222: + #endif /* aout */ ! 3223: ! 3224: know( symbolP ); /* NULL pointer is logic error. */ ! 3225: ! #ifdef aout ! 3226: ! ext=S_IS_EXTERNAL(symbolP); ! 3227: ! #endif /* aout */ ! 3228: if ((segment = expression( & exp )) == SEG_NONE) ! 3229: { ! 3230: as_warn( "Missing expression: absolute 0 assumed" ); ! 3231: *************** ! 3232: *** 1317,1348 **** ! 3233: case SEG_BIG: ! 3234: as_warn( "%s number illegal. Absolute 0 assumed.", ! 3235: exp . X_add_number > 0 ? "Bignum" : "Floating-Point" ); ! 3236: ! symbolP -> sy_type = N_ABS | ext; ! 3237: ! symbolP -> sy_value = 0; ! 3238: symbolP -> sy_frag = & zero_address_frag; ! 3239: break; ! 3240: ! 3241: case SEG_NONE: ! 3242: as_warn("No expression: Using absolute 0"); ! 3243: ! symbolP -> sy_type = N_ABS | ext; ! 3244: ! symbolP -> sy_value = 0; ! 3245: symbolP -> sy_frag = & zero_address_frag; ! 3246: break; ! 3247: ! 3248: case SEG_DIFFERENCE: ! 3249: if (exp.X_add_symbol && exp.X_subtract_symbol ! 3250: ! && (exp.X_add_symbol->sy_type & N_TYPE) ! 3251: ! == (exp.X_subtract_symbol->sy_type & N_TYPE)) { ! 3252: if(exp.X_add_symbol->sy_frag != exp.X_subtract_symbol->sy_frag) { ! 3253: ! as_bad("Unknown expression: symbols %s and %s are in different frags.",exp.X_add_symbol->sy_name, exp.X_subtract_symbol->sy_name); ! 3254: need_pass_2++; ! 3255: } ! 3256: ! exp.X_add_number+=exp.X_add_symbol->sy_value - exp.X_subtract_symbol->sy_value; ! 3257: } else ! 3258: as_warn( "Complex expression. Absolute segment assumed." ); ! 3259: case SEG_ABSOLUTE: ! 3260: ! symbolP -> sy_type = N_ABS | ext; ! 3261: ! symbolP -> sy_value = exp . X_add_number; ! 3262: symbolP -> sy_frag = & zero_address_frag; ! 3263: break; ! 3264: ! 3265: --- 1688,1732 ---- ! 3266: case SEG_BIG: ! 3267: as_warn( "%s number illegal. Absolute 0 assumed.", ! 3268: exp . X_add_number > 0 ? "Bignum" : "Floating-Point" ); ! 3269: ! S_SET_ABS(symbolP); ! 3270: ! #ifdef aout ! 3271: ! ext ? S_SET_EXTERNAL(symbolP) : ! 3272: ! S_CLEAR_EXTERNAL(symbolP); ! 3273: ! #endif /* aout */ ! 3274: ! S_SET_VALUE(symbolP, 0); ! 3275: symbolP -> sy_frag = & zero_address_frag; ! 3276: break; ! 3277: ! 3278: case SEG_NONE: ! 3279: as_warn("No expression: Using absolute 0"); ! 3280: ! S_SET_ABS(symbolP); ! 3281: ! #ifdef aout ! 3282: ! ext ? S_SET_EXTERNAL(symbolP) : ! 3283: ! S_CLEAR_EXTERNAL(symbolP); ! 3284: ! #endif /* aout */ ! 3285: ! S_SET_VALUE(symbolP, 0); ! 3286: symbolP -> sy_frag = & zero_address_frag; ! 3287: break; ! 3288: ! 3289: case SEG_DIFFERENCE: ! 3290: if (exp.X_add_symbol && exp.X_subtract_symbol ! 3291: ! && (S_GET_SEGMENT(exp.X_add_symbol) == ! 3292: ! S_GET_SEGMENT(exp.X_subtract_symbol))) { ! 3293: if(exp.X_add_symbol->sy_frag != exp.X_subtract_symbol->sy_frag) { ! 3294: ! as_bad("Unknown expression: symbols %s and %s are in different frags.",S_GET_NAME(exp.X_add_symbol), S_GET_NAME(exp.X_subtract_symbol)); ! 3295: need_pass_2++; ! 3296: } ! 3297: ! exp.X_add_number+=S_GET_VALUE(exp.X_add_symbol) - ! 3298: ! S_GET_VALUE(exp.X_subtract_symbol); ! 3299: } else ! 3300: as_warn( "Complex expression. Absolute segment assumed." ); ! 3301: case SEG_ABSOLUTE: ! 3302: ! S_SET_ABS(symbolP); ! 3303: ! #ifdef aout ! 3304: ! ext ? S_SET_EXTERNAL(symbolP) : ! 3305: ! S_CLEAR_EXTERNAL(symbolP); ! 3306: ! #endif /* aout */ ! 3307: ! S_SET_VALUE(symbolP, exp.X_add_number); ! 3308: symbolP -> sy_frag = & zero_address_frag; ! 3309: break; ! 3310: ! 3311: *************** ! 3312: *** 1349,1356 **** ! 3313: case SEG_DATA: ! 3314: case SEG_TEXT: ! 3315: case SEG_BSS: ! 3316: ! symbolP -> sy_type = seg_N_TYPE [(int) segment] | ext; ! 3317: ! symbolP -> sy_value= exp . X_add_number + exp . X_add_symbol -> sy_value; ! 3318: symbolP -> sy_frag = exp . X_add_symbol -> sy_frag; ! 3319: break; ! 3320: ! 3321: --- 1733,1748 ---- ! 3322: case SEG_DATA: ! 3323: case SEG_TEXT: ! 3324: case SEG_BSS: ! 3325: ! switch(segment) { ! 3326: ! case SEG_DATA: S_SET_DATA(symbolP); break; ! 3327: ! case SEG_TEXT: S_SET_TEXT(symbolP); break; ! 3328: ! case SEG_BSS: S_SET_BSS(symbolP); break; ! 3329: ! } ! 3330: ! #ifdef aout ! 3331: ! ext ? S_SET_EXTERNAL(symbolP) : ! 3332: ! S_CLEAR_EXTERNAL(symbolP); ! 3333: ! #endif /* aout */ ! 3334: ! S_SET_VALUE(symbolP, exp.X_add_number + S_GET_VALUE(exp.X_add_symbol)); ! 3335: symbolP -> sy_frag = exp . X_add_symbol -> sy_frag; ! 3336: break; ! 3337: ! 3338: *************** ! 3339: *** 1447,1454 **** ! 3340: if ( segment == SEG_DIFFERENCE && exp . X_add_symbol == NULL ) ! 3341: { ! 3342: as_warn( "Subtracting symbol \"%s\"(segment\"%s\") is too hard. Absolute segment assumed.", ! 3343: ! exp . X_subtract_symbol -> sy_name, ! 3344: ! seg_name [(int) N_TYPE_seg [exp . X_subtract_symbol -> sy_type & N_TYPE]]); ! 3345: segment = SEG_ABSOLUTE; ! 3346: /* Leave exp . X_add_number alone. */ ! 3347: } ! 3348: --- 1839,1846 ---- ! 3349: if ( segment == SEG_DIFFERENCE && exp . X_add_symbol == NULL ) ! 3350: { ! 3351: as_warn( "Subtracting symbol \"%s\"(segment\"%s\") is too hard. Absolute segment assumed.", ! 3352: ! S_GET_NAME(exp.X_subtract_symbol), ! 3353: ! segment_name((int)SEG_seg(S_GET_SEGMENT(exp.X_subtract_symbol)))); ! 3354: segment = SEG_ABSOLUTE; ! 3355: /* Leave exp . X_add_number alone. */ ! 3356: } ! 3357: *************** ! 3358: *** 1929,1936 **** ! 3359: if ( (retval = get_segmented_expression (expP)) == SEG_UNKNOWN ! 3360: ) ! 3361: { ! 3362: ! name1 = expP -> X_add_symbol ? expP -> X_add_symbol -> sy_name : ""; ! 3363: ! name2 = expP -> X_subtract_symbol ? expP -> X_subtract_symbol -> sy_name : ""; ! 3364: if ( name1 && name2 ) ! 3365: { ! 3366: as_warn("Symbols \"%s\" \"%s\" are undefined: absolute 0 assumed.", ! 3367: --- 2321,2330 ---- ! 3368: if ( (retval = get_segmented_expression (expP)) == SEG_UNKNOWN ! 3369: ) ! 3370: { ! 3371: ! name1 = expP->X_add_symbol ? S_GET_NAME(expP->X_add_symbol) : ""; ! 3372: ! name2 = expP->X_subtract_symbol ? ! 3373: ! S_GET_NAME(expP->X_subtract_symbol) : ! 3374: ! ""; ! 3375: if ( name1 && name2 ) ! 3376: { ! 3377: as_warn("Symbols \"%s\" \"%s\" are undefined: absolute 0 assumed.", ! 3378: *************** ! 3379: *** 2064,2070 **** ! 3380: equals(sym_name) ! 3381: char *sym_name; ! 3382: { ! 3383: ! register struct symbol * symbolP; /* symbol we are working with */ ! 3384: ! 3385: if(sym_name[0]=='.' && sym_name[1]=='\0') { ! 3386: /* Turn '. = mumble' into a .org mumble */ ! 3387: --- 2458,2464 ---- ! 3388: equals(sym_name) ! 3389: char *sym_name; ! 3390: { ! 3391: ! register symbolS * symbolP; /* symbol we are working with */ ! 3392: ! 3393: if(sym_name[0]=='.' && sym_name[1]=='\0') { ! 3394: /* Turn '. = mumble' into a .org mumble */ ! 3395: *************** ! 3396: *** 2082,2088 **** ! 3397: if ( ! need_pass_2 ) { ! 3398: if (segment != now_seg && segment != SEG_ABSOLUTE) ! 3399: as_warn("Illegal segment \"%s\". Segment \"%s\" assumed.", ! 3400: ! seg_name [(int) segment], seg_name [(int) now_seg]); ! 3401: p = frag_var (rs_org, 1, 1, (relax_substateT)0, exp.X_add_symbol, ! 3402: exp.X_add_number, (char *)0); ! 3403: * p = 0; ! 3404: --- 2476,2483 ---- ! 3405: if ( ! need_pass_2 ) { ! 3406: if (segment != now_seg && segment != SEG_ABSOLUTE) ! 3407: as_warn("Illegal segment \"%s\". Segment \"%s\" assumed.", ! 3408: ! segment_name((int) segment), ! 3409: ! segment_name((int) now_seg)); ! 3410: p = frag_var (rs_org, 1, 1, (relax_substateT)0, exp.X_add_symbol, ! 3411: exp.X_add_number, (char *)0); ! 3412: * p = 0; ! 3413: *** /lasvegas/spare/usenet/work/gas-1.37.genuine/./struc-symbol.h Fri Jul 6 20:43:12 1990 ! 3414: --- ./struc-symbol.h Wed Nov 7 07:33:52 1990 ! 3415: *************** ! 3416: *** 17,31 **** ! 3417: along with GAS; see the file COPYING. If not, write to ! 3418: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ ! 3419: ! 3420: - #ifndef VMS ! 3421: - #include "a.out.gnu.h" /* Needed to define struct nlist. Sigh. */ ! 3422: - #else ! 3423: - #include "a_out.h" ! 3424: - #endif ! 3425: - ! 3426: struct symbol /* our version of an nlist node */ ! 3427: { ! 3428: ! struct nlist sy_nlist; /* what we write in .o file (if permitted) */ ! 3429: long unsigned sy_name_offset; /* 4-origin position of sy_name in symbols */ ! 3430: /* part of object file. */ ! 3431: /* 0 for (nameless) .stabd symbols. */ ! 3432: --- 17,25 ---- ! 3433: along with GAS; see the file COPYING. If not, write to ! 3434: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ ! 3435: ! 3436: struct symbol /* our version of an nlist node */ ! 3437: { ! 3438: ! symbol_type sy_symbol; /* what we write in .o file (if permitted) */ ! 3439: long unsigned sy_name_offset; /* 4-origin position of sy_name in symbols */ ! 3440: /* part of object file. */ ! 3441: /* 0 for (nameless) .stabd symbols. */ ! 3442: *************** ! 3443: *** 34,54 **** ! 3444: /* Symbol numbers start at 0 and are */ ! 3445: /* unsigned. */ ! 3446: struct symbol * sy_next; /* forward chain, or NULL */ ! 3447: struct frag * sy_frag; /* NULL or -> frag this symbol attaches to. */ ! 3448: struct symbol *sy_forward; /* value is really that of this other symbol */ ! 3449: }; ! 3450: ! 3451: typedef struct symbol symbolS; ! 3452: ! 3453: ! #define sy_name sy_nlist .n_un. n_name ! 3454: /* Name field always points to a string. */ ! 3455: /* 0 means .stabd-like anonymous symbol. */ ! 3456: ! #define sy_type sy_nlist. n_type ! 3457: ! #define sy_other sy_nlist. n_other ! 3458: ! #define sy_desc sy_nlist. n_desc ! 3459: ! #define sy_value sy_nlist. n_value ! 3460: /* Value of symbol is this value + object */ ! 3461: /* file address of sy_frag. */ ! 3462: ! 3463: typedef unsigned valueT; /* The type of n_value. Helps casting. */ ! 3464: ! 3465: --- 28,71 ---- ! 3466: /* Symbol numbers start at 0 and are */ ! 3467: /* unsigned. */ ! 3468: struct symbol * sy_next; /* forward chain, or NULL */ ! 3469: + #ifdef coff ! 3470: + struct symbol * sy_previous; /* backward chain, or NULL */ ! 3471: + #endif /* coff */ ! 3472: struct frag * sy_frag; /* NULL or -> frag this symbol attaches to. */ ! 3473: struct symbol *sy_forward; /* value is really that of this other symbol */ ! 3474: + #ifdef coff ! 3475: + unsigned int sy_flags; /* Internal use only flags (see coff.h) */ ! 3476: + AUXENT sy_auxent; /* Auxiliary entry. */ ! 3477: + #endif /* coff */ ! 3478: }; ! 3479: ! 3480: typedef struct symbol symbolS; ! 3481: ! 3482: ! #ifdef coff ! 3483: ! ! 3484: ! #define sy_name sy_symbol.n_name /* Symbol name */ ! 3485: ! #define sy_zeroes sy_symbol.n_zeroes /* All 0 if pointer to str. */ ! 3486: ! #define sy_offset sy_symbol.n_offset /* Offset in string table */ ! 3487: ! #define sy_value sy_symbol.n_value /* Symbol 0 or ptr in file */ ! 3488: ! #define sy_scnum sy_symbol.n_scnum /* Section number */ ! 3489: ! #define sy_type sy_symbol.n_type /* Type and derived type */ ! 3490: ! #define sy_sclass sy_symbol.n_sclass /* Storage class */ ! 3491: ! #define sy_numaux sy_symbol.n_numaux /* Number of aux. entries */ ! 3492: ! ! 3493: ! #else /* coff */ ! 3494: ! ! 3495: ! #define sy_name sy_symbol.n_un.n_name ! 3496: /* Name field always points to a string. */ ! 3497: /* 0 means .stabd-like anonymous symbol. */ ! 3498: ! #define sy_strx sy_symbol.n_un.n_strx ! 3499: ! #define sy_type sy_symbol.n_type ! 3500: ! #define sy_other sy_symbol.n_other ! 3501: ! #define sy_desc sy_symbol.n_desc ! 3502: ! #define sy_value sy_symbol.n_value ! 3503: /* Value of symbol is this value + object */ ! 3504: /* file address of sy_frag. */ ! 3505: + ! 3506: + #endif /* coff */ ! 3507: ! 3508: typedef unsigned valueT; /* The type of n_value. Helps casting. */ ! 3509: ! 3510: *** /lasvegas/spare/usenet/work/gas-1.37.genuine/./subsegs.c Thu Oct 11 18:26:23 1990 ! 3511: --- ./subsegs.c Wed Nov 7 07:33:53 1990 ! 3512: *************** ! 3513: *** 21,26 **** ! 3514: --- 21,27 ---- ! 3515: * Segments & sub-segments. ! 3516: */ ! 3517: ! 3518: + #include "oformat.h" ! 3519: #include "as.h" ! 3520: #include "subsegs.h" ! 3521: #include "obstack.h" ! 3522: *************** ! 3523: *** 33,38 **** ! 3524: --- 34,93 ---- ! 3525: * data0_frchainP; ! 3526: ! 3527: ! 3528: + #ifdef coff ! 3529: + const int /* in: segT out: N_TYPE bits */ ! 3530: + seg_N_TYPE[] = { ! 3531: + C_ABS_SECTION, ! 3532: + C_TEXT_SECTION, ! 3533: + C_DATA_SECTION, ! 3534: + C_BSS_SECTION, ! 3535: + C_UNDEF_SECTION, /* SEG_UNKNOWN */ ! 3536: + C_UNDEF_SECTION, /* SEG_NONE */ ! 3537: + C_UNDEF_SECTION, /* SEG_PASS1 */ ! 3538: + C_UNDEF_SECTION, /* SEG_GOOF */ ! 3539: + C_UNDEF_SECTION, /* SEG_BIG */ ! 3540: + C_UNDEF_SECTION, /* SEG_DIFFERENCE */ ! 3541: + C_DEBUG_SECTION, /* SEG_DEBUG */ ! 3542: + C_NTV_SECTION, /* SEG_NTV */ ! 3543: + C_PTV_SECTION, /* SEG_PTV */ ! 3544: + }; ! 3545: + ! 3546: + ! 3547: + char * const /* in: segT out: char* */ ! 3548: + seg_name[] = { ! 3549: + "absolute", ! 3550: + "text", ! 3551: + "data", ! 3552: + "bss", ! 3553: + "unknown", ! 3554: + "absent", ! 3555: + "pass1", ! 3556: + "ASSEMBLER-INTERNAL-LOGIC-ERROR!", ! 3557: + "bignum/flonum", ! 3558: + "difference", ! 3559: + "debug", ! 3560: + "transfert vector preload", ! 3561: + "transfert vector postload", ! 3562: + "" ! 3563: + }; /* Used by error reporters, dumpers etc. */ ! 3564: + ! 3565: + /* Add 4 to the real value to get the index and compensate the negatives */ ! 3566: + ! 3567: + const segT N_TYPE_seg [32] = ! 3568: + { ! 3569: + SEG_PTV, /* C_PTV_SECTION == -4 */ ! 3570: + SEG_NTV, /* C_NTV_SECTION == -3 */ ! 3571: + SEG_DEBUG, /* C_DEBUG_SECTION == -2 */ ! 3572: + SEG_ABSOLUTE, /* C_ABS_SECTION == -1 */ ! 3573: + SEG_UNKNOWN, /* C_UNDEF_SECTION == 0 */ ! 3574: + SEG_TEXT, /* C_TEXT_SECTION == 1 */ ! 3575: + SEG_DATA, /* C_DATA_SECTION == 2 */ ! 3576: + SEG_BSS, /* C_BSS_SECTION == 3 */ ! 3577: + SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF, ! 3578: + SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF, ! 3579: + SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF ! 3580: + }; ! 3581: + #else /* coff */ ! 3582: const int /* in: segT out: N_TYPE bits */ ! 3583: seg_N_TYPE[] = { ! 3584: N_ABS, ! 3585: *************** ! 3586: *** 78,83 **** ! 3587: --- 133,139 ---- ! 3588: SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, ! 3589: SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF ! 3590: }; ! 3591: + #endif /* coff */ ! 3592: ! 3593: void ! 3594: subsegs_begin() ! 3595: *** /lasvegas/spare/usenet/work/gas-1.37.genuine/./symbols.c Thu Oct 18 22:01:13 1990 ! 3596: --- ./symbols.c Wed Nov 7 07:33:55 1990 ! 3597: *************** ! 3598: *** 18,23 **** ! 3599: --- 18,24 ---- ! 3600: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ ! 3601: ! 3602: ! 3603: + #include "oformat.h" ! 3604: #include "as.h" ! 3605: #include "hash.h" ! 3606: #include "obstack.h" /* For "symbols.h" */ ! 3607: *************** ! 3608: *** 41,46 **** ! 3609: --- 42,52 ---- ! 3610: symbolS * symbol_rootP; ! 3611: symbolS * symbol_lastP; ! 3612: symbolS abs_symbol; ! 3613: + ! 3614: + symbolS* dot_text_symbol; ! 3615: + symbolS* dot_data_symbol; ! 3616: + symbolS* dot_bss_symbol; ! 3617: + ! 3618: struct obstack notes; ! 3619: ! 3620: ! 3621: *************** ! 3622: *** 87,93 **** ! 3623: symbol_rootP = NULL; /* In case we have 0 symbols (!!) */ ! 3624: sy_hash = hash_new(); ! 3625: bzero ((char *)(& abs_symbol), sizeof(abs_symbol)); ! 3626: ! abs_symbol . sy_type = N_ABS; /* Can't initialise a union. Sigh. */ ! 3627: bzero ((char *)(local_label_counter), sizeof(local_label_counter) ); ! 3628: local_bss_counter = 0; ! 3629: } ! 3630: --- 93,99 ---- ! 3631: symbol_rootP = NULL; /* In case we have 0 symbols (!!) */ ! 3632: sy_hash = hash_new(); ! 3633: bzero ((char *)(& abs_symbol), sizeof(abs_symbol)); ! 3634: ! S_SET_ABS(&abs_symbol); /* Can't initialise a union. Sigh. */ ! 3635: bzero ((char *)(local_label_counter), sizeof(local_label_counter) ); ! 3636: local_bss_counter = 0; ! 3637: } ! 3638: *************** ! 3639: *** 160,165 **** ! 3640: --- 166,239 ---- ! 3641: * Changes since 1985: Symbol names may not contain '\0'. Sigh. ! 3642: */ ! 3643: ! 3644: + #ifdef coff ! 3645: + ! 3646: + symbolS * ! 3647: + symbol_new (name, segment, value, sclass, frag) ! 3648: + char* name; /* It is copied, the caller can destroy/modify */ ! 3649: + segT segment;/* Segment identifier (SEG_<something>) */ ! 3650: + long value; /* Symbol value */ ! 3651: + short sclass; /* Symbol storage class */ ! 3652: + fragS* frag; /* Associated fragment */ ! 3653: + { ! 3654: + register unsigned int name_length; ! 3655: + register char* name_copy; ! 3656: + register symbolS* symbolP; ! 3657: + register char underscore = 0; /* Symbol has leading _ */ ! 3658: + ! 3659: + #if STRIP_UNDERSCORE ! 3660: + /* Remove leading underscore at the beginning of the symbol. ! 3661: + * This is to be compatible with the standard librairies. ! 3662: + */ ! 3663: + if(*name == '_') { ! 3664: + underscore = 1; ! 3665: + name++; ! 3666: + } else ! 3667: + underscore = 0; ! 3668: + #endif /* STRIP_UNDERSCORE */ ! 3669: + name_length = strlen(name) + 1; /* +1 for \0 */ ! 3670: + obstack_grow(¬es, name, name_length); ! 3671: + name_copy = obstack_finish(¬es); ! 3672: + symbolP = (symbolS *)obstack_alloc(¬es, sizeof(symbolS)); ! 3673: + ! 3674: + /* Effective symbol */ ! 3675: + /* Store the pointer in the offset. */ ! 3676: + symbolP->sy_offset = (long unsigned)name_copy; ! 3677: + symbolP->sy_zeroes = 0L; ! 3678: + symbolP->sy_value = value; ! 3679: + symbolP->sy_scnum = seg_SEG(segment); ! 3680: + symbolP->sy_type = T_NULL; ! 3681: + symbolP->sy_sclass = sclass; ! 3682: + symbolP->sy_numaux = 0; ! 3683: + /* Additional information */ ! 3684: + symbolP->sy_next = NULL; ! 3685: + symbolP->sy_frag = frag; ! 3686: + symbolP->sy_forward = NULL; ! 3687: + symbolP->sy_name_offset = ~0; ! 3688: + symbolP->sy_number = ~0; ! 3689: + symbolP->sy_flags = 0; ! 3690: + /* Auxiliary entries */ ! 3691: + memset((char*)&symbolP->sy_auxent, '\0', AUXESZ); ! 3692: + ! 3693: + if(S_IS_STRING(symbolP)) ! 3694: + SF_SET_STRING(symbolP); ! 3695: + if(!underscore && S_IS_LOCAL(symbolP)) ! 3696: + SF_SET_LOCAL(symbolP); ! 3697: + /* ! 3698: + * Link to end of symbol chain . ! 3699: + */ ! 3700: + if (symbol_lastP) { ! 3701: + DL_APPEND(symbolP, symbol_lastP); ! 3702: + } else { ! 3703: + symbol_rootP = symbolP; ! 3704: + } ! 3705: + symbol_lastP = symbolP; ! 3706: + ! 3707: + return (symbolP); ! 3708: + } ! 3709: + ! 3710: + #else /* coff */ ! 3711: + ! 3712: symbolS * ! 3713: symbol_new (name, type, other, desc, value, frag) ! 3714: char * name; /* We copy this: OK to alter your copy. */ ! 3715: *************** ! 3716: *** 168,174 **** ! 3717: short int desc; /* As in <a.out.h>. */ ! 3718: valueT value; /* As in <a.out.h>, often an address. */ ! 3719: /* Often used as offset from frag address. */ ! 3720: ! struct frag * frag; /* For sy_frag. */ ! 3721: { ! 3722: register symbolS * symbolP; ! 3723: register char * preserved_copy_of_name; ! 3724: --- 242,248 ---- ! 3725: short int desc; /* As in <a.out.h>. */ ! 3726: valueT value; /* As in <a.out.h>, often an address. */ ! 3727: /* Often used as offset from frag address. */ ! 3728: ! fragS* frag; /* For sy_frag. */ ! 3729: { ! 3730: register symbolS * symbolP; ! 3731: register char * preserved_copy_of_name; ! 3732: *************** ! 3733: *** 180,187 **** ! 3734: p=obstack_finish(¬es); ! 3735: /* obstack_1done( ¬es, name, name_length, &p ); */ ! 3736: preserved_copy_of_name = p; ! 3737: ! p=obstack_alloc(¬es,sizeof(struct symbol)); ! 3738: ! /* obstack_1blank( ¬es, sizeof(struct symbol), &p ); */ ! 3739: symbolP = (symbolS *) p; ! 3740: symbolP -> sy_name = preserved_copy_of_name; ! 3741: symbolP -> sy_type = type; ! 3742: --- 254,261 ---- ! 3743: p=obstack_finish(¬es); ! 3744: /* obstack_1done( ¬es, name, name_length, &p ); */ ! 3745: preserved_copy_of_name = p; ! 3746: ! p=obstack_alloc(¬es,sizeof(symbolS)); ! 3747: ! /* obstack_1blank( ¬es, sizeof(symbolS), &p ); */ ! 3748: symbolP = (symbolS *) p; ! 3749: symbolP -> sy_name = preserved_copy_of_name; ! 3750: symbolP -> sy_type = type; ! 3751: *************** ! 3752: *** 210,215 **** ! 3753: --- 284,291 ---- ! 3754: ! 3755: return (symbolP); ! 3756: } ! 3757: + ! 3758: + #endif /* coff */ ! 3759: ! 3760: /* ! 3761: * colon() ! 3762: *************** ! 3763: *** 225,231 **** ! 3764: register char * sym_name; /* symbol name, as a cannonical string */ ! 3765: /* We copy this string: OK to alter later. */ ! 3766: { ! 3767: ! register struct symbol * symbolP; /* symbol we are working with */ ! 3768: ! 3769: #ifdef SUN_ASM_SYNTAX ! 3770: /* Sun local labes go out of scope whenever a non-local symbol is ! 3771: --- 301,307 ---- ! 3772: register char * sym_name; /* symbol name, as a cannonical string */ ! 3773: /* We copy this string: OK to alter later. */ ! 3774: { ! 3775: ! register symbolS * symbolP; /* symbol we are working with */ ! 3776: ! 3777: #ifdef SUN_ASM_SYNTAX ! 3778: /* Sun local labes go out of scope whenever a non-local symbol is ! 3779: *************** ! 3780: *** 267,273 **** ! 3781: * If the new symbol is .comm AND it has a size of zero, ! 3782: * we ignore it (i.e. the old symbol overrides it) ! 3783: */ ! 3784: ! if ((seg_N_TYPE [(int) now_seg] == (N_UNDF | N_EXT)) && ! 3785: ((obstack_next_free(& frags) - frag_now -> fr_literal) == 0)) ! 3786: return; ! 3787: /* ! 3788: --- 343,349 ---- ! 3789: * If the new symbol is .comm AND it has a size of zero, ! 3790: * we ignore it (i.e. the old symbol overrides it) ! 3791: */ ! 3792: ! if ((seg_SEG((int) now_seg) == (N_UNDF | N_EXT)) && ! 3793: ((obstack_next_free(& frags) - frag_now -> fr_literal) == 0)) ! 3794: return; ! 3795: /* ! 3796: *************** ! 3797: *** 279,285 **** ! 3798: symbolP -> sy_frag = frag_now; ! 3799: symbolP -> sy_other = const_flag; ! 3800: symbolP -> sy_value = obstack_next_free(& frags) - frag_now -> fr_literal; ! 3801: ! symbolP -> sy_type |= seg_N_TYPE [(int) now_seg]; /* keep N_EXT bit */ ! 3802: return; ! 3803: } ! 3804: #endif /* VMS */ ! 3805: --- 355,361 ---- ! 3806: symbolP -> sy_frag = frag_now; ! 3807: symbolP -> sy_other = const_flag; ! 3808: symbolP -> sy_value = obstack_next_free(& frags) - frag_now -> fr_literal; ! 3809: ! symbolP -> sy_type |= seg_SEG((int) now_seg); /* keep N_EXT bit */ ! 3810: return; ! 3811: } ! 3812: #endif /* VMS */ ! 3813: *************** ! 3814: *** 286,304 **** ! 3815: /* ! 3816: * Now check for undefined symbols ! 3817: */ ! 3818: ! if ((symbolP -> sy_type & N_TYPE) == N_UNDF) ! 3819: { ! 3820: ! if( symbolP -> sy_other == 0 ! 3821: ! && symbolP -> sy_desc == 0 ! 3822: ! && symbolP -> sy_value == 0) ! 3823: { ! 3824: symbolP -> sy_frag = frag_now; ! 3825: #ifdef VMS ! 3826: symbolP -> sy_other = const_flag; ! 3827: #endif ! 3828: ! symbolP -> sy_value = obstack_next_free(& frags) - frag_now -> fr_literal; ! 3829: ! know( N_UNDF == 0 ); ! 3830: ! symbolP -> sy_type |= seg_N_TYPE [(int) now_seg]; /* keep N_EXT bit */ ! 3831: } ! 3832: else ! 3833: { ! 3834: --- 362,388 ---- ! 3835: /* ! 3836: * Now check for undefined symbols ! 3837: */ ! 3838: ! if (!S_IS_DEFINED(symbolP)) ! 3839: { ! 3840: ! if( ! 3841: ! #ifdef aout ! 3842: ! S_GET_OTHER(symbolP) == 0 && ! 3843: ! S_GET_DESC(symbolP) == 0 && ! 3844: ! #endif /* aout */ ! 3845: ! S_GET_VALUE(symbolP) == 0) ! 3846: { ! 3847: symbolP -> sy_frag = frag_now; ! 3848: #ifdef VMS ! 3849: symbolP -> sy_other = const_flag; ! 3850: #endif ! 3851: ! S_SET_VALUE(symbolP, obstack_next_free(& frags) - ! 3852: ! frag_now -> fr_literal); ! 3853: ! switch(now_seg) { ! 3854: ! case SEG_TEXT: S_SET_TEXT(symbolP); break; ! 3855: ! case SEG_DATA: S_SET_DATA(symbolP); break; ! 3856: ! case SEG_BSS: S_SET_BSS(symbolP); break; ! 3857: ! case SEG_ABSOLUTE: S_SET_ABS(symbolP); break; ! 3858: ! } ! 3859: } ! 3860: else ! 3861: { ! 3862: *************** ! 3863: *** 310,316 **** ! 3864: * A .comm/.lcomm symbol being redefined with ! 3865: * a larger size is also OK ! 3866: */ ! 3867: ! char New_Type = seg_N_TYPE [(int) now_seg]; ! 3868: if (((symbolP->sy_type == (N_UNDF | N_EXT)) || ! 3869: (symbolP->sy_type == N_BSS)) && ! 3870: (((New_Type & ~N_EXT) == N_DATA) || ! 3871: --- 394,400 ---- ! 3872: * A .comm/.lcomm symbol being redefined with ! 3873: * a larger size is also OK ! 3874: */ ! 3875: ! char New_Type = seg_SEG((int) now_seg); ! 3876: if (((symbolP->sy_type == (N_UNDF | N_EXT)) || ! 3877: (symbolP->sy_type == N_BSS)) && ! 3878: (((New_Type & ~N_EXT) == N_DATA) || ! 3879: *************** ! 3880: *** 339,353 **** ! 3881: symbolP -> sy_frag = frag_now; ! 3882: symbolP -> sy_other = const_flag; ! 3883: symbolP -> sy_value = obstack_next_free(& frags) - frag_now -> fr_literal; ! 3884: ! symbolP -> sy_type |= seg_N_TYPE [(int) now_seg]; /* keep N_EXT bit */ ! 3885: } ! 3886: } else { ! 3887: #endif /* VMS */ ! 3888: as_fatal( "Symbol \"%s\" is already defined as \"%s\"/%d.%d.%d.", ! 3889: sym_name, ! 3890: ! seg_name [(int) N_TYPE_seg [symbolP -> sy_type & N_TYPE]], ! 3891: ! symbolP -> sy_other, symbolP -> sy_desc, ! 3892: ! symbolP -> sy_value); ! 3893: #ifdef VMS ! 3894: } ! 3895: #endif /* VMS */ ! 3896: --- 423,444 ---- ! 3897: symbolP -> sy_frag = frag_now; ! 3898: symbolP -> sy_other = const_flag; ! 3899: symbolP -> sy_value = obstack_next_free(& frags) - frag_now -> fr_literal; ! 3900: ! symbolP -> sy_type |= seg_SEG((int) now_seg); /* keep N_EXT bit */ ! 3901: } ! 3902: } else { ! 3903: #endif /* VMS */ ! 3904: + #ifdef coff ! 3905: + as_fatal( "Symbol \"%s\" is already defined as \"%s\"/%d.", ! 3906: + sym_name, ! 3907: + segment_name((int)SEG_seg(S_GET_SEGMENT(symbolP))), ! 3908: + S_GET_VALUE(symbolP)); ! 3909: + #else /* coff */ ! 3910: as_fatal( "Symbol \"%s\" is already defined as \"%s\"/%d.%d.%d.", ! 3911: sym_name, ! 3912: ! segment_name((int)SEG_seg(S_GET_SEGMENT(symbolP))), ! 3913: ! S_GET_OTHER(symbolP), S_GET_DESC(symbolP), ! 3914: ! S_GET_VALUE(symbolP)); ! 3915: ! #endif /* coff */ ! 3916: #ifdef VMS ! 3917: } ! 3918: #endif /* VMS */ ! 3919: *************** ! 3920: *** 360,367 **** ! 3921: } ! 3922: else ! 3923: { ! 3924: symbolP = symbol_new (sym_name, ! 3925: ! (unsigned char)(seg_N_TYPE [(int) now_seg]), ! 3926: #ifdef VMS ! 3927: const_flag, ! 3928: #else ! 3929: --- 451,463 ---- ! 3930: } ! 3931: else ! 3932: { ! 3933: + #ifdef coff ! 3934: + symbolP = symbol_new (sym_name, now_seg, ! 3935: + (valueT)(obstack_next_free(&frags)-frag_now->fr_literal), ! 3936: + 0, frag_now); ! 3937: + #else /* coff */ ! 3938: symbolP = symbol_new (sym_name, ! 3939: ! (unsigned char)(seg_SEG((int) now_seg)), ! 3940: #ifdef VMS ! 3941: const_flag, ! 3942: #else ! 3943: *************** ! 3944: *** 370,375 **** ! 3945: --- 466,472 ---- ! 3946: 0, ! 3947: (valueT)(obstack_next_free(&frags)-frag_now->fr_literal), ! 3948: frag_now); ! 3949: + #endif /* coff */ ! 3950: symbol_table_insert (symbolP); ! 3951: } ! 3952: } ! 3953: *************** ! 3954: *** 384,399 **** ! 3955: ! 3956: void ! 3957: symbol_table_insert (symbolP) ! 3958: ! struct symbol * symbolP; ! 3959: { ! 3960: register char * error_string; ! 3961: ! 3962: ! know( symbolP ); ! 3963: ! know( symbolP -> sy_name ); ! 3964: ! if ( * (error_string = hash_jam (sy_hash, symbolP -> sy_name, (char *)symbolP))) ! 3965: { ! 3966: as_fatal( "Inserting \"%s\" into symbol table failed: %s", ! 3967: ! symbolP -> sy_name, error_string); ! 3968: } ! 3969: } ! 3970: ! 3971: --- 481,498 ---- ! 3972: ! 3973: void ! 3974: symbol_table_insert (symbolP) ! 3975: ! symbolS * symbolP; ! 3976: { ! 3977: register char * error_string; ! 3978: ! 3979: ! know(symbolP); ! 3980: ! know(S_GET_NAME(symbolP)); ! 3981: ! ! 3982: ! if ( * (error_string = hash_jam (sy_hash, S_GET_NAME(symbolP), ! 3983: ! (char *)symbolP))) ! 3984: { ! 3985: as_fatal( "Inserting \"%s\" into symbol table failed: %s", ! 3986: ! S_GET_NAME(symbolP), error_string); ! 3987: } ! 3988: } ! 3989: ! 3990: *************** ! 3991: *** 404,421 **** ! 3992: * it into the symbol table. Return a pointer to it. ! 3993: */ ! 3994: symbolS * ! 3995: ! symbol_find_or_make (name) ! 3996: ! char * name; ! 3997: { ! 3998: ! register symbolS * symbolP; ! 3999: ! 4000: ! symbolP = symbol_table_lookup (name); ! 4001: ! if (symbolP == NULL) ! 4002: ! { ! 4003: ! symbolP = symbol_new (name, N_UNDF, 0, 0, 0, & zero_address_frag); ! 4004: ! symbol_table_insert (symbolP); ! 4005: ! } ! 4006: ! return (symbolP); ! 4007: } ! 4008: ! 4009: /* ! 4010: --- 503,525 ---- ! 4011: * it into the symbol table. Return a pointer to it. ! 4012: */ ! 4013: symbolS * ! 4014: ! symbol_find_or_make (name) ! 4015: ! char * name; ! 4016: { ! 4017: ! register symbolS * symbolP; ! 4018: ! 4019: ! symbolP = symbol_table_lookup (name); ! 4020: ! ! 4021: ! if (symbolP == NULL) ! 4022: ! { ! 4023: ! #ifdef coff ! 4024: ! symbolP = symbol_new (name, SEG_UNKNOWN, 0, 0, &zero_address_frag); ! 4025: ! #else /* coff */ ! 4026: ! symbolP = symbol_new (name, N_UNDF, 0, 0, 0, & zero_address_frag); ! 4027: ! #endif /* coff */ ! 4028: ! symbol_table_insert (symbolP); ! 4029: ! } ! 4030: ! return (symbolP); ! 4031: } ! 4032: ! 4033: /* ! 4034: *************** ! 4035: *** 429,438 **** ! 4036: ! 4037: symbolS * ! 4038: symbol_find (name) ! 4039: ! char * name; ! 4040: { ! 4041: ! return ( (symbolS *) hash_find( sy_hash, name )); ! 4042: } ! 4043: ! 4044: ! 4045: /* end: symbols.c */ ! 4046: --- 533,550 ---- ! 4047: ! 4048: symbolS * ! 4049: symbol_find (name) ! 4050: ! char* name; ! 4051: { ! 4052: ! return symbol_find_base(name, STRIP_UNDERSCORE); ! 4053: } ! 4054: ! 4055: + symbolS * ! 4056: + symbol_find_base (name, strip_underscore) ! 4057: + char * name; ! 4058: + int strip_underscore; ! 4059: + { ! 4060: + if(strip_underscore && *name == '_') name++; ! 4061: + return ( (symbolS *) hash_find( sy_hash, name )); ! 4062: + } ! 4063: ! 4064: /* end: symbols.c */ ! 4065: *** /lasvegas/spare/usenet/work/gas-1.37.genuine/./symbols.h Wed Mar 1 23:48:43 1989 ! 4066: --- ./symbols.h Wed Nov 7 07:33:56 1990 ! 4067: *************** ! 4068: *** 30,36 **** ! 4069: --- 30,41 ---- ! 4070: ! 4071: extern symbolS abs_symbol; ! 4072: ! 4073: + extern symbolS* dot_text_symbol; ! 4074: + extern symbolS* dot_data_symbol; ! 4075: + extern symbolS* dot_bss_symbol; ! 4076: + ! 4077: symbolS * symbol_find(); ! 4078: + symbolS * symbol_find_base(); ! 4079: void symbol_begin(); ! 4080: char * local_label_name(); ! 4081: void local_colon(); ! 4082: *** /lasvegas/spare/usenet/work/gas-1.37.genuine/./write.c Thu Oct 11 18:26:15 1990 ! 4083: --- ./write.c Wed Nov 7 07:41:02 1990 ! 4084: *************** ! 4085: *** 30,35 **** ! 4086: --- 30,36 ---- ! 4087: trouble. ! 4088: */ ! 4089: ! 4090: + #include "oformat.h" ! 4091: #include "as.h" ! 4092: #include "md.h" ! 4093: #include "subsegs.h" ! 4094: *************** ! 4095: *** 37,42 **** ! 4096: --- 38,47 ---- ! 4097: #include "struc-symbol.h" ! 4098: #include "write.h" ! 4099: #include "symbols.h" ! 4100: + #include "append.h" ! 4101: + #ifdef coff ! 4102: + #include <sys/types.h> ! 4103: + #endif /* coff */ ! 4104: ! 4105: #ifdef SPARC ! 4106: #include "sparc.h" ! 4107: *************** ! 4108: *** 45,74 **** ! 4109: #include "i860.h" ! 4110: #endif ! 4111: ! 4112: - void append(); ! 4113: - ! 4114: #ifdef hpux ! 4115: #define EXEC_MACHINE_TYPE HP9000S200_ID ! 4116: #endif ! 4117: ! 4118: ! #ifdef DOT_LABEL_PREFIX ! 4119: ! #define LOCAL_LABEL(name) (name[0] =='.' \ ! 4120: ! && ( name [1] == 'L' || name [1] == '.' )) ! 4121: ! #else /* not defined DOT_LABEL_PREFIX */ ! 4122: ! #define LOCAL_LABEL(name) (name [0] == 'L' ) ! 4123: ! #endif /* not defined DOT_LABEL_PREFIX */ ! 4124: ! ! 4125: ! /* ! 4126: ! * In: length of relocation (or of address) in chars: 1, 2 or 4. ! 4127: ! * Out: GNU LD relocation length code: 0, 1, or 2. ! 4128: ! */ ! 4129: ! ! 4130: ! static unsigned char ! 4131: ! ! 4132: ! nbytes_r_length [] = { ! 4133: ! 42, 0, 1, 42, 2 ! 4134: ! }; ! 4135: ! ! 4136: ! 4137: static struct frag * text_frag_root; ! 4138: static struct frag * data_frag_root; ! 4139: --- 50,62 ---- ! 4140: #include "i860.h" ! 4141: #endif ! 4142: ! 4143: #ifdef hpux ! 4144: #define EXEC_MACHINE_TYPE HP9000S200_ID ! 4145: #endif ! 4146: ! 4147: ! #ifdef coff ! 4148: ! extern time_t time(); ! 4149: ! #endif /* coff */ ! 4150: ! 4151: static struct frag * text_frag_root; ! 4152: static struct frag * data_frag_root; ! 4153: *************** ! 4154: *** 76,94 **** ! 4155: static struct frag * text_last_frag; /* Last frag in segment. */ ! 4156: static struct frag * data_last_frag; /* Last frag in segment. */ ! 4157: ! 4158: ! static struct exec the_exec; ! 4159: ! 4160: static long int string_byte_count; ! 4161: ! 4162: static char * the_object_file; ! 4163: ! 4164: - #if !defined(SPARC) && !defined(I860) ! 4165: - static ! 4166: - #endif ! 4167: char * next_object_file_charP; /* Tracks object file bytes. */ ! 4168: ! 4169: - static long int size_of_the_object_file; /* # bytes in object file. */ ! 4170: - ! 4171: /* static long int length; JF unused */ /* String length, including trailing '\0'. */ ! 4172: ! 4173: static void relax_segment(); ! 4174: --- 64,77 ---- ! 4175: static struct frag * text_last_frag; /* Last frag in segment. */ ! 4176: static struct frag * data_last_frag; /* Last frag in segment. */ ! 4177: ! 4178: ! static object_headers headers; ! 4179: ! 4180: static long int string_byte_count; ! 4181: ! 4182: static char * the_object_file; ! 4183: ! 4184: char * next_object_file_charP; /* Tracks object file bytes. */ ! 4185: ! 4186: /* static long int length; JF unused */ /* String length, including trailing '\0'. */ ! 4187: ! 4188: static void relax_segment(); ! 4189: *************** ! 4190: *** 95,103 **** ! 4191: void emit_segment(); ! 4192: static relax_addressT relax_align(); ! 4193: static long int fixup_segment(); ! 4194: - #if !defined(SPARC) && !defined(I860) ! 4195: - static void emit_relocations(); ! 4196: - #endif ! 4197: /* ! 4198: * fix_new() ! 4199: * ! 4200: --- 78,83 ---- ! 4201: *************** ! 4202: *** 154,160 **** ! 4203: register struct frchain * next_frchainP; ! 4204: register fragS * * prev_fragPP; ! 4205: register char * name; ! 4206: ! register symbolS * symbolP; ! 4207: register symbolS ** symbolPP; ! 4208: /* register fixS * fixP; JF unused */ ! 4209: unsigned ! 4210: --- 134,140 ---- ! 4211: register struct frchain * next_frchainP; ! 4212: register fragS * * prev_fragPP; ! 4213: register char * name; ! 4214: ! symbolS * symbolP; ! 4215: register symbolS ** symbolPP; ! 4216: /* register fixS * fixP; JF unused */ ! 4217: unsigned ! 4218: *************** ! 4219: *** 163,168 **** ! 4220: --- 143,155 ---- ! 4221: syms_siz, ! 4222: tr_siz, ! 4223: dr_siz; ! 4224: + #ifdef coff ! 4225: + SCNHDR text_section_header; ! 4226: + SCNHDR data_section_header; ! 4227: + SCNHDR bss_section_header; ! 4228: + symbolS* last_functionP = (symbolS*)0; ! 4229: + symbolS* last_tagP; ! 4230: + #endif /* coff */ ! 4231: void output_file_create(); ! 4232: void output_file_append(); ! 4233: void output_file_close(); ! 4234: *************** ! 4235: *** 170,178 **** ! 4236: --- 157,171 ---- ! 4237: void gdb_emit(); ! 4238: void gdb_end(); ! 4239: #endif ! 4240: + long int object_file_size; ! 4241: extern long omagic; /* JF magic # to write out. Is different for ! 4242: Suns and Vaxen and other boxes */ ! 4243: ! 4244: + #ifdef coff ! 4245: + /* Initialize the stack used to keep track of the matching .bb .be */ ! 4246: + stack* block_stack = stack_init(512, sizeof(symbolS*)); ! 4247: + #endif /* coff */ ! 4248: + ! 4249: #ifdef VMS ! 4250: /* ! 4251: * Under VMS we try to be compatible with VAX-11 "C". Thus, we ! 4252: *************** ! 4253: *** 271,283 **** ! 4254: */ ! 4255: ! 4256: know( text_last_frag -> fr_type == rs_fill && text_last_frag -> fr_offset == 0 ); ! 4257: ! text_siz=text_last_frag->fr_address; ! 4258: #ifdef SPARC ! 4259: ! text_siz= (text_siz+7)&(~7); ! 4260: ! text_last_frag->fr_address=text_siz; ! 4261: #endif ! 4262: - md_number_to_chars((char *)&the_exec.a_text,text_siz, sizeof(the_exec.a_text)); ! 4263: - /* the_exec . a_text = text_last_frag -> fr_address; */ ! 4264: ! 4265: /* ! 4266: * Join the 2 segments into 1 huge segment. ! 4267: --- 264,275 ---- ! 4268: */ ! 4269: ! 4270: know( text_last_frag -> fr_type == rs_fill && text_last_frag -> fr_offset == 0 ); ! 4271: ! H_SET_TEXT_SIZE(&headers,text_last_frag->fr_address); ! 4272: #ifdef SPARC ! 4273: ! H_SET_TEXT_SIZE(&headers,H_GET_TEXT_SIZE(&headers) + ! 4274: ! (H_GET_TEXT_SIZE(&headers)+7)&(~7)); ! 4275: ! text_last_frag->fr_address=H_GET_TEXT_SIZE(&headers); ! 4276: #endif ! 4277: ! 4278: /* ! 4279: * Join the 2 segments into 1 huge segment. ! 4280: *************** ! 4281: *** 291,304 **** ! 4282: register relax_addressT slide; ! 4283: ! 4284: know( text_last_frag -> fr_type == rs_fill && text_last_frag -> fr_offset == 0 ); ! 4285: ! data_siz=data_last_frag->fr_address; ! 4286: #ifdef SPARC ! 4287: ! data_siz += (8 - (data_siz % 8)) % 8; ! 4288: ! data_last_frag->fr_address = data_siz; ! 4289: #endif ! 4290: ! md_number_to_chars((char *)&the_exec.a_data,data_siz,sizeof(the_exec.a_data)); ! 4291: ! /* the_exec . a_data = data_last_frag -> fr_address; */ ! 4292: ! slide = text_siz; /* Address in file of the data segment. */ ! 4293: for (fragP = data_frag_root; ! 4294: fragP; ! 4295: fragP = fragP -> fr_next) ! 4296: --- 283,295 ---- ! 4297: register relax_addressT slide; ! 4298: ! 4299: know( text_last_frag -> fr_type == rs_fill && text_last_frag -> fr_offset == 0 ); ! 4300: ! H_SET_DATA_SIZE(&headers,data_last_frag->fr_address); ! 4301: #ifdef SPARC ! 4302: ! H_SET_DATA_SIZE(&headers,(H_GET_DATA_SIZE(&headers) + ! 4303: ! (8 - (H_GET_DATA_SIZE(&headers) % 8)) % 8)); ! 4304: ! data_last_frag->fr_address = H_GET_DATA_SIZE(&headers); ! 4305: #endif ! 4306: ! slide = H_GET_TEXT_SIZE(&headers); /* & in file of the data segment. */ ! 4307: for (fragP = data_frag_root; ! 4308: fragP; ! 4309: fragP = fragP -> fr_next) ! 4310: *************** ! 4311: *** 308,324 **** ! 4312: know( text_last_frag ); ! 4313: text_last_frag -> fr_next = data_frag_root; ! 4314: } ! 4315: ! else { ! 4316: ! md_number_to_chars((char *)&the_exec.a_data,0,sizeof(the_exec.a_data)); ! 4317: ! data_siz = 0; ! 4318: ! } ! 4319: ! 4320: ! bss_address_frag . fr_address = text_siz + data_siz; ! 4321: #ifdef SPARC ! 4322: local_bss_counter=(local_bss_counter+7)&(~7); ! 4323: #endif ! 4324: ! md_number_to_chars((char *)&the_exec.a_bss,local_bss_counter,sizeof(the_exec.a_bss)); ! 4325: ! ! 4326: ! 4327: /* ! 4328: * ! 4329: --- 299,313 ---- ! 4330: know( text_last_frag ); ! 4331: text_last_frag -> fr_next = data_frag_root; ! 4332: } ! 4333: ! else ! 4334: ! H_SET_DATA_SIZE(&headers,0); ! 4335: ! 4336: ! bss_address_frag . fr_address = H_GET_TEXT_SIZE(&headers) + ! 4337: ! H_GET_DATA_SIZE(&headers); ! 4338: #ifdef SPARC ! 4339: local_bss_counter=(local_bss_counter+7)&(~7); ! 4340: #endif ! 4341: ! H_SET_BSS_SIZE(&headers,local_bss_counter); ! 4342: ! 4343: /* ! 4344: * ! 4345: *************** ! 4346: *** 347,390 **** ! 4347: for(symbolP=symbol_rootP;symbolP;symbolP=symbolP->sy_next) { ! 4348: if(symbolP->sy_forward) { ! 4349: symbolP->sy_value+=symbolP->sy_forward->sy_value+symbolP->sy_forward->sy_frag->fr_address; ! 4350: symbolP->sy_forward=0; ! 4351: } ! 4352: } ! 4353: ! symbolPP = & symbol_rootP; /* -> last symbol chain link. */ ! 4354: { ! 4355: ! register long int symbol_number; ! 4356: ! 4357: ! symbol_number = 0; ! 4358: while (symbolP = * symbolPP) ! 4359: { ! 4360: ! name = symbolP -> sy_name; ! 4361: ! if(flagseen['R'] && (symbolP->sy_nlist.n_type&N_DATA)) { ! 4362: ! symbolP->sy_nlist.n_type&= ~N_DATA; ! 4363: ! symbolP->sy_nlist.n_type|= N_TEXT; ! 4364: ! } ! 4365: ! /* if(symbolP->sy_forward) { ! 4366: ! symbolP->sy_value += symbolP->sy_forward->sy_value + symbolP->sy_forward->sy_frag->fr_address; ! 4367: ! } */ ! 4368: ! 4369: symbolP -> sy_value += symbolP -> sy_frag -> fr_address; ! 4370: - /* JF the 128 bit is a hack so stabs like ! 4371: - "LET_STMT:23. . ." don't go away */ ! 4372: - /* CPH: 128 bit hack is moby loser. N_SO for file "Lower.c" ! 4373: - fell through the cracks. I think that N_STAB should be ! 4374: - used instead of 128. */ ! 4375: /* JF the \001 bit is to make sure that local labels ! 4376: ( 1: - 9: don't make it into the symtable either */ ! 4377: #ifndef VMS /* Under VMS we need to keep local symbols */ ! 4378: ! if ( !name || (symbolP->sy_nlist.n_type&N_STAB) ! 4379: ! || (name[2]!='\001' && (flagseen ['L'] || ! LOCAL_LABEL(name) ))) ! 4380: #endif /* not VMS */ ! 4381: { ! 4382: - symbolP -> sy_number = symbol_number ++; ! 4383: #ifndef VMS ! 4384: ! if (name) ! 4385: { /* Ordinary case. */ ! 4386: symbolP -> sy_name_offset = string_byte_count; ! 4387: ! string_byte_count += strlen (symbolP -> sy_name) + 1; ! 4388: } ! 4389: else /* .Stabd case. */ ! 4390: #endif /* not VMS */ ! 4391: --- 336,582 ---- ! 4392: for(symbolP=symbol_rootP;symbolP;symbolP=symbolP->sy_next) { ! 4393: if(symbolP->sy_forward) { ! 4394: symbolP->sy_value+=symbolP->sy_forward->sy_value+symbolP->sy_forward->sy_frag->fr_address; ! 4395: + #ifdef coff ! 4396: + if(SF_GET_GET_SEGMENT(symbolP) && ! 4397: + S_GET_SEGMENT(symbolP) == seg_SEG(SEG_UNKNOWN)) ! 4398: + S_SET_SEGMENT(symbolP, S_GET_SEGMENT(symbolP->sy_forward)); ! 4399: + #endif /* coff */ ! 4400: symbolP->sy_forward=0; ! 4401: } ! 4402: } ! 4403: ! ! 4404: { ! 4405: ! register int symbol_number = 0; ! 4406: ! #if defined(coff) ! 4407: ! symbolS* symbol_externP = (symbolS*)0; ! 4408: ! symbolS* symbol_extern_lastP = (symbolS*)0; ! 4409: ! ! 4410: ! /* The symbol list should be ordered according to the following sequence ! 4411: ! * order : ! 4412: ! * . .file symbol ! 4413: ! * . debug entries for functions ! 4414: ! * . fake symbols for .text .data and .bss ! 4415: ! * . defined symbols ! 4416: ! * . undefined symbols ! 4417: ! * But this is not mandatory. The only important point is to put the ! 4418: ! * undefined symbols at the end of the list. ! 4419: ! */ ! 4420: ! ! 4421: ! { ! 4422: ! /* Is there a .file symbol ? If not insert one at the beginning. */ ! 4423: ! if(symbol_rootP == NULL || ! 4424: ! S_GET_STORAGE_CLASS(symbol_rootP) != C_FILE) ! 4425: ! c_dot_file_symbol("fake"); ! 4426: ! ! 4427: ! /* ! 4428: ! * Build up static symbols for .text, .data and .bss ! 4429: ! */ ! 4430: ! dot_text_symbol = (symbolS*) ! 4431: ! c_section_symbol(".text", 0, H_GET_TEXT_SIZE(&headers), ! 4432: ! 0/*text_relocation_number*/, 0/*text_lineno_number*/); ! 4433: ! dot_data_symbol = (symbolS*) ! 4434: ! c_section_symbol(".data", H_GET_TEXT_SIZE(&headers), ! 4435: ! H_GET_DATA_SIZE(&headers), ! 4436: ! 0/*data_relocation_number*/, ! 4437: ! 0); /* There is no data lineno entries */ ! 4438: ! dot_bss_symbol = (symbolS*) ! 4439: ! c_section_symbol(".bss", H_GET_TEXT_SIZE(&headers) + ! 4440: ! H_GET_DATA_SIZE(&headers), ! 4441: ! H_GET_BSS_SIZE(&headers), ! 4442: ! 0, /* No relocation for a bss section. */ ! 4443: ! 0); /* There is no bss lineno entries */ ! 4444: ! } ! 4445: ! ! 4446: ! symbolP = symbol_rootP; ! 4447: ! if(symbolP) { ! 4448: ! while(symbolP) { ! 4449: ! /* If the symbol has a tagndx entry, resolve it */ ! 4450: ! if(SF_GET_TAGGED(symbolP)) { ! 4451: ! SA_SET_SYM_TAGNDX(symbolP, ! 4452: ! ((symbolS*)SA_GET_SYM_TAGNDX(symbolP))->sy_number); ! 4453: ! } ! 4454: ! /* Debug symbol do not need all this rubbish */ ! 4455: ! if(!SF_GET_DEBUG(symbolP)) { ! 4456: ! symbolS* real_symbolP; ! 4457: ! /* L* and C_EFCN symbols never merge. */ ! 4458: ! if(!SF_GET_LOCAL(symbolP) && ! 4459: ! (real_symbolP = ! 4460: ! symbol_find_base(S_GET_NAME(symbolP), DO_NOT_STRIP)) && ! 4461: ! real_symbolP != symbolP) { ! 4462: ! /* Move the debug data from the debug symbol to the ! 4463: ! real symbol. Do NOT do the oposite (i.e. move from ! 4464: ! real symbol to symbol and remove real symbol from the ! 4465: ! list.) Because some pointers refer to the real symbol ! 4466: ! whereas no pointers refer to the symbol. */ ! 4467: ! c_symbol_merge(symbolP, real_symbolP); ! 4468: ! /* Replace the current symbol by the real one */ ! 4469: ! /* The symbols will never be the last or the first ! 4470: ! because : 1st symbol is .file and 3 last symbols are ! 4471: ! .text, .data, .bss */ ! 4472: ! DL_REMOVE(real_symbolP); ! 4473: ! DL_INSERT(real_symbolP, symbolP); ! 4474: ! DL_REMOVE(symbolP); ! 4475: ! symbolP = real_symbolP; ! 4476: ! } ! 4477: ! if(flagseen['R'] && S_IS_DATA(symbolP)) ! 4478: ! S_SET_TEXT(symbolP); ! 4479: ! ! 4480: ! symbolP->sy_value += symbolP->sy_frag->fr_address; ! 4481: ! ! 4482: ! if(!S_IS_DEFINED(symbolP)) ! 4483: ! S_SET_EXTERNAL(symbolP); ! 4484: ! else if(S_GET_STORAGE_CLASS(symbolP) == C_NULL) ! 4485: ! S_SET_STORAGE_CLASS(symbolP, C_STAT); ! 4486: ! ! 4487: ! /* Mainly to speed up if not -g */ ! 4488: ! if(SF_GET_PROCESS(symbolP)) { ! 4489: ! /* Handle the nested blocks auxiliary info. */ ! 4490: ! if(S_GET_STORAGE_CLASS(symbolP) == C_BLOCK) { ! 4491: ! if(!strcmp(S_GET_NAME(symbolP), ".bb")) ! 4492: ! stack_push(block_stack, &symbolP); ! 4493: ! else { /* .eb */ ! 4494: ! register symbolS* begin_symbolP; ! 4495: ! begin_symbolP = *(symbolS**)stack_pop(block_stack); ! 4496: ! if(begin_symbolP == (symbolS*)0) ! 4497: ! as_warn("mismatched .eb"); ! 4498: ! else ! 4499: ! SA_SET_SYM_ENDNDX(begin_symbolP, symbol_number); ! 4500: ! } ! 4501: ! } ! 4502: ! /* If we are able to identify the type of a function, and we ! 4503: ! are out of a function (last_functionP == 0) then, the ! 4504: ! function symbol will be associated with an auxiliary ! 4505: ! entry. */ ! 4506: ! if(last_functionP == (symbolS*)0 && ! 4507: ! SF_GET_FUNCTION(symbolP)) { ! 4508: ! last_functionP = symbolP; ! 4509: ! S_SET_NUMBER_AUXILIARY(symbolP, 1); ! 4510: ! /* Clobber possible stale .dim information. */ ! 4511: ! memset(&symbolP->sy_auxent, '\0', sizeof(union auxent)); ! 4512: ! } ! 4513: ! /* The C_FCN do not need any additional information. ! 4514: ! I don't even know if this is needed for sdb. But the ! 4515: ! standard assembler generate it, so... ! 4516: ! */ ! 4517: ! if(S_GET_STORAGE_CLASS(symbolP) == C_EFCN) { ! 4518: ! if(last_functionP == (symbolS*)0) ! 4519: ! as_fatal("C_EFCN symbol out of scope"); ! 4520: ! SA_SET_SYM_FSIZE(last_functionP, ! 4521: ! (long)(symbolP->sy_value - ! 4522: ! last_functionP->sy_value)); ! 4523: ! SA_SET_SYM_ENDNDX(last_functionP, symbol_number); ! 4524: ! last_functionP = (symbolS*)0; ! 4525: ! } ! 4526: ! } ! 4527: ! } else { ! 4528: ! /* First descriptor of a structure must point to the next ! 4529: ! slot outside the structure description. */ ! 4530: ! if(SF_GET_TAG(symbolP)) ! 4531: ! last_tagP = symbolP; ! 4532: ! else if(S_GET_STORAGE_CLASS(symbolP) == C_EOS) ! 4533: ! /* +2 take in account the current symbol */ ! 4534: ! SA_SET_SYM_ENDNDX(last_tagP, symbol_number+2); ! 4535: ! } ! 4536: ! ! 4537: ! /* We must put the external symbols appart. The loader ! 4538: ! does not bomb if we do not. But the references in ! 4539: ! the endndx field for a .bb symbol are not corrected ! 4540: ! if an external symbol is removed between .bb and .be. ! 4541: ! I.e int the following case : ! 4542: ! [20] .bb endndx = 22 ! 4543: ! [21] foo external ! 4544: ! [22] .be ! 4545: ! ld will move the symbol 21 to the end of the list but ! 4546: ! endndx will still be 22 instead of 21. */ ! 4547: ! { ! 4548: ! register symbolS* thisP = symbolP; ! 4549: ! 4550: ! symbolP = thisP->sy_next; ! 4551: ! /* remove C_EFCN and LOCAL (L...) symbols */ ! 4552: ! if(SF_GET_LOCAL(thisP)) ! 4553: ! DL_REMOVE(thisP); ! 4554: ! else { ! 4555: ! if(S_GET_STORAGE_CLASS(thisP) == C_EXT && ! 4556: ! !SF_GET_FUNCTION(thisP)) { ! 4557: ! /* Remove from the list */ ! 4558: ! DL_REMOVE(thisP); ! 4559: ! DL_CLEAR(thisP); ! 4560: ! /* Move at the end of the list */ ! 4561: ! if (symbol_extern_lastP == (symbolS*)0) ! 4562: ! symbol_externP = thisP; ! 4563: ! else ! 4564: ! DL_APPEND(thisP, symbol_extern_lastP); ! 4565: ! symbol_extern_lastP = thisP; ! 4566: ! } else { ! 4567: ! if(SF_GET_STRING(thisP)) { ! 4568: ! thisP->sy_name_offset = string_byte_count; ! 4569: ! string_byte_count += strlen(S_GET_NAME(thisP)) + 1; ! 4570: ! } else ! 4571: ! thisP->sy_name_offset = 0; ! 4572: ! thisP->sy_number = symbol_number; ! 4573: ! symbol_number += 1 + S_GET_NUMBER_AUXILIARY(thisP); ! 4574: ! } ! 4575: ! } ! 4576: ! } ! 4577: ! } ! 4578: ! ! 4579: ! symbol_lastP->sy_next = symbol_externP; ! 4580: ! symbolP = symbol_externP; ! 4581: ! while(symbolP) { ! 4582: ! if(SF_GET_STRING(symbolP)) { ! 4583: ! symbolP->sy_name_offset = string_byte_count; ! 4584: ! string_byte_count += strlen(S_GET_NAME(symbolP)) + 1; ! 4585: ! } else ! 4586: ! symbolP->sy_name_offset = 0; ! 4587: ! symbolP->sy_number = symbol_number; ! 4588: ! symbol_number += 1 + S_GET_NUMBER_AUXILIARY(symbolP); ! 4589: ! symbolP = symbolP->sy_next; ! 4590: ! } ! 4591: ! } ! 4592: ! { ! 4593: ! lineno* lineP; ! 4594: ! for(lineP = lineno_rootP; lineP; lineP = lineP->next) { ! 4595: ! if(lineP->line.l_lnno) ! 4596: ! lineP->line.l_addr.l_paddr += ! 4597: ! ((fragS*)lineP->frag)->fr_address; ! 4598: ! else { ! 4599: ! /* There is a good chance that the symbol pointed to ! 4600: ! is not the one that will be emitted and that the ! 4601: ! sy_number is not accurate. */ ! 4602: ! char* name; ! 4603: ! name = (char*)lineP->line.l_addr.l_symndx; ! 4604: ! if((symbolP = symbol_find_base(name, DO_NOT_STRIP)) == ! 4605: ! (symbolS*)0) ! 4606: ! as_warn("line number lost symbol %s", name); ! 4607: ! else ! 4608: ! lineP->line.l_addr.l_symndx = symbolP->sy_number; ! 4609: ! } ! 4610: ! text_lineno_number++; ! 4611: ! } ! 4612: ! } ! 4613: ! #elif defined(aout) ! 4614: ! symbolPP = & symbol_rootP; /* -> last symbol chain link. */ ! 4615: while (symbolP = * symbolPP) ! 4616: { ! 4617: ! name = S_GET_NAME(symbolP); ! 4618: ! if(flagseen['R'] && S_IS_DATA(symbolP)) ! 4619: ! S_SET_TEXT(symbolP); ! 4620: ! 4621: symbolP -> sy_value += symbolP -> sy_frag -> fr_address; ! 4622: /* JF the \001 bit is to make sure that local labels ! 4623: ( 1: - 9: don't make it into the symtable either */ ! 4624: #ifndef VMS /* Under VMS we need to keep local symbols */ ! 4625: ! if (!S_IS_LOCAL(symbolP)) ! 4626: #endif /* not VMS */ ! 4627: { ! 4628: #ifndef VMS ! 4629: ! /* The + 1 after strlen account for the \0 at the end of each string */ ! 4630: ! symbolP -> sy_number = symbol_number ++; ! 4631: ! if(!S_IS_STABD(symbolP)) ! 4632: { /* Ordinary case. */ ! 4633: symbolP -> sy_name_offset = string_byte_count; ! 4634: ! string_byte_count += ! 4635: ! strlen (S_GET_NAME(symbolP)) + 1; ! 4636: } ! 4637: else /* .Stabd case. */ ! 4638: #endif /* not VMS */ ! 4639: *************** ! 4640: *** 392,407 **** ! 4641: symbolPP = & (symbolP -> sy_next); ! 4642: } ! 4643: #ifndef VMS ! 4644: ! else ! 4645: * symbolPP = symbolP -> sy_next; ! 4646: #endif /* not VMS */ ! 4647: } /* for each symbol */ ! 4648: ! 4649: ! syms_siz = sizeof( struct nlist) * symbol_number; ! 4650: ! md_number_to_chars((char *)&the_exec.a_syms,syms_siz,sizeof(the_exec.a_syms)); ! 4651: ! /* the_exec . a_syms = sizeof( struct nlist) * symbol_number; */ ! 4652: } ! 4653: - ! 4654: /* ! 4655: * Addresses of frags now reflect addresses we use in the object file. ! 4656: * Symbol values are correct. ! 4657: --- 584,602 ---- ! 4658: symbolPP = & (symbolP -> sy_next); ! 4659: } ! 4660: #ifndef VMS ! 4661: ! else /* skip the symbol */ ! 4662: * symbolPP = symbolP -> sy_next; ! 4663: #endif /* not VMS */ ! 4664: } /* for each symbol */ ! 4665: ! 4666: ! #elif defined(elf) ! 4667: ! do it yourself ! ! 4668: ! #else ! 4669: ! you lose ! 4670: ! #endif ! 4671: ! H_SET_STRING_SIZE(&headers,string_byte_count); ! 4672: ! H_SET_SYMBOL_TABLE_SIZE(&headers, symbol_number); ! 4673: } ! 4674: /* ! 4675: * Addresses of frags now reflect addresses we use in the object file. ! 4676: * Symbol values are correct. ! 4677: *************** ! 4678: *** 563,605 **** ! 4679: * Scan every FixS performing fixups. We had to wait until now to do ! 4680: * this because md_convert_frag() may have made some fixSs. ! 4681: */ ! 4682: ! /* the_exec . a_trsize ! 4683: ! = sizeof(struct relocation_info) * fixup_segment (text_fix_root, N_TEXT); ! 4684: ! the_exec . a_drsize ! 4685: ! = sizeof(struct relocation_info) * fixup_segment (data_fix_root, N_DATA); */ ! 4686: ! ! 4687: ! tr_siz=sizeof(struct relocation_info) * fixup_segment (text_fix_root, N_TEXT); ! 4688: ! md_number_to_chars((char *)&the_exec.a_trsize, tr_siz ,sizeof(the_exec.a_trsize)); ! 4689: ! dr_siz=sizeof(struct relocation_info) * fixup_segment (data_fix_root, N_DATA); ! 4690: ! md_number_to_chars((char *)&the_exec.a_drsize, dr_siz, sizeof(the_exec.a_drsize)); ! 4691: ! md_number_to_chars((char *)&the_exec.a_info,omagic,sizeof(the_exec.a_info)); ! 4692: ! md_number_to_chars((char *)&the_exec.a_entry,0,sizeof(the_exec.a_entry)); ! 4693: ! 4694: #ifdef EXEC_MACHINE_TYPE ! 4695: ! md_number_to_chars((char *)&the_exec.a_machtype, EXEC_MACHINE_TYPE, sizeof(the_exec.a_machtype)); ! 4696: #endif ! 4697: #ifdef EXEC_VERSION ! 4698: ! md_number_to_chars((char *)&the_exec.a_version,EXEC_VERSION,sizeof(the_exec.a_version)); ! 4699: #endif ! 4700: - ! 4701: - /* the_exec . a_entry = 0; */ ! 4702: ! 4703: ! size_of_the_object_file = ! 4704: ! sizeof( the_exec ) + ! 4705: ! text_siz + ! 4706: ! data_siz + ! 4707: ! syms_siz + ! 4708: ! tr_siz + ! 4709: ! dr_siz + ! 4710: ! string_byte_count; ! 4711: ! ! 4712: ! next_object_file_charP ! 4713: ! = the_object_file ! 4714: ! = xmalloc ( size_of_the_object_file ); ! 4715: ! 4716: output_file_create (out_file_name); ! 4717: ! 4718: ! append (& next_object_file_charP, (char *)(&the_exec), (unsigned long)sizeof(the_exec)); ! 4719: ! 4720: /* ! 4721: * Emit code. ! 4722: --- 758,877 ---- ! 4723: * Scan every FixS performing fixups. We had to wait until now to do ! 4724: * this because md_convert_frag() may have made some fixSs. ! 4725: */ ! 4726: ! ! 4727: ! H_SET_RELOCATION_SIZE(&headers, ! 4728: ! RELSZ*fixup_segment (text_fix_root, SEG_TEXT), ! 4729: ! RELSZ*fixup_segment (data_fix_root, SEG_DATA)); ! 4730: ! H_SET_MAGIC_NUMBER(&headers,omagic); ! 4731: ! H_SET_ENTRY_POINT(&headers,0); ! 4732: ! 4733: #ifdef EXEC_MACHINE_TYPE ! 4734: ! H_SET_MACHINE_TYPE(&headers,EXEC_MACHINE_TYPE); ! 4735: #endif ! 4736: #ifdef EXEC_VERSION ! 4737: ! H_SET_VERSION(&headers,EXEC_VERSION); ! 4738: #endif ! 4739: ! 4740: ! #ifdef coff ! 4741: ! { ! 4742: ! register int text_relocation_number = 0; ! 4743: ! register int data_relocation_number = 0; ! 4744: ! register fixS* fixP; ! 4745: ! ! 4746: ! /* Count the number of relocation entries for text and data */ ! 4747: ! for(fixP = text_fix_root; fixP; fixP = fixP->fx_next) ! 4748: ! if(fixP->fx_addsy) ! 4749: ! text_relocation_number++; ! 4750: ! SA_SET_SCN_NRELOC(dot_text_symbol, text_relocation_number); ! 4751: ! /* Assign the number of line number entries for the text section */ ! 4752: ! SA_SET_SCN_NLINNO(dot_text_symbol, text_lineno_number); ! 4753: ! /* Assign the size of the section */ ! 4754: ! SA_SET_SCN_SCNLEN(dot_text_symbol, H_GET_TEXT_SIZE(&headers)); ! 4755: ! ! 4756: ! for(fixP = data_fix_root; fixP; fixP = fixP->fx_next) ! 4757: ! if(fixP->fx_addsy) ! 4758: ! data_relocation_number++; ! 4759: ! SA_SET_SCN_NRELOC(dot_data_symbol, data_relocation_number); ! 4760: ! /* Assign the size of the section */ ! 4761: ! SA_SET_SCN_SCNLEN(dot_data_symbol, H_GET_DATA_SIZE(&headers)); ! 4762: ! ! 4763: ! /* Assign the size of the section */ ! 4764: ! SA_SET_SCN_SCNLEN(dot_bss_symbol, H_GET_BSS_SIZE(&headers)); ! 4765: ! } ! 4766: ! ! 4767: ! /* Fill in extra coff fields */ ! 4768: ! ! 4769: ! /* Initialize general line number information. */ ! 4770: ! H_SET_LINENO_SIZE(&headers, text_lineno_number * LINESZ); ! 4771: ! ! 4772: ! /* filehdr */ ! 4773: ! H_SET_FILE_MAGIC_NUMBER(&headers, FILE_HEADER_MAGIC); ! 4774: ! H_SET_NUMBER_OF_SECTIONS(&headers, 3); /* text+data+bss */ ! 4775: ! H_SET_TIME_STAMP(&headers, (long)time((long*)0)); ! 4776: ! H_SET_SYMBOL_TABLE_POINTER(&headers, ! 4777: ! H_GET_SYMBOL_TABLE_FILE_OFFSET(&headers)); ! 4778: ! /* symbol table size allready set */ ! 4779: ! H_SET_SIZEOF_OPTIONAL_HEADER(&headers, AOUTHDRSZ); ! 4780: ! H_SET_FLAGS(&headers, (text_lineno_number == 0 ? F_LNNO : 0 ) | ! 4781: ! BYTE_ORDERING); ! 4782: ! ! 4783: ! /* aouthdr */ ! 4784: ! /* magic number allready set */ ! 4785: ! H_SET_VERSION_STAMP(&headers, 0); ! 4786: ! /* Text, data, bss size; entry point; text_start and data_start ! 4787: ! are already set */ ! 4788: ! ! 4789: ! /* Build section headers */ ! 4790: ! ! 4791: ! c_section_header(&text_section_header, ! 4792: ! ".text", ! 4793: ! 0, ! 4794: ! H_GET_TEXT_SIZE(&headers), ! 4795: ! H_GET_TEXT_FILE_OFFSET(&headers), ! 4796: ! SA_GET_SCN_NRELOC(dot_text_symbol) ? ! 4797: ! H_GET_RELOCATION_FILE_OFFSET(&headers) : 0, ! 4798: ! text_lineno_number ? H_GET_LINENO_FILE_OFFSET(&headers) : 0, ! 4799: ! SA_GET_SCN_NRELOC(dot_text_symbol), ! 4800: ! text_lineno_number); ! 4801: ! c_section_header(&data_section_header, ! 4802: ! ".data", ! 4803: ! H_GET_TEXT_SIZE(&headers), ! 4804: ! H_GET_DATA_SIZE(&headers), ! 4805: ! H_GET_DATA_SIZE(&headers) ? ! 4806: ! H_GET_DATA_FILE_OFFSET(&headers) : 0, ! 4807: ! SA_GET_SCN_NRELOC(dot_data_symbol) ? ! 4808: ! H_GET_RELOCATION_FILE_OFFSET(&headers) + ! 4809: ! text_section_header.s_nreloc * RELSZ : 0, ! 4810: ! 0, /* No line number information */ ! 4811: ! SA_GET_SCN_NRELOC(dot_data_symbol), ! 4812: ! 0); /* No line number information */ ! 4813: ! c_section_header(&bss_section_header, ! 4814: ! ".bss", ! 4815: ! H_GET_TEXT_SIZE(&headers) + H_GET_DATA_SIZE(&headers), ! 4816: ! H_GET_BSS_SIZE(&headers), ! 4817: ! 0, /* No file offset */ ! 4818: ! 0, /* No relocation information */ ! 4819: ! 0, /* No line number information */ ! 4820: ! 0, /* No relocation information */ ! 4821: ! 0); /* No line number information */ ! 4822: ! ! 4823: ! #endif /* coff */ ! 4824: ! ! 4825: ! object_file_size = H_GET_FILE_SIZE(&headers); ! 4826: ! next_object_file_charP = the_object_file = xmalloc ( object_file_size ); ! 4827: ! 4828: output_file_create (out_file_name); ! 4829: ! 4830: ! ! 4831: ! H_OUTPUT(&headers, &next_object_file_charP); ! 4832: ! ! 4833: ! #ifdef coff ! 4834: ! /* Output the section headers */ ! 4835: ! c_section_header_append(&text_section_header, &next_object_file_charP); ! 4836: ! c_section_header_append(&data_section_header, &next_object_file_charP); ! 4837: ! c_section_header_append(&bss_section_header, &next_object_file_charP); ! 4838: ! #endif /* coff */ ! 4839: ! ! 4840: ! 4841: /* ! 4842: * Emit code. ! 4843: *************** ! 4844: *** 624,652 **** ! 4845: */ ! 4846: emit_relocations (text_fix_root, (relax_addressT)0); ! 4847: emit_relocations (data_fix_root, text_last_frag -> fr_address); ! 4848: /* ! 4849: ! * Emit all symbols left in the symbol chain. ! 4850: ! * Any symbol still undefined is made N_EXT. ! 4851: */ ! 4852: ! for ( symbolP = symbol_rootP; symbolP; symbolP = symbolP -> sy_next ) ! 4853: ! { ! 4854: ! register char * temp; ! 4855: ! ! 4856: ! temp = symbolP -> sy_nlist . n_un . n_name; ! 4857: ! /* JF fix the numbers up. Call by value RULES! */ ! 4858: ! md_number_to_chars((char *)&(symbolP -> sy_nlist . n_un . n_strx ),symbolP -> sy_name_offset,sizeof(symbolP -> sy_nlist . n_un . n_strx )); ! 4859: ! md_number_to_chars((char *)&(symbolP->sy_nlist.n_desc),symbolP->sy_nlist.n_desc,sizeof(symbolP -> sy_nlist . n_desc)); ! 4860: ! md_number_to_chars((char *)&(symbolP->sy_nlist.n_value),symbolP->sy_nlist.n_value,sizeof(symbolP->sy_nlist.n_value)); ! 4861: ! /* symbolP -> sy_nlist . n_un . n_strx = symbolP -> sy_name_offset; JF replaced by md above */ ! 4862: ! if (symbolP -> sy_type == N_UNDF) ! 4863: ! symbolP -> sy_type |= N_EXT; /* Any undefined symbols become N_EXT. */ ! 4864: ! append (& next_object_file_charP, (char *)(& symbolP -> sy_nlist), ! 4865: ! (unsigned long)sizeof(struct nlist)); ! 4866: ! symbolP -> sy_nlist . n_un . n_name = temp; ! 4867: ! } /* for each symbol */ ! 4868: ! 4869: /* ! 4870: - * next_object_file_charP -> slot for next object byte. ! 4871: * Emit strings. ! 4872: * Find strings by crawling along symbol table chain. ! 4873: */ ! 4874: --- 896,915 ---- ! 4875: */ ! 4876: emit_relocations (text_fix_root, (relax_addressT)0); ! 4877: emit_relocations (data_fix_root, text_last_frag -> fr_address); ! 4878: + ! 4879: + #ifdef coff ! 4880: /* ! 4881: ! * Emit line number entries. ! 4882: */ ! 4883: ! emit_lineno(lineno_rootP, &next_object_file_charP); ! 4884: ! #endif /* coff */ ! 4885: ! ! 4886: ! /* ! 4887: ! * Emit symbols. ! 4888: ! */ ! 4889: ! emit_symbols (symbol_rootP,&next_object_file_charP); ! 4890: ! 4891: /* ! 4892: * Emit strings. ! 4893: * Find strings by crawling along symbol table chain. ! 4894: */ ! 4895: *************** ! 4896: *** 654,671 **** ! 4897: md_number_to_chars((char *)&string_byte_count, string_byte_count, sizeof(string_byte_count)); ! 4898: ! 4899: append (& next_object_file_charP, (char *)&string_byte_count, (unsigned long)sizeof(string_byte_count)); ! 4900: ! for ( symbolP = symbol_rootP; symbolP; symbolP = symbolP -> sy_next ) ! 4901: ! { ! 4902: ! if (symbolP -> sy_name) ! 4903: ! { /* Ordinary case: not .stabd. */ ! 4904: ! append (& next_object_file_charP, symbolP -> sy_name, ! 4905: ! (unsigned long)(strlen (symbolP -> sy_name) + 1)); ! 4906: ! } ! 4907: ! } /* for each symbol */ ! 4908: ! ! 4909: ! know( next_object_file_charP == the_object_file + size_of_the_object_file ); ! 4910: ! 4911: ! output_file_append (the_object_file, size_of_the_object_file, out_file_name); ! 4912: ! 4913: #ifdef DONTDEF ! 4914: if (flagseen['G']) /* GDB symbol file to be appended? */ ! 4915: --- 917,935 ---- ! 4916: md_number_to_chars((char *)&string_byte_count, string_byte_count, sizeof(string_byte_count)); ! 4917: ! 4918: append (& next_object_file_charP, (char *)&string_byte_count, (unsigned long)sizeof(string_byte_count)); ! 4919: ! for(symbolP = symbol_rootP; symbolP; symbolP = symbolP->sy_next) { ! 4920: ! #ifdef coff ! 4921: ! if(SF_GET_STRING(symbolP)) ! 4922: ! #else /* coff */ ! 4923: ! if(S_GET_NAME(symbolP)) ! 4924: ! #endif /* coff */ ! 4925: ! append(&next_object_file_charP, S_GET_NAME(symbolP), ! 4926: ! (unsigned long)(strlen (S_GET_NAME(symbolP)) + 1)); ! 4927: ! } ! 4928: ! 4929: ! know( next_object_file_charP == the_object_file + object_file_size); ! 4930: ! /* Write the data to the file */ ! 4931: ! output_file_append (the_object_file,object_file_size,out_file_name); ! 4932: ! 4933: #ifdef DONTDEF ! 4934: if (flagseen['G']) /* GDB symbol file to be appended? */ ! 4935: *************** ! 4936: *** 702,708 **** ! 4937: void ! 4938: relax_segment (segment_frag_root, segment_type) ! 4939: struct frag * segment_frag_root; ! 4940: ! segT segment_type; /* N_DATA or N_TEXT */ ! 4941: { ! 4942: register struct frag * fragP; ! 4943: register relax_addressT address; ! 4944: --- 966,972 ---- ! 4945: void ! 4946: relax_segment (segment_frag_root, segment_type) ! 4947: struct frag * segment_frag_root; ! 4948: ! segT segment_type; /* SEG_DATA or SEG_TEXT */ ! 4949: { ! 4950: register struct frag * fragP; ! 4951: register relax_addressT address; ! 4952: *************** ! 4953: *** 740,746 **** ! 4954: ! 4955: case rs_machine_dependent: ! 4956: address += md_estimate_size_before_relax ! 4957: ! (fragP, seg_N_TYPE [(int) segment_type]); ! 4958: break; ! 4959: ! 4960: #ifndef WORKING_DOT_WORD ! 4961: --- 1004,1010 ---- ! 4962: ! 4963: case rs_machine_dependent: ! 4964: address += md_estimate_size_before_relax ! 4965: ! (fragP, seg_SEG((int) segment_type)); ! 4966: break; ! 4967: ! 4968: #ifndef WORKING_DOT_WORD ! 4969: *************** ! 4970: *** 847,855 **** ! 4971: target = offset; ! 4972: if (symbolP) ! 4973: { ! 4974: ! know( ((symbolP -> sy_type & N_TYPE) == N_ABS) || ((symbolP -> sy_type & N_TYPE) == N_DATA) || ((symbolP -> sy_type & N_TYPE) == N_TEXT)); ! 4975: ! know( symbolP -> sy_frag ); ! 4976: ! know( (symbolP->sy_type&N_TYPE)!=N_ABS || symbolP->sy_frag==&zero_address_frag ); ! 4977: target += ! 4978: symbolP -> sy_value ! 4979: + symbolP -> sy_frag -> fr_address; ! 4980: --- 1111,1122 ---- ! 4981: target = offset; ! 4982: if (symbolP) ! 4983: { ! 4984: ! know(S_IS_ABS(symbolP) || ! 4985: ! S_IS_DATA(symbolP) || ! 4986: ! S_IS_TEXT(symbolP)) ! 4987: ! know(symbolP -> sy_frag); ! 4988: ! know(!S_IS_ABS(symbolP) || ! 4989: ! symbolP->sy_frag==&zero_address_frag ); ! 4990: target += ! 4991: symbolP -> sy_value ! 4992: + symbolP -> sy_frag -> fr_address; ! 4993: *************** ! 4994: *** 876,885 **** ! 4995: target = offset; ! 4996: if (symbolP) ! 4997: { ! 4998: ! know( ((symbolP -> sy_type & N_TYPE) == N_ABS) || ((symbolP -> sy_type & ! 4999: ! N_TYPE) == N_DATA) || ((symbolP -> sy_type & N_TYPE) == N_TEXT)); ! 5000: ! know( symbolP -> sy_frag ); ! 5001: ! know( (symbolP->sy_type&N_TYPE)!=N_ABS || symbolP->sy_frag==&zero_address_frag ); ! 5002: target += ! 5003: symbolP -> sy_value ! 5004: + symbolP -> sy_frag -> fr_address; ! 5005: --- 1143,1154 ---- ! 5006: target = offset; ! 5007: if (symbolP) ! 5008: { ! 5009: ! know(S_IS_ABS(symbolP) || ! 5010: ! S_IS_DATA(symbolP) || ! 5011: ! S_IS_TEXT(symbolP)) ! 5012: ! know(symbolP -> sy_frag); ! 5013: ! know(!S_IS_ABS(symbolP) || ! 5014: ! symbolP->sy_frag==&zero_address_frag ); ! 5015: target += ! 5016: symbolP -> sy_value ! 5017: + symbolP -> sy_frag -> fr_address; ! 5018: *************** ! 5019: *** 1041,1065 **** ! 5020: add_number = fixP -> fx_offset; ! 5021: pcrel = fixP -> fx_pcrel; ! 5022: if(add_symbolP) ! 5023: ! add_symbol_N_TYPE = add_symbolP -> sy_type & N_TYPE; ! 5024: if (sub_symbolP) ! 5025: { ! 5026: if(!add_symbolP) /* Its just -sym */ ! 5027: { ! 5028: ! if(sub_symbolP->sy_type!=N_ABS) ! 5029: ! as_warn("Negative of non-absolute symbol %s", sub_symbolP->sy_name); ! 5030: ! add_number-=sub_symbolP->sy_value; ! 5031: } ! 5032: ! else if ( ((sub_symbolP -> sy_type ^ add_symbol_N_TYPE) & N_TYPE) == 0 ! 5033: ! && ( add_symbol_N_TYPE == N_DATA ! 5034: ! || add_symbol_N_TYPE == N_TEXT ! 5035: ! || add_symbol_N_TYPE == N_BSS ! 5036: ! || add_symbol_N_TYPE == N_ABS)) ! 5037: { ! 5038: /* Difference of 2 symbols from same segment. */ ! 5039: /* Can't make difference of 2 undefineds: 'value' means */ ! 5040: /* something different for N_UNDF. */ ! 5041: ! add_number += add_symbolP -> sy_value - sub_symbolP -> sy_value; ! 5042: add_symbolP = NULL; ! 5043: fixP -> fx_addsy = NULL; ! 5044: } ! 5045: --- 1310,1339 ---- ! 5046: add_number = fixP -> fx_offset; ! 5047: pcrel = fixP -> fx_pcrel; ! 5048: if(add_symbolP) ! 5049: ! add_symbol_N_TYPE = SEG_seg(S_GET_SEGMENT(add_symbolP)); ! 5050: if (sub_symbolP) ! 5051: { ! 5052: if(!add_symbolP) /* Its just -sym */ ! 5053: { ! 5054: ! if(SEG_seg(sub_symbolP->sy_type)!=SEG_ABSOLUTE) ! 5055: ! as_warn("Negative of non-absolute symbol %s", ! 5056: ! S_GET_NAME(sub_symbolP)); ! 5057: ! add_number-=S_GET_VALUE(sub_symbolP); ! 5058: } ! 5059: ! /* if sub_symbol is in the same segment that add_symbol ! 5060: ! and add_symbol is either in DATA, TEXT, BSS or ABSOLUTE */ ! 5061: ! else if((SEG_seg(S_GET_SEGMENT(sub_symbolP)) == ! 5062: ! add_symbol_N_TYPE) && ! 5063: ! ((add_symbol_N_TYPE == SEG_DATA) || ! 5064: ! (add_symbol_N_TYPE == SEG_TEXT) || ! 5065: ! (add_symbol_N_TYPE == SEG_BSS) || ! 5066: ! (add_symbol_N_TYPE == SEG_ABSOLUTE))) ! 5067: { ! 5068: /* Difference of 2 symbols from same segment. */ ! 5069: /* Can't make difference of 2 undefineds: 'value' means */ ! 5070: /* something different for N_UNDF. */ ! 5071: ! add_number += S_GET_VALUE(add_symbolP) - ! 5072: ! S_GET_VALUE(sub_symbolP); ! 5073: add_symbolP = NULL; ! 5074: fixP -> fx_addsy = NULL; ! 5075: } ! 5076: *************** ! 5077: *** 1066,1079 **** ! 5078: else ! 5079: { ! 5080: /* Different segments in subtraction. */ ! 5081: ! know( sub_symbolP -> sy_type != (N_ABS | N_EXT)) ! 5082: ! if (sub_symbolP -> sy_type == N_ABS) ! 5083: ! add_number -= sub_symbolP -> sy_value; ! 5084: else ! 5085: { ! 5086: ! as_warn("Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %d.", ! 5087: ! seg_name[(int)N_TYPE_seg[sub_symbolP->sy_type&N_TYPE]], ! 5088: ! sub_symbolP -> sy_name, fragP -> fr_address + where); ! 5089: } ! 5090: } ! 5091: } ! 5092: --- 1340,1353 ---- ! 5093: else ! 5094: { ! 5095: /* Different segments in subtraction. */ ! 5096: ! know(!(S_IS_EXTERNAL(sub_symbolP) && S_IS_ABS(sub_symbolP))); ! 5097: ! if (S_IS_ABS(sub_symbolP)) ! 5098: ! add_number -= S_GET_VALUE(sub_symbolP); ! 5099: else ! 5100: { ! 5101: ! as_warn("Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %d.", ! 5102: ! segment_name((int)SEG_seg(S_GET_SEGMENT(sub_symbolP))), ! 5103: ! S_GET_NAME(sub_symbolP), fragP -> fr_address + where); ! 5104: } ! 5105: } ! 5106: } ! 5107: *************** ! 5108: *** 1086,1092 **** ! 5109: * SEG_UNKNOWN, but it is now in the local segment. ! 5110: * So we know how to do the address without relocation. ! 5111: */ ! 5112: ! add_number += add_symbolP -> sy_value; ! 5113: add_number -= ! 5114: #ifndef NS32K ! 5115: size + ! 5116: --- 1360,1366 ---- ! 5117: * SEG_UNKNOWN, but it is now in the local segment. ! 5118: * So we know how to do the address without relocation. ! 5119: */ ! 5120: ! add_number += S_GET_VALUE(add_symbolP); ! 5121: add_number -= ! 5122: #ifndef NS32K ! 5123: size + ! 5124: *************** ! 5125: *** 1112,1131 **** ! 5126: { ! 5127: switch (add_symbol_N_TYPE) ! 5128: { ! 5129: ! case N_ABS: ! 5130: ! add_number += add_symbolP -> sy_value; ! 5131: fixP -> fx_addsy = NULL; ! 5132: add_symbolP = NULL; ! 5133: break; ! 5134: ! 5135: ! case N_BSS: ! 5136: ! case N_DATA: ! 5137: ! case N_TEXT: ! 5138: seg_reloc_count ++; ! 5139: ! add_number += add_symbolP -> sy_value; ! 5140: break; ! 5141: ! 5142: ! case N_UNDF: ! 5143: seg_reloc_count ++; ! 5144: break; ! 5145: ! 5146: --- 1386,1409 ---- ! 5147: { ! 5148: switch (add_symbol_N_TYPE) ! 5149: { ! 5150: ! case SEG_ABSOLUTE: ! 5151: ! add_number += S_GET_VALUE(add_symbolP); ! 5152: fixP -> fx_addsy = NULL; ! 5153: add_symbolP = NULL; ! 5154: break; ! 5155: ! 5156: ! case SEG_BSS: ! 5157: ! case SEG_DATA: ! 5158: ! case SEG_TEXT: ! 5159: seg_reloc_count ++; ! 5160: ! add_number += S_GET_VALUE(add_symbolP); ! 5161: break; ! 5162: ! 5163: ! case SEG_UNKNOWN: ! 5164: ! #ifdef coff ! 5165: ! if(S_IS_COMMON(add_symbolP)) ! 5166: ! add_number += S_GET_VALUE(add_symbolP); ! 5167: ! #endif /* coff */ ! 5168: seg_reloc_count ++; ! 5169: break; ! 5170: ! 5171: *************** ! 5172: *** 1159,1165 **** ! 5173: case 0: ! 5174: #if defined(SPARC) || defined(I860) ! 5175: fixP->fx_addnumber = add_number; ! 5176: ! md_number_to_imm(place, add_number, size, fixP, this_segment_type); ! 5177: #else ! 5178: md_number_to_imm (place, add_number, size); ! 5179: /* OVE: the immediates, like disps, have lsb at lowest address */ ! 5180: --- 1437,1444 ---- ! 5181: case 0: ! 5182: #if defined(SPARC) || defined(I860) ! 5183: fixP->fx_addnumber = add_number; ! 5184: ! md_number_to_imm(place, add_number, size, fixP, ! 5185: ! seg_SEG(this_segment_type)); ! 5186: #else ! 5187: md_number_to_imm (place, add_number, size); ! 5188: /* OVE: the immediates, like disps, have lsb at lowest address */ ! 5189: *************** ! 5190: *** 1183,1249 **** ! 5191: return (seg_reloc_count); ! 5192: } /* fixup_segment() */ ! 5193: ! 5194: - ! 5195: - /* The sparc needs its own emit_relocations() */ ! 5196: - #if !defined(SPARC) && !defined(I860) ! 5197: - /* ! 5198: - * emit_relocations() ! 5199: - * ! 5200: - * Crawl along a fixS chain. Emit the segment's relocations. ! 5201: - */ ! 5202: - static void ! 5203: - emit_relocations (fixP, segment_address_in_file) ! 5204: - register fixS * fixP; /* Fixup chain for this segment. */ ! 5205: - relax_addressT segment_address_in_file; ! 5206: - { ! 5207: - struct relocation_info ri; ! 5208: - register symbolS * symbolP; ! 5209: - ! 5210: - /* JF this is for paranoia */ ! 5211: - bzero((char *)&ri,sizeof(ri)); ! 5212: - for ( ; fixP; fixP = fixP -> fx_next) ! 5213: - { ! 5214: - if (symbolP = fixP -> fx_addsy) ! 5215: - { ! 5216: - ! 5217: - #ifdef NS32K ! 5218: - /* These two 'cuz of NS32K */ ! 5219: - ri . r_bsr = fixP -> fx_bsr; ! 5220: - ri . r_disp = fixP -> fx_im_disp; ! 5221: - #endif ! 5222: - ! 5223: - ri . r_length = nbytes_r_length [fixP -> fx_size]; ! 5224: - ri . r_pcrel = fixP -> fx_pcrel; ! 5225: - ri . r_address = fixP -> fx_frag -> fr_address ! 5226: - + fixP -> fx_where ! 5227: - - segment_address_in_file; ! 5228: - if ((symbolP -> sy_type & N_TYPE) == N_UNDF) ! 5229: - { ! 5230: - ri . r_extern = 1; ! 5231: - ri . r_symbolnum = symbolP -> sy_number; ! 5232: - } ! 5233: - else ! 5234: - { ! 5235: - ri . r_extern = 0; ! 5236: - ri . r_symbolnum = symbolP -> sy_type & N_TYPE; ! 5237: - } ! 5238: - ! 5239: - /* ! 5240: - The 68k machines assign bit-fields from higher bits to ! 5241: - lower bits ("left-to-right") within the int. VAXen assign ! 5242: - bit-fields from lower bits to higher bits ("right-to-left"). ! 5243: - Both handle multi-byte numbers in their usual fashion ! 5244: - (Big-endian and little-endian stuff). ! 5245: - Thus we need a machine dependent routine to make ! 5246: - sure the structure is written out correctly. FUN! ! 5247: - */ ! 5248: - md_ri_to_chars((char *) &ri, ri); ! 5249: - append (&next_object_file_charP, (char *)& ri, (unsigned long)sizeof(ri)); ! 5250: - } ! 5251: - } ! 5252: - ! 5253: - } ! 5254: - #endif ! 5255: ! 5256: int ! 5257: is_dnrange(f1,f2) ! 5258: --- 1462,1467 ---- ! 5259: *** /lasvegas/spare/usenet/work/gas-1.37.genuine/./write.h Thu Oct 11 18:45:31 1990 ! 5260: --- ./write.h Wed Nov 7 07:34:00 1990 ! 5261: *************** ! 5262: *** 72,77 **** ! 5263: --- 72,79 ---- ! 5264: COMMON fixS * data_fix_root; /* Chains fixSs. */ ! 5265: COMMON fixS ** seg_fix_rootP; /* -> one of above. */ ! 5266: ! 5267: + COMMON char * next_object_file_charP; ! 5268: + ! 5269: bit_fixS *bit_fix_new(); ! 5270: /* end: write.h */ ! 5271: ! 5272: *** /lasvegas/spare/usenet/work/gas-1.37.genuine/./xmalloc.c Wed Mar 1 23:48:34 1989 ! 5273: --- ./xmalloc.c Wed Nov 7 07:34:01 1990 ! 5274: *************** ! 5275: *** 43,48 **** ! 5276: --- 43,50 ---- ! 5277: #include <malloc.h> ! 5278: #endif ! 5279: ! 5280: + #define error as_fatal ! 5281: + ! 5282: char * xmalloc(n) ! 5283: long n; ! 5284: { ! 5285: *** /lasvegas/spare/usenet/work/gas-1.37.genuine/./xrealloc.c Wed Mar 1 23:48:33 1989 ! 5286: --- ./xrealloc.c Wed Nov 7 07:34:02 1990 ! 5287: *************** ! 5288: *** 45,50 **** ! 5289: --- 45,52 ---- ! 5290: #include <malloc.h> ! 5291: #endif ! 5292: ! 5293: + #define error as_fatal ! 5294: + ! 5295: char * ! 5296: xrealloc (ptr, n) ! 5297: register char *ptr;
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.