1991-12-12 00:53:23 +00:00
|
|
|
/* coff object file format with bfd
|
* Extensive changes to permit symbols to contain any expression
type and to delay the computation of the expression until the
value is actually needed. This permits setting symbols to values
calculated based on object code size. Expressions were changed to
no longer be in a section, to stop the overloading of segment and
expression type that previously occurred.
* as.c (big_section, pass1_section, diff_section, absent_section):
Removed.
(expr_section): Added (used for dummy symbols which hold
intermediate expression values).
(perform_an_assembly_pass): Create expr_section, do not create the
sections now removed.
* as.h (segT): Removed SEG_ABSENT, SEG_PASS1, SEG_BIG, and
SEG_DIFFERENCE. Added SEG_EXPR.
(SEG_NORMAL): Corresponding changes.
* subsegs.c (seg_name, subsegs_begin): Changed accordingly.
* write.c (write_object_file): Ditto.
* config/obj-aout.c (seg_N_TYPE): Ditto.
* config/obj-bout.c (seg_N_TYPE): Ditto.
* config/obj-coff.c (seg_N_TYPE): Ditto.
* config/obj-coffbfd.c (seg_N_TYPE): Ditto.
* config/obj-vms.c (seg_N_TYPE): Ditto.
* expr.h (operatorT): Moved in from expr.c, added some values.
(expressionS): Added X_op field, removed X_seg field; renamed
X_subtract_symbol to X_op_symbol.
* expr.c: Extensive changes to assign expression types rather than
sections and to simplify the parsing.
* write.c (fix_new_internal): New static function.
(fix_new): Removed sub_symbol argument.
(fix_new_exp): New function, takes expression argument.
* write.h: Prototype changes for fix_new and fix_new_exp.
* cond.c (s_if): Changed accordingly.
* read.c (s_lsym, pseudo_set, emit_expr, parse_bitfield_cons,
parse_repeat_cons, get_segmented_expression,
get_known_segmented_expression, get_absolute_expression): Ditto.
* symbols.c (resolve_symbol_value, S_GET_VALUE, S_SET_VALUE):
Ditto.
* write.c (write_object_file): Ditto.
* config/obj-coff.c (obj_coff_def, obj_coff_val): Ditto.
* config/obj-coffbfd.c (obj_coff_def, obj_coff_val,
obj_coff_endef, yank_symbols): Ditto.
* config/obj-elf.c (obj_elf_stab_generic, obj_elf_size): Ditto.
* config/tc-a29k.c (md_assemble, parse_operand, machine_ip,
print_insn, md_operand): Ditto.
* config/tc-h8300.c (parse_exp, colonmod24, check_operand,
do_a_fix_imm, build_bytes): Ditto.
* config/tc-h8500.c (parse_exp, skip_colonthing, parse_reglist,
get_specific, check, insert, md_convert_frag): Ditto.
* config/tc-hppa.c (the_insn, fix_new_hppa, cons_fix_new_hppa,
md_assemble, pa_ip, getExpression, getAbsoluteExpression,
evaluateAbsolute, pa_build_unwind_subspace, pa_entry,
process_exit): Ditto.
* config/tc-hppa.h (STAB_FIXUP, is_DP_relative, is_PC_relative,
is_complex): Ditto.
* config/tc-i386.c (pe, md_assemble, i386_operand,
md_estimate_size_before_relax, md_create_long_jump): Ditto.
* config/tc-i860.c (md_assemble, getExpression, print_insn):
Ditto.
* config/tc-i960.c (parse_expr, subs, segs, md_convert_frag,
get_cdisp, mem_fmt, parse_ldconst, relax_cobr, s_sysproc,
i960_handle_align): Ditto.
* config/tc-m68k.c (struct m68k_exp, struct m68k_it, seg, op,
subs, add_fix, isvar, m68k_ip, md_assemble, md_convert_frag_1,
md_estimate_size_before_relax, md_create_long_jump, get_num):
Ditto.
* config/tc-m88k.c (md_assemble, get_imm16, get_pcr,
md_create_short_jump, md_create_long_jump): Ditto.
* config/tc-mips.c (md_assemble, append_insn, gp_reference,
macro_build, macro, my_getExpression): Ditto. Also removed
get_optional_absolute_expression; just use get_absolute_expression
instead.
* config/tc-ns32k.c (get_addr_mode, evaluate_expr, convert_iif,
fix_new_ns32k, fix_new_ns32k_exp, cons_fix_new_ns32k): Ditto.
* config/tc-ns32k.h (fix_new_ns32k prototype): Ditto.
* config/tc-sh.c (parse_exp, check, insert, md_convert_frag):
Ditto.
* config/tc-sparc.c (md_assemble, sparc_ip, getExpression,
print_insn): Ditto.
* config/tc-tahoe.c (struct top, md_estimate_size_before_relax,
tip_op, md_assemble): Ditto.
* config/tc-vax.c (seg_of_operand, md_assemble,
md_estimate_size_before_relax, md_create_long_jump): Ditto.
* config/tc-z8k.c (parse_exp, check_operand, newfix): Ditto.
1993-07-21 00:41:42 +00:00
|
|
|
Copyright (C) 1989, 1990, 1991, 1993 Free Software Foundation, Inc.
|
1992-02-22 20:45:24 +00:00
|
|
|
|
|
|
|
This file is part of GAS.
|
|
|
|
|
|
|
|
GAS is free software; you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation; either version 2, or (at your option)
|
|
|
|
any later version.
|
|
|
|
|
|
|
|
GAS is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with GAS; see the file COPYING. If not, write to
|
|
|
|
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
|
1991-12-12 00:53:23 +00:00
|
|
|
|
|
|
|
/*
|
1992-02-22 20:45:24 +00:00
|
|
|
|
|
|
|
How does this releate to the rest of GAS ?
|
|
|
|
|
|
|
|
Well, all the other files in gas are more or less a black box. It
|
|
|
|
takes care of opening files, parsing command lines, stripping blanks
|
|
|
|
etc etc. This module gets a chance to register what it wants to do by
|
|
|
|
saying that it is interested in various pseduo ops. The other big
|
|
|
|
change is write_object_file. This runs through all the data
|
|
|
|
structures that gas builds, and outputs the file in the format of our
|
|
|
|
choice.
|
1992-11-23 20:42:33 +00:00
|
|
|
|
1992-02-22 20:45:24 +00:00
|
|
|
Hacked for BFDness by steve chamberlain
|
|
|
|
|
1993-02-04 20:47:48 +00:00
|
|
|
This object module now supports the Hitachi H8/{3|5}00 and the AMD 29k
|
1992-02-22 20:45:24 +00:00
|
|
|
|
|
|
|
sac@cygnus.com
|
|
|
|
*/
|
1991-12-12 00:53:23 +00:00
|
|
|
|
|
|
|
#include "as.h"
|
|
|
|
#include "obstack.h"
|
|
|
|
#include "subsegs.h"
|
|
|
|
#include "frags.h"
|
|
|
|
#include "../bfd/libbfd.h"
|
1992-12-08 08:48:16 +00:00
|
|
|
#include "../bfd/libcoff.h"
|
1991-12-12 00:53:23 +00:00
|
|
|
|
Sat Dec 12 15:26:34 1992 Ian Lance Taylor (ian@cygnus.com)
* listing.c: Call xmalloc, not malloc; don't declare malloc.
* Changes to support SCO 3.2v4:
* read.c (s_align_bytes, s_align_ptwo): If not SEG_DATA or
SEG_BSS, fill with NOP_OPCODE.
* config/i386coff.mt: Add opcode/i386.h to TARG_CPU_DEPENDENTS.
* config/obj-coffbfd.c (do_relocs_for): Increment addr even if not
using ZERO_BASED_SEGMENTS.
(fill_section): If ZERO_BASED_SEGMENTS, set segment addresses, but
never set segment address for SEG_E2 (.bss) and don't write out
SEG_E2 contents. Set .init and .fini sections to STYP_TEXT.
(obj_coff_endef): Don't merge labels or symbols awaiting forward
definitions, and don't merge tags with non-tags. Check for .bf
rather than just checking whether the second character is b and
the third character is f.
(obj_coff_val): gcc can generate values which we don't handle
correctly; discard information for now, since it only affects the
debugging information.
(tag_find_or_name): Don't insert tags in the symbol table.
(yank_symbols): Don't merge labels.
(write_object_file): Don't define SUB_SEGMENT_ALIGN if it is
already defined. Fill subsegments with NOP_OPCODE, not 0. Don't
set segment address if ZERO_BASED_SEGMENTS.
(obj_coff_section): Accept and ignore a trailing quoted string, as
used in AT&T i386 syntax.
(fixup_segment): Take segment as argument. On the i386, adjust PC
relative addends by the segment vaddr.
* tc-i386.h: Define SUB_SEGMENT_ALIGN.
* tc-a29k.h: Define ZERO_BASED_SEGMENTS.
* tc-i386.c: (i386_operand): If I386COFF, accept any segment type.
1992-12-13 00:56:14 +00:00
|
|
|
/* The NOP_OPCODE is for the alignment fill value. Fill with nop so
|
|
|
|
that we can stick sections together without causing trouble. */
|
|
|
|
#ifndef NOP_OPCODE
|
|
|
|
#define NOP_OPCODE 0x00
|
|
|
|
#endif
|
1991-12-12 00:53:23 +00:00
|
|
|
|
1992-05-02 02:34:21 +00:00
|
|
|
#define MIN(a,b) ((a) < (b)? (a) : (b))
|
1991-12-12 00:53:23 +00:00
|
|
|
/* This vector is used to turn an internal segment into a section #
|
1992-11-23 20:42:33 +00:00
|
|
|
suitable for insertion into a coff symbol table
|
1992-02-22 20:45:24 +00:00
|
|
|
*/
|
1991-12-12 00:53:23 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
const short seg_N_TYPE[] =
|
|
|
|
{ /* in: segT out: N_TYPE bits */
|
|
|
|
C_ABS_SECTION,
|
|
|
|
1,
|
|
|
|
2,
|
|
|
|
3,
|
|
|
|
4,
|
|
|
|
5,
|
|
|
|
6,
|
|
|
|
7,
|
|
|
|
8,
|
|
|
|
9,
|
|
|
|
10,
|
|
|
|
C_UNDEF_SECTION, /* SEG_UNKNOWN */
|
|
|
|
C_UNDEF_SECTION, /* SEG_GOOF */
|
* Extensive changes to permit symbols to contain any expression
type and to delay the computation of the expression until the
value is actually needed. This permits setting symbols to values
calculated based on object code size. Expressions were changed to
no longer be in a section, to stop the overloading of segment and
expression type that previously occurred.
* as.c (big_section, pass1_section, diff_section, absent_section):
Removed.
(expr_section): Added (used for dummy symbols which hold
intermediate expression values).
(perform_an_assembly_pass): Create expr_section, do not create the
sections now removed.
* as.h (segT): Removed SEG_ABSENT, SEG_PASS1, SEG_BIG, and
SEG_DIFFERENCE. Added SEG_EXPR.
(SEG_NORMAL): Corresponding changes.
* subsegs.c (seg_name, subsegs_begin): Changed accordingly.
* write.c (write_object_file): Ditto.
* config/obj-aout.c (seg_N_TYPE): Ditto.
* config/obj-bout.c (seg_N_TYPE): Ditto.
* config/obj-coff.c (seg_N_TYPE): Ditto.
* config/obj-coffbfd.c (seg_N_TYPE): Ditto.
* config/obj-vms.c (seg_N_TYPE): Ditto.
* expr.h (operatorT): Moved in from expr.c, added some values.
(expressionS): Added X_op field, removed X_seg field; renamed
X_subtract_symbol to X_op_symbol.
* expr.c: Extensive changes to assign expression types rather than
sections and to simplify the parsing.
* write.c (fix_new_internal): New static function.
(fix_new): Removed sub_symbol argument.
(fix_new_exp): New function, takes expression argument.
* write.h: Prototype changes for fix_new and fix_new_exp.
* cond.c (s_if): Changed accordingly.
* read.c (s_lsym, pseudo_set, emit_expr, parse_bitfield_cons,
parse_repeat_cons, get_segmented_expression,
get_known_segmented_expression, get_absolute_expression): Ditto.
* symbols.c (resolve_symbol_value, S_GET_VALUE, S_SET_VALUE):
Ditto.
* write.c (write_object_file): Ditto.
* config/obj-coff.c (obj_coff_def, obj_coff_val): Ditto.
* config/obj-coffbfd.c (obj_coff_def, obj_coff_val,
obj_coff_endef, yank_symbols): Ditto.
* config/obj-elf.c (obj_elf_stab_generic, obj_elf_size): Ditto.
* config/tc-a29k.c (md_assemble, parse_operand, machine_ip,
print_insn, md_operand): Ditto.
* config/tc-h8300.c (parse_exp, colonmod24, check_operand,
do_a_fix_imm, build_bytes): Ditto.
* config/tc-h8500.c (parse_exp, skip_colonthing, parse_reglist,
get_specific, check, insert, md_convert_frag): Ditto.
* config/tc-hppa.c (the_insn, fix_new_hppa, cons_fix_new_hppa,
md_assemble, pa_ip, getExpression, getAbsoluteExpression,
evaluateAbsolute, pa_build_unwind_subspace, pa_entry,
process_exit): Ditto.
* config/tc-hppa.h (STAB_FIXUP, is_DP_relative, is_PC_relative,
is_complex): Ditto.
* config/tc-i386.c (pe, md_assemble, i386_operand,
md_estimate_size_before_relax, md_create_long_jump): Ditto.
* config/tc-i860.c (md_assemble, getExpression, print_insn):
Ditto.
* config/tc-i960.c (parse_expr, subs, segs, md_convert_frag,
get_cdisp, mem_fmt, parse_ldconst, relax_cobr, s_sysproc,
i960_handle_align): Ditto.
* config/tc-m68k.c (struct m68k_exp, struct m68k_it, seg, op,
subs, add_fix, isvar, m68k_ip, md_assemble, md_convert_frag_1,
md_estimate_size_before_relax, md_create_long_jump, get_num):
Ditto.
* config/tc-m88k.c (md_assemble, get_imm16, get_pcr,
md_create_short_jump, md_create_long_jump): Ditto.
* config/tc-mips.c (md_assemble, append_insn, gp_reference,
macro_build, macro, my_getExpression): Ditto. Also removed
get_optional_absolute_expression; just use get_absolute_expression
instead.
* config/tc-ns32k.c (get_addr_mode, evaluate_expr, convert_iif,
fix_new_ns32k, fix_new_ns32k_exp, cons_fix_new_ns32k): Ditto.
* config/tc-ns32k.h (fix_new_ns32k prototype): Ditto.
* config/tc-sh.c (parse_exp, check, insert, md_convert_frag):
Ditto.
* config/tc-sparc.c (md_assemble, sparc_ip, getExpression,
print_insn): Ditto.
* config/tc-tahoe.c (struct top, md_estimate_size_before_relax,
tip_op, md_assemble): Ditto.
* config/tc-vax.c (seg_of_operand, md_assemble,
md_estimate_size_before_relax, md_create_long_jump): Ditto.
* config/tc-z8k.c (parse_exp, check_operand, newfix): Ditto.
1993-07-21 00:41:42 +00:00
|
|
|
C_UNDEF_SECTION, /* SEG_EXPR */
|
1992-11-23 20:42:33 +00:00
|
|
|
C_DEBUG_SECTION, /* SEG_DEBUG */
|
|
|
|
C_NTV_SECTION, /* SEG_NTV */
|
|
|
|
C_PTV_SECTION, /* SEG_PTV */
|
|
|
|
C_REGISTER_SECTION, /* SEG_REGISTER */
|
1991-12-12 00:53:23 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
int function_lineoff = -1; /* Offset in line#s where the last function
|
|
|
|
started (the odd entry for line #0) */
|
|
|
|
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
static symbolS *last_line_symbol;
|
1992-12-30 21:39:51 +00:00
|
|
|
|
1991-12-12 00:53:23 +00:00
|
|
|
/* Add 4 to the real value to get the index and compensate the
|
|
|
|
negatives. This vector is used by S_GET_SEGMENT to turn a coff
|
1992-11-23 20:42:33 +00:00
|
|
|
section number into a segment number
|
1992-02-22 20:45:24 +00:00
|
|
|
*/
|
1991-12-12 00:53:23 +00:00
|
|
|
static symbolS *previous_file_symbol = NULL;
|
1992-11-23 20:42:33 +00:00
|
|
|
void c_symbol_merge ();
|
1992-01-28 03:43:23 +00:00
|
|
|
static int line_base;
|
1991-12-12 00:53:23 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
symbolS *c_section_symbol ();
|
1991-12-12 00:53:23 +00:00
|
|
|
bfd *abfd;
|
1992-11-23 20:42:33 +00:00
|
|
|
void EXFUN (bfd_as_write_hook, (struct internal_filehdr *,
|
|
|
|
bfd * abfd));
|
1991-12-12 00:53:23 +00:00
|
|
|
|
Sat Dec 12 15:26:34 1992 Ian Lance Taylor (ian@cygnus.com)
* listing.c: Call xmalloc, not malloc; don't declare malloc.
* Changes to support SCO 3.2v4:
* read.c (s_align_bytes, s_align_ptwo): If not SEG_DATA or
SEG_BSS, fill with NOP_OPCODE.
* config/i386coff.mt: Add opcode/i386.h to TARG_CPU_DEPENDENTS.
* config/obj-coffbfd.c (do_relocs_for): Increment addr even if not
using ZERO_BASED_SEGMENTS.
(fill_section): If ZERO_BASED_SEGMENTS, set segment addresses, but
never set segment address for SEG_E2 (.bss) and don't write out
SEG_E2 contents. Set .init and .fini sections to STYP_TEXT.
(obj_coff_endef): Don't merge labels or symbols awaiting forward
definitions, and don't merge tags with non-tags. Check for .bf
rather than just checking whether the second character is b and
the third character is f.
(obj_coff_val): gcc can generate values which we don't handle
correctly; discard information for now, since it only affects the
debugging information.
(tag_find_or_name): Don't insert tags in the symbol table.
(yank_symbols): Don't merge labels.
(write_object_file): Don't define SUB_SEGMENT_ALIGN if it is
already defined. Fill subsegments with NOP_OPCODE, not 0. Don't
set segment address if ZERO_BASED_SEGMENTS.
(obj_coff_section): Accept and ignore a trailing quoted string, as
used in AT&T i386 syntax.
(fixup_segment): Take segment as argument. On the i386, adjust PC
relative addends by the segment vaddr.
* tc-i386.h: Define SUB_SEGMENT_ALIGN.
* tc-a29k.h: Define ZERO_BASED_SEGMENTS.
* tc-i386.c: (i386_operand): If I386COFF, accept any segment type.
1992-12-13 00:56:14 +00:00
|
|
|
static void EXFUN (fixup_segment, (segment_info_type *segP,
|
1992-11-23 20:42:33 +00:00
|
|
|
segT this_segment_type));
|
1991-12-12 00:53:23 +00:00
|
|
|
|
1992-09-09 18:38:16 +00:00
|
|
|
|
1992-12-30 21:39:51 +00:00
|
|
|
static void EXFUN (fixup_mdeps, (fragS *,
|
|
|
|
object_headers *,
|
|
|
|
segT));
|
1992-09-09 18:38:16 +00:00
|
|
|
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
static void EXFUN (fill_section, (bfd * abfd,
|
1992-12-30 21:39:51 +00:00
|
|
|
object_headers *,
|
|
|
|
unsigned long *));
|
1991-12-12 00:53:23 +00:00
|
|
|
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
char *EXFUN (s_get_name, (symbolS * s));
|
|
|
|
static symbolS *EXFUN (tag_find_or_make, (char *name));
|
|
|
|
static symbolS *EXFUN (tag_find, (char *name));
|
1991-12-12 00:53:23 +00:00
|
|
|
|
|
|
|
|
|
|
|
static int
|
1992-11-23 20:42:33 +00:00
|
|
|
EXFUN (c_line_new, (
|
|
|
|
symbolS * symbol,
|
|
|
|
long paddr,
|
|
|
|
unsigned short line_number,
|
|
|
|
fragS * frag));
|
|
|
|
|
|
|
|
|
|
|
|
static void EXFUN (w_symbols,
|
|
|
|
(bfd * abfd,
|
|
|
|
char *where,
|
|
|
|
symbolS * symbol_rootP));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void EXFUN (obj_coff_def, (int what));
|
|
|
|
static void EXFUN (obj_coff_lcomm, (void));
|
|
|
|
static void EXFUN (obj_coff_dim, (void));
|
|
|
|
static void EXFUN (obj_coff_text, (void));
|
|
|
|
static void EXFUN (obj_coff_data, (void));
|
1992-12-30 21:39:51 +00:00
|
|
|
static void EXFUN( obj_coff_bss,(void));
|
|
|
|
static void EXFUN( obj_coff_ident,(void));
|
1992-11-23 20:42:33 +00:00
|
|
|
static void EXFUN (obj_coff_endef, (void));
|
|
|
|
static void EXFUN (obj_coff_line, (void));
|
1993-05-27 19:29:38 +00:00
|
|
|
static void EXFUN (obj_coff_ln, (int));
|
1992-11-23 20:42:33 +00:00
|
|
|
static void EXFUN (obj_coff_scl, (void));
|
|
|
|
static void EXFUN (obj_coff_size, (void));
|
|
|
|
static void EXFUN (obj_coff_tag, (void));
|
|
|
|
static void EXFUN (obj_coff_type, (void));
|
|
|
|
static void EXFUN (obj_coff_val, (void));
|
|
|
|
void EXFUN (obj_coff_section, (void));
|
|
|
|
static void EXFUN (tag_init, (void));
|
|
|
|
static void EXFUN (tag_insert, (char *name, symbolS * symbolP));
|
1991-12-12 00:53:23 +00:00
|
|
|
|
|
|
|
|
|
|
|
static struct hash_control *tag_hash;
|
|
|
|
static symbolS *def_symbol_in_progress = NULL;
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
const pseudo_typeS obj_pseudo_table[] =
|
|
|
|
{
|
|
|
|
{"def", obj_coff_def, 0},
|
|
|
|
{"dim", obj_coff_dim, 0},
|
|
|
|
{"endef", obj_coff_endef, 0},
|
|
|
|
{"line", obj_coff_line, 0},
|
|
|
|
{"ln", obj_coff_ln, 0},
|
1993-05-27 19:29:38 +00:00
|
|
|
{"appline", obj_coff_ln, 1},
|
1992-11-23 20:42:33 +00:00
|
|
|
{"scl", obj_coff_scl, 0},
|
|
|
|
{"size", obj_coff_size, 0},
|
|
|
|
{"tag", obj_coff_tag, 0},
|
|
|
|
{"type", obj_coff_type, 0},
|
|
|
|
{"val", obj_coff_val, 0},
|
|
|
|
{"section", obj_coff_section, 0},
|
|
|
|
{"use", obj_coff_section, 0},
|
|
|
|
{"sect", obj_coff_section, 0},
|
|
|
|
{"text", obj_coff_text, 0},
|
|
|
|
{"data", obj_coff_data, 0},
|
1992-12-30 21:39:51 +00:00
|
|
|
{"bss", obj_coff_bss, 0},
|
|
|
|
{"ident", obj_coff_ident, 0},
|
1992-11-23 20:42:33 +00:00
|
|
|
{"ABORT", s_abort, 0},
|
|
|
|
{"lcomm", obj_coff_lcomm, 0},
|
1993-07-15 16:02:21 +00:00
|
|
|
#ifdef TC_M88K
|
|
|
|
/* The m88k uses sdef instead of def. */
|
|
|
|
{"sdef", obj_coff_def, 0},
|
|
|
|
#endif
|
1992-11-23 20:42:33 +00:00
|
|
|
{NULL} /* end sentinel */
|
|
|
|
}; /* obj_pseudo_table */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Section stuff
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1991-12-12 00:53:23 +00:00
|
|
|
We allow more than just the standard 3 sections, infact, we allow
|
|
|
|
10 sections, (though the usual three have to be there).
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1991-12-12 00:53:23 +00:00
|
|
|
This structure performs the mappings for us:
|
1992-02-22 20:45:24 +00:00
|
|
|
|
|
|
|
*/
|
1991-12-12 00:53:23 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
/* OBS stuff
|
1992-02-22 20:45:24 +00:00
|
|
|
static struct internal_scnhdr bss_section_header;
|
|
|
|
struct internal_scnhdr data_section_header;
|
|
|
|
struct internal_scnhdr text_section_header;
|
|
|
|
|
|
|
|
const segT N_TYPE_seg [32] =
|
|
|
|
{
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
*/
|
1991-12-12 00:53:23 +00:00
|
|
|
|
|
|
|
#define N_SEG 32
|
1992-11-23 20:42:33 +00:00
|
|
|
typedef struct
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
1992-12-15 22:49:55 +00:00
|
|
|
segT seg_t;
|
|
|
|
int i;
|
|
|
|
} seg_info_type;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
1992-12-15 22:49:55 +00:00
|
|
|
seg_info_type seg_info_off_by_4[N_SEG] =
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
1992-12-15 22:49:55 +00:00
|
|
|
{SEG_PTV, },
|
|
|
|
{SEG_NTV, },
|
|
|
|
{SEG_DEBUG, },
|
|
|
|
{SEG_ABSOLUTE, },
|
|
|
|
{SEG_UNKNOWN, },
|
|
|
|
{SEG_E0},
|
|
|
|
{SEG_E1},
|
|
|
|
{SEG_E2},
|
|
|
|
{SEG_E3},
|
|
|
|
{SEG_E4},
|
|
|
|
{SEG_E5},
|
|
|
|
{SEG_E6},
|
|
|
|
{SEG_E7},
|
|
|
|
{SEG_E8},
|
|
|
|
{SEG_E9},
|
|
|
|
{(segT)15},
|
|
|
|
{(segT)16},
|
|
|
|
{(segT)17},
|
|
|
|
{(segT)18},
|
|
|
|
{(segT)19},
|
|
|
|
{(segT)20},
|
|
|
|
{(segT)0},
|
|
|
|
{(segT)0},
|
|
|
|
{(segT)0},
|
|
|
|
{SEG_REGISTER}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
1991-12-12 00:53:23 +00:00
|
|
|
|
|
|
|
#define SEG_INFO_FROM_SECTION_NUMBER(x) (seg_info_off_by_4[(x)+4])
|
|
|
|
#define SEG_INFO_FROM_SEG_NUMBER(x) (seg_info_off_by_4[(x)])
|
|
|
|
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
relax_addressT
|
|
|
|
DEFUN (relax_align, (address, alignment),
|
|
|
|
register relax_addressT address AND
|
|
|
|
register long alignment)
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
relax_addressT mask;
|
|
|
|
relax_addressT new_address;
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
mask = ~((~0) << alignment);
|
|
|
|
new_address = (address + mask) & (~mask);
|
1992-02-22 20:45:24 +00:00
|
|
|
return (new_address - address);
|
1992-11-23 20:42:33 +00:00
|
|
|
} /* relax_align() */
|
1991-12-12 00:53:23 +00:00
|
|
|
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
segT
|
|
|
|
DEFUN (s_get_segment, (x),
|
|
|
|
symbolS * x)
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
return SEG_INFO_FROM_SECTION_NUMBER (x->sy_symbol.ost_entry.n_scnum).seg_t;
|
1991-12-12 00:53:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* calculate the size of the frag chain and fill in the section header
|
|
|
|
to contain all of it, also fill in the addr of the sections */
|
1992-11-23 20:42:33 +00:00
|
|
|
static unsigned int
|
|
|
|
DEFUN (size_section, (abfd, idx),
|
|
|
|
bfd * abfd AND
|
|
|
|
unsigned int idx)
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
1992-02-22 20:45:24 +00:00
|
|
|
|
|
|
|
unsigned int size = 0;
|
|
|
|
fragS *frag = segment_info[idx].frchainP->frch_root;
|
1992-11-23 20:42:33 +00:00
|
|
|
while (frag)
|
|
|
|
{
|
|
|
|
size = frag->fr_address;
|
|
|
|
if (frag->fr_address != size)
|
|
|
|
{
|
|
|
|
printf ("Out of step\n");
|
1992-02-22 20:45:24 +00:00
|
|
|
size = frag->fr_address;
|
1991-12-12 00:53:23 +00:00
|
|
|
}
|
1992-09-09 18:38:16 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
switch (frag->fr_type)
|
|
|
|
{
|
1992-09-09 18:38:16 +00:00
|
|
|
#ifdef TC_COFF_SIZEMACHDEP
|
1992-11-23 20:42:33 +00:00
|
|
|
case rs_machine_dependent:
|
|
|
|
size += TC_COFF_SIZEMACHDEP (frag);
|
|
|
|
break;
|
1992-09-09 18:38:16 +00:00
|
|
|
#endif
|
1992-02-22 20:45:24 +00:00
|
|
|
case rs_fill:
|
|
|
|
case rs_org:
|
1992-11-23 20:42:33 +00:00
|
|
|
size += frag->fr_fix;
|
|
|
|
size += frag->fr_offset * frag->fr_var;
|
1992-02-22 20:45:24 +00:00
|
|
|
break;
|
|
|
|
case rs_align:
|
1992-11-23 20:42:33 +00:00
|
|
|
size += frag->fr_fix;
|
|
|
|
size += relax_align (size, frag->fr_offset);
|
1992-02-22 20:45:24 +00:00
|
|
|
}
|
|
|
|
frag = frag->fr_next;
|
|
|
|
}
|
|
|
|
segment_info[idx].scnhdr.s_size = size;
|
|
|
|
return size;
|
1991-12-12 00:53:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
static unsigned int
|
|
|
|
DEFUN (count_entries_in_chain, (idx),
|
|
|
|
unsigned int idx)
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
unsigned int nrelocs;
|
|
|
|
fixS *fixup_ptr;
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
/* Count the relocations */
|
|
|
|
fixup_ptr = segment_info[idx].fix_root;
|
|
|
|
nrelocs = 0;
|
|
|
|
while (fixup_ptr != (fixS *) NULL)
|
1992-02-22 20:45:24 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
if (TC_COUNT_RELOC (fixup_ptr))
|
1992-02-22 20:45:24 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
|
1991-12-12 00:53:23 +00:00
|
|
|
#ifdef TC_A29K
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
if (fixup_ptr->fx_r_type == RELOC_CONSTH)
|
|
|
|
nrelocs += 2;
|
|
|
|
else
|
1992-02-22 20:45:24 +00:00
|
|
|
nrelocs++;
|
1992-11-23 20:42:33 +00:00
|
|
|
#else
|
|
|
|
nrelocs++;
|
1991-12-12 00:53:23 +00:00
|
|
|
#endif
|
1992-02-22 20:45:24 +00:00
|
|
|
}
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
|
|
fixup_ptr = fixup_ptr->fx_next;
|
1992-02-22 20:45:24 +00:00
|
|
|
}
|
1992-11-23 20:42:33 +00:00
|
|
|
return nrelocs;
|
1991-12-12 00:53:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* output all the relocations for a section */
|
1992-11-23 20:42:33 +00:00
|
|
|
void
|
1992-12-30 21:39:51 +00:00
|
|
|
DEFUN (do_relocs_for, (abfd, h, file_cursor),
|
1992-11-23 20:42:33 +00:00
|
|
|
bfd * abfd AND
|
1992-12-30 21:39:51 +00:00
|
|
|
object_headers * h AND
|
1992-11-23 20:42:33 +00:00
|
|
|
unsigned long *file_cursor)
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
1992-02-22 20:45:24 +00:00
|
|
|
unsigned int nrelocs;
|
|
|
|
unsigned int idx;
|
1992-12-30 21:39:51 +00:00
|
|
|
unsigned long reloc_start = *file_cursor;
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
for (idx = SEG_E0; idx < SEG_E9; idx++)
|
|
|
|
{
|
|
|
|
if (segment_info[idx].scnhdr.s_name[0])
|
|
|
|
{
|
|
|
|
struct external_reloc *ext_ptr;
|
|
|
|
struct external_reloc *external_reloc_vec;
|
|
|
|
unsigned int external_reloc_size;
|
1992-12-30 21:39:51 +00:00
|
|
|
unsigned int base = segment_info[idx].scnhdr.s_paddr;
|
1992-11-23 20:42:33 +00:00
|
|
|
fixS *fix_ptr = segment_info[idx].fix_root;
|
|
|
|
nrelocs = count_entries_in_chain (idx);
|
|
|
|
|
1993-03-23 13:34:55 +00:00
|
|
|
if (nrelocs)
|
|
|
|
/* Bypass this stuff if no relocs. This also incidentally
|
|
|
|
avoids a SCO bug, where free(malloc(0)) tends to crash. */
|
1992-11-23 20:42:33 +00:00
|
|
|
{
|
1993-03-23 13:34:55 +00:00
|
|
|
external_reloc_size = nrelocs * RELSZ;
|
|
|
|
external_reloc_vec =
|
|
|
|
(struct external_reloc *) malloc (external_reloc_size);
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1993-03-23 13:34:55 +00:00
|
|
|
ext_ptr = external_reloc_vec;
|
|
|
|
|
|
|
|
/* Fill in the internal coff style reloc struct from the
|
|
|
|
internal fix list. */
|
|
|
|
while (fix_ptr)
|
1992-11-23 20:42:33 +00:00
|
|
|
{
|
1993-03-23 13:34:55 +00:00
|
|
|
symbolS *symbol_ptr;
|
|
|
|
struct internal_reloc intr;
|
|
|
|
|
|
|
|
/* Only output some of the relocations */
|
|
|
|
if (TC_COUNT_RELOC (fix_ptr))
|
|
|
|
{
|
1992-01-08 19:39:50 +00:00
|
|
|
#ifdef TC_RELOC_MANGLE
|
1993-03-23 13:34:55 +00:00
|
|
|
TC_RELOC_MANGLE (fix_ptr, &intr, base);
|
1992-11-23 20:42:33 +00:00
|
|
|
|
1991-12-12 02:17:22 +00:00
|
|
|
#else
|
1993-03-23 13:34:55 +00:00
|
|
|
symbolS *dot;
|
|
|
|
symbol_ptr = fix_ptr->fx_addsy;
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1993-03-23 13:34:55 +00:00
|
|
|
intr.r_type = TC_COFF_FIX2RTYPE (fix_ptr);
|
|
|
|
intr.r_vaddr =
|
|
|
|
base + fix_ptr->fx_frag->fr_address + fix_ptr->fx_where;
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1993-07-21 17:19:33 +00:00
|
|
|
#ifdef TC_M88K
|
1993-03-23 13:34:55 +00:00
|
|
|
intr.r_offset = fix_ptr->fx_offset;
|
1993-07-21 17:19:33 +00:00
|
|
|
#else
|
1993-03-23 13:34:55 +00:00
|
|
|
intr.r_offset = 0;
|
1993-07-21 17:19:33 +00:00
|
|
|
#endif
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1993-03-23 13:34:55 +00:00
|
|
|
/* Turn the segment of the symbol into an offset. */
|
|
|
|
if (symbol_ptr)
|
1992-11-23 20:42:33 +00:00
|
|
|
{
|
1993-03-23 13:34:55 +00:00
|
|
|
dot = segment_info[S_GET_SEGMENT (symbol_ptr)].dot;
|
|
|
|
if (dot)
|
|
|
|
{
|
|
|
|
intr.r_symndx = dot->sy_number;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
intr.r_symndx = symbol_ptr->sy_number;
|
|
|
|
}
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
1993-03-23 13:34:55 +00:00
|
|
|
intr.r_symndx = -1;
|
1992-11-23 20:42:33 +00:00
|
|
|
}
|
1991-12-12 02:17:22 +00:00
|
|
|
#endif
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1993-03-23 13:34:55 +00:00
|
|
|
(void) bfd_coff_swap_reloc_out (abfd, &intr, ext_ptr);
|
|
|
|
ext_ptr++;
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1991-12-12 00:53:23 +00:00
|
|
|
#if defined(TC_A29K)
|
1992-12-30 21:39:51 +00:00
|
|
|
|
1993-03-23 13:34:55 +00:00
|
|
|
/* The 29k has a special kludge for the high 16 bit
|
|
|
|
reloc. Two relocations are emited, R_IHIHALF,
|
|
|
|
and R_IHCONST. The second one doesn't contain a
|
|
|
|
symbol, but uses the value for offset. */
|
1992-11-23 20:42:33 +00:00
|
|
|
|
1993-03-23 13:34:55 +00:00
|
|
|
if (intr.r_type == R_IHIHALF)
|
|
|
|
{
|
|
|
|
/* now emit the second bit */
|
|
|
|
intr.r_type = R_IHCONST;
|
|
|
|
intr.r_symndx = fix_ptr->fx_addnumber;
|
|
|
|
(void) bfd_coff_swap_reloc_out (abfd, &intr, ext_ptr);
|
|
|
|
ext_ptr++;
|
|
|
|
}
|
1991-12-12 00:53:23 +00:00
|
|
|
#endif
|
1993-03-23 13:34:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
fix_ptr = fix_ptr->fx_next;
|
1992-11-23 20:42:33 +00:00
|
|
|
}
|
|
|
|
|
1993-03-23 13:34:55 +00:00
|
|
|
/* Write out the reloc table */
|
|
|
|
bfd_write ((PTR) external_reloc_vec, 1, external_reloc_size,
|
|
|
|
abfd);
|
|
|
|
free (external_reloc_vec);
|
1992-11-23 20:42:33 +00:00
|
|
|
|
1993-03-23 13:34:55 +00:00
|
|
|
/* Fill in section header info. */
|
|
|
|
segment_info[idx].scnhdr.s_relptr = *file_cursor;
|
|
|
|
*file_cursor += external_reloc_size;
|
1993-03-29 21:56:49 +00:00
|
|
|
segment_info[idx].scnhdr.s_nreloc = nrelocs;
|
1993-03-23 13:34:55 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* No relocs */
|
|
|
|
segment_info[idx].scnhdr.s_relptr = 0;
|
|
|
|
}
|
1992-02-22 20:45:24 +00:00
|
|
|
}
|
1992-11-23 20:42:33 +00:00
|
|
|
}
|
1992-12-30 21:39:51 +00:00
|
|
|
/* Set relocation_size field in file headers */
|
|
|
|
H_SET_RELOCATION_SIZE (h, *file_cursor - reloc_start, 0);
|
1991-12-12 00:53:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* run through a frag chain and write out the data to go with it, fill
|
1992-11-23 20:42:33 +00:00
|
|
|
in the scnhdrs with the info on the file postions
|
1992-02-22 20:45:24 +00:00
|
|
|
*/
|
1992-11-23 20:42:33 +00:00
|
|
|
static void
|
1992-12-30 21:39:51 +00:00
|
|
|
DEFUN (fill_section, (abfd, h, file_cursor),
|
1992-11-23 20:42:33 +00:00
|
|
|
bfd * abfd AND
|
1992-12-30 21:39:51 +00:00
|
|
|
object_headers *h AND
|
1992-11-23 20:42:33 +00:00
|
|
|
unsigned long *file_cursor)
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-05-05 01:59:04 +00:00
|
|
|
unsigned int i;
|
Sat Dec 12 15:26:34 1992 Ian Lance Taylor (ian@cygnus.com)
* listing.c: Call xmalloc, not malloc; don't declare malloc.
* Changes to support SCO 3.2v4:
* read.c (s_align_bytes, s_align_ptwo): If not SEG_DATA or
SEG_BSS, fill with NOP_OPCODE.
* config/i386coff.mt: Add opcode/i386.h to TARG_CPU_DEPENDENTS.
* config/obj-coffbfd.c (do_relocs_for): Increment addr even if not
using ZERO_BASED_SEGMENTS.
(fill_section): If ZERO_BASED_SEGMENTS, set segment addresses, but
never set segment address for SEG_E2 (.bss) and don't write out
SEG_E2 contents. Set .init and .fini sections to STYP_TEXT.
(obj_coff_endef): Don't merge labels or symbols awaiting forward
definitions, and don't merge tags with non-tags. Check for .bf
rather than just checking whether the second character is b and
the third character is f.
(obj_coff_val): gcc can generate values which we don't handle
correctly; discard information for now, since it only affects the
debugging information.
(tag_find_or_name): Don't insert tags in the symbol table.
(yank_symbols): Don't merge labels.
(write_object_file): Don't define SUB_SEGMENT_ALIGN if it is
already defined. Fill subsegments with NOP_OPCODE, not 0. Don't
set segment address if ZERO_BASED_SEGMENTS.
(obj_coff_section): Accept and ignore a trailing quoted string, as
used in AT&T i386 syntax.
(fixup_segment): Take segment as argument. On the i386, adjust PC
relative addends by the segment vaddr.
* tc-i386.h: Define SUB_SEGMENT_ALIGN.
* tc-a29k.h: Define ZERO_BASED_SEGMENTS.
* tc-i386.c: (i386_operand): If I386COFF, accept any segment type.
1992-12-13 00:56:14 +00:00
|
|
|
unsigned int paddr = 0;
|
1992-05-05 01:59:04 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
for (i = SEG_E0; i < SEG_UNKNOWN; i++)
|
|
|
|
{
|
|
|
|
unsigned int offset = 0;
|
|
|
|
|
|
|
|
struct internal_scnhdr *s = &(segment_info[i].scnhdr);
|
|
|
|
|
|
|
|
if (s->s_name[0])
|
|
|
|
{
|
|
|
|
fragS *frag = segment_info[i].frchainP->frch_root;
|
Sat Dec 12 15:26:34 1992 Ian Lance Taylor (ian@cygnus.com)
* listing.c: Call xmalloc, not malloc; don't declare malloc.
* Changes to support SCO 3.2v4:
* read.c (s_align_bytes, s_align_ptwo): If not SEG_DATA or
SEG_BSS, fill with NOP_OPCODE.
* config/i386coff.mt: Add opcode/i386.h to TARG_CPU_DEPENDENTS.
* config/obj-coffbfd.c (do_relocs_for): Increment addr even if not
using ZERO_BASED_SEGMENTS.
(fill_section): If ZERO_BASED_SEGMENTS, set segment addresses, but
never set segment address for SEG_E2 (.bss) and don't write out
SEG_E2 contents. Set .init and .fini sections to STYP_TEXT.
(obj_coff_endef): Don't merge labels or symbols awaiting forward
definitions, and don't merge tags with non-tags. Check for .bf
rather than just checking whether the second character is b and
the third character is f.
(obj_coff_val): gcc can generate values which we don't handle
correctly; discard information for now, since it only affects the
debugging information.
(tag_find_or_name): Don't insert tags in the symbol table.
(yank_symbols): Don't merge labels.
(write_object_file): Don't define SUB_SEGMENT_ALIGN if it is
already defined. Fill subsegments with NOP_OPCODE, not 0. Don't
set segment address if ZERO_BASED_SEGMENTS.
(obj_coff_section): Accept and ignore a trailing quoted string, as
used in AT&T i386 syntax.
(fixup_segment): Take segment as argument. On the i386, adjust PC
relative addends by the segment vaddr.
* tc-i386.h: Define SUB_SEGMENT_ALIGN.
* tc-a29k.h: Define ZERO_BASED_SEGMENTS.
* tc-i386.c: (i386_operand): If I386COFF, accept any segment type.
1992-12-13 00:56:14 +00:00
|
|
|
char *buffer;
|
|
|
|
|
1992-12-30 21:39:51 +00:00
|
|
|
if (s->s_size == 0)
|
|
|
|
s->s_scnptr = 0;
|
1992-11-23 20:42:33 +00:00
|
|
|
else
|
Sat Dec 12 15:26:34 1992 Ian Lance Taylor (ian@cygnus.com)
* listing.c: Call xmalloc, not malloc; don't declare malloc.
* Changes to support SCO 3.2v4:
* read.c (s_align_bytes, s_align_ptwo): If not SEG_DATA or
SEG_BSS, fill with NOP_OPCODE.
* config/i386coff.mt: Add opcode/i386.h to TARG_CPU_DEPENDENTS.
* config/obj-coffbfd.c (do_relocs_for): Increment addr even if not
using ZERO_BASED_SEGMENTS.
(fill_section): If ZERO_BASED_SEGMENTS, set segment addresses, but
never set segment address for SEG_E2 (.bss) and don't write out
SEG_E2 contents. Set .init and .fini sections to STYP_TEXT.
(obj_coff_endef): Don't merge labels or symbols awaiting forward
definitions, and don't merge tags with non-tags. Check for .bf
rather than just checking whether the second character is b and
the third character is f.
(obj_coff_val): gcc can generate values which we don't handle
correctly; discard information for now, since it only affects the
debugging information.
(tag_find_or_name): Don't insert tags in the symbol table.
(yank_symbols): Don't merge labels.
(write_object_file): Don't define SUB_SEGMENT_ALIGN if it is
already defined. Fill subsegments with NOP_OPCODE, not 0. Don't
set segment address if ZERO_BASED_SEGMENTS.
(obj_coff_section): Accept and ignore a trailing quoted string, as
used in AT&T i386 syntax.
(fixup_segment): Take segment as argument. On the i386, adjust PC
relative addends by the segment vaddr.
* tc-i386.h: Define SUB_SEGMENT_ALIGN.
* tc-a29k.h: Define ZERO_BASED_SEGMENTS.
* tc-i386.c: (i386_operand): If I386COFF, accept any segment type.
1992-12-13 00:56:14 +00:00
|
|
|
{
|
1992-12-30 21:39:51 +00:00
|
|
|
buffer = xmalloc (s->s_size);
|
|
|
|
s->s_scnptr = *file_cursor;
|
Sat Dec 12 15:26:34 1992 Ian Lance Taylor (ian@cygnus.com)
* listing.c: Call xmalloc, not malloc; don't declare malloc.
* Changes to support SCO 3.2v4:
* read.c (s_align_bytes, s_align_ptwo): If not SEG_DATA or
SEG_BSS, fill with NOP_OPCODE.
* config/i386coff.mt: Add opcode/i386.h to TARG_CPU_DEPENDENTS.
* config/obj-coffbfd.c (do_relocs_for): Increment addr even if not
using ZERO_BASED_SEGMENTS.
(fill_section): If ZERO_BASED_SEGMENTS, set segment addresses, but
never set segment address for SEG_E2 (.bss) and don't write out
SEG_E2 contents. Set .init and .fini sections to STYP_TEXT.
(obj_coff_endef): Don't merge labels or symbols awaiting forward
definitions, and don't merge tags with non-tags. Check for .bf
rather than just checking whether the second character is b and
the third character is f.
(obj_coff_val): gcc can generate values which we don't handle
correctly; discard information for now, since it only affects the
debugging information.
(tag_find_or_name): Don't insert tags in the symbol table.
(yank_symbols): Don't merge labels.
(write_object_file): Don't define SUB_SEGMENT_ALIGN if it is
already defined. Fill subsegments with NOP_OPCODE, not 0. Don't
set segment address if ZERO_BASED_SEGMENTS.
(obj_coff_section): Accept and ignore a trailing quoted string, as
used in AT&T i386 syntax.
(fixup_segment): Take segment as argument. On the i386, adjust PC
relative addends by the segment vaddr.
* tc-i386.h: Define SUB_SEGMENT_ALIGN.
* tc-a29k.h: Define ZERO_BASED_SEGMENTS.
* tc-i386.c: (i386_operand): If I386COFF, accept any segment type.
1992-12-13 00:56:14 +00:00
|
|
|
}
|
1992-12-30 21:39:51 +00:00
|
|
|
know (s->s_paddr == paddr);
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
|
|
if (strcmp (s->s_name, ".text") == 0)
|
|
|
|
s->s_flags |= STYP_TEXT;
|
|
|
|
else if (strcmp (s->s_name, ".data") == 0)
|
|
|
|
s->s_flags |= STYP_DATA;
|
|
|
|
else if (strcmp (s->s_name, ".bss") == 0)
|
1992-12-30 21:39:51 +00:00
|
|
|
{
|
|
|
|
s->s_scnptr = 0;
|
|
|
|
s->s_flags |= STYP_BSS;
|
|
|
|
#ifndef TC_I386
|
1993-03-29 20:58:34 +00:00
|
|
|
#ifndef TC_A29K
|
1992-12-30 21:39:51 +00:00
|
|
|
/* Apparently the SVR3 linker is confused by noload
|
1993-03-29 20:58:34 +00:00
|
|
|
sections. So is the UDI mondfe program. */
|
1992-12-30 21:39:51 +00:00
|
|
|
s->s_flags |= STYP_NOLOAD;
|
1993-03-29 20:58:34 +00:00
|
|
|
#endif
|
1992-12-30 21:39:51 +00:00
|
|
|
#endif
|
|
|
|
}
|
1992-11-23 20:42:33 +00:00
|
|
|
else if (strcmp (s->s_name, ".lit") == 0)
|
|
|
|
s->s_flags = STYP_LIT | STYP_TEXT;
|
Sat Dec 12 15:26:34 1992 Ian Lance Taylor (ian@cygnus.com)
* listing.c: Call xmalloc, not malloc; don't declare malloc.
* Changes to support SCO 3.2v4:
* read.c (s_align_bytes, s_align_ptwo): If not SEG_DATA or
SEG_BSS, fill with NOP_OPCODE.
* config/i386coff.mt: Add opcode/i386.h to TARG_CPU_DEPENDENTS.
* config/obj-coffbfd.c (do_relocs_for): Increment addr even if not
using ZERO_BASED_SEGMENTS.
(fill_section): If ZERO_BASED_SEGMENTS, set segment addresses, but
never set segment address for SEG_E2 (.bss) and don't write out
SEG_E2 contents. Set .init and .fini sections to STYP_TEXT.
(obj_coff_endef): Don't merge labels or symbols awaiting forward
definitions, and don't merge tags with non-tags. Check for .bf
rather than just checking whether the second character is b and
the third character is f.
(obj_coff_val): gcc can generate values which we don't handle
correctly; discard information for now, since it only affects the
debugging information.
(tag_find_or_name): Don't insert tags in the symbol table.
(yank_symbols): Don't merge labels.
(write_object_file): Don't define SUB_SEGMENT_ALIGN if it is
already defined. Fill subsegments with NOP_OPCODE, not 0. Don't
set segment address if ZERO_BASED_SEGMENTS.
(obj_coff_section): Accept and ignore a trailing quoted string, as
used in AT&T i386 syntax.
(fixup_segment): Take segment as argument. On the i386, adjust PC
relative addends by the segment vaddr.
* tc-i386.h: Define SUB_SEGMENT_ALIGN.
* tc-a29k.h: Define ZERO_BASED_SEGMENTS.
* tc-i386.c: (i386_operand): If I386COFF, accept any segment type.
1992-12-13 00:56:14 +00:00
|
|
|
else if (strcmp (s->s_name, ".init") == 0)
|
|
|
|
s->s_flags |= STYP_TEXT;
|
|
|
|
else if (strcmp (s->s_name, ".fini") == 0)
|
|
|
|
s->s_flags |= STYP_TEXT;
|
1992-12-30 21:39:51 +00:00
|
|
|
else if (strncmp (s->s_name, ".comment", 8) == 0)
|
|
|
|
s->s_flags |= STYP_INFO;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
|
|
while (frag)
|
1992-05-05 01:59:04 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
unsigned int fill_size;
|
|
|
|
switch (frag->fr_type)
|
|
|
|
{
|
|
|
|
case rs_machine_dependent:
|
|
|
|
if (frag->fr_fix)
|
|
|
|
{
|
|
|
|
memcpy (buffer + frag->fr_address,
|
|
|
|
frag->fr_literal,
|
|
|
|
frag->fr_fix);
|
|
|
|
offset += frag->fr_fix;
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
case rs_fill:
|
|
|
|
case rs_align:
|
|
|
|
case rs_org:
|
|
|
|
if (frag->fr_fix)
|
|
|
|
{
|
|
|
|
memcpy (buffer + frag->fr_address,
|
|
|
|
frag->fr_literal,
|
|
|
|
frag->fr_fix);
|
|
|
|
offset += frag->fr_fix;
|
|
|
|
}
|
|
|
|
|
|
|
|
fill_size = frag->fr_var;
|
1993-06-17 21:58:28 +00:00
|
|
|
if (fill_size && frag->fr_offset > 0)
|
1992-11-23 20:42:33 +00:00
|
|
|
{
|
|
|
|
unsigned int count;
|
|
|
|
unsigned int off = frag->fr_fix;
|
|
|
|
for (count = frag->fr_offset; count; count--)
|
|
|
|
{
|
1992-12-30 21:39:51 +00:00
|
|
|
if (fill_size < s->s_size)
|
|
|
|
{
|
|
|
|
memcpy (buffer + frag->fr_address + off,
|
|
|
|
frag->fr_literal + frag->fr_fix,
|
|
|
|
fill_size);
|
|
|
|
off += fill_size;
|
|
|
|
offset += fill_size;
|
|
|
|
}
|
1992-12-15 22:49:55 +00:00
|
|
|
}
|
1992-11-23 20:42:33 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case rs_broken_word:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
abort ();
|
|
|
|
}
|
|
|
|
frag = frag->fr_next;
|
1992-02-13 08:33:54 +00:00
|
|
|
}
|
1992-05-05 01:59:04 +00:00
|
|
|
|
1992-12-30 21:39:51 +00:00
|
|
|
if (s->s_size != 0)
|
Sat Dec 12 15:26:34 1992 Ian Lance Taylor (ian@cygnus.com)
* listing.c: Call xmalloc, not malloc; don't declare malloc.
* Changes to support SCO 3.2v4:
* read.c (s_align_bytes, s_align_ptwo): If not SEG_DATA or
SEG_BSS, fill with NOP_OPCODE.
* config/i386coff.mt: Add opcode/i386.h to TARG_CPU_DEPENDENTS.
* config/obj-coffbfd.c (do_relocs_for): Increment addr even if not
using ZERO_BASED_SEGMENTS.
(fill_section): If ZERO_BASED_SEGMENTS, set segment addresses, but
never set segment address for SEG_E2 (.bss) and don't write out
SEG_E2 contents. Set .init and .fini sections to STYP_TEXT.
(obj_coff_endef): Don't merge labels or symbols awaiting forward
definitions, and don't merge tags with non-tags. Check for .bf
rather than just checking whether the second character is b and
the third character is f.
(obj_coff_val): gcc can generate values which we don't handle
correctly; discard information for now, since it only affects the
debugging information.
(tag_find_or_name): Don't insert tags in the symbol table.
(yank_symbols): Don't merge labels.
(write_object_file): Don't define SUB_SEGMENT_ALIGN if it is
already defined. Fill subsegments with NOP_OPCODE, not 0. Don't
set segment address if ZERO_BASED_SEGMENTS.
(obj_coff_section): Accept and ignore a trailing quoted string, as
used in AT&T i386 syntax.
(fixup_segment): Take segment as argument. On the i386, adjust PC
relative addends by the segment vaddr.
* tc-i386.h: Define SUB_SEGMENT_ALIGN.
* tc-a29k.h: Define ZERO_BASED_SEGMENTS.
* tc-i386.c: (i386_operand): If I386COFF, accept any segment type.
1992-12-13 00:56:14 +00:00
|
|
|
{
|
1992-12-30 21:39:51 +00:00
|
|
|
if (s->s_scnptr != 0)
|
|
|
|
{
|
|
|
|
bfd_write (buffer, s->s_size, 1, abfd);
|
|
|
|
*file_cursor += s->s_size;
|
|
|
|
}
|
Sat Dec 12 15:26:34 1992 Ian Lance Taylor (ian@cygnus.com)
* listing.c: Call xmalloc, not malloc; don't declare malloc.
* Changes to support SCO 3.2v4:
* read.c (s_align_bytes, s_align_ptwo): If not SEG_DATA or
SEG_BSS, fill with NOP_OPCODE.
* config/i386coff.mt: Add opcode/i386.h to TARG_CPU_DEPENDENTS.
* config/obj-coffbfd.c (do_relocs_for): Increment addr even if not
using ZERO_BASED_SEGMENTS.
(fill_section): If ZERO_BASED_SEGMENTS, set segment addresses, but
never set segment address for SEG_E2 (.bss) and don't write out
SEG_E2 contents. Set .init and .fini sections to STYP_TEXT.
(obj_coff_endef): Don't merge labels or symbols awaiting forward
definitions, and don't merge tags with non-tags. Check for .bf
rather than just checking whether the second character is b and
the third character is f.
(obj_coff_val): gcc can generate values which we don't handle
correctly; discard information for now, since it only affects the
debugging information.
(tag_find_or_name): Don't insert tags in the symbol table.
(yank_symbols): Don't merge labels.
(write_object_file): Don't define SUB_SEGMENT_ALIGN if it is
already defined. Fill subsegments with NOP_OPCODE, not 0. Don't
set segment address if ZERO_BASED_SEGMENTS.
(obj_coff_section): Accept and ignore a trailing quoted string, as
used in AT&T i386 syntax.
(fixup_segment): Take segment as argument. On the i386, adjust PC
relative addends by the segment vaddr.
* tc-i386.h: Define SUB_SEGMENT_ALIGN.
* tc-a29k.h: Define ZERO_BASED_SEGMENTS.
* tc-i386.c: (i386_operand): If I386COFF, accept any segment type.
1992-12-13 00:56:14 +00:00
|
|
|
free (buffer);
|
|
|
|
}
|
|
|
|
paddr += s->s_size;
|
1992-11-23 20:42:33 +00:00
|
|
|
}
|
|
|
|
}
|
1991-12-12 00:53:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Coff file generation & utilities */
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
static void
|
1992-12-30 21:39:51 +00:00
|
|
|
DEFUN (coff_header_append, (abfd, h),
|
1992-11-23 20:42:33 +00:00
|
|
|
bfd * abfd AND
|
1992-12-30 21:39:51 +00:00
|
|
|
object_headers * h)
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
1992-02-22 20:45:24 +00:00
|
|
|
unsigned int i;
|
|
|
|
char buffer[1000];
|
|
|
|
char buffero[1000];
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
bfd_seek (abfd, 0, 0);
|
1992-12-30 21:39:51 +00:00
|
|
|
|
|
|
|
#ifndef OBJ_COFF_OMIT_OPTIONAL_HEADER
|
|
|
|
H_SET_MAGIC_NUMBER (h, COFF_MAGIC);
|
|
|
|
H_SET_VERSION_STAMP (h, 0);
|
|
|
|
H_SET_ENTRY_POINT (h, 0);
|
|
|
|
H_SET_TEXT_START (h, segment_info[SEG_E0].frchainP->frch_root->fr_address);
|
|
|
|
H_SET_DATA_START (h, segment_info[SEG_E1].frchainP->frch_root->fr_address);
|
|
|
|
H_SET_SIZEOF_OPTIONAL_HEADER (h, bfd_coff_swap_aouthdr_out(abfd, &h->aouthdr,
|
|
|
|
buffero));
|
|
|
|
#else /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
|
|
|
|
H_SET_SIZEOF_OPTIONAL_HEADER (h, 0);
|
|
|
|
#endif /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
|
|
|
|
|
|
|
|
i = bfd_coff_swap_filehdr_out (abfd, &h->filehdr, buffer);
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
bfd_write (buffer, i, 1, abfd);
|
1992-12-30 21:39:51 +00:00
|
|
|
bfd_write (buffero, H_GET_SIZEOF_OPTIONAL_HEADER (h), 1, abfd);
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
for (i = SEG_E0; i < SEG_E9; i++)
|
|
|
|
{
|
|
|
|
if (segment_info[i].scnhdr.s_name[0])
|
|
|
|
{
|
|
|
|
unsigned int size =
|
|
|
|
bfd_coff_swap_scnhdr_out (abfd,
|
|
|
|
&(segment_info[i].scnhdr),
|
|
|
|
buffer);
|
|
|
|
bfd_write (buffer, size, 1, abfd);
|
|
|
|
}
|
1992-02-22 20:45:24 +00:00
|
|
|
}
|
1991-12-12 00:53:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
char *
|
1992-11-23 20:42:33 +00:00
|
|
|
DEFUN (symbol_to_chars, (abfd, where, symbolP),
|
|
|
|
bfd * abfd AND
|
|
|
|
char *where AND
|
|
|
|
symbolS * symbolP)
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
unsigned int numaux = symbolP->sy_symbol.ost_entry.n_numaux;
|
|
|
|
unsigned int i;
|
* Changes to keep a full expression as the value of a symbol, not
just a longword:
* struc-symbol.h: New field sy_value.
* as.h: Include expr.h before struc-symbol.h.
* expr.h: Use struct symbol rather than symbolS.
* symbols.c (S_GET_VALUE, S_SET_VALUE): Rewrote to retrieve value
of sy_value field; compile unconditionally, not just if
BFD_ASSEMBLER.
* symbols.h: Compile S_{SG}ET_VALUE prototypes unconditionally.
* write.c (write_object_file): Set BFD symbol value to gas symbol
value.
* config/obj-aout.h, config/obj-bout.h, config/obj-coff.h,
config/obj-coffbfd.h, config/obj-generic.h, config/obj-vms.h
(S_GET_VALUE, S_SET_VALUE): Removed macro definitions.
* config/obj-ieee.c (S_GET_VALUE, S_SET_VALUE): Removed.
* config/obj-coff.h, obj-coffbfd.h: Rewrote several macros to use
S_GET_VALUE rather than ost_entry.n_value.
* config/obj-aout.c (obj_symbol_to_chars), config/obj-bout.c
(obj_symbol_to_chars), config/obj-coff.c (obj_symbol_to_chars),
config/obj-coffbfd.c (symbol_to_chars): Get value to write out
using S_GET_VALUE--don't assume it is already set.
* config/obj-ieee.c (do_symbols): Set BFD symbol value to gas
symbol value.
* config/obj-vms.c (various): Don't assign directly to
S_GET_VALUE; use S_SET_VALUE instead.
1993-07-14 19:35:45 +00:00
|
|
|
valueT val;
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
/* Turn any symbols with register attributes into abs symbols */
|
|
|
|
if (S_GET_SEGMENT (symbolP) == SEG_REGISTER)
|
1992-02-22 20:45:24 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
S_SET_SEGMENT (symbolP, SEG_ABSOLUTE);
|
1992-02-22 20:45:24 +00:00
|
|
|
}
|
1992-11-23 20:42:33 +00:00
|
|
|
/* At the same time, relocate all symbols to their output value */
|
|
|
|
|
* Changes to keep a full expression as the value of a symbol, not
just a longword:
* struc-symbol.h: New field sy_value.
* as.h: Include expr.h before struc-symbol.h.
* expr.h: Use struct symbol rather than symbolS.
* symbols.c (S_GET_VALUE, S_SET_VALUE): Rewrote to retrieve value
of sy_value field; compile unconditionally, not just if
BFD_ASSEMBLER.
* symbols.h: Compile S_{SG}ET_VALUE prototypes unconditionally.
* write.c (write_object_file): Set BFD symbol value to gas symbol
value.
* config/obj-aout.h, config/obj-bout.h, config/obj-coff.h,
config/obj-coffbfd.h, config/obj-generic.h, config/obj-vms.h
(S_GET_VALUE, S_SET_VALUE): Removed macro definitions.
* config/obj-ieee.c (S_GET_VALUE, S_SET_VALUE): Removed.
* config/obj-coff.h, obj-coffbfd.h: Rewrote several macros to use
S_GET_VALUE rather than ost_entry.n_value.
* config/obj-aout.c (obj_symbol_to_chars), config/obj-bout.c
(obj_symbol_to_chars), config/obj-coff.c (obj_symbol_to_chars),
config/obj-coffbfd.c (symbol_to_chars): Get value to write out
using S_GET_VALUE--don't assume it is already set.
* config/obj-ieee.c (do_symbols): Set BFD symbol value to gas
symbol value.
* config/obj-vms.c (various): Don't assign directly to
S_GET_VALUE; use S_SET_VALUE instead.
1993-07-14 19:35:45 +00:00
|
|
|
val = (segment_info[S_GET_SEGMENT (symbolP)].scnhdr.s_paddr
|
|
|
|
+ S_GET_VALUE (symbolP));
|
|
|
|
|
|
|
|
S_SET_VALUE (symbolP, val);
|
|
|
|
|
|
|
|
symbolP->sy_symbol.ost_entry.n_value = val;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
|
|
where += bfd_coff_swap_sym_out (abfd, &symbolP->sy_symbol.ost_entry,
|
|
|
|
where);
|
|
|
|
|
|
|
|
for (i = 0; i < numaux; i++)
|
|
|
|
{
|
|
|
|
where += bfd_coff_swap_aux_out (abfd,
|
|
|
|
&symbolP->sy_symbol.ost_auxent[i],
|
|
|
|
S_GET_DATA_TYPE (symbolP),
|
|
|
|
S_GET_STORAGE_CLASS (symbolP),
|
|
|
|
where);
|
1992-02-22 20:45:24 +00:00
|
|
|
}
|
1992-11-23 20:42:33 +00:00
|
|
|
return where;
|
|
|
|
|
|
|
|
}
|
1991-12-12 00:53:23 +00:00
|
|
|
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
void
|
|
|
|
obj_symbol_new_hook (symbolP)
|
|
|
|
symbolS *symbolP;
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
char underscore = 0; /* Symbol has leading _ */
|
|
|
|
|
|
|
|
/* Effective symbol */
|
|
|
|
/* Store the pointer in the offset. */
|
|
|
|
S_SET_ZEROES (symbolP, 0L);
|
|
|
|
S_SET_DATA_TYPE (symbolP, T_NULL);
|
|
|
|
S_SET_STORAGE_CLASS (symbolP, 0);
|
|
|
|
S_SET_NUMBER_AUXILIARY (symbolP, 0);
|
|
|
|
/* Additional information */
|
|
|
|
symbolP->sy_symbol.ost_flags = 0;
|
|
|
|
/* Auxiliary entries */
|
|
|
|
bzero ((char *) &symbolP->sy_symbol.ost_auxent[0], AUXESZ);
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1991-12-12 00:53:23 +00:00
|
|
|
#ifdef STRIP_UNDERSCORE
|
1992-11-23 20:42:33 +00:00
|
|
|
/* Remove leading underscore at the beginning of the symbol.
|
1991-12-12 00:53:23 +00:00
|
|
|
* This is to be compatible with the standard librairies.
|
|
|
|
*/
|
1992-11-23 20:42:33 +00:00
|
|
|
if (*S_GET_NAME (symbolP) == '_')
|
|
|
|
{
|
|
|
|
underscore = 1;
|
|
|
|
S_SET_NAME (symbolP, S_GET_NAME (symbolP) + 1);
|
|
|
|
} /* strip underscore */
|
1991-12-12 00:53:23 +00:00
|
|
|
#endif /* STRIP_UNDERSCORE */
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
if (S_IS_STRING (symbolP))
|
|
|
|
SF_SET_STRING (symbolP);
|
|
|
|
if (!underscore && S_IS_LOCAL (symbolP))
|
|
|
|
SF_SET_LOCAL (symbolP);
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
return;
|
|
|
|
} /* obj_symbol_new_hook() */
|
1991-12-12 00:53:23 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
/* stack stuff */
|
|
|
|
stack *
|
|
|
|
stack_init (chunk_size, element_size)
|
|
|
|
unsigned long chunk_size;
|
|
|
|
unsigned long element_size;
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
stack *st;
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
if ((st = (stack *) malloc (sizeof (stack))) == (stack *) 0)
|
|
|
|
return (stack *) 0;
|
|
|
|
if ((st->data = malloc (chunk_size)) == (char *) 0)
|
|
|
|
{
|
|
|
|
free (st);
|
|
|
|
return (stack *) 0;
|
|
|
|
}
|
|
|
|
st->pointer = 0;
|
|
|
|
st->size = chunk_size;
|
|
|
|
st->chunk_size = chunk_size;
|
|
|
|
st->element_size = element_size;
|
|
|
|
return st;
|
|
|
|
} /* stack_init() */
|
|
|
|
|
|
|
|
void
|
|
|
|
stack_delete (st)
|
|
|
|
stack *st;
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
free (st->data);
|
|
|
|
free (st);
|
1991-12-12 00:53:23 +00:00
|
|
|
}
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
char *
|
|
|
|
stack_push (st, element)
|
|
|
|
stack *st;
|
|
|
|
char *element;
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
if (st->pointer + st->element_size >= st->size)
|
|
|
|
{
|
|
|
|
st->size += st->chunk_size;
|
|
|
|
if ((st->data = xrealloc (st->data, st->size)) == (char *) 0)
|
|
|
|
return (char *) 0;
|
|
|
|
}
|
|
|
|
memcpy (st->data + st->pointer, element, st->element_size);
|
|
|
|
st->pointer += st->element_size;
|
|
|
|
return st->data + st->pointer;
|
|
|
|
} /* stack_push() */
|
1991-12-12 00:53:23 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
char *
|
|
|
|
stack_pop (st)
|
|
|
|
stack *st;
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
if ((st->pointer -= st->element_size) < 0)
|
|
|
|
{
|
|
|
|
st->pointer = 0;
|
|
|
|
return (char *) 0;
|
1992-02-22 20:45:24 +00:00
|
|
|
}
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
return st->data + st->pointer;
|
1991-12-12 00:53:23 +00:00
|
|
|
}
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
char *
|
|
|
|
stack_top (st)
|
|
|
|
stack *st;
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
return st->data + st->pointer - st->element_size;
|
1991-12-12 00:53:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Handle .ln directives.
|
|
|
|
*/
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
static void
|
1993-05-27 19:29:38 +00:00
|
|
|
obj_coff_ln (appline)
|
|
|
|
int appline;
|
1992-01-28 03:43:23 +00:00
|
|
|
{
|
1992-02-22 20:45:24 +00:00
|
|
|
int l;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
1993-05-27 19:29:38 +00:00
|
|
|
if (! appline && def_symbol_in_progress != NULL)
|
1992-11-23 20:42:33 +00:00
|
|
|
{
|
|
|
|
as_warn (".ln pseudo-op inside .def/.endef: ignored.");
|
|
|
|
demand_empty_rest_of_line ();
|
1992-02-22 20:45:24 +00:00
|
|
|
return;
|
|
|
|
} /* wrong context */
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
c_line_new (0,
|
|
|
|
obstack_next_free (&frags) - frag_now->fr_literal,
|
|
|
|
l = get_absolute_expression (),
|
|
|
|
frag_now);
|
1992-01-28 03:43:23 +00:00
|
|
|
#ifndef NO_LISTING
|
1992-02-22 20:45:24 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
extern int listing;
|
|
|
|
|
|
|
|
if (listing)
|
|
|
|
{
|
1993-05-27 19:29:38 +00:00
|
|
|
if (! appline)
|
|
|
|
l += line_base - 1;
|
|
|
|
listing_source_line (l);
|
1992-11-23 20:42:33 +00:00
|
|
|
}
|
|
|
|
|
1992-02-22 20:45:24 +00:00
|
|
|
}
|
1992-01-28 03:43:23 +00:00
|
|
|
#endif
|
1992-11-23 20:42:33 +00:00
|
|
|
demand_empty_rest_of_line ();
|
1992-02-22 20:45:24 +00:00
|
|
|
return;
|
1992-01-28 03:43:23 +00:00
|
|
|
} /* obj_coff_line() */
|
1991-12-12 00:53:23 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* def()
|
|
|
|
*
|
|
|
|
* Handle .def directives.
|
|
|
|
*
|
|
|
|
* One might ask : why can't we symbol_new if the symbol does not
|
|
|
|
* already exist and fill it with debug information. Because of
|
|
|
|
* the C_EFCN special symbol. It would clobber the value of the
|
|
|
|
* function symbol before we have a chance to notice that it is
|
|
|
|
* a C_EFCN. And a second reason is that the code is more clear this
|
|
|
|
* way. (at least I think it is :-).
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define SKIP_SEMI_COLON() while (*input_line_pointer++ != ';')
|
|
|
|
#define SKIP_WHITESPACES() while (*input_line_pointer == ' ' || \
|
1992-02-22 20:45:24 +00:00
|
|
|
*input_line_pointer == '\t') \
|
|
|
|
input_line_pointer++;
|
1991-12-12 00:53:23 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
static void
|
|
|
|
DEFUN (obj_coff_def, (what),
|
|
|
|
int what)
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
char name_end; /* Char after the end of name */
|
|
|
|
char *symbol_name; /* Name of the debug symbol */
|
|
|
|
char *symbol_name_copy; /* Temporary copy of the name */
|
|
|
|
unsigned int symbol_name_length;
|
|
|
|
/*$char* directiveP;$ *//* Name of the pseudo opcode */
|
|
|
|
/*$char directive[MAX_DIRECTIVE];$ *//* Backup of the directive */
|
|
|
|
/*$char end = 0;$ *//* If 1, stop parsing */
|
|
|
|
|
|
|
|
if (def_symbol_in_progress != NULL)
|
|
|
|
{
|
|
|
|
as_warn (".def pseudo-op used inside of .def/.endef: ignored.");
|
|
|
|
demand_empty_rest_of_line ();
|
|
|
|
return;
|
|
|
|
} /* if not inside .def/.endef */
|
|
|
|
|
|
|
|
SKIP_WHITESPACES ();
|
|
|
|
|
|
|
|
def_symbol_in_progress = (symbolS *) obstack_alloc (¬es, sizeof (*def_symbol_in_progress));
|
|
|
|
bzero (def_symbol_in_progress, sizeof (*def_symbol_in_progress));
|
|
|
|
|
|
|
|
symbol_name = input_line_pointer;
|
|
|
|
name_end = get_symbol_end ();
|
|
|
|
symbol_name_length = strlen (symbol_name);
|
|
|
|
symbol_name_copy = xmalloc (symbol_name_length + 1);
|
|
|
|
strcpy (symbol_name_copy, symbol_name);
|
|
|
|
|
|
|
|
/* Initialize the new symbol */
|
1991-12-12 00:53:23 +00:00
|
|
|
#ifdef STRIP_UNDERSCORE
|
1992-11-23 20:42:33 +00:00
|
|
|
S_SET_NAME (def_symbol_in_progress, (*symbol_name_copy == '_'
|
|
|
|
? symbol_name_copy + 1
|
|
|
|
: symbol_name_copy));
|
|
|
|
#else /* STRIP_UNDERSCORE */
|
|
|
|
S_SET_NAME (def_symbol_in_progress, symbol_name_copy);
|
|
|
|
#endif /* STRIP_UNDERSCORE */
|
|
|
|
/* free(symbol_name_copy); */
|
|
|
|
def_symbol_in_progress->sy_name_offset = ~0;
|
|
|
|
def_symbol_in_progress->sy_number = ~0;
|
|
|
|
def_symbol_in_progress->sy_frag = &zero_address_frag;
|
* Extensive changes to permit symbols to contain any expression
type and to delay the computation of the expression until the
value is actually needed. This permits setting symbols to values
calculated based on object code size. Expressions were changed to
no longer be in a section, to stop the overloading of segment and
expression type that previously occurred.
* as.c (big_section, pass1_section, diff_section, absent_section):
Removed.
(expr_section): Added (used for dummy symbols which hold
intermediate expression values).
(perform_an_assembly_pass): Create expr_section, do not create the
sections now removed.
* as.h (segT): Removed SEG_ABSENT, SEG_PASS1, SEG_BIG, and
SEG_DIFFERENCE. Added SEG_EXPR.
(SEG_NORMAL): Corresponding changes.
* subsegs.c (seg_name, subsegs_begin): Changed accordingly.
* write.c (write_object_file): Ditto.
* config/obj-aout.c (seg_N_TYPE): Ditto.
* config/obj-bout.c (seg_N_TYPE): Ditto.
* config/obj-coff.c (seg_N_TYPE): Ditto.
* config/obj-coffbfd.c (seg_N_TYPE): Ditto.
* config/obj-vms.c (seg_N_TYPE): Ditto.
* expr.h (operatorT): Moved in from expr.c, added some values.
(expressionS): Added X_op field, removed X_seg field; renamed
X_subtract_symbol to X_op_symbol.
* expr.c: Extensive changes to assign expression types rather than
sections and to simplify the parsing.
* write.c (fix_new_internal): New static function.
(fix_new): Removed sub_symbol argument.
(fix_new_exp): New function, takes expression argument.
* write.h: Prototype changes for fix_new and fix_new_exp.
* cond.c (s_if): Changed accordingly.
* read.c (s_lsym, pseudo_set, emit_expr, parse_bitfield_cons,
parse_repeat_cons, get_segmented_expression,
get_known_segmented_expression, get_absolute_expression): Ditto.
* symbols.c (resolve_symbol_value, S_GET_VALUE, S_SET_VALUE):
Ditto.
* write.c (write_object_file): Ditto.
* config/obj-coff.c (obj_coff_def, obj_coff_val): Ditto.
* config/obj-coffbfd.c (obj_coff_def, obj_coff_val,
obj_coff_endef, yank_symbols): Ditto.
* config/obj-elf.c (obj_elf_stab_generic, obj_elf_size): Ditto.
* config/tc-a29k.c (md_assemble, parse_operand, machine_ip,
print_insn, md_operand): Ditto.
* config/tc-h8300.c (parse_exp, colonmod24, check_operand,
do_a_fix_imm, build_bytes): Ditto.
* config/tc-h8500.c (parse_exp, skip_colonthing, parse_reglist,
get_specific, check, insert, md_convert_frag): Ditto.
* config/tc-hppa.c (the_insn, fix_new_hppa, cons_fix_new_hppa,
md_assemble, pa_ip, getExpression, getAbsoluteExpression,
evaluateAbsolute, pa_build_unwind_subspace, pa_entry,
process_exit): Ditto.
* config/tc-hppa.h (STAB_FIXUP, is_DP_relative, is_PC_relative,
is_complex): Ditto.
* config/tc-i386.c (pe, md_assemble, i386_operand,
md_estimate_size_before_relax, md_create_long_jump): Ditto.
* config/tc-i860.c (md_assemble, getExpression, print_insn):
Ditto.
* config/tc-i960.c (parse_expr, subs, segs, md_convert_frag,
get_cdisp, mem_fmt, parse_ldconst, relax_cobr, s_sysproc,
i960_handle_align): Ditto.
* config/tc-m68k.c (struct m68k_exp, struct m68k_it, seg, op,
subs, add_fix, isvar, m68k_ip, md_assemble, md_convert_frag_1,
md_estimate_size_before_relax, md_create_long_jump, get_num):
Ditto.
* config/tc-m88k.c (md_assemble, get_imm16, get_pcr,
md_create_short_jump, md_create_long_jump): Ditto.
* config/tc-mips.c (md_assemble, append_insn, gp_reference,
macro_build, macro, my_getExpression): Ditto. Also removed
get_optional_absolute_expression; just use get_absolute_expression
instead.
* config/tc-ns32k.c (get_addr_mode, evaluate_expr, convert_iif,
fix_new_ns32k, fix_new_ns32k_exp, cons_fix_new_ns32k): Ditto.
* config/tc-ns32k.h (fix_new_ns32k prototype): Ditto.
* config/tc-sh.c (parse_exp, check, insert, md_convert_frag):
Ditto.
* config/tc-sparc.c (md_assemble, sparc_ip, getExpression,
print_insn): Ditto.
* config/tc-tahoe.c (struct top, md_estimate_size_before_relax,
tip_op, md_assemble): Ditto.
* config/tc-vax.c (seg_of_operand, md_assemble,
md_estimate_size_before_relax, md_create_long_jump): Ditto.
* config/tc-z8k.c (parse_exp, check_operand, newfix): Ditto.
1993-07-21 00:41:42 +00:00
|
|
|
S_SET_VALUE (def_symbol_in_progress, 0);
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
|
|
if (S_IS_STRING (def_symbol_in_progress))
|
|
|
|
{
|
|
|
|
SF_SET_STRING (def_symbol_in_progress);
|
|
|
|
} /* "long" name */
|
|
|
|
|
|
|
|
*input_line_pointer = name_end;
|
|
|
|
|
|
|
|
demand_empty_rest_of_line ();
|
|
|
|
return;
|
1991-12-12 00:53:23 +00:00
|
|
|
} /* obj_coff_def() */
|
|
|
|
|
|
|
|
unsigned int dim_index;
|
1992-11-23 20:42:33 +00:00
|
|
|
static void
|
|
|
|
DEFUN_VOID (obj_coff_endef)
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
symbolS *symbolP = 0;
|
|
|
|
/* DIM BUG FIX sac@cygnus.com */
|
|
|
|
dim_index = 0;
|
|
|
|
if (def_symbol_in_progress == NULL)
|
|
|
|
{
|
|
|
|
as_warn (".endef pseudo-op used outside of .def/.endef: ignored.");
|
|
|
|
demand_empty_rest_of_line ();
|
|
|
|
return;
|
|
|
|
} /* if not inside .def/.endef */
|
|
|
|
|
|
|
|
/* Set the section number according to storage class. */
|
|
|
|
switch (S_GET_STORAGE_CLASS (def_symbol_in_progress))
|
|
|
|
{
|
|
|
|
case C_STRTAG:
|
|
|
|
case C_ENTAG:
|
|
|
|
case C_UNTAG:
|
|
|
|
SF_SET_TAG (def_symbol_in_progress);
|
|
|
|
/* intentional fallthrough */
|
|
|
|
case C_FILE:
|
|
|
|
case C_TPDEF:
|
|
|
|
SF_SET_DEBUG (def_symbol_in_progress);
|
|
|
|
S_SET_SEGMENT (def_symbol_in_progress, SEG_DEBUG);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case C_EFCN:
|
|
|
|
SF_SET_LOCAL (def_symbol_in_progress); /* Do not emit this symbol. */
|
|
|
|
/* intentional fallthrough */
|
|
|
|
case C_BLOCK:
|
|
|
|
SF_SET_PROCESS (def_symbol_in_progress); /* Will need processing before writing */
|
|
|
|
/* intentional fallthrough */
|
|
|
|
case C_FCN:
|
|
|
|
S_SET_SEGMENT (def_symbol_in_progress, SEG_E0);
|
|
|
|
|
1993-03-15 20:21:13 +00:00
|
|
|
if (strcmp (S_GET_NAME (def_symbol_in_progress), ".bf") == 0)
|
1992-11-23 20:42:33 +00:00
|
|
|
{ /* .bf */
|
|
|
|
if (function_lineoff < 0)
|
|
|
|
{
|
|
|
|
fprintf (stderr, "`.bf' symbol without preceding function\n");
|
|
|
|
} /* missing function symbol */
|
|
|
|
SA_GET_SYM_LNNOPTR (last_line_symbol) = function_lineoff;
|
|
|
|
|
|
|
|
SF_SET_PROCESS (last_line_symbol);
|
|
|
|
function_lineoff = -1;
|
|
|
|
}
|
|
|
|
break;
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1991-12-12 00:53:23 +00:00
|
|
|
#ifdef C_AUTOARG
|
1992-11-23 20:42:33 +00:00
|
|
|
case C_AUTOARG:
|
|
|
|
#endif /* C_AUTOARG */
|
|
|
|
case C_AUTO:
|
|
|
|
case C_REG:
|
|
|
|
case C_MOS:
|
|
|
|
case C_MOE:
|
|
|
|
case C_MOU:
|
|
|
|
case C_ARG:
|
|
|
|
case C_REGPARM:
|
|
|
|
case C_FIELD:
|
|
|
|
case C_EOS:
|
|
|
|
SF_SET_DEBUG (def_symbol_in_progress);
|
|
|
|
S_SET_SEGMENT (def_symbol_in_progress, SEG_ABSOLUTE);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case C_EXT:
|
|
|
|
case C_STAT:
|
|
|
|
case C_LABEL:
|
|
|
|
/* Valid but set somewhere else (s_comm, s_lcomm, colon) */
|
|
|
|
break;
|
|
|
|
|
|
|
|
case C_USTATIC:
|
|
|
|
case C_EXTDEF:
|
|
|
|
case C_ULABEL:
|
|
|
|
as_warn ("unexpected storage class %d", S_GET_STORAGE_CLASS (def_symbol_in_progress));
|
|
|
|
break;
|
|
|
|
} /* switch on storage class */
|
|
|
|
|
1993-05-05 20:32:12 +00:00
|
|
|
/* Now that we have built a debug symbol, try to find if we should
|
|
|
|
merge with an existing symbol or not. If a symbol is C_EFCN or
|
|
|
|
SEG_ABSOLUTE or untagged SEG_DEBUG it never merges. We also
|
|
|
|
don't merge labels, which are in a different namespace, nor
|
|
|
|
symbols which have not yet been defined since they are typically
|
|
|
|
unique, nor do we merge tags with non-tags. */
|
|
|
|
|
|
|
|
/* Two cases for functions. Either debug followed by definition or
|
|
|
|
definition followed by debug. For definition first, we will
|
|
|
|
merge the debug symbol into the definition. For debug first, the
|
|
|
|
lineno entry MUST point to the definition function or else it
|
|
|
|
will point off into space when crawl_symbols() merges the debug
|
|
|
|
symbol into the real symbol. Therefor, let's presume the debug
|
|
|
|
symbol is a real function reference. */
|
|
|
|
|
|
|
|
/* FIXME-SOON If for some reason the definition label/symbol is
|
|
|
|
never seen, this will probably leave an undefined symbol at link
|
|
|
|
time. */
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
if (S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_EFCN
|
Sat Dec 12 15:26:34 1992 Ian Lance Taylor (ian@cygnus.com)
* listing.c: Call xmalloc, not malloc; don't declare malloc.
* Changes to support SCO 3.2v4:
* read.c (s_align_bytes, s_align_ptwo): If not SEG_DATA or
SEG_BSS, fill with NOP_OPCODE.
* config/i386coff.mt: Add opcode/i386.h to TARG_CPU_DEPENDENTS.
* config/obj-coffbfd.c (do_relocs_for): Increment addr even if not
using ZERO_BASED_SEGMENTS.
(fill_section): If ZERO_BASED_SEGMENTS, set segment addresses, but
never set segment address for SEG_E2 (.bss) and don't write out
SEG_E2 contents. Set .init and .fini sections to STYP_TEXT.
(obj_coff_endef): Don't merge labels or symbols awaiting forward
definitions, and don't merge tags with non-tags. Check for .bf
rather than just checking whether the second character is b and
the third character is f.
(obj_coff_val): gcc can generate values which we don't handle
correctly; discard information for now, since it only affects the
debugging information.
(tag_find_or_name): Don't insert tags in the symbol table.
(yank_symbols): Don't merge labels.
(write_object_file): Don't define SUB_SEGMENT_ALIGN if it is
already defined. Fill subsegments with NOP_OPCODE, not 0. Don't
set segment address if ZERO_BASED_SEGMENTS.
(obj_coff_section): Accept and ignore a trailing quoted string, as
used in AT&T i386 syntax.
(fixup_segment): Take segment as argument. On the i386, adjust PC
relative addends by the segment vaddr.
* tc-i386.h: Define SUB_SEGMENT_ALIGN.
* tc-a29k.h: Define ZERO_BASED_SEGMENTS.
* tc-i386.c: (i386_operand): If I386COFF, accept any segment type.
1992-12-13 00:56:14 +00:00
|
|
|
|| S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_LABEL
|
1992-11-23 20:42:33 +00:00
|
|
|
|| (S_GET_SEGMENT (def_symbol_in_progress) == SEG_DEBUG
|
|
|
|
&& !SF_GET_TAG (def_symbol_in_progress))
|
|
|
|
|| S_GET_SEGMENT (def_symbol_in_progress) == SEG_ABSOLUTE
|
* Extensive changes to permit symbols to contain any expression
type and to delay the computation of the expression until the
value is actually needed. This permits setting symbols to values
calculated based on object code size. Expressions were changed to
no longer be in a section, to stop the overloading of segment and
expression type that previously occurred.
* as.c (big_section, pass1_section, diff_section, absent_section):
Removed.
(expr_section): Added (used for dummy symbols which hold
intermediate expression values).
(perform_an_assembly_pass): Create expr_section, do not create the
sections now removed.
* as.h (segT): Removed SEG_ABSENT, SEG_PASS1, SEG_BIG, and
SEG_DIFFERENCE. Added SEG_EXPR.
(SEG_NORMAL): Corresponding changes.
* subsegs.c (seg_name, subsegs_begin): Changed accordingly.
* write.c (write_object_file): Ditto.
* config/obj-aout.c (seg_N_TYPE): Ditto.
* config/obj-bout.c (seg_N_TYPE): Ditto.
* config/obj-coff.c (seg_N_TYPE): Ditto.
* config/obj-coffbfd.c (seg_N_TYPE): Ditto.
* config/obj-vms.c (seg_N_TYPE): Ditto.
* expr.h (operatorT): Moved in from expr.c, added some values.
(expressionS): Added X_op field, removed X_seg field; renamed
X_subtract_symbol to X_op_symbol.
* expr.c: Extensive changes to assign expression types rather than
sections and to simplify the parsing.
* write.c (fix_new_internal): New static function.
(fix_new): Removed sub_symbol argument.
(fix_new_exp): New function, takes expression argument.
* write.h: Prototype changes for fix_new and fix_new_exp.
* cond.c (s_if): Changed accordingly.
* read.c (s_lsym, pseudo_set, emit_expr, parse_bitfield_cons,
parse_repeat_cons, get_segmented_expression,
get_known_segmented_expression, get_absolute_expression): Ditto.
* symbols.c (resolve_symbol_value, S_GET_VALUE, S_SET_VALUE):
Ditto.
* write.c (write_object_file): Ditto.
* config/obj-coff.c (obj_coff_def, obj_coff_val): Ditto.
* config/obj-coffbfd.c (obj_coff_def, obj_coff_val,
obj_coff_endef, yank_symbols): Ditto.
* config/obj-elf.c (obj_elf_stab_generic, obj_elf_size): Ditto.
* config/tc-a29k.c (md_assemble, parse_operand, machine_ip,
print_insn, md_operand): Ditto.
* config/tc-h8300.c (parse_exp, colonmod24, check_operand,
do_a_fix_imm, build_bytes): Ditto.
* config/tc-h8500.c (parse_exp, skip_colonthing, parse_reglist,
get_specific, check, insert, md_convert_frag): Ditto.
* config/tc-hppa.c (the_insn, fix_new_hppa, cons_fix_new_hppa,
md_assemble, pa_ip, getExpression, getAbsoluteExpression,
evaluateAbsolute, pa_build_unwind_subspace, pa_entry,
process_exit): Ditto.
* config/tc-hppa.h (STAB_FIXUP, is_DP_relative, is_PC_relative,
is_complex): Ditto.
* config/tc-i386.c (pe, md_assemble, i386_operand,
md_estimate_size_before_relax, md_create_long_jump): Ditto.
* config/tc-i860.c (md_assemble, getExpression, print_insn):
Ditto.
* config/tc-i960.c (parse_expr, subs, segs, md_convert_frag,
get_cdisp, mem_fmt, parse_ldconst, relax_cobr, s_sysproc,
i960_handle_align): Ditto.
* config/tc-m68k.c (struct m68k_exp, struct m68k_it, seg, op,
subs, add_fix, isvar, m68k_ip, md_assemble, md_convert_frag_1,
md_estimate_size_before_relax, md_create_long_jump, get_num):
Ditto.
* config/tc-m88k.c (md_assemble, get_imm16, get_pcr,
md_create_short_jump, md_create_long_jump): Ditto.
* config/tc-mips.c (md_assemble, append_insn, gp_reference,
macro_build, macro, my_getExpression): Ditto. Also removed
get_optional_absolute_expression; just use get_absolute_expression
instead.
* config/tc-ns32k.c (get_addr_mode, evaluate_expr, convert_iif,
fix_new_ns32k, fix_new_ns32k_exp, cons_fix_new_ns32k): Ditto.
* config/tc-ns32k.h (fix_new_ns32k prototype): Ditto.
* config/tc-sh.c (parse_exp, check, insert, md_convert_frag):
Ditto.
* config/tc-sparc.c (md_assemble, sparc_ip, getExpression,
print_insn): Ditto.
* config/tc-tahoe.c (struct top, md_estimate_size_before_relax,
tip_op, md_assemble): Ditto.
* config/tc-vax.c (seg_of_operand, md_assemble,
md_estimate_size_before_relax, md_create_long_jump): Ditto.
* config/tc-z8k.c (parse_exp, check_operand, newfix): Ditto.
1993-07-21 00:41:42 +00:00
|
|
|
|| def_symbol_in_progress->sy_value.X_op != O_constant
|
Sat Dec 12 15:26:34 1992 Ian Lance Taylor (ian@cygnus.com)
* listing.c: Call xmalloc, not malloc; don't declare malloc.
* Changes to support SCO 3.2v4:
* read.c (s_align_bytes, s_align_ptwo): If not SEG_DATA or
SEG_BSS, fill with NOP_OPCODE.
* config/i386coff.mt: Add opcode/i386.h to TARG_CPU_DEPENDENTS.
* config/obj-coffbfd.c (do_relocs_for): Increment addr even if not
using ZERO_BASED_SEGMENTS.
(fill_section): If ZERO_BASED_SEGMENTS, set segment addresses, but
never set segment address for SEG_E2 (.bss) and don't write out
SEG_E2 contents. Set .init and .fini sections to STYP_TEXT.
(obj_coff_endef): Don't merge labels or symbols awaiting forward
definitions, and don't merge tags with non-tags. Check for .bf
rather than just checking whether the second character is b and
the third character is f.
(obj_coff_val): gcc can generate values which we don't handle
correctly; discard information for now, since it only affects the
debugging information.
(tag_find_or_name): Don't insert tags in the symbol table.
(yank_symbols): Don't merge labels.
(write_object_file): Don't define SUB_SEGMENT_ALIGN if it is
already defined. Fill subsegments with NOP_OPCODE, not 0. Don't
set segment address if ZERO_BASED_SEGMENTS.
(obj_coff_section): Accept and ignore a trailing quoted string, as
used in AT&T i386 syntax.
(fixup_segment): Take segment as argument. On the i386, adjust PC
relative addends by the segment vaddr.
* tc-i386.h: Define SUB_SEGMENT_ALIGN.
* tc-a29k.h: Define ZERO_BASED_SEGMENTS.
* tc-i386.c: (i386_operand): If I386COFF, accept any segment type.
1992-12-13 00:56:14 +00:00
|
|
|
|| (symbolP = symbol_find_base (S_GET_NAME (def_symbol_in_progress), DO_NOT_STRIP)) == NULL
|
|
|
|
|| (SF_GET_TAG (def_symbol_in_progress) != SF_GET_TAG (symbolP)))
|
1992-11-23 20:42:33 +00:00
|
|
|
{
|
1993-05-05 20:32:12 +00:00
|
|
|
symbol_append (def_symbol_in_progress, symbol_lastP, &symbol_rootP,
|
|
|
|
&symbol_lastP);
|
1992-11-23 20:42:33 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
1993-05-05 20:32:12 +00:00
|
|
|
/* This symbol already exists, merge the newly created symbol
|
|
|
|
into the This is not mandatory. The linker can handle
|
|
|
|
duplicate symbols correctly. But I guess that it save a *lot*
|
|
|
|
of space if the assembly file defines a lot of
|
|
|
|
symbols. [loic] */
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1993-05-05 20:32:12 +00:00
|
|
|
/* The debug entry (def_symbol_in_progress) is merged into the
|
|
|
|
previous definition. */
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
c_symbol_merge (def_symbol_in_progress, symbolP);
|
|
|
|
/* FIXME-SOON Should *def_symbol_in_progress be free'd? xoxorich. */
|
|
|
|
def_symbol_in_progress = symbolP;
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
if (SF_GET_FUNCTION (def_symbol_in_progress)
|
|
|
|
|| SF_GET_TAG (def_symbol_in_progress))
|
|
|
|
{
|
1993-05-05 20:32:12 +00:00
|
|
|
/* For functions, and tags, the symbol *must* be where the
|
|
|
|
debug symbol appears. Move the existing symbol to the
|
|
|
|
current place. */
|
1992-11-23 20:42:33 +00:00
|
|
|
/* If it already is at the end of the symbol list, do nothing */
|
|
|
|
if (def_symbol_in_progress != symbol_lastP)
|
|
|
|
{
|
1993-05-05 20:32:12 +00:00
|
|
|
symbol_remove (def_symbol_in_progress, &symbol_rootP,
|
|
|
|
&symbol_lastP);
|
|
|
|
symbol_append (def_symbol_in_progress, symbol_lastP,
|
|
|
|
&symbol_rootP, &symbol_lastP);
|
1992-11-23 20:42:33 +00:00
|
|
|
} /* if not already in place */
|
|
|
|
} /* if function */
|
|
|
|
} /* normal or mergable */
|
|
|
|
|
|
|
|
if (SF_GET_TAG (def_symbol_in_progress)
|
|
|
|
&& symbol_find_base (S_GET_NAME (def_symbol_in_progress), DO_NOT_STRIP) == NULL)
|
|
|
|
{
|
|
|
|
tag_insert (S_GET_NAME (def_symbol_in_progress), def_symbol_in_progress);
|
1993-05-05 20:32:12 +00:00
|
|
|
}
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
if (SF_GET_FUNCTION (def_symbol_in_progress))
|
|
|
|
{
|
|
|
|
know (sizeof (def_symbol_in_progress) <= sizeof (long));
|
|
|
|
function_lineoff
|
|
|
|
= c_line_new (def_symbol_in_progress, 0, 0, &zero_address_frag);
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
SF_SET_PROCESS (def_symbol_in_progress);
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
if (symbolP == NULL)
|
|
|
|
{
|
1993-05-05 20:32:12 +00:00
|
|
|
/* That is, if this is the first time we've seen the
|
|
|
|
function... */
|
1992-11-23 20:42:33 +00:00
|
|
|
symbol_table_insert (def_symbol_in_progress);
|
|
|
|
} /* definition follows debug */
|
|
|
|
} /* Create the line number entry pointing to the function being defined */
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
def_symbol_in_progress = NULL;
|
|
|
|
demand_empty_rest_of_line ();
|
|
|
|
return;
|
1993-05-05 20:32:12 +00:00
|
|
|
}
|
1991-12-12 00:53:23 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
static void
|
|
|
|
DEFUN_VOID (obj_coff_dim)
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
register int dim_index;
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
if (def_symbol_in_progress == NULL)
|
1992-02-22 20:45:24 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
as_warn (".dim pseudo-op used outside of .def/.endef: ignored.");
|
|
|
|
demand_empty_rest_of_line ();
|
|
|
|
return;
|
1992-02-22 20:45:24 +00:00
|
|
|
} /* if not inside .def/.endef */
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
for (dim_index = 0; dim_index < DIMNUM; dim_index++)
|
1992-02-22 20:45:24 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
SKIP_WHITESPACES ();
|
|
|
|
SA_SET_SYM_DIMEN (def_symbol_in_progress, dim_index, get_absolute_expression ());
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
switch (*input_line_pointer)
|
1992-02-22 20:45:24 +00:00
|
|
|
{
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
case ',':
|
|
|
|
input_line_pointer++;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
as_warn ("badly formed .dim directive ignored");
|
|
|
|
/* intentional fallthrough */
|
|
|
|
case '\n':
|
|
|
|
case ';':
|
|
|
|
dim_index = DIMNUM;
|
|
|
|
break;
|
1992-02-22 20:45:24 +00:00
|
|
|
} /* switch on following character */
|
|
|
|
} /* for each dimension */
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
demand_empty_rest_of_line ();
|
|
|
|
return;
|
1991-12-12 00:53:23 +00:00
|
|
|
} /* obj_coff_dim() */
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
static void
|
|
|
|
obj_coff_line ()
|
1992-01-28 03:43:23 +00:00
|
|
|
{
|
1992-02-22 20:45:24 +00:00
|
|
|
int this_base;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
|
|
if (def_symbol_in_progress == NULL)
|
|
|
|
{
|
1993-05-27 19:29:38 +00:00
|
|
|
obj_coff_ln (0);
|
1992-02-22 20:45:24 +00:00
|
|
|
return;
|
|
|
|
} /* if it looks like a stabs style line */
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
this_base = get_absolute_expression ();
|
|
|
|
if (this_base > line_base)
|
|
|
|
{
|
|
|
|
line_base = this_base;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#ifndef NO_LISTING
|
1992-02-22 20:45:24 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
extern int listing;
|
|
|
|
if (listing && 0)
|
|
|
|
{
|
|
|
|
listing_source_line (line_base);
|
|
|
|
}
|
1992-02-22 20:45:24 +00:00
|
|
|
}
|
1992-01-28 03:43:23 +00:00
|
|
|
#endif
|
1992-11-23 20:42:33 +00:00
|
|
|
S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
|
|
|
|
SA_SET_SYM_LNNO (def_symbol_in_progress, line_base);
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
demand_empty_rest_of_line ();
|
1992-02-22 20:45:24 +00:00
|
|
|
return;
|
1992-01-28 03:43:23 +00:00
|
|
|
} /* obj_coff_line() */
|
1991-12-12 00:53:23 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
static void
|
|
|
|
obj_coff_size ()
|
|
|
|
{
|
|
|
|
if (def_symbol_in_progress == NULL)
|
|
|
|
{
|
|
|
|
as_warn (".size pseudo-op used outside of .def/.endef ignored.");
|
|
|
|
demand_empty_rest_of_line ();
|
|
|
|
return;
|
|
|
|
} /* if not inside .def/.endef */
|
|
|
|
|
|
|
|
S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
|
|
|
|
SA_SET_SYM_SIZE (def_symbol_in_progress, get_absolute_expression ());
|
|
|
|
demand_empty_rest_of_line ();
|
|
|
|
return;
|
|
|
|
} /* obj_coff_size() */
|
|
|
|
|
|
|
|
static void
|
|
|
|
obj_coff_scl ()
|
|
|
|
{
|
|
|
|
if (def_symbol_in_progress == NULL)
|
|
|
|
{
|
|
|
|
as_warn (".scl pseudo-op used outside of .def/.endef ignored.");
|
|
|
|
demand_empty_rest_of_line ();
|
|
|
|
return;
|
|
|
|
} /* if not inside .def/.endef */
|
|
|
|
|
|
|
|
S_SET_STORAGE_CLASS (def_symbol_in_progress, get_absolute_expression ());
|
|
|
|
demand_empty_rest_of_line ();
|
|
|
|
return;
|
|
|
|
} /* obj_coff_scl() */
|
|
|
|
|
|
|
|
static void
|
|
|
|
obj_coff_tag ()
|
|
|
|
{
|
|
|
|
char *symbol_name;
|
|
|
|
char name_end;
|
|
|
|
|
|
|
|
if (def_symbol_in_progress == NULL)
|
|
|
|
{
|
|
|
|
as_warn (".tag pseudo-op used outside of .def/.endef ignored.");
|
|
|
|
demand_empty_rest_of_line ();
|
|
|
|
return;
|
|
|
|
} /* if not inside .def/.endef */
|
|
|
|
|
|
|
|
S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
|
|
|
|
symbol_name = input_line_pointer;
|
|
|
|
name_end = get_symbol_end ();
|
|
|
|
|
|
|
|
/* Assume that the symbol referred to by .tag is always defined. */
|
|
|
|
/* This was a bad assumption. I've added find_or_make. xoxorich. */
|
|
|
|
SA_SET_SYM_TAGNDX (def_symbol_in_progress, (long) tag_find_or_make (symbol_name));
|
|
|
|
if (SA_GET_SYM_TAGNDX (def_symbol_in_progress) == 0L)
|
|
|
|
{
|
|
|
|
as_warn ("tag not found for .tag %s", symbol_name);
|
|
|
|
} /* not defined */
|
|
|
|
|
|
|
|
SF_SET_TAGGED (def_symbol_in_progress);
|
|
|
|
*input_line_pointer = name_end;
|
|
|
|
|
|
|
|
demand_empty_rest_of_line ();
|
|
|
|
return;
|
|
|
|
} /* obj_coff_tag() */
|
|
|
|
|
|
|
|
static void
|
|
|
|
obj_coff_type ()
|
|
|
|
{
|
|
|
|
if (def_symbol_in_progress == NULL)
|
|
|
|
{
|
|
|
|
as_warn (".type pseudo-op used outside of .def/.endef ignored.");
|
|
|
|
demand_empty_rest_of_line ();
|
|
|
|
return;
|
|
|
|
} /* if not inside .def/.endef */
|
|
|
|
|
|
|
|
S_SET_DATA_TYPE (def_symbol_in_progress, get_absolute_expression ());
|
|
|
|
|
|
|
|
if (ISFCN (S_GET_DATA_TYPE (def_symbol_in_progress)) &&
|
|
|
|
S_GET_STORAGE_CLASS (def_symbol_in_progress) != C_TPDEF)
|
|
|
|
{
|
|
|
|
SF_SET_FUNCTION (def_symbol_in_progress);
|
|
|
|
} /* is a function */
|
|
|
|
|
|
|
|
demand_empty_rest_of_line ();
|
|
|
|
return;
|
|
|
|
} /* obj_coff_type() */
|
|
|
|
|
|
|
|
static void
|
|
|
|
obj_coff_val ()
|
|
|
|
{
|
|
|
|
if (def_symbol_in_progress == NULL)
|
|
|
|
{
|
|
|
|
as_warn (".val pseudo-op used outside of .def/.endef ignored.");
|
|
|
|
demand_empty_rest_of_line ();
|
|
|
|
return;
|
|
|
|
} /* if not inside .def/.endef */
|
|
|
|
|
|
|
|
if (is_name_beginner (*input_line_pointer))
|
|
|
|
{
|
|
|
|
char *symbol_name = input_line_pointer;
|
|
|
|
char name_end = get_symbol_end ();
|
|
|
|
|
|
|
|
if (!strcmp (symbol_name, "."))
|
|
|
|
{
|
|
|
|
def_symbol_in_progress->sy_frag = frag_now;
|
|
|
|
S_SET_VALUE (def_symbol_in_progress, obstack_next_free (&frags) - frag_now->fr_literal);
|
|
|
|
/* If the .val is != from the .def (e.g. statics) */
|
|
|
|
}
|
|
|
|
else if (strcmp (S_GET_NAME (def_symbol_in_progress), symbol_name))
|
|
|
|
{
|
* Extensive changes to permit symbols to contain any expression
type and to delay the computation of the expression until the
value is actually needed. This permits setting symbols to values
calculated based on object code size. Expressions were changed to
no longer be in a section, to stop the overloading of segment and
expression type that previously occurred.
* as.c (big_section, pass1_section, diff_section, absent_section):
Removed.
(expr_section): Added (used for dummy symbols which hold
intermediate expression values).
(perform_an_assembly_pass): Create expr_section, do not create the
sections now removed.
* as.h (segT): Removed SEG_ABSENT, SEG_PASS1, SEG_BIG, and
SEG_DIFFERENCE. Added SEG_EXPR.
(SEG_NORMAL): Corresponding changes.
* subsegs.c (seg_name, subsegs_begin): Changed accordingly.
* write.c (write_object_file): Ditto.
* config/obj-aout.c (seg_N_TYPE): Ditto.
* config/obj-bout.c (seg_N_TYPE): Ditto.
* config/obj-coff.c (seg_N_TYPE): Ditto.
* config/obj-coffbfd.c (seg_N_TYPE): Ditto.
* config/obj-vms.c (seg_N_TYPE): Ditto.
* expr.h (operatorT): Moved in from expr.c, added some values.
(expressionS): Added X_op field, removed X_seg field; renamed
X_subtract_symbol to X_op_symbol.
* expr.c: Extensive changes to assign expression types rather than
sections and to simplify the parsing.
* write.c (fix_new_internal): New static function.
(fix_new): Removed sub_symbol argument.
(fix_new_exp): New function, takes expression argument.
* write.h: Prototype changes for fix_new and fix_new_exp.
* cond.c (s_if): Changed accordingly.
* read.c (s_lsym, pseudo_set, emit_expr, parse_bitfield_cons,
parse_repeat_cons, get_segmented_expression,
get_known_segmented_expression, get_absolute_expression): Ditto.
* symbols.c (resolve_symbol_value, S_GET_VALUE, S_SET_VALUE):
Ditto.
* write.c (write_object_file): Ditto.
* config/obj-coff.c (obj_coff_def, obj_coff_val): Ditto.
* config/obj-coffbfd.c (obj_coff_def, obj_coff_val,
obj_coff_endef, yank_symbols): Ditto.
* config/obj-elf.c (obj_elf_stab_generic, obj_elf_size): Ditto.
* config/tc-a29k.c (md_assemble, parse_operand, machine_ip,
print_insn, md_operand): Ditto.
* config/tc-h8300.c (parse_exp, colonmod24, check_operand,
do_a_fix_imm, build_bytes): Ditto.
* config/tc-h8500.c (parse_exp, skip_colonthing, parse_reglist,
get_specific, check, insert, md_convert_frag): Ditto.
* config/tc-hppa.c (the_insn, fix_new_hppa, cons_fix_new_hppa,
md_assemble, pa_ip, getExpression, getAbsoluteExpression,
evaluateAbsolute, pa_build_unwind_subspace, pa_entry,
process_exit): Ditto.
* config/tc-hppa.h (STAB_FIXUP, is_DP_relative, is_PC_relative,
is_complex): Ditto.
* config/tc-i386.c (pe, md_assemble, i386_operand,
md_estimate_size_before_relax, md_create_long_jump): Ditto.
* config/tc-i860.c (md_assemble, getExpression, print_insn):
Ditto.
* config/tc-i960.c (parse_expr, subs, segs, md_convert_frag,
get_cdisp, mem_fmt, parse_ldconst, relax_cobr, s_sysproc,
i960_handle_align): Ditto.
* config/tc-m68k.c (struct m68k_exp, struct m68k_it, seg, op,
subs, add_fix, isvar, m68k_ip, md_assemble, md_convert_frag_1,
md_estimate_size_before_relax, md_create_long_jump, get_num):
Ditto.
* config/tc-m88k.c (md_assemble, get_imm16, get_pcr,
md_create_short_jump, md_create_long_jump): Ditto.
* config/tc-mips.c (md_assemble, append_insn, gp_reference,
macro_build, macro, my_getExpression): Ditto. Also removed
get_optional_absolute_expression; just use get_absolute_expression
instead.
* config/tc-ns32k.c (get_addr_mode, evaluate_expr, convert_iif,
fix_new_ns32k, fix_new_ns32k_exp, cons_fix_new_ns32k): Ditto.
* config/tc-ns32k.h (fix_new_ns32k prototype): Ditto.
* config/tc-sh.c (parse_exp, check, insert, md_convert_frag):
Ditto.
* config/tc-sparc.c (md_assemble, sparc_ip, getExpression,
print_insn): Ditto.
* config/tc-tahoe.c (struct top, md_estimate_size_before_relax,
tip_op, md_assemble): Ditto.
* config/tc-vax.c (seg_of_operand, md_assemble,
md_estimate_size_before_relax, md_create_long_jump): Ditto.
* config/tc-z8k.c (parse_exp, check_operand, newfix): Ditto.
1993-07-21 00:41:42 +00:00
|
|
|
def_symbol_in_progress->sy_value.X_op = O_symbol;
|
1993-07-14 22:21:25 +00:00
|
|
|
def_symbol_in_progress->sy_value.X_add_symbol =
|
|
|
|
symbol_find_or_make (symbol_name);
|
* Extensive changes to permit symbols to contain any expression
type and to delay the computation of the expression until the
value is actually needed. This permits setting symbols to values
calculated based on object code size. Expressions were changed to
no longer be in a section, to stop the overloading of segment and
expression type that previously occurred.
* as.c (big_section, pass1_section, diff_section, absent_section):
Removed.
(expr_section): Added (used for dummy symbols which hold
intermediate expression values).
(perform_an_assembly_pass): Create expr_section, do not create the
sections now removed.
* as.h (segT): Removed SEG_ABSENT, SEG_PASS1, SEG_BIG, and
SEG_DIFFERENCE. Added SEG_EXPR.
(SEG_NORMAL): Corresponding changes.
* subsegs.c (seg_name, subsegs_begin): Changed accordingly.
* write.c (write_object_file): Ditto.
* config/obj-aout.c (seg_N_TYPE): Ditto.
* config/obj-bout.c (seg_N_TYPE): Ditto.
* config/obj-coff.c (seg_N_TYPE): Ditto.
* config/obj-coffbfd.c (seg_N_TYPE): Ditto.
* config/obj-vms.c (seg_N_TYPE): Ditto.
* expr.h (operatorT): Moved in from expr.c, added some values.
(expressionS): Added X_op field, removed X_seg field; renamed
X_subtract_symbol to X_op_symbol.
* expr.c: Extensive changes to assign expression types rather than
sections and to simplify the parsing.
* write.c (fix_new_internal): New static function.
(fix_new): Removed sub_symbol argument.
(fix_new_exp): New function, takes expression argument.
* write.h: Prototype changes for fix_new and fix_new_exp.
* cond.c (s_if): Changed accordingly.
* read.c (s_lsym, pseudo_set, emit_expr, parse_bitfield_cons,
parse_repeat_cons, get_segmented_expression,
get_known_segmented_expression, get_absolute_expression): Ditto.
* symbols.c (resolve_symbol_value, S_GET_VALUE, S_SET_VALUE):
Ditto.
* write.c (write_object_file): Ditto.
* config/obj-coff.c (obj_coff_def, obj_coff_val): Ditto.
* config/obj-coffbfd.c (obj_coff_def, obj_coff_val,
obj_coff_endef, yank_symbols): Ditto.
* config/obj-elf.c (obj_elf_stab_generic, obj_elf_size): Ditto.
* config/tc-a29k.c (md_assemble, parse_operand, machine_ip,
print_insn, md_operand): Ditto.
* config/tc-h8300.c (parse_exp, colonmod24, check_operand,
do_a_fix_imm, build_bytes): Ditto.
* config/tc-h8500.c (parse_exp, skip_colonthing, parse_reglist,
get_specific, check, insert, md_convert_frag): Ditto.
* config/tc-hppa.c (the_insn, fix_new_hppa, cons_fix_new_hppa,
md_assemble, pa_ip, getExpression, getAbsoluteExpression,
evaluateAbsolute, pa_build_unwind_subspace, pa_entry,
process_exit): Ditto.
* config/tc-hppa.h (STAB_FIXUP, is_DP_relative, is_PC_relative,
is_complex): Ditto.
* config/tc-i386.c (pe, md_assemble, i386_operand,
md_estimate_size_before_relax, md_create_long_jump): Ditto.
* config/tc-i860.c (md_assemble, getExpression, print_insn):
Ditto.
* config/tc-i960.c (parse_expr, subs, segs, md_convert_frag,
get_cdisp, mem_fmt, parse_ldconst, relax_cobr, s_sysproc,
i960_handle_align): Ditto.
* config/tc-m68k.c (struct m68k_exp, struct m68k_it, seg, op,
subs, add_fix, isvar, m68k_ip, md_assemble, md_convert_frag_1,
md_estimate_size_before_relax, md_create_long_jump, get_num):
Ditto.
* config/tc-m88k.c (md_assemble, get_imm16, get_pcr,
md_create_short_jump, md_create_long_jump): Ditto.
* config/tc-mips.c (md_assemble, append_insn, gp_reference,
macro_build, macro, my_getExpression): Ditto. Also removed
get_optional_absolute_expression; just use get_absolute_expression
instead.
* config/tc-ns32k.c (get_addr_mode, evaluate_expr, convert_iif,
fix_new_ns32k, fix_new_ns32k_exp, cons_fix_new_ns32k): Ditto.
* config/tc-ns32k.h (fix_new_ns32k prototype): Ditto.
* config/tc-sh.c (parse_exp, check, insert, md_convert_frag):
Ditto.
* config/tc-sparc.c (md_assemble, sparc_ip, getExpression,
print_insn): Ditto.
* config/tc-tahoe.c (struct top, md_estimate_size_before_relax,
tip_op, md_assemble): Ditto.
* config/tc-vax.c (seg_of_operand, md_assemble,
md_estimate_size_before_relax, md_create_long_jump): Ditto.
* config/tc-z8k.c (parse_exp, check_operand, newfix): Ditto.
1993-07-21 00:41:42 +00:00
|
|
|
def_symbol_in_progress->sy_value.X_op_symbol = NULL;
|
1993-07-14 22:21:25 +00:00
|
|
|
def_symbol_in_progress->sy_value.X_add_number = 0;
|
|
|
|
|
|
|
|
/* If the segment is undefined when the forward reference is
|
|
|
|
resolved, then copy the segment id from the forward
|
|
|
|
symbol. */
|
1992-11-23 20:42:33 +00:00
|
|
|
SF_SET_GET_SEGMENT (def_symbol_in_progress);
|
Sat Dec 12 15:26:34 1992 Ian Lance Taylor (ian@cygnus.com)
* listing.c: Call xmalloc, not malloc; don't declare malloc.
* Changes to support SCO 3.2v4:
* read.c (s_align_bytes, s_align_ptwo): If not SEG_DATA or
SEG_BSS, fill with NOP_OPCODE.
* config/i386coff.mt: Add opcode/i386.h to TARG_CPU_DEPENDENTS.
* config/obj-coffbfd.c (do_relocs_for): Increment addr even if not
using ZERO_BASED_SEGMENTS.
(fill_section): If ZERO_BASED_SEGMENTS, set segment addresses, but
never set segment address for SEG_E2 (.bss) and don't write out
SEG_E2 contents. Set .init and .fini sections to STYP_TEXT.
(obj_coff_endef): Don't merge labels or symbols awaiting forward
definitions, and don't merge tags with non-tags. Check for .bf
rather than just checking whether the second character is b and
the third character is f.
(obj_coff_val): gcc can generate values which we don't handle
correctly; discard information for now, since it only affects the
debugging information.
(tag_find_or_name): Don't insert tags in the symbol table.
(yank_symbols): Don't merge labels.
(write_object_file): Don't define SUB_SEGMENT_ALIGN if it is
already defined. Fill subsegments with NOP_OPCODE, not 0. Don't
set segment address if ZERO_BASED_SEGMENTS.
(obj_coff_section): Accept and ignore a trailing quoted string, as
used in AT&T i386 syntax.
(fixup_segment): Take segment as argument. On the i386, adjust PC
relative addends by the segment vaddr.
* tc-i386.h: Define SUB_SEGMENT_ALIGN.
* tc-a29k.h: Define ZERO_BASED_SEGMENTS.
* tc-i386.c: (i386_operand): If I386COFF, accept any segment type.
1992-12-13 00:56:14 +00:00
|
|
|
|
|
|
|
/* FIXME: gcc can generate address expressions
|
|
|
|
here in unusual cases (search for "obscure"
|
|
|
|
in sdbout.c). We just ignore the offset
|
|
|
|
here, thus generating incorrect debugging
|
|
|
|
information. We ignore the rest of the
|
|
|
|
line just below. */
|
1992-11-23 20:42:33 +00:00
|
|
|
}
|
Sat Dec 12 15:26:34 1992 Ian Lance Taylor (ian@cygnus.com)
* listing.c: Call xmalloc, not malloc; don't declare malloc.
* Changes to support SCO 3.2v4:
* read.c (s_align_bytes, s_align_ptwo): If not SEG_DATA or
SEG_BSS, fill with NOP_OPCODE.
* config/i386coff.mt: Add opcode/i386.h to TARG_CPU_DEPENDENTS.
* config/obj-coffbfd.c (do_relocs_for): Increment addr even if not
using ZERO_BASED_SEGMENTS.
(fill_section): If ZERO_BASED_SEGMENTS, set segment addresses, but
never set segment address for SEG_E2 (.bss) and don't write out
SEG_E2 contents. Set .init and .fini sections to STYP_TEXT.
(obj_coff_endef): Don't merge labels or symbols awaiting forward
definitions, and don't merge tags with non-tags. Check for .bf
rather than just checking whether the second character is b and
the third character is f.
(obj_coff_val): gcc can generate values which we don't handle
correctly; discard information for now, since it only affects the
debugging information.
(tag_find_or_name): Don't insert tags in the symbol table.
(yank_symbols): Don't merge labels.
(write_object_file): Don't define SUB_SEGMENT_ALIGN if it is
already defined. Fill subsegments with NOP_OPCODE, not 0. Don't
set segment address if ZERO_BASED_SEGMENTS.
(obj_coff_section): Accept and ignore a trailing quoted string, as
used in AT&T i386 syntax.
(fixup_segment): Take segment as argument. On the i386, adjust PC
relative addends by the segment vaddr.
* tc-i386.h: Define SUB_SEGMENT_ALIGN.
* tc-a29k.h: Define ZERO_BASED_SEGMENTS.
* tc-i386.c: (i386_operand): If I386COFF, accept any segment type.
1992-12-13 00:56:14 +00:00
|
|
|
/* Otherwise, it is the name of a non debug symbol and
|
|
|
|
its value will be calculated later. */
|
1992-11-23 20:42:33 +00:00
|
|
|
*input_line_pointer = name_end;
|
Sat Dec 12 15:26:34 1992 Ian Lance Taylor (ian@cygnus.com)
* listing.c: Call xmalloc, not malloc; don't declare malloc.
* Changes to support SCO 3.2v4:
* read.c (s_align_bytes, s_align_ptwo): If not SEG_DATA or
SEG_BSS, fill with NOP_OPCODE.
* config/i386coff.mt: Add opcode/i386.h to TARG_CPU_DEPENDENTS.
* config/obj-coffbfd.c (do_relocs_for): Increment addr even if not
using ZERO_BASED_SEGMENTS.
(fill_section): If ZERO_BASED_SEGMENTS, set segment addresses, but
never set segment address for SEG_E2 (.bss) and don't write out
SEG_E2 contents. Set .init and .fini sections to STYP_TEXT.
(obj_coff_endef): Don't merge labels or symbols awaiting forward
definitions, and don't merge tags with non-tags. Check for .bf
rather than just checking whether the second character is b and
the third character is f.
(obj_coff_val): gcc can generate values which we don't handle
correctly; discard information for now, since it only affects the
debugging information.
(tag_find_or_name): Don't insert tags in the symbol table.
(yank_symbols): Don't merge labels.
(write_object_file): Don't define SUB_SEGMENT_ALIGN if it is
already defined. Fill subsegments with NOP_OPCODE, not 0. Don't
set segment address if ZERO_BASED_SEGMENTS.
(obj_coff_section): Accept and ignore a trailing quoted string, as
used in AT&T i386 syntax.
(fixup_segment): Take segment as argument. On the i386, adjust PC
relative addends by the segment vaddr.
* tc-i386.h: Define SUB_SEGMENT_ALIGN.
* tc-a29k.h: Define ZERO_BASED_SEGMENTS.
* tc-i386.c: (i386_operand): If I386COFF, accept any segment type.
1992-12-13 00:56:14 +00:00
|
|
|
|
|
|
|
/* FIXME: this is to avoid an error message in the
|
|
|
|
FIXME case mentioned just above. */
|
|
|
|
while (! is_end_of_line[*input_line_pointer])
|
|
|
|
++input_line_pointer;
|
1992-11-23 20:42:33 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
S_SET_VALUE (def_symbol_in_progress, get_absolute_expression ());
|
|
|
|
} /* if symbol based */
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
demand_empty_rest_of_line ();
|
|
|
|
return;
|
|
|
|
} /* obj_coff_val() */
|
1991-12-12 00:53:23 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Maintain a list of the tagnames of the structres.
|
|
|
|
*/
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
static void
|
|
|
|
tag_init ()
|
|
|
|
{
|
|
|
|
tag_hash = hash_new ();
|
|
|
|
return;
|
|
|
|
} /* tag_init() */
|
1991-12-12 00:53:23 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
static void
|
|
|
|
tag_insert (name, symbolP)
|
|
|
|
char *name;
|
|
|
|
symbolS *symbolP;
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
register char *error_string;
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
if (*(error_string = hash_jam (tag_hash, name, (char *) symbolP)))
|
|
|
|
{
|
|
|
|
as_fatal ("Inserting \"%s\" into structure table failed: %s",
|
|
|
|
name, error_string);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
} /* tag_insert() */
|
1991-12-12 00:53:23 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
static symbolS *
|
|
|
|
tag_find_or_make (name)
|
|
|
|
char *name;
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
symbolS *symbolP;
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
if ((symbolP = tag_find (name)) == NULL)
|
|
|
|
{
|
|
|
|
symbolP = symbol_new (name,
|
|
|
|
SEG_UNKNOWN,
|
|
|
|
0,
|
|
|
|
&zero_address_frag);
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
tag_insert (S_GET_NAME (symbolP), symbolP);
|
|
|
|
} /* not found */
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
return (symbolP);
|
|
|
|
} /* tag_find_or_make() */
|
1991-12-12 00:53:23 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
static symbolS *
|
|
|
|
tag_find (name)
|
|
|
|
char *name;
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
|
|
|
#ifdef STRIP_UNDERSCORE
|
1992-11-23 20:42:33 +00:00
|
|
|
if (*name == '_')
|
|
|
|
name++;
|
1991-12-12 00:53:23 +00:00
|
|
|
#endif /* STRIP_UNDERSCORE */
|
1992-11-23 20:42:33 +00:00
|
|
|
return ((symbolS *) hash_find (tag_hash, name));
|
|
|
|
} /* tag_find() */
|
1991-12-12 00:53:23 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
void
|
|
|
|
obj_read_begin_hook ()
|
|
|
|
{
|
|
|
|
/* These had better be the same. Usually 18 bytes. */
|
1991-12-12 00:53:23 +00:00
|
|
|
#ifndef BFD_HEADERS
|
1992-11-23 20:42:33 +00:00
|
|
|
know (sizeof (SYMENT) == sizeof (AUXENT));
|
|
|
|
know (SYMESZ == AUXESZ);
|
1991-12-12 00:53:23 +00:00
|
|
|
#endif
|
1992-11-23 20:42:33 +00:00
|
|
|
tag_init ();
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
return;
|
|
|
|
} /* obj_read_begin_hook() */
|
1991-12-12 00:53:23 +00:00
|
|
|
|
|
|
|
/* This function runs through the symbol table and puts all the
|
|
|
|
externals onto another chain */
|
|
|
|
|
|
|
|
/* The chain of externals */
|
|
|
|
symbolS *symbol_externP = NULL;
|
|
|
|
symbolS *symbol_extern_lastP = NULL;
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
stack *block_stack;
|
|
|
|
symbolS *last_functionP = NULL;
|
|
|
|
symbolS *last_tagP;
|
1991-12-12 00:53:23 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
static unsigned int
|
|
|
|
DEFUN_VOID (yank_symbols)
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
1992-02-22 20:45:24 +00:00
|
|
|
symbolS *symbolP;
|
1992-11-23 20:42:33 +00:00
|
|
|
unsigned int symbol_number = 0;
|
1993-03-30 15:22:27 +00:00
|
|
|
unsigned int last_file_symno = 0;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
1992-02-22 20:45:24 +00:00
|
|
|
for (symbolP = symbol_rootP;
|
|
|
|
symbolP;
|
1992-11-23 20:42:33 +00:00
|
|
|
symbolP = symbolP ? symbol_next (symbolP) : symbol_rootP)
|
|
|
|
{
|
|
|
|
if (!SF_GET_DEBUG (symbolP))
|
|
|
|
{
|
1992-02-22 20:45:24 +00:00
|
|
|
/* Debug symbols do not need all this rubbish */
|
1992-11-23 20:42:33 +00:00
|
|
|
symbolS *real_symbolP;
|
1992-02-22 20:45:24 +00:00
|
|
|
|
|
|
|
/* L* and C_EFCN symbols never merge. */
|
1992-11-23 20:42:33 +00:00
|
|
|
if (!SF_GET_LOCAL (symbolP)
|
Sat Dec 12 15:26:34 1992 Ian Lance Taylor (ian@cygnus.com)
* listing.c: Call xmalloc, not malloc; don't declare malloc.
* Changes to support SCO 3.2v4:
* read.c (s_align_bytes, s_align_ptwo): If not SEG_DATA or
SEG_BSS, fill with NOP_OPCODE.
* config/i386coff.mt: Add opcode/i386.h to TARG_CPU_DEPENDENTS.
* config/obj-coffbfd.c (do_relocs_for): Increment addr even if not
using ZERO_BASED_SEGMENTS.
(fill_section): If ZERO_BASED_SEGMENTS, set segment addresses, but
never set segment address for SEG_E2 (.bss) and don't write out
SEG_E2 contents. Set .init and .fini sections to STYP_TEXT.
(obj_coff_endef): Don't merge labels or symbols awaiting forward
definitions, and don't merge tags with non-tags. Check for .bf
rather than just checking whether the second character is b and
the third character is f.
(obj_coff_val): gcc can generate values which we don't handle
correctly; discard information for now, since it only affects the
debugging information.
(tag_find_or_name): Don't insert tags in the symbol table.
(yank_symbols): Don't merge labels.
(write_object_file): Don't define SUB_SEGMENT_ALIGN if it is
already defined. Fill subsegments with NOP_OPCODE, not 0. Don't
set segment address if ZERO_BASED_SEGMENTS.
(obj_coff_section): Accept and ignore a trailing quoted string, as
used in AT&T i386 syntax.
(fixup_segment): Take segment as argument. On the i386, adjust PC
relative addends by the segment vaddr.
* tc-i386.h: Define SUB_SEGMENT_ALIGN.
* tc-a29k.h: Define ZERO_BASED_SEGMENTS.
* tc-i386.c: (i386_operand): If I386COFF, accept any segment type.
1992-12-13 00:56:14 +00:00
|
|
|
&& S_GET_STORAGE_CLASS (symbolP) != C_LABEL
|
* Extensive changes to permit symbols to contain any expression
type and to delay the computation of the expression until the
value is actually needed. This permits setting symbols to values
calculated based on object code size. Expressions were changed to
no longer be in a section, to stop the overloading of segment and
expression type that previously occurred.
* as.c (big_section, pass1_section, diff_section, absent_section):
Removed.
(expr_section): Added (used for dummy symbols which hold
intermediate expression values).
(perform_an_assembly_pass): Create expr_section, do not create the
sections now removed.
* as.h (segT): Removed SEG_ABSENT, SEG_PASS1, SEG_BIG, and
SEG_DIFFERENCE. Added SEG_EXPR.
(SEG_NORMAL): Corresponding changes.
* subsegs.c (seg_name, subsegs_begin): Changed accordingly.
* write.c (write_object_file): Ditto.
* config/obj-aout.c (seg_N_TYPE): Ditto.
* config/obj-bout.c (seg_N_TYPE): Ditto.
* config/obj-coff.c (seg_N_TYPE): Ditto.
* config/obj-coffbfd.c (seg_N_TYPE): Ditto.
* config/obj-vms.c (seg_N_TYPE): Ditto.
* expr.h (operatorT): Moved in from expr.c, added some values.
(expressionS): Added X_op field, removed X_seg field; renamed
X_subtract_symbol to X_op_symbol.
* expr.c: Extensive changes to assign expression types rather than
sections and to simplify the parsing.
* write.c (fix_new_internal): New static function.
(fix_new): Removed sub_symbol argument.
(fix_new_exp): New function, takes expression argument.
* write.h: Prototype changes for fix_new and fix_new_exp.
* cond.c (s_if): Changed accordingly.
* read.c (s_lsym, pseudo_set, emit_expr, parse_bitfield_cons,
parse_repeat_cons, get_segmented_expression,
get_known_segmented_expression, get_absolute_expression): Ditto.
* symbols.c (resolve_symbol_value, S_GET_VALUE, S_SET_VALUE):
Ditto.
* write.c (write_object_file): Ditto.
* config/obj-coff.c (obj_coff_def, obj_coff_val): Ditto.
* config/obj-coffbfd.c (obj_coff_def, obj_coff_val,
obj_coff_endef, yank_symbols): Ditto.
* config/obj-elf.c (obj_elf_stab_generic, obj_elf_size): Ditto.
* config/tc-a29k.c (md_assemble, parse_operand, machine_ip,
print_insn, md_operand): Ditto.
* config/tc-h8300.c (parse_exp, colonmod24, check_operand,
do_a_fix_imm, build_bytes): Ditto.
* config/tc-h8500.c (parse_exp, skip_colonthing, parse_reglist,
get_specific, check, insert, md_convert_frag): Ditto.
* config/tc-hppa.c (the_insn, fix_new_hppa, cons_fix_new_hppa,
md_assemble, pa_ip, getExpression, getAbsoluteExpression,
evaluateAbsolute, pa_build_unwind_subspace, pa_entry,
process_exit): Ditto.
* config/tc-hppa.h (STAB_FIXUP, is_DP_relative, is_PC_relative,
is_complex): Ditto.
* config/tc-i386.c (pe, md_assemble, i386_operand,
md_estimate_size_before_relax, md_create_long_jump): Ditto.
* config/tc-i860.c (md_assemble, getExpression, print_insn):
Ditto.
* config/tc-i960.c (parse_expr, subs, segs, md_convert_frag,
get_cdisp, mem_fmt, parse_ldconst, relax_cobr, s_sysproc,
i960_handle_align): Ditto.
* config/tc-m68k.c (struct m68k_exp, struct m68k_it, seg, op,
subs, add_fix, isvar, m68k_ip, md_assemble, md_convert_frag_1,
md_estimate_size_before_relax, md_create_long_jump, get_num):
Ditto.
* config/tc-m88k.c (md_assemble, get_imm16, get_pcr,
md_create_short_jump, md_create_long_jump): Ditto.
* config/tc-mips.c (md_assemble, append_insn, gp_reference,
macro_build, macro, my_getExpression): Ditto. Also removed
get_optional_absolute_expression; just use get_absolute_expression
instead.
* config/tc-ns32k.c (get_addr_mode, evaluate_expr, convert_iif,
fix_new_ns32k, fix_new_ns32k_exp, cons_fix_new_ns32k): Ditto.
* config/tc-ns32k.h (fix_new_ns32k prototype): Ditto.
* config/tc-sh.c (parse_exp, check, insert, md_convert_frag):
Ditto.
* config/tc-sparc.c (md_assemble, sparc_ip, getExpression,
print_insn): Ditto.
* config/tc-tahoe.c (struct top, md_estimate_size_before_relax,
tip_op, md_assemble): Ditto.
* config/tc-vax.c (seg_of_operand, md_assemble,
md_estimate_size_before_relax, md_create_long_jump): Ditto.
* config/tc-z8k.c (parse_exp, check_operand, newfix): Ditto.
1993-07-21 00:41:42 +00:00
|
|
|
&& symbolP->sy_value.X_op == O_constant
|
1992-11-23 20:42:33 +00:00
|
|
|
&& (real_symbolP = symbol_find_base (S_GET_NAME (symbolP), DO_NOT_STRIP))
|
|
|
|
&& real_symbolP != symbolP)
|
|
|
|
{
|
1992-02-22 20:45:24 +00:00
|
|
|
/* FIXME-SOON: where do dups come from?
|
|
|
|
Maybe tag references before definitions? xoxorich. */
|
|
|
|
/* Move the debug data from the debug symbol to the
|
|
|
|
real symbol. Do NOT do the oposite (i.e. move from
|
|
|
|
real symbol to debug symbol and remove real symbol from the
|
|
|
|
list.) Because some pointers refer to the real symbol
|
|
|
|
whereas no pointers refer to the debug symbol. */
|
1992-11-23 20:42:33 +00:00
|
|
|
c_symbol_merge (symbolP, real_symbolP);
|
1992-02-22 20:45:24 +00:00
|
|
|
/* Replace the current symbol by the real one */
|
|
|
|
/* The symbols will never be the last or the first
|
|
|
|
because : 1st symbol is .file and 3 last symbols are
|
|
|
|
.text, .data, .bss */
|
1992-11-23 20:42:33 +00:00
|
|
|
symbol_remove (real_symbolP, &symbol_rootP, &symbol_lastP);
|
|
|
|
symbol_insert (real_symbolP, symbolP, &symbol_rootP, &symbol_lastP);
|
|
|
|
symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
|
1992-02-22 20:45:24 +00:00
|
|
|
symbolP = real_symbolP;
|
|
|
|
} /* if not local but dup'd */
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
if (flagseen['R'] && (S_GET_SEGMENT (symbolP) == SEG_E1))
|
|
|
|
{
|
|
|
|
S_SET_SEGMENT (symbolP, SEG_E0);
|
1992-02-22 20:45:24 +00:00
|
|
|
} /* push data into text */
|
|
|
|
|
1993-07-14 22:21:25 +00:00
|
|
|
resolve_symbol_value (symbolP);
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
if (!S_IS_DEFINED (symbolP) && !SF_GET_LOCAL (symbolP))
|
1992-02-22 20:45:24 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
S_SET_EXTERNAL (symbolP);
|
|
|
|
}
|
|
|
|
else if (S_GET_STORAGE_CLASS (symbolP) == C_NULL)
|
1992-02-22 20:45:24 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
if (S_GET_SEGMENT (symbolP) == SEG_E0)
|
|
|
|
{
|
|
|
|
S_SET_STORAGE_CLASS (symbolP, C_LABEL);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
S_SET_STORAGE_CLASS (symbolP, C_STAT);
|
|
|
|
}
|
1992-02-22 20:45:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Mainly to speed up if not -g */
|
1992-11-23 20:42:33 +00:00
|
|
|
if (SF_GET_PROCESS (symbolP))
|
|
|
|
{
|
|
|
|
/* Handle the nested blocks auxiliary info. */
|
|
|
|
if (S_GET_STORAGE_CLASS (symbolP) == C_BLOCK)
|
|
|
|
{
|
|
|
|
if (!strcmp (S_GET_NAME (symbolP), ".bb"))
|
|
|
|
stack_push (block_stack, (char *) &symbolP);
|
|
|
|
else
|
|
|
|
{ /* .eb */
|
|
|
|
register symbolS *begin_symbolP;
|
|
|
|
begin_symbolP = *(symbolS **) stack_pop (block_stack);
|
|
|
|
if (begin_symbolP == (symbolS *) 0)
|
|
|
|
as_warn ("mismatched .eb");
|
|
|
|
else
|
|
|
|
SA_SET_SYM_ENDNDX (begin_symbolP, symbol_number + 2);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* If we are able to identify the type of a function, and we
|
1992-02-22 20:45:24 +00:00
|
|
|
are out of a function (last_functionP == 0) then, the
|
|
|
|
function symbol will be associated with an auxiliary
|
|
|
|
entry. */
|
1992-11-23 20:42:33 +00:00
|
|
|
if (last_functionP == (symbolS *) 0 &&
|
|
|
|
SF_GET_FUNCTION (symbolP))
|
|
|
|
{
|
|
|
|
last_functionP = symbolP;
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
if (S_GET_NUMBER_AUXILIARY (symbolP) < 1)
|
|
|
|
{
|
|
|
|
S_SET_NUMBER_AUXILIARY (symbolP, 1);
|
|
|
|
} /* make it at least 1 */
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
/* Clobber possible stale .dim information. */
|
1992-02-22 20:45:24 +00:00
|
|
|
#if 0
|
1992-11-23 20:42:33 +00:00
|
|
|
/* Iffed out by steve - this fries the lnnoptr info too */
|
|
|
|
bzero (symbolP->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_ary.x_dimen,
|
|
|
|
sizeof (symbolP->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_ary.x_dimen));
|
1992-02-22 20:45:24 +00:00
|
|
|
#endif
|
1992-11-23 20:42:33 +00:00
|
|
|
}
|
1993-03-30 15:22:27 +00:00
|
|
|
/* The C_FCN doesn't need any additional information. I
|
|
|
|
don't even know if this is needed for sdb. But the
|
|
|
|
standard assembler generates it, so... */
|
1992-11-23 20:42:33 +00:00
|
|
|
if (S_GET_STORAGE_CLASS (symbolP) == C_EFCN)
|
|
|
|
{
|
|
|
|
if (last_functionP == (symbolS *) 0)
|
|
|
|
as_fatal ("C_EFCN symbol out of scope");
|
|
|
|
SA_SET_SYM_FSIZE (last_functionP,
|
|
|
|
(long) (S_GET_VALUE (symbolP) -
|
|
|
|
S_GET_VALUE (last_functionP)));
|
|
|
|
SA_SET_SYM_ENDNDX (last_functionP, symbol_number);
|
|
|
|
last_functionP = (symbolS *) 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (SF_GET_TAG (symbolP))
|
|
|
|
{
|
|
|
|
/* First descriptor of a structure must point to
|
1992-02-22 20:45:24 +00:00
|
|
|
the first slot after the structure description. */
|
1992-11-23 20:42:33 +00:00
|
|
|
last_tagP = symbolP;
|
|
|
|
|
|
|
|
}
|
|
|
|
else if (S_GET_STORAGE_CLASS (symbolP) == C_EOS)
|
|
|
|
{
|
|
|
|
/* +2 take in account the current symbol */
|
|
|
|
SA_SET_SYM_ENDNDX (last_tagP, symbol_number + 2);
|
|
|
|
}
|
|
|
|
else if (S_GET_STORAGE_CLASS (symbolP) == C_FILE)
|
|
|
|
{
|
|
|
|
if (S_GET_VALUE (symbolP))
|
|
|
|
{
|
1993-03-30 15:22:27 +00:00
|
|
|
S_SET_VALUE (symbolP, last_file_symno);
|
|
|
|
last_file_symno = symbol_number;
|
1992-11-23 20:42:33 +00:00
|
|
|
} /* no one points at the first .file symbol */
|
|
|
|
} /* if debug or tag or eos or file */
|
1992-02-22 20:45:24 +00:00
|
|
|
|
|
|
|
/* We must put the external symbols apart. The loader
|
|
|
|
does not bomb if we do not. But the references in
|
|
|
|
the endndx field for a .bb symbol are not corrected
|
|
|
|
if an external symbol is removed between .bb and .be.
|
|
|
|
I.e in the following case :
|
|
|
|
[20] .bb endndx = 22
|
|
|
|
[21] foo external
|
|
|
|
[22] .be
|
|
|
|
ld will move the symbol 21 to the end of the list but
|
|
|
|
endndx will still be 22 instead of 21. */
|
|
|
|
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
if (SF_GET_LOCAL (symbolP))
|
|
|
|
{
|
1992-02-22 20:45:24 +00:00
|
|
|
/* remove C_EFCN and LOCAL (L...) symbols */
|
|
|
|
/* next pointer remains valid */
|
1992-11-23 20:42:33 +00:00
|
|
|
symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
|
1992-02-22 20:45:24 +00:00
|
|
|
|
|
|
|
}
|
1992-11-23 20:42:33 +00:00
|
|
|
else if (!S_IS_DEFINED (symbolP)
|
|
|
|
&& !S_IS_DEBUG (symbolP)
|
|
|
|
&& !SF_GET_STATICS (symbolP) &&
|
|
|
|
S_GET_STORAGE_CLASS (symbolP) == C_EXT)
|
|
|
|
{ /* C_EXT && !SF_GET_FUNCTION(symbolP)) */
|
|
|
|
/* if external, Remove from the list */
|
|
|
|
symbolS *hold = symbol_previous (symbolP);
|
|
|
|
|
|
|
|
symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
|
|
|
|
symbol_clear_list_pointers (symbolP);
|
|
|
|
symbol_append (symbolP, symbol_extern_lastP, &symbol_externP, &symbol_extern_lastP);
|
|
|
|
symbolP = hold;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (SF_GET_STRING (symbolP))
|
|
|
|
{
|
|
|
|
symbolP->sy_name_offset = string_byte_count;
|
|
|
|
string_byte_count += strlen (S_GET_NAME (symbolP)) + 1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
symbolP->sy_name_offset = 0;
|
|
|
|
} /* fix "long" names */
|
|
|
|
|
|
|
|
symbolP->sy_number = symbol_number;
|
|
|
|
symbol_number += 1 + S_GET_NUMBER_AUXILIARY (symbolP);
|
|
|
|
} /* if local symbol */
|
1992-02-22 20:45:24 +00:00
|
|
|
} /* traverse the symbol list */
|
|
|
|
return symbol_number;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
1991-12-12 00:53:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
static unsigned int
|
|
|
|
DEFUN_VOID (glue_symbols)
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
1992-02-22 20:45:24 +00:00
|
|
|
unsigned int symbol_number = 0;
|
1992-11-23 20:42:33 +00:00
|
|
|
symbolS *symbolP;
|
|
|
|
for (symbolP = symbol_externP; symbol_externP;)
|
|
|
|
{
|
1992-02-22 20:45:24 +00:00
|
|
|
symbolS *tmp = symbol_externP;
|
|
|
|
|
|
|
|
/* append */
|
1992-11-23 20:42:33 +00:00
|
|
|
symbol_remove (tmp, &symbol_externP, &symbol_extern_lastP);
|
|
|
|
symbol_append (tmp, symbol_lastP, &symbol_rootP, &symbol_lastP);
|
1992-02-22 20:45:24 +00:00
|
|
|
|
|
|
|
/* and process */
|
1992-11-23 20:42:33 +00:00
|
|
|
if (SF_GET_STRING (tmp))
|
|
|
|
{
|
1992-02-22 20:45:24 +00:00
|
|
|
tmp->sy_name_offset = string_byte_count;
|
1992-11-23 20:42:33 +00:00
|
|
|
string_byte_count += strlen (S_GET_NAME (tmp)) + 1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
tmp->sy_name_offset = 0;
|
|
|
|
} /* fix "long" names */
|
1992-02-22 20:45:24 +00:00
|
|
|
|
|
|
|
tmp->sy_number = symbol_number;
|
1992-11-23 20:42:33 +00:00
|
|
|
symbol_number += 1 + S_GET_NUMBER_AUXILIARY (tmp);
|
1992-02-22 20:45:24 +00:00
|
|
|
} /* append the entire extern chain */
|
|
|
|
return symbol_number;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
1991-12-12 00:53:23 +00:00
|
|
|
}
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
static unsigned int
|
|
|
|
DEFUN_VOID (tie_tags)
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
1992-02-22 20:45:24 +00:00
|
|
|
unsigned int symbol_number = 0;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
|
|
symbolS *symbolP;
|
1992-02-22 20:45:24 +00:00
|
|
|
for (symbolP = symbol_rootP; symbolP; symbolP =
|
1992-11-23 20:42:33 +00:00
|
|
|
symbol_next (symbolP))
|
|
|
|
{
|
|
|
|
symbolP->sy_number = symbol_number;
|
1992-02-22 20:45:24 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
if (SF_GET_TAGGED (symbolP))
|
|
|
|
{
|
|
|
|
SA_SET_SYM_TAGNDX
|
|
|
|
(symbolP,
|
|
|
|
((symbolS *) SA_GET_SYM_TAGNDX (symbolP))->sy_number);
|
|
|
|
}
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
symbol_number += 1 + S_GET_NUMBER_AUXILIARY (symbolP);
|
|
|
|
}
|
1992-02-22 20:45:24 +00:00
|
|
|
return symbol_number;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
1991-12-12 00:53:23 +00:00
|
|
|
}
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
static void
|
1992-12-30 21:39:51 +00:00
|
|
|
DEFUN (crawl_symbols, (h, abfd),
|
|
|
|
object_headers *h AND
|
1992-11-23 20:42:33 +00:00
|
|
|
bfd * abfd)
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
unsigned int i;
|
1992-02-22 20:45:24 +00:00
|
|
|
symbolS *symbolP;
|
|
|
|
|
|
|
|
/* Initialize the stack used to keep track of the matching .bb .be */
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
block_stack = stack_init (512, sizeof (symbolS *));
|
1992-02-22 20:45:24 +00:00
|
|
|
|
|
|
|
/* The symbol list should be ordered according to the following sequence
|
|
|
|
* order :
|
|
|
|
* . .file symbol
|
|
|
|
* . debug entries for functions
|
|
|
|
* . fake symbols for the sections, including.text .data and .bss
|
|
|
|
* . defined symbols
|
|
|
|
* . undefined symbols
|
|
|
|
* But this is not mandatory. The only important point is to put the
|
|
|
|
* undefined symbols at the end of the list.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (symbol_rootP == NULL
|
1992-11-23 20:42:33 +00:00
|
|
|
|| S_GET_STORAGE_CLASS (symbol_rootP) != C_FILE)
|
|
|
|
{
|
|
|
|
c_dot_file_symbol ("fake");
|
1992-02-22 20:45:24 +00:00
|
|
|
}
|
|
|
|
/* Is there a .file symbol ? If not insert one at the beginning. */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Build up static symbols for the sections, they are filled in later
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
for (i = SEG_E0; i < SEG_E9; i++)
|
1992-02-22 20:45:24 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
if (segment_info[i].scnhdr.s_name[0])
|
|
|
|
{
|
1992-12-30 21:39:51 +00:00
|
|
|
char name[9];
|
1992-11-23 20:42:33 +00:00
|
|
|
|
1992-12-30 21:39:51 +00:00
|
|
|
strncpy (name, segment_info[i].scnhdr.s_name, 8);
|
|
|
|
name[8] = '\0';
|
|
|
|
segment_info[i].dot = c_section_symbol (name, i - SEG_E0 + 1);
|
1992-11-23 20:42:33 +00:00
|
|
|
}
|
1992-02-22 20:45:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Take all the externals out and put them into another chain */
|
1992-12-30 21:39:51 +00:00
|
|
|
H_SET_SYMBOL_TABLE_SIZE (h, yank_symbols ());
|
1992-02-22 20:45:24 +00:00
|
|
|
/* Take the externals and glue them onto the end.*/
|
1992-12-30 21:39:51 +00:00
|
|
|
H_SET_SYMBOL_TABLE_SIZE (h, H_GET_SYMBOL_COUNT (h) + glue_symbols ());
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-12-30 21:39:51 +00:00
|
|
|
H_SET_SYMBOL_TABLE_SIZE (h, tie_tags ());
|
1992-11-23 20:42:33 +00:00
|
|
|
know (symbol_externP == NULL);
|
|
|
|
know (symbol_extern_lastP == NULL);
|
1992-02-22 20:45:24 +00:00
|
|
|
|
|
|
|
return;
|
1991-12-12 00:53:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Find strings by crawling along symbol table chain.
|
|
|
|
*/
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
void
|
|
|
|
DEFUN (w_strings, (where),
|
|
|
|
char *where)
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
1992-02-22 20:45:24 +00:00
|
|
|
symbolS *symbolP;
|
|
|
|
|
|
|
|
/* Gotta do md_ byte-ordering stuff for string_byte_count first - KWK */
|
1993-06-04 23:03:00 +00:00
|
|
|
md_number_to_chars (where, string_byte_count, 4);
|
|
|
|
where += 4;
|
1992-02-22 20:45:24 +00:00
|
|
|
for (symbolP = symbol_rootP;
|
|
|
|
symbolP;
|
1992-11-23 20:42:33 +00:00
|
|
|
symbolP = symbol_next (symbolP))
|
|
|
|
{
|
|
|
|
unsigned int size;
|
|
|
|
|
|
|
|
if (SF_GET_STRING (symbolP))
|
|
|
|
{
|
|
|
|
size = strlen (S_GET_NAME (symbolP)) + 1;
|
|
|
|
|
|
|
|
memcpy (where, S_GET_NAME (symbolP), size);
|
|
|
|
where += size;
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1991-12-12 00:53:23 +00:00
|
|
|
}
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
static void
|
1992-12-30 21:39:51 +00:00
|
|
|
DEFUN (do_linenos_for, (abfd, h, file_cursor),
|
1992-11-23 20:42:33 +00:00
|
|
|
bfd * abfd AND
|
1992-12-30 21:39:51 +00:00
|
|
|
object_headers * h AND
|
1992-11-23 20:42:33 +00:00
|
|
|
unsigned long *file_cursor)
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
1992-02-22 20:45:24 +00:00
|
|
|
unsigned int idx;
|
1992-12-30 21:39:51 +00:00
|
|
|
unsigned long start = *file_cursor;
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
for (idx = SEG_E0; idx < SEG_E9; idx++)
|
1992-02-22 20:45:24 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
segment_info_type *s = segment_info + idx;
|
1992-02-22 20:45:24 +00:00
|
|
|
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
if (s->scnhdr.s_nlnno != 0)
|
|
|
|
{
|
|
|
|
struct lineno_list *line_ptr;
|
|
|
|
|
|
|
|
struct external_lineno *buffer =
|
|
|
|
(struct external_lineno *) xmalloc (s->scnhdr.s_nlnno * LINESZ);
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
struct external_lineno *dst = buffer;
|
|
|
|
|
|
|
|
/* Run through the table we've built and turn it into its external
|
1992-02-22 20:45:24 +00:00
|
|
|
form, take this chance to remove duplicates */
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
for (line_ptr = s->lineno_list_head;
|
|
|
|
line_ptr != (struct lineno_list *) NULL;
|
|
|
|
line_ptr = line_ptr->next)
|
|
|
|
{
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
if (line_ptr->line.l_lnno == 0)
|
|
|
|
{
|
|
|
|
/* Turn a pointer to a symbol into the symbols' index */
|
|
|
|
line_ptr->line.l_addr.l_symndx =
|
|
|
|
((symbolS *) line_ptr->line.l_addr.l_symndx)->sy_number;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
line_ptr->line.l_addr.l_paddr += ((struct frag *) (line_ptr->frag))->fr_address;
|
|
|
|
}
|
1992-02-22 20:45:24 +00:00
|
|
|
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
(void) bfd_coff_swap_lineno_out (abfd, &(line_ptr->line), dst);
|
|
|
|
dst++;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
s->scnhdr.s_lnnoptr = *file_cursor;
|
|
|
|
|
|
|
|
bfd_write (buffer, 1, s->scnhdr.s_nlnno * LINESZ, abfd);
|
|
|
|
free (buffer);
|
|
|
|
|
|
|
|
*file_cursor += s->scnhdr.s_nlnno * LINESZ;
|
|
|
|
}
|
1992-02-22 20:45:24 +00:00
|
|
|
}
|
1992-12-30 21:39:51 +00:00
|
|
|
H_SET_LINENO_SIZE (h, *file_cursor - start);
|
1991-12-12 00:53:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Now we run through the list of frag chains in a segment and
|
|
|
|
make all the subsegment frags appear at the end of the
|
|
|
|
list, as if the seg 0 was extra long */
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
static void
|
|
|
|
DEFUN_VOID (remove_subsegs)
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
for (i = SEG_E0; i < SEG_UNKNOWN; i++)
|
|
|
|
{
|
|
|
|
frchainS *head = segment_info[i].frchainP;
|
|
|
|
fragS dummy;
|
|
|
|
fragS *prev_frag = &dummy;
|
|
|
|
|
|
|
|
while (head && head->frch_seg == i)
|
1992-02-22 20:45:24 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
prev_frag->fr_next = head->frch_root;
|
|
|
|
prev_frag = head->frch_last;
|
|
|
|
head = head->frch_next;
|
1992-02-22 20:45:24 +00:00
|
|
|
}
|
1992-11-23 20:42:33 +00:00
|
|
|
prev_frag->fr_next = 0;
|
1992-02-22 20:45:24 +00:00
|
|
|
}
|
1991-12-12 00:53:23 +00:00
|
|
|
}
|
|
|
|
|
1992-08-25 22:12:54 +00:00
|
|
|
int machine;
|
|
|
|
int coff_flags;
|
1992-11-23 20:42:33 +00:00
|
|
|
extern void
|
|
|
|
DEFUN_VOID (write_object_file)
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
int i;
|
|
|
|
struct frchain *frchain_ptr;
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-12-30 21:39:51 +00:00
|
|
|
object_headers headers;
|
1992-11-23 20:42:33 +00:00
|
|
|
unsigned long file_cursor;
|
|
|
|
bfd *abfd;
|
|
|
|
unsigned int addr;
|
|
|
|
abfd = bfd_openw (out_file_name, TARGET_FORMAT);
|
1992-02-22 20:45:24 +00:00
|
|
|
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
if (abfd == 0)
|
|
|
|
{
|
|
|
|
as_perror ("FATAL: Can't create %s", out_file_name);
|
|
|
|
exit (42);
|
|
|
|
}
|
|
|
|
bfd_set_format (abfd, bfd_object);
|
|
|
|
bfd_set_arch_mach (abfd, BFD_ARCH, machine);
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
string_byte_count = 4;
|
|
|
|
|
|
|
|
for (frchain_ptr = frchain_root;
|
|
|
|
frchain_ptr != (struct frchain *) NULL;
|
|
|
|
frchain_ptr = frchain_ptr->frch_next)
|
|
|
|
{
|
|
|
|
/* Run through all the sub-segments and align them up. Also close any
|
1992-02-22 20:45:24 +00:00
|
|
|
open frags. We tack a .fill onto the end of the frag chain so
|
|
|
|
that any .align's size can be worked by looking at the next
|
|
|
|
frag */
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
subseg_new (frchain_ptr->frch_seg, frchain_ptr->frch_subseg);
|
Sat Dec 12 15:26:34 1992 Ian Lance Taylor (ian@cygnus.com)
* listing.c: Call xmalloc, not malloc; don't declare malloc.
* Changes to support SCO 3.2v4:
* read.c (s_align_bytes, s_align_ptwo): If not SEG_DATA or
SEG_BSS, fill with NOP_OPCODE.
* config/i386coff.mt: Add opcode/i386.h to TARG_CPU_DEPENDENTS.
* config/obj-coffbfd.c (do_relocs_for): Increment addr even if not
using ZERO_BASED_SEGMENTS.
(fill_section): If ZERO_BASED_SEGMENTS, set segment addresses, but
never set segment address for SEG_E2 (.bss) and don't write out
SEG_E2 contents. Set .init and .fini sections to STYP_TEXT.
(obj_coff_endef): Don't merge labels or symbols awaiting forward
definitions, and don't merge tags with non-tags. Check for .bf
rather than just checking whether the second character is b and
the third character is f.
(obj_coff_val): gcc can generate values which we don't handle
correctly; discard information for now, since it only affects the
debugging information.
(tag_find_or_name): Don't insert tags in the symbol table.
(yank_symbols): Don't merge labels.
(write_object_file): Don't define SUB_SEGMENT_ALIGN if it is
already defined. Fill subsegments with NOP_OPCODE, not 0. Don't
set segment address if ZERO_BASED_SEGMENTS.
(obj_coff_section): Accept and ignore a trailing quoted string, as
used in AT&T i386 syntax.
(fixup_segment): Take segment as argument. On the i386, adjust PC
relative addends by the segment vaddr.
* tc-i386.h: Define SUB_SEGMENT_ALIGN.
* tc-a29k.h: Define ZERO_BASED_SEGMENTS.
* tc-i386.c: (i386_operand): If I386COFF, accept any segment type.
1992-12-13 00:56:14 +00:00
|
|
|
#ifndef SUB_SEGMENT_ALIGN
|
1993-03-03 19:47:15 +00:00
|
|
|
#define SUB_SEGMENT_ALIGN(SEG) 1
|
Sat Dec 12 15:26:34 1992 Ian Lance Taylor (ian@cygnus.com)
* listing.c: Call xmalloc, not malloc; don't declare malloc.
* Changes to support SCO 3.2v4:
* read.c (s_align_bytes, s_align_ptwo): If not SEG_DATA or
SEG_BSS, fill with NOP_OPCODE.
* config/i386coff.mt: Add opcode/i386.h to TARG_CPU_DEPENDENTS.
* config/obj-coffbfd.c (do_relocs_for): Increment addr even if not
using ZERO_BASED_SEGMENTS.
(fill_section): If ZERO_BASED_SEGMENTS, set segment addresses, but
never set segment address for SEG_E2 (.bss) and don't write out
SEG_E2 contents. Set .init and .fini sections to STYP_TEXT.
(obj_coff_endef): Don't merge labels or symbols awaiting forward
definitions, and don't merge tags with non-tags. Check for .bf
rather than just checking whether the second character is b and
the third character is f.
(obj_coff_val): gcc can generate values which we don't handle
correctly; discard information for now, since it only affects the
debugging information.
(tag_find_or_name): Don't insert tags in the symbol table.
(yank_symbols): Don't merge labels.
(write_object_file): Don't define SUB_SEGMENT_ALIGN if it is
already defined. Fill subsegments with NOP_OPCODE, not 0. Don't
set segment address if ZERO_BASED_SEGMENTS.
(obj_coff_section): Accept and ignore a trailing quoted string, as
used in AT&T i386 syntax.
(fixup_segment): Take segment as argument. On the i386, adjust PC
relative addends by the segment vaddr.
* tc-i386.h: Define SUB_SEGMENT_ALIGN.
* tc-a29k.h: Define ZERO_BASED_SEGMENTS.
* tc-i386.c: (i386_operand): If I386COFF, accept any segment type.
1992-12-13 00:56:14 +00:00
|
|
|
#endif
|
1993-03-03 19:47:15 +00:00
|
|
|
frag_align (SUB_SEGMENT_ALIGN (now_seg), NOP_OPCODE);
|
1992-11-23 20:42:33 +00:00
|
|
|
frag_wane (frag_now);
|
|
|
|
frag_now->fr_fix = 0;
|
|
|
|
know (frag_now->fr_next == NULL);
|
|
|
|
}
|
1992-02-22 20:45:24 +00:00
|
|
|
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
remove_subsegs ();
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
|
|
for (i = SEG_E0; i < SEG_UNKNOWN; i++)
|
1992-02-22 20:45:24 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
relax_segment (segment_info[i].frchainP->frch_root, i);
|
1992-02-22 20:45:24 +00:00
|
|
|
}
|
|
|
|
|
1992-12-30 21:39:51 +00:00
|
|
|
H_SET_NUMBER_OF_SECTIONS (&headers, 0);
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
|
|
/* Find out how big the sections are, and set the addresses. */
|
|
|
|
addr = 0;
|
|
|
|
for (i = SEG_E0; i < SEG_UNKNOWN; i++)
|
|
|
|
{
|
1992-12-30 21:39:51 +00:00
|
|
|
long size;
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
segment_info[i].scnhdr.s_paddr = addr;
|
1993-02-11 17:22:42 +00:00
|
|
|
segment_info[i].scnhdr.s_vaddr = addr;
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
if (segment_info[i].scnhdr.s_name[0])
|
1992-02-13 08:33:54 +00:00
|
|
|
{
|
1992-12-30 21:39:51 +00:00
|
|
|
H_SET_NUMBER_OF_SECTIONS (&headers,
|
|
|
|
H_GET_NUMBER_OF_SECTIONS (&headers) + 1);
|
1992-02-13 08:33:54 +00:00
|
|
|
}
|
1992-11-23 20:42:33 +00:00
|
|
|
|
1992-12-30 21:39:51 +00:00
|
|
|
size = size_section (abfd, i);
|
|
|
|
addr += size;
|
Sat Dec 12 15:26:34 1992 Ian Lance Taylor (ian@cygnus.com)
* listing.c: Call xmalloc, not malloc; don't declare malloc.
* Changes to support SCO 3.2v4:
* read.c (s_align_bytes, s_align_ptwo): If not SEG_DATA or
SEG_BSS, fill with NOP_OPCODE.
* config/i386coff.mt: Add opcode/i386.h to TARG_CPU_DEPENDENTS.
* config/obj-coffbfd.c (do_relocs_for): Increment addr even if not
using ZERO_BASED_SEGMENTS.
(fill_section): If ZERO_BASED_SEGMENTS, set segment addresses, but
never set segment address for SEG_E2 (.bss) and don't write out
SEG_E2 contents. Set .init and .fini sections to STYP_TEXT.
(obj_coff_endef): Don't merge labels or symbols awaiting forward
definitions, and don't merge tags with non-tags. Check for .bf
rather than just checking whether the second character is b and
the third character is f.
(obj_coff_val): gcc can generate values which we don't handle
correctly; discard information for now, since it only affects the
debugging information.
(tag_find_or_name): Don't insert tags in the symbol table.
(yank_symbols): Don't merge labels.
(write_object_file): Don't define SUB_SEGMENT_ALIGN if it is
already defined. Fill subsegments with NOP_OPCODE, not 0. Don't
set segment address if ZERO_BASED_SEGMENTS.
(obj_coff_section): Accept and ignore a trailing quoted string, as
used in AT&T i386 syntax.
(fixup_segment): Take segment as argument. On the i386, adjust PC
relative addends by the segment vaddr.
* tc-i386.h: Define SUB_SEGMENT_ALIGN.
* tc-a29k.h: Define ZERO_BASED_SEGMENTS.
* tc-i386.c: (i386_operand): If I386COFF, accept any segment type.
1992-12-13 00:56:14 +00:00
|
|
|
|
1992-12-30 21:39:51 +00:00
|
|
|
if (i == SEG_E0)
|
|
|
|
H_SET_TEXT_SIZE (&headers, size);
|
|
|
|
else if (i == SEG_E1)
|
|
|
|
H_SET_DATA_SIZE (&headers, size);
|
|
|
|
else if (i == SEG_E2)
|
|
|
|
H_SET_BSS_SIZE (&headers, size);
|
1992-11-23 20:42:33 +00:00
|
|
|
}
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-12-30 21:39:51 +00:00
|
|
|
/* Turn the gas native symbol table shape into a coff symbol table */
|
|
|
|
crawl_symbols (&headers, abfd);
|
|
|
|
|
|
|
|
if (string_byte_count == 4)
|
|
|
|
string_byte_count = 0;
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-12-30 21:39:51 +00:00
|
|
|
H_SET_STRING_SIZE (&headers, string_byte_count);
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1993-02-04 20:47:48 +00:00
|
|
|
#if !defined(TC_H8300) && !defined(TC_Z8K)
|
1992-11-23 20:42:33 +00:00
|
|
|
for (i = SEG_E0; i < SEG_UNKNOWN; i++)
|
1992-02-22 20:45:24 +00:00
|
|
|
{
|
1992-12-30 21:39:51 +00:00
|
|
|
fixup_mdeps (segment_info[i].frchainP->frch_root, &headers, i);
|
Sat Dec 12 15:26:34 1992 Ian Lance Taylor (ian@cygnus.com)
* listing.c: Call xmalloc, not malloc; don't declare malloc.
* Changes to support SCO 3.2v4:
* read.c (s_align_bytes, s_align_ptwo): If not SEG_DATA or
SEG_BSS, fill with NOP_OPCODE.
* config/i386coff.mt: Add opcode/i386.h to TARG_CPU_DEPENDENTS.
* config/obj-coffbfd.c (do_relocs_for): Increment addr even if not
using ZERO_BASED_SEGMENTS.
(fill_section): If ZERO_BASED_SEGMENTS, set segment addresses, but
never set segment address for SEG_E2 (.bss) and don't write out
SEG_E2 contents. Set .init and .fini sections to STYP_TEXT.
(obj_coff_endef): Don't merge labels or symbols awaiting forward
definitions, and don't merge tags with non-tags. Check for .bf
rather than just checking whether the second character is b and
the third character is f.
(obj_coff_val): gcc can generate values which we don't handle
correctly; discard information for now, since it only affects the
debugging information.
(tag_find_or_name): Don't insert tags in the symbol table.
(yank_symbols): Don't merge labels.
(write_object_file): Don't define SUB_SEGMENT_ALIGN if it is
already defined. Fill subsegments with NOP_OPCODE, not 0. Don't
set segment address if ZERO_BASED_SEGMENTS.
(obj_coff_section): Accept and ignore a trailing quoted string, as
used in AT&T i386 syntax.
(fixup_segment): Take segment as argument. On the i386, adjust PC
relative addends by the segment vaddr.
* tc-i386.h: Define SUB_SEGMENT_ALIGN.
* tc-a29k.h: Define ZERO_BASED_SEGMENTS.
* tc-i386.c: (i386_operand): If I386COFF, accept any segment type.
1992-12-13 00:56:14 +00:00
|
|
|
fixup_segment (&segment_info[i], i);
|
1992-02-22 20:45:24 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
1992-12-30 21:39:51 +00:00
|
|
|
file_cursor = H_GET_TEXT_FILE_OFFSET (&headers);
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
|
|
bfd_seek (abfd, file_cursor, 0);
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
/* Plant the data */
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-12-30 21:39:51 +00:00
|
|
|
fill_section (abfd, &headers, &file_cursor);
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-12-30 21:39:51 +00:00
|
|
|
do_relocs_for (abfd, &headers, &file_cursor);
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-12-30 21:39:51 +00:00
|
|
|
do_linenos_for (abfd, &headers, &file_cursor);
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-12-30 21:39:51 +00:00
|
|
|
H_SET_FILE_MAGIC_NUMBER (&headers, COFF_MAGIC);
|
|
|
|
#ifndef OBJ_COFF_OMIT_TIMESTAMP
|
|
|
|
H_SET_TIME_STAMP (&headers, (long)time((long*)0));
|
|
|
|
#else
|
|
|
|
H_SET_TIME_STAMP (&headers, 0);
|
|
|
|
#endif
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-12-30 21:39:51 +00:00
|
|
|
#ifdef KEEP_RELOC_INFO
|
|
|
|
H_SET_FLAGS (&headers, ((H_GET_LINENO_SIZE(&headers) ? 0 : F_LNNO) |
|
|
|
|
COFF_FLAGS | coff_flags));
|
|
|
|
#else
|
|
|
|
H_SET_FLAGS (&headers, ((H_GET_LINENO_SIZE(&headers) ? 0 : F_LNNO) |
|
|
|
|
(H_GET_RELOCATION_SIZE(&headers) ? 0 : F_RELFLG) |
|
|
|
|
COFF_FLAGS | coff_flags));
|
|
|
|
#endif
|
1992-02-22 20:45:24 +00:00
|
|
|
|
|
|
|
{
|
1992-12-30 21:39:51 +00:00
|
|
|
unsigned int symtable_size = H_GET_SYMBOL_TABLE_SIZE (&headers);
|
|
|
|
char *buffer1 = xmalloc (symtable_size + string_byte_count + 1);
|
1992-11-23 20:42:33 +00:00
|
|
|
char *ptr = buffer1;
|
1992-12-30 21:39:51 +00:00
|
|
|
H_SET_SYMBOL_TABLE_POINTER (&headers, bfd_tell (abfd));
|
1992-11-23 20:42:33 +00:00
|
|
|
w_symbols (abfd, buffer1, symbol_rootP);
|
1992-12-30 21:39:51 +00:00
|
|
|
if (string_byte_count > 0)
|
|
|
|
w_strings (buffer1 + symtable_size);
|
|
|
|
bfd_write (buffer1, 1, symtable_size + string_byte_count, abfd);
|
1992-11-23 20:42:33 +00:00
|
|
|
free (buffer1);
|
1992-02-22 20:45:24 +00:00
|
|
|
}
|
1992-12-30 21:39:51 +00:00
|
|
|
|
|
|
|
coff_header_append (abfd, &headers);
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
if (bfd_close_all_done (abfd) == false)
|
|
|
|
as_fatal ("Can't close %s: %s", out_file_name,
|
|
|
|
bfd_errmsg (bfd_error));
|
1991-12-12 00:53:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
static void
|
|
|
|
DEFUN (change_to_section, (name, len, exp),
|
|
|
|
char *name AND
|
|
|
|
unsigned int len AND
|
|
|
|
unsigned int exp)
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
unsigned int i;
|
1992-02-22 20:45:24 +00:00
|
|
|
/* Find out if we've already got a section of this name etc */
|
1992-11-23 20:42:33 +00:00
|
|
|
for (i = SEG_E0; i < SEG_E9 && segment_info[i].scnhdr.s_name[0]; i++)
|
1992-02-22 20:45:24 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
if (strncmp (segment_info[i].scnhdr.s_name, name, len) == 0)
|
|
|
|
{
|
|
|
|
subseg_new (i, exp);
|
|
|
|
return;
|
|
|
|
}
|
1992-02-22 20:45:24 +00:00
|
|
|
}
|
|
|
|
/* No section, add one */
|
1992-11-23 20:42:33 +00:00
|
|
|
strncpy (segment_info[i].scnhdr.s_name, name, 8);
|
1993-05-05 20:32:12 +00:00
|
|
|
segment_info[i].scnhdr.s_flags = STYP_REG;
|
1992-11-23 20:42:33 +00:00
|
|
|
subseg_new (i, exp);
|
1991-12-12 00:53:23 +00:00
|
|
|
}
|
|
|
|
|
1992-12-30 21:39:51 +00:00
|
|
|
/*
|
|
|
|
* implement the .section pseudo op:
|
|
|
|
* .section name {, "flags"}
|
|
|
|
* ^ ^
|
|
|
|
* | +--- optional flags: 'b' for bss
|
|
|
|
* | 'i' for info
|
|
|
|
* +-- section name 'l' for lib
|
|
|
|
* 'n' for noload
|
|
|
|
* 'o' for over
|
|
|
|
* 'w' for data
|
|
|
|
* 'x' for text
|
|
|
|
* But if the argument is not a quoted string, treat it as a
|
|
|
|
* subsegment number.
|
|
|
|
*/
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
void
|
|
|
|
DEFUN_VOID (obj_coff_section)
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
/* Strip out the section name */
|
|
|
|
char *section_name;
|
|
|
|
char *section_name_end;
|
|
|
|
char c;
|
1992-12-30 21:39:51 +00:00
|
|
|
int argp;
|
1992-11-23 20:42:33 +00:00
|
|
|
unsigned int len;
|
|
|
|
unsigned int exp;
|
1992-12-30 21:39:51 +00:00
|
|
|
long flags;
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
|
|
section_name = input_line_pointer;
|
|
|
|
c = get_symbol_end ();
|
|
|
|
section_name_end = input_line_pointer;
|
|
|
|
|
|
|
|
len = section_name_end - section_name;
|
|
|
|
input_line_pointer++;
|
|
|
|
SKIP_WHITESPACE ();
|
Sat Dec 12 15:26:34 1992 Ian Lance Taylor (ian@cygnus.com)
* listing.c: Call xmalloc, not malloc; don't declare malloc.
* Changes to support SCO 3.2v4:
* read.c (s_align_bytes, s_align_ptwo): If not SEG_DATA or
SEG_BSS, fill with NOP_OPCODE.
* config/i386coff.mt: Add opcode/i386.h to TARG_CPU_DEPENDENTS.
* config/obj-coffbfd.c (do_relocs_for): Increment addr even if not
using ZERO_BASED_SEGMENTS.
(fill_section): If ZERO_BASED_SEGMENTS, set segment addresses, but
never set segment address for SEG_E2 (.bss) and don't write out
SEG_E2 contents. Set .init and .fini sections to STYP_TEXT.
(obj_coff_endef): Don't merge labels or symbols awaiting forward
definitions, and don't merge tags with non-tags. Check for .bf
rather than just checking whether the second character is b and
the third character is f.
(obj_coff_val): gcc can generate values which we don't handle
correctly; discard information for now, since it only affects the
debugging information.
(tag_find_or_name): Don't insert tags in the symbol table.
(yank_symbols): Don't merge labels.
(write_object_file): Don't define SUB_SEGMENT_ALIGN if it is
already defined. Fill subsegments with NOP_OPCODE, not 0. Don't
set segment address if ZERO_BASED_SEGMENTS.
(obj_coff_section): Accept and ignore a trailing quoted string, as
used in AT&T i386 syntax.
(fixup_segment): Take segment as argument. On the i386, adjust PC
relative addends by the segment vaddr.
* tc-i386.h: Define SUB_SEGMENT_ALIGN.
* tc-a29k.h: Define ZERO_BASED_SEGMENTS.
* tc-i386.c: (i386_operand): If I386COFF, accept any segment type.
1992-12-13 00:56:14 +00:00
|
|
|
|
1992-12-30 21:39:51 +00:00
|
|
|
argp = 0;
|
|
|
|
if (c == ',')
|
|
|
|
argp = 1;
|
|
|
|
else if (*input_line_pointer == ',')
|
1992-11-23 20:42:33 +00:00
|
|
|
{
|
1992-12-30 21:39:51 +00:00
|
|
|
argp = 1;
|
|
|
|
++input_line_pointer;
|
|
|
|
SKIP_WHITESPACE ();
|
1992-02-22 20:45:24 +00:00
|
|
|
}
|
1992-12-30 21:39:51 +00:00
|
|
|
|
|
|
|
exp = 0;
|
|
|
|
flags = 0;
|
|
|
|
if (argp)
|
1992-02-22 20:45:24 +00:00
|
|
|
{
|
1992-12-30 21:39:51 +00:00
|
|
|
if (*input_line_pointer != '"')
|
|
|
|
exp = get_absolute_expression ();
|
|
|
|
else
|
|
|
|
{
|
|
|
|
++input_line_pointer;
|
|
|
|
while (*input_line_pointer != '"'
|
|
|
|
&& ! is_end_of_line[*input_line_pointer])
|
|
|
|
{
|
|
|
|
switch (*input_line_pointer)
|
|
|
|
{
|
|
|
|
case 'b': flags |= STYP_BSS; break;
|
|
|
|
case 'i': flags |= STYP_INFO; break;
|
|
|
|
case 'l': flags |= STYP_LIB; break;
|
|
|
|
case 'n': flags |= STYP_NOLOAD; break;
|
|
|
|
case 'o': flags |= STYP_OVER; break;
|
|
|
|
case 'w': flags |= STYP_DATA; break;
|
|
|
|
case 'x': flags |= STYP_TEXT; break;
|
|
|
|
default:
|
|
|
|
as_warn("unknown section attribute '%c'",
|
|
|
|
*input_line_pointer);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
++input_line_pointer;
|
|
|
|
}
|
|
|
|
if (*input_line_pointer == '"')
|
|
|
|
++input_line_pointer;
|
|
|
|
}
|
1992-02-22 20:45:24 +00:00
|
|
|
}
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
|
|
change_to_section (section_name, len, exp);
|
1992-12-30 21:39:51 +00:00
|
|
|
|
|
|
|
segment_info[now_seg].scnhdr.s_flags |= flags;
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
*section_name_end = c;
|
1991-12-12 00:53:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
static void
|
|
|
|
obj_coff_text ()
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
change_to_section (".text", 5, get_absolute_expression ());
|
1991-12-12 00:53:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
static void
|
|
|
|
obj_coff_data ()
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
1993-07-19 18:46:39 +00:00
|
|
|
if (flagseen['R'])
|
|
|
|
change_to_section (".text", 5, get_absolute_expression () + 1000);
|
|
|
|
else
|
|
|
|
change_to_section (".data", 5, get_absolute_expression ());
|
1991-12-12 00:53:23 +00:00
|
|
|
}
|
|
|
|
|
1992-12-30 21:39:51 +00:00
|
|
|
static void
|
|
|
|
obj_coff_bss()
|
|
|
|
{
|
|
|
|
if (*input_line_pointer == '\n') /* .bss */
|
|
|
|
change_to_section(".bss",4, get_absolute_expression());
|
|
|
|
else /* .bss id,expr */
|
|
|
|
obj_coff_lcomm();
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
obj_coff_ident()
|
|
|
|
{
|
|
|
|
segT current_seg = now_seg; /* save current seg */
|
|
|
|
subsegT current_subseg = now_subseg;
|
|
|
|
change_to_section (".comment", 8, 0); /* .comment seg */
|
|
|
|
stringer (1); /* read string */
|
|
|
|
subseg_new (current_seg, current_subseg); /* restore current seg */
|
|
|
|
}
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
void
|
|
|
|
c_symbol_merge (debug, normal)
|
|
|
|
symbolS *debug;
|
|
|
|
symbolS *normal;
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
S_SET_DATA_TYPE (normal, S_GET_DATA_TYPE (debug));
|
|
|
|
S_SET_STORAGE_CLASS (normal, S_GET_STORAGE_CLASS (debug));
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
if (S_GET_NUMBER_AUXILIARY (debug) > S_GET_NUMBER_AUXILIARY (normal))
|
|
|
|
{
|
|
|
|
S_SET_NUMBER_AUXILIARY (normal, S_GET_NUMBER_AUXILIARY (debug));
|
|
|
|
} /* take the most we have */
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
if (S_GET_NUMBER_AUXILIARY (debug) > 0)
|
|
|
|
{
|
|
|
|
memcpy ((char *) &normal->sy_symbol.ost_auxent[0], (char *) &debug->sy_symbol.ost_auxent[0], S_GET_NUMBER_AUXILIARY (debug) * AUXESZ);
|
|
|
|
} /* Move all the auxiliary information */
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
/* Move the debug flags. */
|
|
|
|
SF_SET_DEBUG_FIELD (normal, SF_GET_DEBUG_FIELD (debug));
|
|
|
|
} /* c_symbol_merge() */
|
1991-12-12 00:53:23 +00:00
|
|
|
|
|
|
|
static int
|
1992-11-23 20:42:33 +00:00
|
|
|
DEFUN (c_line_new, (symbol, paddr, line_number, frag),
|
|
|
|
symbolS * symbol AND
|
|
|
|
long paddr AND
|
|
|
|
unsigned short line_number AND
|
|
|
|
fragS * frag)
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
struct lineno_list *new_line =
|
|
|
|
(struct lineno_list *) xmalloc (sizeof (struct lineno_list));
|
|
|
|
|
|
|
|
segment_info_type *s = segment_info + now_seg;
|
1992-02-22 20:45:24 +00:00
|
|
|
new_line->line.l_lnno = line_number;
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
if (line_number == 0)
|
|
|
|
{
|
|
|
|
last_line_symbol = symbol;
|
|
|
|
new_line->line.l_addr.l_symndx = (long) symbol;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
new_line->line.l_addr.l_paddr = paddr;
|
|
|
|
}
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
new_line->frag = (char *) frag;
|
|
|
|
new_line->next = (struct lineno_list *) NULL;
|
|
|
|
|
|
|
|
|
|
|
|
if (s->lineno_list_head == (struct lineno_list *) NULL)
|
|
|
|
{
|
|
|
|
s->lineno_list_head = new_line;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
s->lineno_list_tail->next = new_line;
|
|
|
|
}
|
1992-05-05 01:59:04 +00:00
|
|
|
s->lineno_list_tail = new_line;
|
1992-11-23 20:42:33 +00:00
|
|
|
return LINESZ * s->scnhdr.s_nlnno++;
|
1991-12-12 00:53:23 +00:00
|
|
|
}
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
void
|
|
|
|
c_dot_file_symbol (filename)
|
|
|
|
char *filename;
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
symbolS *symbolP;
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
symbolP = symbol_new (".file",
|
|
|
|
SEG_DEBUG,
|
|
|
|
0,
|
|
|
|
&zero_address_frag);
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
S_SET_STORAGE_CLASS (symbolP, C_FILE);
|
|
|
|
S_SET_NUMBER_AUXILIARY (symbolP, 1);
|
|
|
|
SA_SET_FILE_FNAME (symbolP, filename);
|
1992-01-28 03:43:23 +00:00
|
|
|
#ifndef NO_LISTING
|
1992-02-22 20:45:24 +00:00
|
|
|
{
|
|
|
|
extern int listing;
|
1992-11-23 20:42:33 +00:00
|
|
|
if (listing)
|
|
|
|
{
|
|
|
|
listing_source_file (filename);
|
|
|
|
}
|
|
|
|
|
1992-02-22 20:45:24 +00:00
|
|
|
}
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
#endif
|
|
|
|
SF_SET_DEBUG (symbolP);
|
|
|
|
S_SET_VALUE (symbolP, (long) previous_file_symbol);
|
|
|
|
|
|
|
|
previous_file_symbol = symbolP;
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
/* Make sure that the symbol is first on the symbol chain */
|
|
|
|
if (symbol_rootP != symbolP)
|
|
|
|
{
|
|
|
|
if (symbolP == symbol_lastP)
|
|
|
|
{
|
|
|
|
symbol_lastP = symbol_lastP->sy_previous;
|
|
|
|
} /* if it was the last thing on the list */
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
|
|
|
|
symbol_insert (symbolP, symbol_rootP, &symbol_rootP, &symbol_lastP);
|
|
|
|
symbol_rootP = symbolP;
|
|
|
|
} /* if not first on the list */
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
} /* c_dot_file_symbol() */
|
1991-12-12 00:53:23 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Build a 'section static' symbol.
|
|
|
|
*/
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
symbolS *
|
|
|
|
c_section_symbol (name, idx)
|
|
|
|
char *name;
|
|
|
|
int idx;
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
symbolS *symbolP;
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
symbolP = symbol_new (name, idx,
|
|
|
|
0,
|
|
|
|
&zero_address_frag);
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
S_SET_STORAGE_CLASS (symbolP, C_STAT);
|
|
|
|
S_SET_NUMBER_AUXILIARY (symbolP, 1);
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
SF_SET_STATICS (symbolP);
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
return symbolP;
|
|
|
|
} /* c_section_symbol() */
|
1991-12-12 00:53:23 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
static void
|
|
|
|
DEFUN (w_symbols, (abfd, where, symbol_rootP),
|
|
|
|
bfd * abfd AND
|
|
|
|
char *where AND
|
|
|
|
symbolS * symbol_rootP)
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
symbolS *symbolP;
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
/* First fill in those values we have only just worked out */
|
|
|
|
for (i = SEG_E0; i < SEG_E9; i++)
|
|
|
|
{
|
|
|
|
symbolP = segment_info[i].dot;
|
|
|
|
if (symbolP)
|
1992-02-22 20:45:24 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
|
|
SA_SET_SCN_SCNLEN (symbolP, segment_info[i].scnhdr.s_size);
|
|
|
|
SA_SET_SCN_NRELOC (symbolP, segment_info[i].scnhdr.s_nreloc);
|
|
|
|
SA_SET_SCN_NLINNO (symbolP, segment_info[i].scnhdr.s_nlnno);
|
|
|
|
|
1992-02-22 20:45:24 +00:00
|
|
|
}
|
|
|
|
}
|
1992-11-23 20:42:33 +00:00
|
|
|
|
|
|
|
/*
|
1992-02-22 20:45:24 +00:00
|
|
|
* Emit all symbols left in the symbol chain.
|
|
|
|
*/
|
1992-11-23 20:42:33 +00:00
|
|
|
for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
|
|
|
|
{
|
|
|
|
/* Used to save the offset of the name. It is used to point
|
1992-02-22 20:45:24 +00:00
|
|
|
to the string in memory but must be a file offset. */
|
1992-11-23 20:42:33 +00:00
|
|
|
register char *temp;
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
tc_coff_symbol_emit_hook (symbolP);
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
temp = S_GET_NAME (symbolP);
|
|
|
|
if (SF_GET_STRING (symbolP))
|
|
|
|
{
|
|
|
|
S_SET_OFFSET (symbolP, symbolP->sy_name_offset);
|
|
|
|
S_SET_ZEROES (symbolP, 0);
|
1991-12-12 00:53:23 +00:00
|
|
|
}
|
1992-11-23 20:42:33 +00:00
|
|
|
else
|
|
|
|
{
|
|
|
|
bzero (symbolP->sy_symbol.ost_entry.n_name, SYMNMLEN);
|
|
|
|
strncpy (symbolP->sy_symbol.ost_entry.n_name, temp, SYMNMLEN);
|
|
|
|
}
|
|
|
|
where = symbol_to_chars (abfd, where, symbolP);
|
|
|
|
S_SET_NAME (symbolP, temp);
|
|
|
|
}
|
|
|
|
|
1991-12-12 00:53:23 +00:00
|
|
|
} /* w_symbols() */
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
static void
|
|
|
|
DEFUN_VOID (obj_coff_lcomm)
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
1992-09-22 20:07:55 +00:00
|
|
|
char *name;
|
|
|
|
char c;
|
|
|
|
int temp;
|
|
|
|
char *p;
|
1992-05-02 02:34:21 +00:00
|
|
|
|
1992-09-22 20:07:55 +00:00
|
|
|
symbolS *symbolP;
|
|
|
|
name = input_line_pointer;
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
c = get_symbol_end ();
|
1992-09-22 20:07:55 +00:00
|
|
|
p = input_line_pointer;
|
|
|
|
*p = c;
|
1992-11-23 20:42:33 +00:00
|
|
|
SKIP_WHITESPACE ();
|
|
|
|
if (*input_line_pointer != ',')
|
|
|
|
{
|
|
|
|
as_bad ("Expected comma after name");
|
|
|
|
ignore_rest_of_line ();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (*input_line_pointer == '\n')
|
|
|
|
{
|
|
|
|
as_bad ("Missing size expression");
|
|
|
|
return;
|
|
|
|
}
|
1992-09-22 20:07:55 +00:00
|
|
|
input_line_pointer++;
|
1992-11-23 20:42:33 +00:00
|
|
|
if ((temp = get_absolute_expression ()) < 0)
|
|
|
|
{
|
|
|
|
as_warn ("lcomm length (%d.) <0! Ignored.", temp);
|
|
|
|
ignore_rest_of_line ();
|
|
|
|
return;
|
|
|
|
}
|
1992-09-22 20:07:55 +00:00
|
|
|
*p = 0;
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-12-30 21:39:51 +00:00
|
|
|
symbolP = symbol_find_or_make(name);
|
|
|
|
|
|
|
|
if (S_GET_SEGMENT(symbolP) == SEG_UNKNOWN &&
|
|
|
|
S_GET_VALUE(symbolP) == 0)
|
|
|
|
{
|
|
|
|
if (! need_pass_2)
|
|
|
|
{
|
|
|
|
char *p;
|
|
|
|
segT current_seg = now_seg; /* save current seg */
|
|
|
|
subsegT current_subseg = now_subseg;
|
|
|
|
|
|
|
|
subseg_new (SEG_E2, 1);
|
|
|
|
symbolP->sy_frag = frag_now;
|
|
|
|
p = frag_var(rs_org, 1, 1, (relax_substateT)0, symbolP,
|
|
|
|
temp, (char *)0);
|
|
|
|
*p = 0;
|
|
|
|
subseg_new (current_seg, current_subseg); /* restore current seg */
|
|
|
|
S_SET_SEGMENT(symbolP, SEG_E2);
|
|
|
|
S_SET_STORAGE_CLASS(symbolP, C_STAT);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
as_bad("Symbol %s already defined", name);
|
|
|
|
|
|
|
|
demand_empty_rest_of_line();
|
1991-12-12 00:53:23 +00:00
|
|
|
}
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
static void
|
1992-12-30 21:39:51 +00:00
|
|
|
DEFUN (fixup_mdeps, (frags, h, this_segment),
|
|
|
|
fragS * frags AND
|
|
|
|
object_headers * h AND
|
|
|
|
segT this_segment)
|
1992-09-09 18:38:16 +00:00
|
|
|
{
|
1992-12-30 21:39:51 +00:00
|
|
|
subseg_change (this_segment, 0);
|
1992-11-23 20:42:33 +00:00
|
|
|
while (frags)
|
1992-09-09 18:38:16 +00:00
|
|
|
{
|
1992-11-23 20:42:33 +00:00
|
|
|
switch (frags->fr_type)
|
|
|
|
{
|
|
|
|
case rs_align:
|
|
|
|
case rs_org:
|
|
|
|
frags->fr_type = rs_fill;
|
|
|
|
frags->fr_offset =
|
|
|
|
(frags->fr_next->fr_address - frags->fr_address - frags->fr_fix);
|
|
|
|
break;
|
|
|
|
case rs_machine_dependent:
|
1992-12-30 21:39:51 +00:00
|
|
|
md_convert_frag (h, frags);
|
|
|
|
frag_wane (frags);
|
1992-11-23 20:42:33 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
;
|
|
|
|
}
|
|
|
|
frags = frags->fr_next;
|
1992-09-09 18:38:16 +00:00
|
|
|
}
|
|
|
|
}
|
1992-11-23 20:42:33 +00:00
|
|
|
|
1991-12-12 00:53:23 +00:00
|
|
|
#if 1
|
1992-11-23 20:42:33 +00:00
|
|
|
static void
|
1992-12-15 22:49:55 +00:00
|
|
|
DEFUN (fixup_segment, (segP, this_segment_type),
|
Sat Dec 12 15:26:34 1992 Ian Lance Taylor (ian@cygnus.com)
* listing.c: Call xmalloc, not malloc; don't declare malloc.
* Changes to support SCO 3.2v4:
* read.c (s_align_bytes, s_align_ptwo): If not SEG_DATA or
SEG_BSS, fill with NOP_OPCODE.
* config/i386coff.mt: Add opcode/i386.h to TARG_CPU_DEPENDENTS.
* config/obj-coffbfd.c (do_relocs_for): Increment addr even if not
using ZERO_BASED_SEGMENTS.
(fill_section): If ZERO_BASED_SEGMENTS, set segment addresses, but
never set segment address for SEG_E2 (.bss) and don't write out
SEG_E2 contents. Set .init and .fini sections to STYP_TEXT.
(obj_coff_endef): Don't merge labels or symbols awaiting forward
definitions, and don't merge tags with non-tags. Check for .bf
rather than just checking whether the second character is b and
the third character is f.
(obj_coff_val): gcc can generate values which we don't handle
correctly; discard information for now, since it only affects the
debugging information.
(tag_find_or_name): Don't insert tags in the symbol table.
(yank_symbols): Don't merge labels.
(write_object_file): Don't define SUB_SEGMENT_ALIGN if it is
already defined. Fill subsegments with NOP_OPCODE, not 0. Don't
set segment address if ZERO_BASED_SEGMENTS.
(obj_coff_section): Accept and ignore a trailing quoted string, as
used in AT&T i386 syntax.
(fixup_segment): Take segment as argument. On the i386, adjust PC
relative addends by the segment vaddr.
* tc-i386.h: Define SUB_SEGMENT_ALIGN.
* tc-a29k.h: Define ZERO_BASED_SEGMENTS.
* tc-i386.c: (i386_operand): If I386COFF, accept any segment type.
1992-12-13 00:56:14 +00:00
|
|
|
segment_info_type * segP AND
|
1992-11-23 20:42:33 +00:00
|
|
|
segT this_segment_type)
|
1991-12-12 00:53:23 +00:00
|
|
|
{
|
Sat Dec 12 15:26:34 1992 Ian Lance Taylor (ian@cygnus.com)
* listing.c: Call xmalloc, not malloc; don't declare malloc.
* Changes to support SCO 3.2v4:
* read.c (s_align_bytes, s_align_ptwo): If not SEG_DATA or
SEG_BSS, fill with NOP_OPCODE.
* config/i386coff.mt: Add opcode/i386.h to TARG_CPU_DEPENDENTS.
* config/obj-coffbfd.c (do_relocs_for): Increment addr even if not
using ZERO_BASED_SEGMENTS.
(fill_section): If ZERO_BASED_SEGMENTS, set segment addresses, but
never set segment address for SEG_E2 (.bss) and don't write out
SEG_E2 contents. Set .init and .fini sections to STYP_TEXT.
(obj_coff_endef): Don't merge labels or symbols awaiting forward
definitions, and don't merge tags with non-tags. Check for .bf
rather than just checking whether the second character is b and
the third character is f.
(obj_coff_val): gcc can generate values which we don't handle
correctly; discard information for now, since it only affects the
debugging information.
(tag_find_or_name): Don't insert tags in the symbol table.
(yank_symbols): Don't merge labels.
(write_object_file): Don't define SUB_SEGMENT_ALIGN if it is
already defined. Fill subsegments with NOP_OPCODE, not 0. Don't
set segment address if ZERO_BASED_SEGMENTS.
(obj_coff_section): Accept and ignore a trailing quoted string, as
used in AT&T i386 syntax.
(fixup_segment): Take segment as argument. On the i386, adjust PC
relative addends by the segment vaddr.
* tc-i386.h: Define SUB_SEGMENT_ALIGN.
* tc-a29k.h: Define ZERO_BASED_SEGMENTS.
* tc-i386.c: (i386_operand): If I386COFF, accept any segment type.
1992-12-13 00:56:14 +00:00
|
|
|
register fixS * fixP;
|
1992-11-23 20:42:33 +00:00
|
|
|
register symbolS *add_symbolP;
|
|
|
|
register symbolS *sub_symbolP;
|
|
|
|
register long add_number;
|
|
|
|
register int size;
|
|
|
|
register char *place;
|
|
|
|
register long where;
|
|
|
|
register char pcrel;
|
|
|
|
register fragS *fragP;
|
|
|
|
register segT add_symbol_segment = SEG_ABSOLUTE;
|
|
|
|
|
|
|
|
|
Sat Dec 12 15:26:34 1992 Ian Lance Taylor (ian@cygnus.com)
* listing.c: Call xmalloc, not malloc; don't declare malloc.
* Changes to support SCO 3.2v4:
* read.c (s_align_bytes, s_align_ptwo): If not SEG_DATA or
SEG_BSS, fill with NOP_OPCODE.
* config/i386coff.mt: Add opcode/i386.h to TARG_CPU_DEPENDENTS.
* config/obj-coffbfd.c (do_relocs_for): Increment addr even if not
using ZERO_BASED_SEGMENTS.
(fill_section): If ZERO_BASED_SEGMENTS, set segment addresses, but
never set segment address for SEG_E2 (.bss) and don't write out
SEG_E2 contents. Set .init and .fini sections to STYP_TEXT.
(obj_coff_endef): Don't merge labels or symbols awaiting forward
definitions, and don't merge tags with non-tags. Check for .bf
rather than just checking whether the second character is b and
the third character is f.
(obj_coff_val): gcc can generate values which we don't handle
correctly; discard information for now, since it only affects the
debugging information.
(tag_find_or_name): Don't insert tags in the symbol table.
(yank_symbols): Don't merge labels.
(write_object_file): Don't define SUB_SEGMENT_ALIGN if it is
already defined. Fill subsegments with NOP_OPCODE, not 0. Don't
set segment address if ZERO_BASED_SEGMENTS.
(obj_coff_section): Accept and ignore a trailing quoted string, as
used in AT&T i386 syntax.
(fixup_segment): Take segment as argument. On the i386, adjust PC
relative addends by the segment vaddr.
* tc-i386.h: Define SUB_SEGMENT_ALIGN.
* tc-a29k.h: Define ZERO_BASED_SEGMENTS.
* tc-i386.c: (i386_operand): If I386COFF, accept any segment type.
1992-12-13 00:56:14 +00:00
|
|
|
for (fixP = segP->fix_root; fixP; fixP = fixP->fx_next)
|
1992-11-23 20:42:33 +00:00
|
|
|
{
|
|
|
|
fragP = fixP->fx_frag;
|
|
|
|
know (fragP);
|
|
|
|
where = fixP->fx_where;
|
|
|
|
place = fragP->fr_literal + where;
|
|
|
|
size = fixP->fx_size;
|
|
|
|
add_symbolP = fixP->fx_addsy;
|
1991-12-12 00:53:23 +00:00
|
|
|
#ifdef TC_I960
|
1992-11-23 20:42:33 +00:00
|
|
|
if (fixP->fx_callj && TC_S_IS_CALLNAME (add_symbolP))
|
|
|
|
{
|
|
|
|
/* Relocation should be done via the
|
1992-02-22 20:45:24 +00:00
|
|
|
associated 'bal' entry point
|
|
|
|
symbol. */
|
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
if (!TC_S_IS_BALNAME (tc_get_bal_of_call (add_symbolP)))
|
|
|
|
{
|
|
|
|
as_bad ("No 'bal' entry point for leafproc %s",
|
|
|
|
S_GET_NAME (add_symbolP));
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
fixP->fx_addsy = add_symbolP = tc_get_bal_of_call (add_symbolP);
|
|
|
|
} /* callj relocation */
|
1991-12-12 00:53:23 +00:00
|
|
|
#endif
|
1992-11-23 20:42:33 +00:00
|
|
|
sub_symbolP = fixP->fx_subsy;
|
|
|
|
add_number = fixP->fx_offset;
|
|
|
|
pcrel = fixP->fx_pcrel;
|
|
|
|
|
|
|
|
if (add_symbolP)
|
|
|
|
{
|
|
|
|
add_symbol_segment = S_GET_SEGMENT (add_symbolP);
|
|
|
|
} /* if there is an addend */
|
|
|
|
|
|
|
|
if (sub_symbolP)
|
|
|
|
{
|
|
|
|
if (!add_symbolP)
|
|
|
|
{
|
|
|
|
/* Its just -sym */
|
|
|
|
if (S_GET_SEGMENT (sub_symbolP) != SEG_ABSOLUTE)
|
|
|
|
{
|
|
|
|
as_bad ("Negative of non-absolute symbol %s", S_GET_NAME (sub_symbolP));
|
|
|
|
} /* not absolute */
|
|
|
|
|
|
|
|
add_number -= S_GET_VALUE (sub_symbolP);
|
|
|
|
fixP->fx_subsy = 0;
|
|
|
|
|
|
|
|
/* if sub_symbol is in the same segment that add_symbol
|
1992-02-22 20:45:24 +00:00
|
|
|
and add_symbol is either in DATA, TEXT, BSS or ABSOLUTE */
|
1992-11-23 20:42:33 +00:00
|
|
|
}
|
|
|
|
else if ((S_GET_SEGMENT (sub_symbolP) == add_symbol_segment)
|
|
|
|
&& (SEG_NORMAL (add_symbol_segment)
|
|
|
|
|| (add_symbol_segment == SEG_ABSOLUTE)))
|
|
|
|
{
|
|
|
|
/* Difference of 2 symbols from same segment. */
|
|
|
|
/* Can't make difference of 2 undefineds: 'value' means */
|
|
|
|
/* something different for N_UNDF. */
|
1991-12-12 00:53:23 +00:00
|
|
|
#ifdef TC_I960
|
1992-11-23 20:42:33 +00:00
|
|
|
/* Makes no sense to use the difference of 2 arbitrary symbols
|
1993-01-20 22:22:21 +00:00
|
|
|
as the target of a call instruction. */
|
1992-11-23 20:42:33 +00:00
|
|
|
if (fixP->fx_callj)
|
|
|
|
{
|
|
|
|
as_bad ("callj to difference of 2 symbols");
|
|
|
|
}
|
|
|
|
#endif /* TC_I960 */
|
|
|
|
add_number += S_GET_VALUE (add_symbolP) -
|
|
|
|
S_GET_VALUE (sub_symbolP);
|
|
|
|
|
|
|
|
add_symbolP = NULL;
|
|
|
|
fixP->fx_addsy = NULL;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Different segments in subtraction. */
|
|
|
|
know (!(S_IS_EXTERNAL (sub_symbolP) && (S_GET_SEGMENT (sub_symbolP) == SEG_ABSOLUTE)));
|
|
|
|
|
|
|
|
if ((S_GET_SEGMENT (sub_symbolP) == SEG_ABSOLUTE))
|
|
|
|
{
|
|
|
|
add_number -= S_GET_VALUE (sub_symbolP);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
as_bad ("Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %d.",
|
|
|
|
segment_name (S_GET_SEGMENT (sub_symbolP)),
|
|
|
|
S_GET_NAME (sub_symbolP), fragP->fr_address + where);
|
|
|
|
} /* if absolute */
|
|
|
|
}
|
|
|
|
} /* if sub_symbolP */
|
|
|
|
|
|
|
|
if (add_symbolP)
|
|
|
|
{
|
|
|
|
if (add_symbol_segment == this_segment_type && pcrel)
|
|
|
|
{
|
|
|
|
/*
|
1993-01-20 22:22:21 +00:00
|
|
|
* This fixup was made when the symbol's segment was
|
|
|
|
* SEG_UNKNOWN, but it is now in the local segment.
|
|
|
|
* So we know how to do the address without relocation.
|
|
|
|
*/
|
1991-12-12 00:53:23 +00:00
|
|
|
#ifdef TC_I960
|
1992-11-23 20:42:33 +00:00
|
|
|
/* reloc_callj() may replace a 'call' with a 'calls' or a 'bal',
|
1993-01-20 22:22:21 +00:00
|
|
|
* in which cases it modifies *fixP as appropriate. In the case
|
|
|
|
* of a 'calls', no further work is required, and *fixP has been
|
|
|
|
* set up to make the rest of the code below a no-op.
|
|
|
|
*/
|
1992-11-23 20:42:33 +00:00
|
|
|
reloc_callj (fixP);
|
|
|
|
#endif /* TC_I960 */
|
|
|
|
|
|
|
|
add_number += S_GET_VALUE (add_symbolP);
|
|
|
|
add_number -= md_pcrel_from (fixP);
|
Sat Dec 12 15:26:34 1992 Ian Lance Taylor (ian@cygnus.com)
* listing.c: Call xmalloc, not malloc; don't declare malloc.
* Changes to support SCO 3.2v4:
* read.c (s_align_bytes, s_align_ptwo): If not SEG_DATA or
SEG_BSS, fill with NOP_OPCODE.
* config/i386coff.mt: Add opcode/i386.h to TARG_CPU_DEPENDENTS.
* config/obj-coffbfd.c (do_relocs_for): Increment addr even if not
using ZERO_BASED_SEGMENTS.
(fill_section): If ZERO_BASED_SEGMENTS, set segment addresses, but
never set segment address for SEG_E2 (.bss) and don't write out
SEG_E2 contents. Set .init and .fini sections to STYP_TEXT.
(obj_coff_endef): Don't merge labels or symbols awaiting forward
definitions, and don't merge tags with non-tags. Check for .bf
rather than just checking whether the second character is b and
the third character is f.
(obj_coff_val): gcc can generate values which we don't handle
correctly; discard information for now, since it only affects the
debugging information.
(tag_find_or_name): Don't insert tags in the symbol table.
(yank_symbols): Don't merge labels.
(write_object_file): Don't define SUB_SEGMENT_ALIGN if it is
already defined. Fill subsegments with NOP_OPCODE, not 0. Don't
set segment address if ZERO_BASED_SEGMENTS.
(obj_coff_section): Accept and ignore a trailing quoted string, as
used in AT&T i386 syntax.
(fixup_segment): Take segment as argument. On the i386, adjust PC
relative addends by the segment vaddr.
* tc-i386.h: Define SUB_SEGMENT_ALIGN.
* tc-a29k.h: Define ZERO_BASED_SEGMENTS.
* tc-i386.c: (i386_operand): If I386COFF, accept any segment type.
1992-12-13 00:56:14 +00:00
|
|
|
#ifdef TC_I386
|
|
|
|
/* On the 386 we must adjust by the segment
|
|
|
|
vaddr as well. Ian Taylor. */
|
|
|
|
add_number -= segP->scnhdr.s_vaddr;
|
|
|
|
#endif
|
1992-11-23 20:42:33 +00:00
|
|
|
pcrel = 0; /* Lie. Don't want further pcrel processing. */
|
|
|
|
fixP->fx_addsy = NULL; /* No relocations please. */
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
switch (add_symbol_segment)
|
|
|
|
{
|
|
|
|
case SEG_ABSOLUTE:
|
1991-12-12 00:53:23 +00:00
|
|
|
#ifdef TC_I960
|
1992-11-23 20:42:33 +00:00
|
|
|
reloc_callj (fixP); /* See comment about reloc_callj() above*/
|
|
|
|
#endif /* TC_I960 */
|
|
|
|
add_number += S_GET_VALUE (add_symbolP);
|
|
|
|
fixP->fx_addsy = NULL;
|
|
|
|
add_symbolP = NULL;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
|
1993-03-25 22:09:27 +00:00
|
|
|
#ifdef TC_A29K
|
|
|
|
/* This really should be handled in the linker, but
|
|
|
|
backward compatibility forbids. */
|
|
|
|
add_number += S_GET_VALUE (add_symbolP);
|
|
|
|
#else
|
1992-11-23 20:42:33 +00:00
|
|
|
add_number += S_GET_VALUE (add_symbolP) +
|
|
|
|
segment_info[S_GET_SEGMENT (add_symbolP)].scnhdr.s_paddr;
|
1993-03-25 22:09:27 +00:00
|
|
|
#endif
|
1992-11-23 20:42:33 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SEG_UNKNOWN:
|
1991-12-12 00:53:23 +00:00
|
|
|
#ifdef TC_I960
|
1992-11-23 20:42:33 +00:00
|
|
|
if ((int) fixP->fx_bit_fixP == 13)
|
|
|
|
{
|
|
|
|
/* This is a COBR instruction. They have only a
|
1993-01-20 22:22:21 +00:00
|
|
|
* 13-bit displacement and are only to be used
|
|
|
|
* for local branches: flag as error, don't generate
|
|
|
|
* relocation.
|
|
|
|
*/
|
1992-11-23 20:42:33 +00:00
|
|
|
as_bad ("can't use COBR format with external label");
|
|
|
|
fixP->fx_addsy = NULL; /* No relocations please. */
|
|
|
|
continue;
|
|
|
|
} /* COBR */
|
|
|
|
#endif /* TC_I960 */
|
1992-10-20 20:10:34 +00:00
|
|
|
#ifdef TC_I386
|
1992-11-23 20:42:33 +00:00
|
|
|
/* 386 COFF uses a peculiar format in
|
Sat Dec 12 15:26:34 1992 Ian Lance Taylor (ian@cygnus.com)
* listing.c: Call xmalloc, not malloc; don't declare malloc.
* Changes to support SCO 3.2v4:
* read.c (s_align_bytes, s_align_ptwo): If not SEG_DATA or
SEG_BSS, fill with NOP_OPCODE.
* config/i386coff.mt: Add opcode/i386.h to TARG_CPU_DEPENDENTS.
* config/obj-coffbfd.c (do_relocs_for): Increment addr even if not
using ZERO_BASED_SEGMENTS.
(fill_section): If ZERO_BASED_SEGMENTS, set segment addresses, but
never set segment address for SEG_E2 (.bss) and don't write out
SEG_E2 contents. Set .init and .fini sections to STYP_TEXT.
(obj_coff_endef): Don't merge labels or symbols awaiting forward
definitions, and don't merge tags with non-tags. Check for .bf
rather than just checking whether the second character is b and
the third character is f.
(obj_coff_val): gcc can generate values which we don't handle
correctly; discard information for now, since it only affects the
debugging information.
(tag_find_or_name): Don't insert tags in the symbol table.
(yank_symbols): Don't merge labels.
(write_object_file): Don't define SUB_SEGMENT_ALIGN if it is
already defined. Fill subsegments with NOP_OPCODE, not 0. Don't
set segment address if ZERO_BASED_SEGMENTS.
(obj_coff_section): Accept and ignore a trailing quoted string, as
used in AT&T i386 syntax.
(fixup_segment): Take segment as argument. On the i386, adjust PC
relative addends by the segment vaddr.
* tc-i386.h: Define SUB_SEGMENT_ALIGN.
* tc-a29k.h: Define ZERO_BASED_SEGMENTS.
* tc-i386.c: (i386_operand): If I386COFF, accept any segment type.
1992-12-13 00:56:14 +00:00
|
|
|
which the value of a common symbol is
|
|
|
|
stored in the .text segment (I've
|
|
|
|
checked this on SVR3.2 and SCO 3.2.2)
|
|
|
|
Ian Taylor <ian@cygnus.com>. */
|
1992-12-30 21:39:51 +00:00
|
|
|
if (S_IS_COMMON (add_symbolP))
|
|
|
|
add_number += S_GET_VALUE (add_symbolP);
|
1992-10-20 20:10:34 +00:00
|
|
|
#endif
|
1992-11-23 20:42:33 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
|
|
} /* switch on symbol seg */
|
|
|
|
} /* if not in local seg */
|
|
|
|
} /* if there was a + symbol */
|
|
|
|
|
|
|
|
if (pcrel)
|
|
|
|
{
|
1993-07-15 20:23:43 +00:00
|
|
|
#ifndef TC_M88K
|
|
|
|
/* This adjustment is not correct on the m88k, for which the
|
|
|
|
linker does all the computation. */
|
1992-11-23 20:42:33 +00:00
|
|
|
add_number -= md_pcrel_from (fixP);
|
1993-07-15 20:23:43 +00:00
|
|
|
#endif
|
1992-11-23 20:42:33 +00:00
|
|
|
if (add_symbolP == 0)
|
|
|
|
{
|
|
|
|
fixP->fx_addsy = &abs_symbol;
|
|
|
|
} /* if there's an add_symbol */
|
Sat Dec 12 15:26:34 1992 Ian Lance Taylor (ian@cygnus.com)
* listing.c: Call xmalloc, not malloc; don't declare malloc.
* Changes to support SCO 3.2v4:
* read.c (s_align_bytes, s_align_ptwo): If not SEG_DATA or
SEG_BSS, fill with NOP_OPCODE.
* config/i386coff.mt: Add opcode/i386.h to TARG_CPU_DEPENDENTS.
* config/obj-coffbfd.c (do_relocs_for): Increment addr even if not
using ZERO_BASED_SEGMENTS.
(fill_section): If ZERO_BASED_SEGMENTS, set segment addresses, but
never set segment address for SEG_E2 (.bss) and don't write out
SEG_E2 contents. Set .init and .fini sections to STYP_TEXT.
(obj_coff_endef): Don't merge labels or symbols awaiting forward
definitions, and don't merge tags with non-tags. Check for .bf
rather than just checking whether the second character is b and
the third character is f.
(obj_coff_val): gcc can generate values which we don't handle
correctly; discard information for now, since it only affects the
debugging information.
(tag_find_or_name): Don't insert tags in the symbol table.
(yank_symbols): Don't merge labels.
(write_object_file): Don't define SUB_SEGMENT_ALIGN if it is
already defined. Fill subsegments with NOP_OPCODE, not 0. Don't
set segment address if ZERO_BASED_SEGMENTS.
(obj_coff_section): Accept and ignore a trailing quoted string, as
used in AT&T i386 syntax.
(fixup_segment): Take segment as argument. On the i386, adjust PC
relative addends by the segment vaddr.
* tc-i386.h: Define SUB_SEGMENT_ALIGN.
* tc-a29k.h: Define ZERO_BASED_SEGMENTS.
* tc-i386.c: (i386_operand): If I386COFF, accept any segment type.
1992-12-13 00:56:14 +00:00
|
|
|
#ifdef TC_I386
|
|
|
|
/* On the 386 we must adjust by the segment vaddr
|
|
|
|
as well. Ian Taylor. */
|
|
|
|
add_number -= segP->scnhdr.s_vaddr;
|
|
|
|
#endif
|
1992-11-23 20:42:33 +00:00
|
|
|
} /* if pcrel */
|
|
|
|
|
|
|
|
if (!fixP->fx_bit_fixP)
|
|
|
|
{
|
1993-07-21 17:19:33 +00:00
|
|
|
#ifndef TC_M88K
|
|
|
|
/* The m88k uses the offset field of the reloc to get around
|
|
|
|
this problem. */
|
1992-11-23 20:42:33 +00:00
|
|
|
if ((size == 1 &&
|
|
|
|
(add_number & ~0xFF) && ((add_number & ~0xFF) != (-1 & ~0xFF))) ||
|
|
|
|
(size == 2 &&
|
|
|
|
(add_number & ~0xFFFF) && ((add_number & ~0xFFFF) != (-1 & ~0xFFFF))))
|
|
|
|
{
|
|
|
|
as_bad ("Value of %d too large for field of %d bytes at 0x%x",
|
|
|
|
add_number, size, fragP->fr_address + where);
|
|
|
|
} /* generic error checking */
|
1993-07-21 17:19:33 +00:00
|
|
|
#endif
|
1992-09-14 05:25:56 +00:00
|
|
|
#ifdef WARN_SIGNED_OVERFLOW_WORD
|
1992-11-23 20:42:33 +00:00
|
|
|
/* Warn if a .word value is too large when treated as
|
1993-01-20 22:22:21 +00:00
|
|
|
a signed number. We already know it is not too
|
|
|
|
negative. This is to catch over-large switches
|
|
|
|
generated by gcc on the 68k. */
|
1992-11-23 20:42:33 +00:00
|
|
|
if (!flagseen['J']
|
|
|
|
&& size == 2
|
|
|
|
&& add_number > 0x7fff)
|
|
|
|
as_bad ("Signed .word overflow; switch may be too large; %d at 0x%x",
|
|
|
|
add_number, fragP->fr_address + where);
|
1992-09-14 05:25:56 +00:00
|
|
|
#endif
|
1992-11-23 20:42:33 +00:00
|
|
|
} /* not a bit fix */
|
|
|
|
/* once this fix has been applied, we don't have to output anything
|
1992-02-22 20:45:24 +00:00
|
|
|
nothing more need be done -*/
|
1992-11-23 20:42:33 +00:00
|
|
|
md_apply_fix (fixP, add_number);
|
|
|
|
} /* For each fixS in this segment. */
|
|
|
|
} /* fixup_segment() */
|
1992-02-22 20:45:24 +00:00
|
|
|
|
1992-11-23 20:42:33 +00:00
|
|
|
#endif
|