gas-1.36 patches for COFF generation
Loic Dachary
loic at adesign.uucp
Tue Oct 16 18:34:47 AEST 1990
*** /dev/null Mon Oct 15 09:51:48 1990
--- coff.c Mon Oct 15 08:53:16 1990
***************
*** 0 ****
--- 1,367 ----
+ #include "oformat.h"
+ #include "as.h"
+ #include "md.h"
+ #include "struc-symbol.h"
+ #include "symbols.h"
+ #include "write.h"
+
+ /* Relocation. */
+
+ /*
+ * emit_relocations()
+ *
+ * Crawl along a fixS chain. Emit the segment's relocations.
+ */
+
+ void
+ emit_relocations (fixP, segment_address_in_file)
+ register fixS * fixP; /* Fixup chain for this segment. */
+ relax_addressT segment_address_in_file;
+ {
+ RELOC ri;
+ register symbolS * symbolP;
+
+ bzero((char *)&ri,sizeof(ri));
+ for ( ; fixP; fixP = fixP->fx_next) {
+ if (symbolP = fixP->fx_addsy) {
+ #if defined(PROCESSOR_68000)
+ ri.r_type = (fixP->fx_pcrel ?
+ ( fixP->fx_size == 1 ? R_PCRBYTE :
+ fixP->fx_size == 2 ? R_PCRWORD :
+ R_PCRLONG):
+ ( fixP->fx_size == 1 ? R_RELBYTE :
+ fixP->fx_size == 2 ? R_RELWORD :
+ R_RELLONG));
+ #elif defined(PROCESSOR_i386)
+ /* !!!! R_OFF8 & R_DIR16 are a vague guess, completly unested. */
+ ri.r_type = (fixP->fx_pcrel ?
+ ( fixP->fx_size == 1 ? R_PCRBYTE :
+ fixP->fx_size == 2 ? R_PCRWORD :
+ R_PCRLONG):
+ ( fixP->fx_size == 1 ? R_OFF8 :
+ fixP->fx_size == 2 ? R_DIR16 :
+ R_DIR32));
+ #else
+ you lose
+ #endif /* PROCESSOR_68000 || PROCESSOR_i386 */
+ ri.r_vaddr = fixP->fx_frag->fr_address + fixP->fx_where;
+ /* If symbol associated to relocation entry is a bss symbol
+ or undefined symbol just remember the index of the symbol.
+ Otherwise store the index of the symbol describing the
+ section the symbol belong to. This heuristic speeds up ld.
+ */
+ /* Local symbols can generate relocation information. In case
+ of structure return for instance. But they have no symbol
+ number because they won't be emitted in the final object.
+ In the case where they are in the BSS section, this leads
+ to an incorrect r_symndx.
+ Under bsd the loader do not care if the symbol reference is
+ incorrect. But the SYS V ld complains about this. To avoid
+ this we associate the symbol to the associated section,
+ *even* if it is the BSS section. */
+ /* If someone can tell me why the other symbols of the bss
+ section are not associated with the .bss section entry,
+ I'd be gratefull. I guess that it has to do with the special
+ nature of the .bss section. Or maybe this is because the
+ bss symbols are declared in the common section and can
+ be resized later. Can it break code some where ? */
+ ri.r_symndx =
+ S_GET_SEGMENT(symbolP) == C_TEXT_SECTION ? dot_text_symbol->sy_number :
+ S_GET_SEGMENT(symbolP) == C_DATA_SECTION ? dot_data_symbol->sy_number :
+ (SF_GET_LOCAL(symbolP) ? dot_bss_symbol->sy_number :
+ symbolP->sy_number); /* bss or undefined */
+
+ /* md_ri_to_chars((char *) &ri, ri); /* Last step : write md f */
+ append (&next_object_file_charP,
+ (char *)& ri,
+ (unsigned long)RELSZ);
+ }
+ }
+ }
+
+ /* Coff file generation & utilities */
+
+ /* Convert a lvalue to machine dependent data */
+ #define MD(s,v) \
+ md_number_to_chars((char *)&(s)->v,(s)->v, sizeof((s)->v))
+
+ void
+ c_header_append(aouthdr, filehdr, where)
+ AOUTHDR* aouthdr;
+ FILHDR* filehdr;
+ char** where;
+ {
+ /* Eventually swap bytes for cross compilation for file header */
+ MD(filehdr, f_magic);
+ MD(filehdr, f_nscns);
+ MD(filehdr, f_timdat);
+ MD(filehdr, f_symptr);
+ MD(filehdr, f_nsyms);
+ MD(filehdr, f_opthdr);
+ MD(filehdr, f_flags);
+ append(where, (char *)filehdr, FILHSZ);
+
+ /* Eventually swap bytes for cross compilation for a.out header */
+ MD(aouthdr, magic);
+ MD(aouthdr, vstamp);
+ MD(aouthdr, tsize);
+ MD(aouthdr, dsize);
+ MD(aouthdr, bsize);
+ MD(aouthdr, entry);
+ MD(aouthdr, text_start);
+ MD(aouthdr, data_start);
+ append(where, (char *)aouthdr, sizeof(struct aouthdr));
+ }
+
+ /*
+ * Beware ! If you cross compile to another ENDIAN machine,
+ * the symbol table values will not be valid any more.
+ */
+
+ void
+ c_symbol_append(symbolP, where)
+ symbolS * symbolP;
+ char** where;
+ {
+ SYMENT *syment = &symbolP->sy_symbol;
+ char numaux = syment->n_numaux;
+ register AUXENT* auxP = &symbolP->sy_auxent;
+ register unsigned short type = S_GET_DATA_TYPE(symbolP);
+
+ MD(syment, n_value);
+ MD(syment, n_scnum);
+ MD(syment, n_type);
+ MD(syment, n_sclass);
+ MD(syment, n_numaux);
+ append(where, (char *)syment, SYMESZ);
+
+ /* Should do the following : if(.file entry) MD(..)... else
+ if(static entry) MD(..)
+ */
+ if(numaux == 1) {
+ #if 0 /* This code has never been tested */
+ /* The most common case, x_sym entry. */
+ if((SF_GET(symbolP) & (SF_FILE | SF_STATICS)) == 0) {
+ MD(auxP, x_sym.x_tagndx);
+ if(ISFCN(type))
+ MD(auxP, x_sym.x_misc.x_fsize);
+ else {
+ MD(auxP, x_sym.x_misc.x_lnno);
+ MD(auxP, x_sym.x_misc.x_size);
+ }
+ if(ISARY(type)) {
+ register int index;
+ for(index = 0; index < DIMNUM; index++)
+ MD(auxP, x_sym.x_fcnary.x_ary.x_dimen[index]);
+ } else {
+ MD(auxP, x_sym.x_fcnary.x_fcn.x_lnnoptr);
+ MD(auxP, x_sym.x_fcnary.x_fcn.x_endndx);
+ }
+ MD(auxP, x_sym.x_tvndx);
+ } else if(SF_GET_FILE(symbolP)) /* .file */
+ ;
+ else if(SF_GET_STATICS(symbolP)) { /* .text, .data, .bss symbols */
+ MD(auxP, x_scn.x_scnlen);
+ MD(auxP, x_scn.x_nreloc);
+ MD(auxP, x_scn.x_nlinno);
+ }
+ #endif /* 0 */
+ append(where, (char *)auxP, AUXESZ);
+ } else if(numaux > 0)
+ as_warn("more than one auxent for symbol");
+
+ return;
+ }
+
+ void
+ c_section_header_append(header, where)
+ SCNHDR* header;
+ char** where;
+ {
+ MD(header, s_paddr);
+ MD(header, s_vaddr);
+ MD(header, s_size);
+ MD(header, s_scnptr);
+ MD(header, s_relptr);
+ MD(header, s_lnnoptr);
+ MD(header, s_nreloc);
+ MD(header, s_nlnno);
+ MD(header, s_flags);
+ append(where, (char *)header, SCNHSZ);
+
+ return;
+ }
+
+
+ void emit_symbols(symbol_rootP, where)
+ symbolS * symbol_rootP;
+ char** where;
+ {
+ symbolS * symbolP;
+ /*
+ * Emit all symbols left in the symbol chain.
+ */
+ for(symbolP = symbol_rootP; symbolP; symbolP = symbolP -> sy_next) {
+ /* Used to save the offset of the name. It is used to point
+ to the string in memory but must be a file offset. */
+ register char * temp;
+
+ temp = S_GET_NAME(symbolP);
+ if (SF_GET_STRING(symbolP)) {
+ S_SET_OFFSET(symbolP, symbolP->sy_name_offset);
+ S_SET_ZEROES(symbolP, 0);
+ } else {
+ memset(symbolP->sy_name, '\0', SYMNMLEN);
+ strncpy(symbolP->sy_name, temp, SYMNMLEN);
+ }
+ SYMBOL_OUTPUT(symbolP, where);
+ S_SET_NAME(symbolP,temp);
+ }
+ }
+
+ /* Merge a debug symbol containing debug information into a normal
+ symbol. */
+
+ void
+ c_symbol_merge(debug, normal)
+ symbolS* debug;
+ symbolS* normal;
+ {
+ S_SET_DATA_TYPE(normal, S_GET_DATA_TYPE(debug));
+ S_SET_STORAGE_CLASS(normal, S_GET_STORAGE_CLASS(debug));
+ S_SET_NUMBER_AUXILIARY(normal, S_GET_NUMBER_AUXILIARY(debug));
+ /* Move all the auxiliary information */
+ if(S_GET_NUMBER_AUXILIARY(debug))
+ memcpy((char*)&normal->sy_auxent, (char*)&debug->sy_auxent,
+ AUXESZ);
+ /* Move the debug flags. */
+ SF_SET_DEBUG_FIELD(normal, SF_GET_DEBUG_FIELD(debug));
+ }
+
+ c_dot_file_symbol(filename)
+ char* filename;
+ {
+ symbolS* symbolP;
+ symbolS* ante_lastP;
+
+ ante_lastP = symbol_lastP;
+
+ symbolP = symbol_new(".file", SEG_DEBUG, 0,
+ C_FILE, &zero_address_frag);
+ S_SET_NUMBER_AUXILIARY(symbolP, 1);
+ SA_SET_FILE_FNAME(symbolP, filename);
+ SF_SET_DEBUG(symbolP);
+
+ /* Make sure that the symbol is first on the symbol chain */
+ if(symbol_rootP != symbolP) {
+ symbol_lastP = ante_lastP;
+ symbol_lastP->sy_next = NULL;
+ symbolP->sy_next = symbol_rootP;
+ symbol_rootP = symbolP;
+ }
+ }
+ /*
+ * Build a 'section static' symbol.
+ */
+
+ char*
+ c_section_symbol(name, value, length, nreloc, nlnno)
+ char* name;
+ long value;
+ long length;
+ unsigned short nreloc;
+ unsigned short nlnno;
+ {
+ symbolS* symbolP;
+
+ symbolP = symbol_new(name,
+ (name[1] == 't' ? SEG_TEXT :
+ name[1] == 'd' ? SEG_DATA :
+ SEG_BSS),
+ value,
+ C_STAT,
+ &zero_address_frag);
+
+ S_SET_NUMBER_AUXILIARY(symbolP, 1);
+
+ SA_SET_SCN_SCNLEN(symbolP, length);
+ SA_SET_SCN_NRELOC(symbolP, nreloc);
+ SA_SET_SCN_NLINNO(symbolP, nlnno);
+
+ SF_SET_STATICS(symbolP);
+
+ return (char*)symbolP;
+ }
+
+ void
+ c_section_header(header, name, core_address, size,
+ data_ptr, reloc_ptr, lineno_ptr,
+ reloc_number, lineno_number)
+ SCNHDR* header;
+ char* name;
+ long core_address;
+ long size;
+ long data_ptr;
+ long reloc_ptr;
+ long lineno_ptr;
+ long reloc_number;
+ long lineno_number;
+ {
+ strncpy(header->s_name, name, 8);
+ header->s_paddr = header->s_vaddr = core_address;
+ header->s_size = size;
+ header->s_scnptr = data_ptr;
+ header->s_relptr = reloc_ptr;
+ header->s_lnnoptr = lineno_ptr;
+ header->s_nreloc = reloc_number;
+ header->s_nlnno = lineno_number;
+ header->s_flags = STYP_REG | ( name[1] == 't' ? STYP_TEXT :
+ name[1] == 'd' ? STYP_DATA :
+ name[1] == 'b' ? STYP_BSS :
+ STYP_INFO );
+ return ;
+ }
+
+ /* Line number handling */
+
+ int text_lineno_number = 0;
+ lineno* lineno_rootP = (lineno*)0;
+ lineno* lineno_lastP = (lineno*)0;
+
+ lineno*
+ c_line_new(paddr, line_number, frag)
+ long paddr;
+ unsigned short line_number;
+ fragS* frag;
+ {
+ lineno* new_line = (lineno*)xmalloc(sizeof(lineno));
+
+ new_line->line.l_addr.l_paddr = paddr;
+ new_line->line.l_lnno = line_number;
+ new_line->frag = (char*)frag;
+ new_line->next = (lineno*)0;
+
+ if(lineno_rootP == (lineno*)0)
+ lineno_rootP = new_line;
+ else
+ lineno_lastP->next = new_line;
+ lineno_lastP = new_line;
+ }
+
+ void
+ emit_lineno(line, where)
+ lineno* line;
+ char** where;
+ {
+ register LINENO* line_entry;
+
+ for(;line;line = line->next) {
+ line_entry = &line->line;
+ /* No matter which member of the union we process, they are
+ both long. */
+ MD(line_entry, l_addr.l_paddr);
+ MD(line_entry, l_lnno);
+ append(where, (char *)line_entry, LINESZ);
+ }
+ return ;
+ }
*** /dev/null Mon Oct 15 09:51:48 1990
--- m-i386.h Mon Oct 15 08:14:18 1990
***************
*** 0 ****
--- 1,10 ----
+ /* Machine specific defines for the SCO Unix V.3.2 ODT */
+ #define scounix
+ #define PROCESSOR_i386
+
+ /* Return true if s (a non null string pointer), points to a local variable
+ name. */
+ #define S_LOCAL_NAME(s) (S_GET_NAME(s)[0] == '.' && S_GET_NAME(s)[1] == 'L')
+
+ /* Compiler does not generate symbol names with a leading underscore. */
+ #define STRIP_UNDERSCORE 0
*** /dev/null Mon Oct 15 09:51:48 1990
--- stack.h Wed Aug 29 13:17:30 1990
***************
*** 0 ****
--- 1,13 ----
+ typedef struct {
+ unsigned long chunk_size;
+ unsigned long element_size;
+ unsigned long size;
+ char* data;
+ unsigned long pointer;
+ } stack;
+
+ extern stack* stack_init();
+ extern void stack_delete();
+ extern char* stack_push();
+ extern char* stack_pop();
+ extern char* stack_top();
*** as.c Tue Mar 20 19:33:57 1990
--- /lasvegas/spare/usenet/port/gas-1.36/as.c Mon Oct 15 09:24:35 1990
***************
*** 35,40 ****
--- 35,41 ----
#include <signal.h>
#define COMMON
+ #include "oformat.h"
#include "as.h"
#include "struc-symbol.h"
#include "write.h"
*** as.h Wed Mar 1 23:49:37 1989
--- /lasvegas/spare/usenet/port/gas-1.36/as.h Sat Oct 13 09:29:35 1990
***************
*** 158,166 ****
/* Invented so we don't crash printing */
/* error message involving weird segment. */
SEG_BIG, /* Bigger than 32 bits constant. */
! SEG_DIFFERENCE /* Mythical Segment: absolute difference. */
} segT;
#define SEG_MAXIMUM_ORDINAL (SEG_DIFFERENCE)
typedef unsigned char subsegT;
--- 158,175 ----
/* Invented so we don't crash printing */
/* error message involving weird segment. */
SEG_BIG, /* Bigger than 32 bits constant. */
! SEG_DIFFERENCE, /* Mythical Segment: absolute difference. */
! #ifdef coff
! SEG_DEBUG, /* Debug segment */
! SEG_NTV, /* Transfert vector preload segment */
! SEG_PTV, /* Transfert vector postload segment */
! #endif /* coff */
} segT;
+ #ifdef coff
+ #define SEG_MAXIMUM_ORDINAL (SEG_PTV)
+ #else /* coff */
#define SEG_MAXIMUM_ORDINAL (SEG_DIFFERENCE)
+ #endif /* coff */
typedef unsigned char subsegT;
***************
*** 176,181 ****
--- 185,207 ----
extern char *seg_name[];
extern int seg_N_TYPE[];
extern segT N_TYPE_seg[];
+ #ifdef coff
+ #define segment_name(v) (seg_name[(v)])
+ /* Machine independent -> machine dependent */
+ #define seg_SEG(v) (seg_N_TYPE[(v)])
+ /*
+ * +4 shift the value of the mnemonics from -4, -3, -2, -1, 0, 1, 2, 3
+ * to 0, 1, 2, 3, 4, 5, 6, 7
+ */
+ /* Machine dependent -> machine independent */
+ #define SEG_seg(v) (N_TYPE_seg[(v) + 4])
+ #else /* coff */
+ #define segment_name(v) (seg_name[(v)])
+ /* Machine independent -> machine dependent */
+ #define seg_SEG(v) (seg_N_TYPE[(v)])
+ /* Machine dependent -> machine independent */
+ #define SEG_seg(v) (N_TYPE_seg[(v)])
+ #endif /* coff */
void subsegs_begin();
void subseg_change();
void subseg_new();
*** expr.c Fri Apr 6 17:51:21 1990
--- /lasvegas/spare/usenet/port/gas-1.36/expr.c Wed Sep 12 09:28:48 1990
***************
*** 25,30 ****
--- 25,31 ----
*/
#include <ctype.h>
+ #include "oformat.h"
#include "as.h"
#include "flonum.h"
#include "read.h"
***************
*** 84,90 ****
{
register char c;
register char *name; /* points to name of symbol */
! register struct symbol * symbolP; /* Points to symbol */
extern char hex_value[]; /* In hex_value.c */
char *local_label_name();
--- 85,91 ----
{
register char c;
register char *name; /* points to name of symbol */
! register symbolS * symbolP; /* Points to symbol */
extern char hex_value[]; /* In hex_value.c */
char *local_label_name();
***************
*** 249,263 ****
*/
name = local_label_name ((int)number, 0);
if ( (symbolP = symbol_table_lookup(name)) /* seen before */
! && (symbolP -> sy_type & N_TYPE) != N_UNDF /* symbol is defined: OK */
! )
{ /* Expected path: symbol defined. */
/* Local labels are never absolute. Don't waste time checking absoluteness. */
! know( (symbolP -> sy_type & N_TYPE) == N_DATA
! || (symbolP -> sy_type & N_TYPE) == N_TEXT );
expressionP -> X_add_symbol = symbolP;
expressionP -> X_add_number = 0;
! expressionP -> X_seg = N_TYPE_seg [symbolP -> sy_type];
}
else
{ /* Either not seen or not defined. */
--- 250,262 ----
*/
name = local_label_name ((int)number, 0);
if ( (symbolP = symbol_table_lookup(name)) /* seen before */
! && (S_IS_DEFINED(symbolP)))
{ /* Expected path: symbol defined. */
/* Local labels are never absolute. Don't waste time checking absoluteness. */
! know((S_IS_DATA(symbolP)) || S_IS_TEXT(symbolP));
expressionP -> X_add_symbol = symbolP;
expressionP -> X_add_number = 0;
! expressionP -> X_seg = SEG_seg(S_GET_SEGMENT(symbolP));
}
else
{ /* Either not seen or not defined. */
***************
*** 288,300 ****
if ( symbolP = symbol_table_lookup( name ))
{
/* We have no need to check symbol properties. */
! know( (symbolP -> sy_type & N_TYPE) == N_UNDF
! || (symbolP -> sy_type & N_TYPE) == N_DATA
! || (symbolP -> sy_type & N_TYPE) == N_TEXT);
}
else
{
! symbolP = symbol_new (name, N_UNDF, 0,0,0, & zero_address_frag);
symbol_table_insert (symbolP);
}
expressionP -> X_add_symbol = symbolP;
--- 287,305 ----
if ( symbolP = symbol_table_lookup( name ))
{
/* We have no need to check symbol properties. */
! know(!S_IS_DEFINED(symbolP) ||
! S_IS_DATA(symbolP) || S_IS_TEXT(symbolP));
}
else
{
! #ifdef coff
! symbolP = symbol_new(name, SEG_UNKNOWN,
! 0, 0,
! &zero_address_frag);
! #else /* coff */
! symbolP = symbol_new (name, N_UNDF, 0,0,0,
! & zero_address_frag);
! #endif /* coff */
symbol_table_insert (symbolP);
}
expressionP -> X_add_symbol = symbolP;
***************
*** 357,368 ****
JF: '.' is pseudo symbol with value of current location in current
segment. . .
*/
symbolP = symbol_new("L0\001",
! (unsigned char)(seg_N_TYPE[(int)now_seg]),
0,
0,
(valueT)(obstack_next_free(&frags)-frag_now->fr_literal),
frag_now);
expressionP->X_add_number=0;
expressionP->X_add_symbol=symbolP;
expressionP->X_seg = now_seg;
--- 362,378 ----
JF: '.' is pseudo symbol with value of current location in current
segment. . .
*/
+ #ifdef coff
+ symbolP = symbol_new("L0\001", now_seg, (valueT)(obstack_next_free(&frags)-
+ frag_now->fr_literal), 0, frag_now);
+ #else /* coff */
symbolP = symbol_new("L0\001",
! (unsigned char)(seg_SEG((int)now_seg)),
0,
0,
(valueT)(obstack_next_free(&frags)-frag_now->fr_literal),
frag_now);
+ #endif /* coff */
expressionP->X_add_number=0;
expressionP->X_add_symbol=symbolP;
expressionP->X_seg = now_seg;
***************
*** 383,389 ****
*/
register segT seg;
! seg = N_TYPE_seg [(int) symbolP -> sy_type & N_TYPE];
if ((expressionP -> X_seg = seg) == SEG_ABSOLUTE )
{
expressionP -> X_add_number = symbolP -> sy_value;
--- 393,399 ----
*/
register segT seg;
! seg = SEG_seg((int)S_GET_SEGMENT(symbolP));
if ((expressionP -> X_seg = seg) == SEG_ABSOLUTE )
{
expressionP -> X_add_number = symbolP -> sy_value;
***************
*** 398,404 ****
--- 408,418 ----
{
expressionP -> X_add_symbol
= symbolP
+ #ifdef coff
+ = symbol_new (name, SEG_UNKNOWN, 0, 0, &zero_address_frag);
+ #else /* coff */
= symbol_new (name, N_UNDF, 0,0,0, & zero_address_frag);
+ #endif /* coff */
expressionP -> X_add_number = 0;
expressionP -> X_seg = SEG_UNKNOWN;
***************
*** 553,578 ****
static segT
expr_part (symbol_1_PP, symbol_2_P)
! struct symbol ** symbol_1_PP;
! struct symbol * symbol_2_P;
{
segT return_value;
know( (* symbol_1_PP) == NULL
! || ((* symbol_1_PP) -> sy_type & N_TYPE) == N_TEXT
! || ((* symbol_1_PP) -> sy_type & N_TYPE) == N_DATA
! || ((* symbol_1_PP) -> sy_type & N_TYPE) == N_BSS
! || ((* symbol_1_PP) -> sy_type & N_TYPE) == N_UNDF
);
know( symbol_2_P == NULL
! || (symbol_2_P -> sy_type & N_TYPE) == N_TEXT
! || (symbol_2_P -> sy_type & N_TYPE) == N_DATA
! || (symbol_2_P -> sy_type & N_TYPE) == N_BSS
! || (symbol_2_P -> sy_type & N_TYPE) == N_UNDF
);
if (* symbol_1_PP)
{
! if (((* symbol_1_PP) -> sy_type & N_TYPE) == N_UNDF)
{
if (symbol_2_P)
{
--- 567,592 ----
static segT
expr_part (symbol_1_PP, symbol_2_P)
! symbolS ** symbol_1_PP;
! symbolS * symbol_2_P;
{
segT return_value;
know( (* symbol_1_PP) == NULL
! || (S_IS_TEXT(* symbol_1_PP))
! || (S_IS_DATA(* symbol_1_PP))
! || (S_IS_BSS(* symbol_1_PP))
! || (!S_IS_DEFINED(* symbol_1_PP))
);
know( symbol_2_P == NULL
! || (S_IS_TEXT(symbol_2_P))
! || (S_IS_DATA(symbol_2_P))
! || (S_IS_BSS(symbol_2_P))
! || (!S_IS_DEFINED(symbol_2_P))
);
if (* symbol_1_PP)
{
! if (!S_IS_DEFINED(* symbol_1_PP))
{
if (symbol_2_P)
{
***************
*** 581,587 ****
}
else
{
! know( ((* symbol_1_PP) -> sy_type & N_TYPE) == N_UNDF)
return_value = SEG_UNKNOWN;
}
}
--- 595,601 ----
}
else
{
! know(!S_IS_DEFINED(* symbol_1_PP));
return_value = SEG_UNKNOWN;
}
}
***************
*** 589,595 ****
{
if (symbol_2_P)
{
! if ((symbol_2_P -> sy_type & N_TYPE) == N_UNDF)
{
* symbol_1_PP = NULL;
return_value = SEG_PASS1;
--- 603,609 ----
{
if (symbol_2_P)
{
! if (!S_IS_DEFINED(symbol_2_P))
{
* symbol_1_PP = NULL;
return_value = SEG_PASS1;
***************
*** 598,604 ****
{
/* {seg1} - {seg2} */
as_warn( "Expression too complex, 2 symbols forgotten: \"%s\" \"%s\"",
! (* symbol_1_PP) -> sy_name, symbol_2_P -> sy_name );
* symbol_1_PP = NULL;
return_value = SEG_ABSOLUTE;
}
--- 612,618 ----
{
/* {seg1} - {seg2} */
as_warn( "Expression too complex, 2 symbols forgotten: \"%s\" \"%s\"",
! S_GET_NAME(* symbol_1_PP), S_GET_NAME(symbol_2_P));
* symbol_1_PP = NULL;
return_value = SEG_ABSOLUTE;
}
***************
*** 605,611 ****
}
else
{
! return_value = N_TYPE_seg [(* symbol_1_PP) -> sy_type & N_TYPE];
}
}
}
--- 619,625 ----
}
else
{
! return_value = SEG_seg(S_GET_SEGMENT(* symbol_1_PP));
}
}
}
***************
*** 614,620 ****
if (symbol_2_P)
{
* symbol_1_PP = symbol_2_P;
! return_value = N_TYPE_seg [(symbol_2_P) -> sy_type & N_TYPE];
}
else
{
--- 628,634 ----
if (symbol_2_P)
{
* symbol_1_PP = symbol_2_P;
! return_value = SEG_seg(S_GET_SEGMENT(symbol_2_P));
}
else
{
***************
*** 630,636 ****
|| return_value == SEG_PASS1
);
know( (* symbol_1_PP) == NULL
! || ((* symbol_1_PP) -> sy_type & N_TYPE) == seg_N_TYPE [(int) return_value] );
return (return_value);
} /* expr_part() */
--- 644,650 ----
|| return_value == SEG_PASS1
);
know( (* symbol_1_PP) == NULL
! || (S_GET_SEGMENT(* symbol_1_PP) == seg_SEG((int) return_value) ));
return (return_value);
} /* expr_part() */
***************
*** 792,798 ****
* does not cause any further inaccuracy.
*/
! register struct symbol * symbolP;
right . X_add_number = - right . X_add_number;
symbolP = right . X_add_symbol;
--- 806,812 ----
* does not cause any further inaccuracy.
*/
! register symbolS * symbolP;
right . X_add_number = - right . X_add_number;
symbolP = right . X_add_symbol;
***************
*** 858,865 ****
know( resultP -> X_add_symbol );
know( resultP -> X_subtract_symbol );
as_warn("Expression too complex: forgetting %s - %s",
! resultP -> X_add_symbol -> sy_name,
! resultP -> X_subtract_symbol -> sy_name);
resultP -> X_seg = SEG_ABSOLUTE;
/* Clean_up_expression() will do the rest. */
}
--- 872,879 ----
know( resultP -> X_add_symbol );
know( resultP -> X_subtract_symbol );
as_warn("Expression too complex: forgetting %s - %s",
! S_GET_NAME(resultP -> X_add_symbol),
! S_GET_NAME(resultP -> X_subtract_symbol));
resultP -> X_seg = SEG_ABSOLUTE;
/* Clean_up_expression() will do the rest. */
}
*** frags.c Thu Aug 17 20:53:21 1989
--- /lasvegas/spare/usenet/port/gas-1.36/frags.c Wed Sep 12 09:28:49 1990
***************
*** 17,22 ****
--- 17,23 ----
along with GAS; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+ #include "oformat.h"
#include "as.h"
#include "subsegs.h"
#include "obstack.h"
*** hash.c Wed Mar 1 23:49:18 1989
--- /lasvegas/spare/usenet/port/gas-1.36/hash.c Wed Sep 12 09:28:45 1990
***************
*** 129,134 ****
--- 129,137 ----
#define min(a, b) ((a) < (b) ? (a) : (b))
#include "hash.h"
+
+ #define error as_fatal
+
char *xmalloc();
#define DELETED ((char *)1) /* guarenteed invalid address */
*** i386.c Wed May 16 16:29:04 1990
--- /lasvegas/spare/usenet/port/gas-1.36/i386.c Sat Oct 13 11:34:21 1990
***************
*** 37,42 ****
--- 37,43 ----
#define index strchr
#endif
+ #include "oformat.h"
#include "as.h"
#include "read.h"
#include "flonum.h"
***************
*** 168,176 ****
{ "tfloat", float_cons, 'x' },
{ "value", cons, 2 },
{ "ident", dummy, 0 }, /* ignore these directives */
! { "def", dummy, 0 },
{ "version", dummy, 0 },
! { "ln", dummy, 0 },
{ 0, 0, 0 }
};
--- 169,177 ----
{ "tfloat", float_cons, 'x' },
{ "value", cons, 2 },
{ "ident", dummy, 0 }, /* ignore these directives */
! /* { "def", dummy, 0 },*/
{ "version", dummy, 0 },
! /* { "ln", dummy, 0 },*/
{ 0, 0, 0 }
};
***************
*** 372,391 ****
}
}
! #define SYMBOL_TYPE(t) \
! (((t&N_TYPE) == N_UNDF) ? "UNDEFINED" : \
! (((t&N_TYPE) == N_ABS) ? "ABSOLUTE" : \
! (((t&N_TYPE) == N_TEXT) ? "TEXT" : \
! (((t&N_TYPE) == N_DATA) ? "DATA" : \
! (((t&N_TYPE) == N_BSS) ? "BSS" : "Bad n_type!")))))
static void ps (s)
symbolS *s;
{
fprintf (stdout, "%s type %s%s",
! s->sy_nlist.n_un.n_name,
! (s->sy_nlist.n_type&N_EXT) ? "EXTERNAL " : "",
! SYMBOL_TYPE (s->sy_nlist.n_type));
}
struct type_name {
--- 373,387 ----
}
}
! #define SYMBOL_TYPE(t) segment_name(SEG_seg(t))
static void ps (s)
symbolS *s;
{
fprintf (stdout, "%s type %s%s",
! S_GET_NAME(s),
! S_IS_EXTERNAL(s) ? "EXTERNAL " : "",
! SYMBOL_TYPE(S_GET_SEGMENT(s))
}
struct type_name {
***************
*** 1543,1549 ****
int
md_estimate_size_before_relax (fragP, segment_type)
register fragS * fragP;
! register int segment_type; /* N_DATA or N_TEXT. */
{
register uchar * opcode;
register int old_fr_fix;
--- 1539,1545 ----
int
md_estimate_size_before_relax (fragP, segment_type)
register fragS * fragP;
! register int segment_type; /* DATA or TEXT. */
{
register uchar * opcode;
register int old_fr_fix;
***************
*** 1552,1558 ****
opcode = (uchar *) fragP -> fr_opcode;
/* We've already got fragP->fr_subtype right; all we have to do is check
for un-relaxable symbols. */
! if ((fragP -> fr_symbol -> sy_type & N_TYPE) != segment_type) {
/* symbol is undefined in this segment */
switch (opcode[0]) {
case JUMP_PC_RELATIVE: /* make jmp (0xeb) a dword displacement jump */
--- 1548,1554 ----
opcode = (uchar *) fragP -> fr_opcode;
/* We've already got fragP->fr_subtype right; all we have to do is check
for un-relaxable symbols. */
! if (S_GET_SEGMENT(fragP->fr_symbol) != segment_type) {
/* symbol is undefined in this segment */
switch (opcode[0]) {
case JUMP_PC_RELATIVE: /* make jmp (0xeb) a dword displacement jump */
***************
*** 1605,1611 ****
opcode = (uchar *) fragP -> fr_opcode;
/* Address we want to reach in file space. */
! target_address = fragP->fr_symbol->sy_value + fragP->fr_offset;
/* Address opcode resides at in file space. */
opcode_address = fragP->fr_address + fragP->fr_fix;
--- 1601,1607 ----
opcode = (uchar *) fragP -> fr_opcode;
/* Address we want to reach in file space. */
! target_address = S_GET_VALUE(fragP->fr_symbol) + fragP->fr_offset;
/* Address opcode resides at in file space. */
opcode_address = fragP->fr_address + fragP->fr_fix;
***************
*** 1684,1690 ****
long offset;
if (flagseen['m']) {
! offset = to_addr - to_symbol->sy_value;
md_number_to_chars (ptr, 0xe9, 1); /* opcode for long jmp */
md_number_to_chars (ptr + 1, offset, 4);
fix_new (frag, (ptr+1) - frag->fr_literal, 4,
--- 1680,1686 ----
long offset;
if (flagseen['m']) {
! offset = to_addr - S_GET_VALUE(to_symbol);
md_number_to_chars (ptr, 0xe9, 1); /* opcode for long jmp */
md_number_to_chars (ptr + 1, offset, 4);
fix_new (frag, (ptr+1) - frag->fr_literal, 4,
***************
*** 1833,1838 ****
--- 1829,1837 ----
return retval;
}
+ /* Not needed for coff since relocation structure does not
+ contain bitfields. */
+ #ifdef aout
void md_ri_to_chars(ri_p, ri)
struct relocation_info *ri_p, ri;
{
***************
*** 1849,1854 ****
--- 1848,1854 ----
/* now put it back where you found it */
bcopy (the_bytes, (char *)ri_p, sizeof(struct relocation_info));
}
+ #endif /* aout */
#define MAX_LITTLENUMS 6
--
Loic Dachary loic at adesign.uucp or loic at afp.uucp
Voice +33 1 40 35 20 20
More information about the Alt.sources
mailing list