diff options
Diffstat (limited to 'gas')
| -rw-r--r-- | gas/ChangeLog | 34 | ||||
| -rw-r--r-- | gas/config/tc-h8500.c | 1 | ||||
| -rw-r--r-- | gas/config/tc-hppa.c | 128 | ||||
| -rw-r--r-- | gas/config/tc-i960.c | 95 | ||||
| -rw-r--r-- | gas/read.c | 752 | ||||
| -rw-r--r-- | gas/write.c | 145 |
6 files changed, 511 insertions, 644 deletions
diff --git a/gas/ChangeLog b/gas/ChangeLog index 7d94f43..4a5e80b 100644 --- a/gas/ChangeLog +++ b/gas/ChangeLog @@ -1,3 +1,37 @@ +Wed Oct 6 13:01:34 1993 Ian Lance Taylor (ian@tweedledumb.cygnus.com) + + Changes to let cons handle bignums like general expressions. + * expr.h (expressionS): New field X_unsigned. + * expr.c (operand): Initialize X_unsigned to 1. Set it to 0 for + unary minus case. + (expr) Fix typo resultP to right if missing operand. Set + X_unsigned to 1 when building new expression. + * read.c (potable): Make "octa" and "quad" call cons, not + big_cons. + (cons): Handle bignums. If given an O_constant (small integer) to + fill a big space, turn it into a bignum. + (parse_bitfield_cons): Set X_unsigned field. + (bignum_low, bignum_limit, bignum_high, grow_bignum, big_cons): + Removed. + * read.h (big_cons): Remove prototype. + * symbols.c (resolve_symbol_value): Don't give a warning if a + symbol in expr_section can not be resolved. + (S_SET_VALUE): Clear X_unsigned. + * write.c (write_object_file): If resolve_symbol_value failed on a + symbol we are writing out, give a warning. + * config/tc-h8500.c (parse_reglist): Set X_unsigned. + * config/tc-hppa.c (md_pseudo_table): Change "octa" and "quad" to + call pa_cons, not pa_big_cons. + (pa_big_cons): Remove. + * config/tc-hppa.h (pa_big_cons): Remove declaration. + * config/tc-i960.c (md_pseudo_table): Change "quad" to call cons, + not big_cons. + +Tue Oct 5 10:53:36 1993 david d `zoo' zuhn (zoo@rtl.cygnus.com) + + * doc/as.texinfo (Copying): new node, to handle the recent changes + in the texinfo/gpl.texinfo file + Mon Oct 4 17:10:15 1993 Ian Lance Taylor (ian@tweedledumb.cygnus.com) * read.c (big_cons): Handle "0" correctly. diff --git a/gas/config/tc-h8500.c b/gas/config/tc-h8500.c index f58163f..0210436 100644 --- a/gas/config/tc-h8500.c +++ b/gas/config/tc-h8500.c @@ -421,6 +421,7 @@ parse_reglist (src, op) op->exp.X_op_symbol = 0; op->exp.X_add_number = mask; op->exp.X_op = O_constant; + op->exp.X_unsigned = 1; op->type = IMM8; return idx; diff --git a/gas/config/tc-hppa.c b/gas/config/tc-hppa.c index 665606c..f48a352 100644 --- a/gas/config/tc-hppa.c +++ b/gas/config/tc-hppa.c @@ -233,8 +233,8 @@ const pseudo_typeS {"LONG", pa_cons, 4}, {"lsym", pa_lsym, 0}, {"LSYM", pa_lsym, 0}, - {"octa", pa_big_cons, 16}, - {"OCTA", pa_big_cons, 16}, + {"octa", pa_cons, 16}, + {"OCTA", pa_cons, 16}, {"org", pa_origin, 0}, {"ORG", pa_origin, 0}, {"origin", pa_origin, 0}, @@ -245,8 +245,8 @@ const pseudo_typeS {"PROC", pa_proc, 0}, {"procend", pa_procend, 0}, {"PROCEND", pa_procend, 0}, - {"quad", pa_big_cons, 8}, - {"QUAD", pa_big_cons, 8}, + {"quad", pa_cons, 8}, + {"QUAD", pa_cons, 8}, {"reg", pa_equ, 1}, /* very similar to .equ */ {"REG", pa_equ, 1}, /* very similar to .equ */ {"short", pa_cons, 2}, @@ -732,7 +732,7 @@ md_begin () { const char *name = pa_opcodes[i].name; retval = hash_insert (op_hash, name, &pa_opcodes[i]); - if (retval != NULL && *retval != '\0') + if (retval != NULL) { as_fatal ("Internal error: can't hash `%s': %s\n", pa_opcodes[i].name, retval); @@ -4291,13 +4291,13 @@ s_seg () if (strncmp (input_line_pointer, "\"text\"", 6) == 0) { input_line_pointer += 6; - s_text (); + s_text (0); return; } if (strncmp (input_line_pointer, "\"data\"", 6) == 0) { input_line_pointer += 6; - s_data (); + s_data (0); return; } if (strncmp (input_line_pointer, "\"data1\"", 7) == 0) @@ -4317,22 +4317,14 @@ s_private () register int temp; temp = get_absolute_expression (); -#ifdef OBJ_SOM - subseg_new (SEG_DATA, (subsegT) temp); -#else - subseg_new (".data", (subsegT) temp); -#endif + subseg_set (data_section, (subsegT) temp); demand_empty_rest_of_line (); } void s_data1 () { -#ifdef OBJ_SOM - subseg_new (SEG_DATA, 1); -#else - subseg_new (".data", 1); -#endif + subseg_set (data_section, 1); demand_empty_rest_of_line (); return; } @@ -4498,7 +4490,7 @@ pa_build_unwind_subspace (call_info) save_seg = now_seg; save_subseg = now_subseg; - subseg_new ((char *) seg->name, subseg); + subseg_set (seg, subseg); unwindP = (char *) &call_info->ci_unwind; p = frag_more (4); @@ -4567,7 +4559,7 @@ pa_build_unwind_subspace (call_info) } } - subseg_new ((char *) save_seg->name, save_subseg); + subseg_set (save_seg, save_subseg); } #else @@ -4625,7 +4617,7 @@ pa_build_unwind_subspace (call_info) save_seg = now_seg; save_subseg = now_subseg; - subseg_new (seg, subseg); + subseg_set (seg, subseg); unwindP = (char *) &call_info->ci_unwind; p = frag_more (4); @@ -4710,7 +4702,7 @@ pa_build_unwind_subspace (call_info) } } - subseg_new (save_seg, save_subseg); + subseg_set (save_seg, save_subseg); } @@ -4834,13 +4826,8 @@ pa_code () } SPACE_DEFINED (sdchain) = 1; -#ifdef OBJ_SOM - subseg_new (SEG_TEXT, SUBSEG_CODE); -#else - - subseg_new (".text", SUBSEG_CODE); -#endif + subseg_set (text_section, SUBSEG_CODE); demand_empty_rest_of_line (); return; @@ -5210,7 +5197,7 @@ void seg, SEC_HAS_CONTENTS | SEC_READONLY | SEC_ALLOC | SEC_LOAD); - subseg_new(save_seg->name, save_subseg); + subseg_set(save_seg, save_subseg); } #endif @@ -5520,7 +5507,7 @@ pa_leave () void pa_origin () { - s_org (); /* ORG actually allows another argument + s_org (0); /* ORG actually allows another argument (the fill value) but maybe this is OK? */ pa_undefine_label (); return; @@ -5787,11 +5774,7 @@ pa_parse_space_stmt (space_name, create_flag) void pa_align_subseg (seg, subseg) -#ifdef OBJ_SOM segT seg; -#else - asection *seg; -#endif subsegT subseg; { subspace_dict_chainS *now_subspace; @@ -5841,22 +5824,12 @@ pa_space () current_space = sd_chain; SPACE_DEFINED (current_space) = 1; current_space->sd_defined = 1; -#ifdef OBJ_SOM - if (now_seg != SEG_TEXT) /* no need to align if we are already there */ -#else if (now_seg != text_section) /* no need to align if we are already there */ -#endif pa_align_subseg (now_seg, now_subseg); -#ifdef OBJ_SOM - subseg_new (SEG_TEXT, sd_chain->sd_last_subseg); - current_subspace = pa_subsegment_to_subspace (SEG_TEXT, - sd_chain->sd_last_subseg); -#else - subseg_new ((char *) text_section->name, sd_chain->sd_last_subseg); + subseg_set (text_section, sd_chain->sd_last_subseg); current_subspace = pa_subsegment_to_subspace (text_section, sd_chain->sd_last_subseg); -#endif demand_empty_rest_of_line (); return; } @@ -5872,21 +5845,11 @@ pa_space () current_space = sd_chain; SPACE_DEFINED (current_space) = 1; current_space->sd_defined = 1; -#ifdef OBJ_SOM - if (now_seg != SEG_DATA) /* no need to align if we are already there */ -#else if (now_seg != data_section) /* no need to align if we are already there */ -#endif pa_align_subseg (now_seg, now_subseg); -#ifdef OBJ_SOM - subseg_new (SEG_DATA, sd_chain->sd_last_subseg); - current_subspace = pa_subsegment_to_subspace (SEG_DATA, - sd_chain->sd_last_subseg); -#else - subseg_new ((char *) data_section->name, sd_chain->sd_last_subseg); + subseg_set (data_section, sd_chain->sd_last_subseg); current_subspace = pa_subsegment_to_subspace (data_section, sd_chain->sd_last_subseg); -#endif demand_empty_rest_of_line (); return; } @@ -5903,19 +5866,22 @@ pa_space () current_space = sd_chain; SPACE_DEFINED (current_space) = 1; current_space->sd_defined = 1; + #ifdef OBJ_SOM - if (now_seg != SEG_GDB) /* no need to align if we are already there */ + if (now_seg != SEG_GDB) /* no need to align if we are already there */ + pa_align_subseg (now_seg, now_subseg); - subseg_new (SEG_GDB, sd_chain->sd_last_subseg); + subseg_set (SEG_GDB, sd_chain->sd_last_subseg); current_subspace = pa_subsegment_to_subspace (SEG_GDB, sd_chain->sd_last_subseg); #else { - asection *gdb_section - = bfd_make_section_old_way (stdoutput, GDB_DEBUG_SPACE_NAME); - if (now_seg != gdb_section) /* no need to align if we are already there */ + segT gdb_section; + /* no need to align if we are already there */ + if (strcmp (segment_name (now_seg), GDB_DEBUG_SPACE_NAME) != 0) pa_align_subseg (now_seg, now_subseg); - subseg_new ((char *) gdb_section->name, sd_chain->sd_last_subseg); + gdb_section = subseg_new (GDB_DEBUG_SPACE_NAME, + sd_chain->sd_last_subseg); current_subspace = pa_subsegment_to_subspace (gdb_section, sd_chain->sd_last_subseg); } @@ -5935,11 +5901,7 @@ pa_space () current_space->sd_defined = 1; if (now_seg != sd_chain->sd_seg) /* don't align if we're already there */ pa_align_subseg (now_seg, now_subseg); -#ifdef OBJ_SOM - subseg_new (sd_chain->sd_seg, sd_chain->sd_last_subseg); -#else - subseg_new ((char *) sd_chain->sd_seg->name, sd_chain->sd_last_subseg); -#endif + subseg_set (sd_chain->sd_seg, sd_chain->sd_last_subseg); current_subspace = pa_subsegment_to_subspace (sd_chain->sd_seg, sd_chain->sd_last_subseg); demand_empty_rest_of_line (); @@ -5961,11 +5923,7 @@ pa_space () current_space->sd_defined = 1; if (now_seg != sd_chain->sd_seg) /* don't align if we're already there */ pa_align_subseg (now_seg, now_subseg); -#ifdef OBJ_SOM - subseg_new (sd_chain->sd_seg, sd_chain->sd_last_subseg); -#else - subseg_new ((char *) sd_chain->sd_seg->name, sd_chain->sd_last_subseg); -#endif + subseg_set (sd_chain->sd_seg, sd_chain->sd_last_subseg); current_subspace = pa_subsegment_to_subspace (sd_chain->sd_seg, sd_chain->sd_last_subseg); demand_empty_rest_of_line (); @@ -6068,7 +6026,7 @@ pa_subspace () if (ssd->ssd_defined) { #ifdef OBJ_SOM - subseg_new (now_seg, ssd->ssd_subseg); + subseg_set (now_seg, ssd->ssd_subseg); #else /* subseg_new(now_seg->name,ssd->ssd_subseg); */ subseg_new ((char *) ssd->ssd_seg->name, ssd->ssd_subseg); @@ -6202,11 +6160,7 @@ pa_subspace () SUBSPACE_SUBSPACE_START (current_subspace) = pa_subspace_start (space, quadrant); demand_empty_rest_of_line (); -#ifdef OBJ_SOM - subseg_new (current_subspace->ssd_seg, current_subspace->ssd_subseg); -#else - subseg_new ((char *) current_subspace->ssd_seg->name, current_subspace->ssd_subseg); -#endif + subseg_set (current_subspace->ssd_seg, current_subspace->ssd_subseg); } return; } @@ -6887,7 +6841,7 @@ pa_cons (nbytes) void pa_data () { - s_data (); + s_data (0); pa_undefine_label (); } @@ -6912,7 +6866,7 @@ pa_float_cons (float_type) void pa_fill () { - s_fill (); + s_fill (0); pa_undefine_label (); } @@ -6929,22 +6883,14 @@ pa_lcomm (needs_align) void pa_lsym () { - s_lsym (); - pa_undefine_label (); -} - -void -pa_big_cons (nbytes) - register int nbytes; -{ - big_cons (nbytes); + s_lsym (0); pa_undefine_label (); } void pa_text () { - s_text (); + s_text (0); pa_undefine_label (); } @@ -7043,7 +6989,7 @@ bfd * abfd; /* now, switch back to the original segment */ - subseg_new(save_seg->name, save_subseg); + subseg_set(save_seg, save_subseg); return; } @@ -7073,6 +7019,6 @@ hppa_tc_make_symextn_section() bfd_set_section_size (stdoutput, symextn_sec, size); /* now, switch back to the original segment */ - subseg_new(save_seg->name, save_subseg); + subseg_set(save_seg, save_subseg); } } diff --git a/gas/config/tc-i960.c b/gas/config/tc-i960.c index be54da4..4c045be 100644 --- a/gas/config/tc-i960.c +++ b/gas/config/tc-i960.c @@ -201,7 +201,7 @@ const pseudo_typeS md_pseudo_table[] = {"sysproc", parse_po, S_SYSPROC}, {"word", cons, 4}, - {"quad", big_cons, 16}, + {"quad", cons, 16}, {0, 0, 0} }; @@ -508,41 +508,31 @@ md_begin () { int i; /* Loop counter */ const struct i960_opcode *oP; /* Pointer into opcode table */ - char *retval; /* Value returned by hash functions */ + const char *retval; /* Value returned by hash functions */ if (((op_hash = hash_new ()) == 0) || ((reg_hash = hash_new ()) == 0) || ((areg_hash = hash_new ()) == 0)) - { - as_fatal ("virtual memory exceeded"); - } + as_fatal ("virtual memory exceeded"); /* For some reason, the base assembler uses an empty string for "no error message", instead of a NULL pointer. */ retval = ""; - for (oP = i960_opcodes; oP->name && !*retval; oP++) - { - retval = hash_insert (op_hash, oP->name, oP); - } + for (oP = i960_opcodes; oP->name && !retval; oP++) + retval = hash_insert (op_hash, oP->name, (PTR) oP); - for (i = 0; regnames[i].reg_name && !*retval; i++) - { - retval = hash_insert (reg_hash, regnames[i].reg_name, - ®names[i].reg_num); - } + for (i = 0; regnames[i].reg_name && !retval; i++) + retval = hash_insert (reg_hash, regnames[i].reg_name, + ®names[i].reg_num); - for (i = 0; aregs[i].areg_name && !*retval; i++) - { - retval = hash_insert (areg_hash, aregs[i].areg_name, - &aregs[i].areg_num); - } + for (i = 0; aregs[i].areg_name && !retval; i++) + retval = hash_insert (areg_hash, aregs[i].areg_name, + &aregs[i].areg_num); - if (*retval) - { - as_fatal ("Hashing returned \"%s\".", retval); - } -} /* md_begin() */ + if (retval) + as_fatal ("Hashing returned \"%s\".", retval); +} /***************************************************************************** * md_end: One-time final cleanup @@ -577,7 +567,6 @@ md_assemble (textP) char *args[4]; int n_ops; /* Number of instruction operands */ - int callx; /* Pointer to instruction description */ struct i960_opcode *oP; /* TRUE iff opcode mnemonic included branch-prediction @@ -896,7 +885,7 @@ md_number_to_field (instrP, val, bfixP) if (((val < 0) && (sign != -1)) || ((val > 0) && (sign != 0))) { - as_bad ("Fixup of %d too large for field width of %d", + as_bad ("Fixup of %ld too large for field width of %d", val, numbits); } else @@ -964,14 +953,14 @@ md_parse_option (argP, cntP, vecP) }; static struct tabentry arch_tab[] = { - "KA", ARCH_KA, - "KB", ARCH_KB, - "SA", ARCH_KA, /* Synonym for KA */ - "SB", ARCH_KB, /* Synonym for KB */ - "KC", ARCH_MC, /* Synonym for MC */ - "MC", ARCH_MC, - "CA", ARCH_CA, - NULL, 0 + { "KA", ARCH_KA }, + { "KB", ARCH_KB }, + { "SA", ARCH_KA }, /* Synonym for KA */ + { "SB", ARCH_KB }, /* Synonym for KB */ + { "KC", ARCH_MC }, /* Synonym for MC */ + { "MC", ARCH_MC }, + { "CA", ARCH_CA }, + { NULL, 0 } }; struct tabentry *tp; if (!strcmp (*argP, "linkrelax")) @@ -2220,7 +2209,7 @@ parse_po (po_num) /* Advance input pointer to end of line. */ p = input_line_pointer; - while (!is_end_of_line[*input_line_pointer]) + while (!is_end_of_line[(unsigned char) *input_line_pointer]) { input_line_pointer++; } @@ -2458,22 +2447,22 @@ struct coj[] = { /* COBR OPCODE: */ - CHKBIT, BNO, /* 0x30 - bbc */ - CMPO, BG, /* 0x31 - cmpobg */ - CMPO, BE, /* 0x32 - cmpobe */ - CMPO, BGE, /* 0x33 - cmpobge */ - CMPO, BL, /* 0x34 - cmpobl */ - CMPO, BNE, /* 0x35 - cmpobne */ - CMPO, BLE, /* 0x36 - cmpoble */ - CHKBIT, BO, /* 0x37 - bbs */ - CMPI, BNO, /* 0x38 - cmpibno */ - CMPI, BG, /* 0x39 - cmpibg */ - CMPI, BE, /* 0x3a - cmpibe */ - CMPI, BGE, /* 0x3b - cmpibge */ - CMPI, BL, /* 0x3c - cmpibl */ - CMPI, BNE, /* 0x3d - cmpibne */ - CMPI, BLE, /* 0x3e - cmpible */ - CMPI, BO, /* 0x3f - cmpibo */ + { CHKBIT, BNO }, /* 0x30 - bbc */ + { CMPO, BG }, /* 0x31 - cmpobg */ + { CMPO, BE }, /* 0x32 - cmpobe */ + { CMPO, BGE }, /* 0x33 - cmpobge */ + { CMPO, BL }, /* 0x34 - cmpobl */ + { CMPO, BNE }, /* 0x35 - cmpobne */ + { CMPO, BLE }, /* 0x36 - cmpoble */ + { CHKBIT, BO }, /* 0x37 - bbs */ + { CMPI, BNO }, /* 0x38 - cmpibno */ + { CMPI, BG }, /* 0x39 - cmpibg */ + { CMPI, BE }, /* 0x3a - cmpibe */ + { CMPI, BGE }, /* 0x3b - cmpibge */ + { CMPI, BL }, /* 0x3c - cmpibl */ + { CMPI, BNE }, /* 0x3d - cmpibne */ + { CMPI, BLE }, /* 0x3e - cmpible */ + { CMPI, BO }, /* 0x3f - cmpibo */ }; static @@ -3174,10 +3163,6 @@ i960_handle_align (fragp) fragS *fragp; { fixS *fixp; - segT old_seg = now_seg, this_seg; - int old_subseg = now_subseg; - int pad_size; - extern struct frag *text_last_frag, *data_last_frag; if (!linkrelax) return; @@ -133,12 +133,6 @@ char is_end_of_line[256] = static char *buffer; /* 1st char of each buffer of lines is here. */ static char *buffer_limit; /*->1 + last char in buffer. */ -static char *bignum_low; /* Lowest char of bignum. */ -static char *bignum_limit; /* 1st illegal address of bignum. */ -static char *bignum_high; /* Highest char of bignum. */ -/* May point to (bignum_start-1). */ -/* Never >= bignum_limit. */ - int target_big_endian; static char *old_buffer; /* JF a hack */ @@ -161,10 +155,7 @@ static char *demand_copy_string PARAMS ((int *lenP)); int is_it_end_of_statement PARAMS ((void)); static segT get_segmented_expression PARAMS ((expressionS *expP)); static segT get_known_segmented_expression PARAMS ((expressionS * expP)); -static void grow_bignum PARAMS ((void)); static void pobegin PARAMS ((void)); - -extern int listing; void @@ -180,10 +171,6 @@ read_begin () obstack_begin (¬es, 5090); obstack_begin (&cond_obstack, 990); -#define BIGNUM_BEGIN_SIZE (16) - bignum_low = xmalloc ((long) BIGNUM_BEGIN_SIZE); - bignum_limit = bignum_low + BIGNUM_BEGIN_SIZE; - /* Use machine dependent syntax */ for (p = line_separator_chars; *p; p++) is_end_of_line[(unsigned char) *p] = 1; @@ -241,11 +228,11 @@ static const pseudo_typeS potable[] = {"long", cons, 4}, {"lsym", s_lsym, 0}, {"nolist", listing_list, 0}, /* Turn listing off */ - {"octa", big_cons, 16}, + {"octa", cons, 16}, {"org", s_org, 0}, {"psize", listing_psize, 0}, /* set paper size */ /* print */ - {"quad", big_cons, 8}, + {"quad", cons, 8}, {"sbttl", listing_title, 1}, /* Subtitle of listing */ /* scl */ /* sect */ @@ -281,7 +268,7 @@ pobegin () for (pop = md_pseudo_table; pop->poc_name; pop++) { errtxt = hash_insert (po_hash, pop->poc_name, (char *) pop); - if (errtxt && *errtxt) + if (errtxt) { as_fatal ("error constructing md pseudo-op table"); } /* on error */ @@ -291,7 +278,7 @@ pobegin () for (pop = obj_pseudo_table; pop->poc_name; pop++) { errtxt = hash_insert (po_hash, pop->poc_name, (char *) pop); - if (errtxt && *errtxt) + if (errtxt) { if (!strcmp (errtxt, "exists")) { @@ -311,7 +298,7 @@ pobegin () for (pop = potable; pop->poc_name; pop++) { errtxt = hash_insert (po_hash, pop->poc_name, (char *) pop); - if (errtxt && *errtxt) + if (errtxt) { if (!strcmp (errtxt, "exists")) { @@ -1529,7 +1516,7 @@ pseudo_set (symbolP) * * CONStruct more frag of .bytes, or .words etc. * Should need_pass_2 be 1 then emit no frag(s). - * This understands EXPRESSIONS, as opposed to big_cons(). + * This understands EXPRESSIONS. * * Bug (?) * @@ -1608,6 +1595,7 @@ emit_expr (exp, nbytes) { operatorT op; register char *p; + valueT extra_digit = 0; /* Don't do anything if we are going to make another pass. */ if (need_pass_2) @@ -1615,16 +1603,46 @@ emit_expr (exp, nbytes) op = exp->X_op; + /* Handle a negative bignum. */ + if (op == O_uminus + && exp->X_add_number == 0 + && exp->X_add_symbol->sy_value.X_op == O_big + && exp->X_add_symbol->sy_value.X_add_number > 0) + { + int i; + unsigned long carry; + + exp = &exp->X_add_symbol->sy_value; + + /* Negate the bignum: one's complement each digit and add 1. */ + carry = 1; + for (i = 0; i < exp->X_add_number; i++) + { + unsigned long next; + + next = (((~ (generic_bignum[i] & LITTLENUM_MASK)) + & LITTLENUM_MASK) + + carry); + generic_bignum[i] = next & LITTLENUM_MASK; + carry = next >> LITTLENUM_NUMBER_OF_BITS; + } + + /* We can ignore any carry out, because it will be handled by + extra_digit if it is needed. */ + + extra_digit = (valueT) -1; + op = O_big; + } + if (op == O_absent || op == O_illegal) { as_warn ("zero assumed for missing expression"); exp->X_add_number = 0; op = O_constant; } - else if (op == O_big) + else if (op == O_big && exp->X_add_number <= 0) { - as_bad ("%s number invalid; zero assumed", - exp->X_add_number > 0 ? "bignum" : "floating point"); + as_bad ("floating point number invalid; zero assumed"); exp->X_add_number = 0; op = O_constant; } @@ -1658,6 +1676,28 @@ emit_expr (exp, nbytes) } #endif + /* If we have an integer, but the number of bytes is too large to + pass to md_number_to_chars, handle it as a bignum. */ + if (op == O_constant && nbytes > sizeof (valueT)) + { + valueT val; + int gencnt; + + if (! exp->X_unsigned && exp->X_add_number < 0) + extra_digit = (valueT) -1; + val = (valueT) exp->X_add_number; + gencnt = 0; + do + { + generic_bignum[gencnt] = val & LITTLENUM_MASK; + val >>= LITTLENUM_NUMBER_OF_BITS; + ++gencnt; + } + while (val != 0); + op = exp->X_op = O_big; + exp->X_add_number = gencnt; + } + if (op == O_constant) { register long get; @@ -1688,6 +1728,58 @@ emit_expr (exp, nbytes) /* put bytes in right order. */ md_number_to_chars (p, (valueT) use, (int) nbytes); } + else if (op == O_big) + { + int size; + LITTLENUM_TYPE *nums; + + know (nbytes % CHARS_PER_LITTLENUM == 0); + + size = exp->X_add_number * CHARS_PER_LITTLENUM; + if (nbytes < size) + { + as_warn ("Bignum truncated to %d bytes", nbytes); + size = nbytes; + } + + if (target_big_endian) + { + while (nbytes > size) + { + md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM); + nbytes -= CHARS_PER_LITTLENUM; + p += CHARS_PER_LITTLENUM; + } + + nums = generic_bignum + size / CHARS_PER_LITTLENUM; + while (size > 0) + { + --nums; + md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM); + size -= CHARS_PER_LITTLENUM; + p += CHARS_PER_LITTLENUM; + } + } + else + { + nums = generic_bignum; + while (size > 0) + { + md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM); + ++nums; + size -= CHARS_PER_LITTLENUM; + p += CHARS_PER_LITTLENUM; + nbytes -= CHARS_PER_LITTLENUM; + } + + while (nbytes > 0) + { + md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM); + nbytes -= CHARS_PER_LITTLENUM; + p += CHARS_PER_LITTLENUM; + } + } + } else { md_number_to_chars (p, (valueT) 0, (int) nbytes); @@ -1725,7 +1817,7 @@ emit_expr (exp, nbytes) #define TC_CONS_RELOC 0 #endif #endif - fix_new_exp (frag_now, p - frag_now->fr_literal, nbytes, exp, 0, + fix_new_exp (frag_now, p - frag_now->fr_literal, (int) nbytes, exp, 0, TC_CONS_RELOC); #endif /* TC_CONS_FIX_NEW */ #endif /* BFD_ASSEMBLER */ @@ -1808,7 +1900,7 @@ parse_bitfield_cons (exp, nbytes) if ((width = exp->X_add_number) > (BITS_PER_CHAR * nbytes)) { - as_warn ("field width %d too big to fit in %d bytes: truncated to %d bits", + as_warn ("field width %lu too big to fit in %d bytes: truncated to %d bits", width, nbytes, (BITS_PER_CHAR * nbytes)); width = BITS_PER_CHAR * nbytes; } /* too big */ @@ -1851,6 +1943,7 @@ parse_bitfield_cons (exp, nbytes) exp->X_add_number = value; exp->X_op = O_constant; + exp->X_unsigned = 1; } /* if looks like a bitfield */ } /* parse_bitfield_cons() */ @@ -1953,164 +2046,6 @@ parse_repeat_cons (exp, nbytes) #endif /* REPEAT_CONS_EXPRESSIONS */ /* - * big_cons() - * - * CONStruct more frag(s) of .quads, or .octa etc. - * Makes 0 or more new frags. - * If need_pass_2 == 1, generate no frag. - * This understands only bignums, not expressions. Cons() understands - * expressions. - * - * Constants recognised are '0...'(octal) '0x...'(hex) '...'(decimal). - * - * This creates objects with struct obstack_control objs, destroying - * any context objs held about a partially completed object. Beware! - * - * - * I think it sucks to have 2 different types of integers, with 2 - * routines to read them, store them etc. - * It would be nicer to permit bignums in expressions and only - * complain if the result overflowed. However, due to "efficiency"... - */ -/* Worker to do .quad etc statements. Clobbers input_line_pointer, checks - end-of-line. 8=.quad 16=.octa ... */ - -void -big_cons (nbytes) - register int nbytes; -{ - register char c; /* input_line_pointer->c. */ - register int radix; - register long length; /* Number of chars in an object. */ - register int digit; /* Value of 1 digit. */ - register int carry; /* For multi-precision arithmetic. */ - register int work; /* For multi-precision arithmetic. */ - register char *p; /* For multi-precision arithmetic. */ - - extern const char hex_value[]; /* In hex_value.c. */ - - /* - * The following awkward logic is to parse ZERO or more strings, - * comma seperated. Recall an expression includes its leading & - * trailing blanks. We fake a leading ',' if there is (supposed to - * be) a 1st expression, and keep demanding 1 expression for each ','. - */ - if (is_it_end_of_statement ()) - { - c = 0; /* Skip loop. */ - } - else - { - c = ','; /* Do loop. */ - --input_line_pointer; - } - while (c == ',') - { - ++input_line_pointer; - SKIP_WHITESPACE (); - c = *input_line_pointer; - /* C contains 1st non-blank character of what we hope is a number. */ - if (c == '0') - { - c = *++input_line_pointer; - if (c == 'x' || c == 'X') - { - c = *++input_line_pointer; - radix = 16; - } - else - { - radix = 8; - } - } - else - { - radix = 10; - } - /* - * This feature (?) is here to stop people worrying about - * mysterious zero constants: which is what they get when - * they completely omit digits. - */ - if (hex_value[(unsigned char) c] >= radix) - { - as_bad ("Missing digits. 0 assumed."); - } - bignum_high = bignum_low - 1; /* Start constant with 0 chars. */ - for (; - (digit = hex_value[(unsigned char) c]) < radix; - c = *++input_line_pointer) - { - /* Multiply existing number by radix, then add digit. */ - carry = digit; - for (p = bignum_low; p <= bignum_high; p++) - { - work = (*p & MASK_CHAR) * radix + carry; - *p = work & MASK_CHAR; - carry = work >> BITS_PER_CHAR; - } - if (carry) - { - grow_bignum (); - *bignum_high = carry & MASK_CHAR; - know ((carry & ~MASK_CHAR) == 0); - } - } - length = bignum_high - bignum_low + 1; - if (length > nbytes) - { - as_warn ("Most significant bits truncated in integer constant."); - } - else - { - register long leading_zeroes; - - for (leading_zeroes = nbytes - length; - leading_zeroes; - leading_zeroes--) - { - grow_bignum (); - *bignum_high = 0; - } - } - if (!need_pass_2) - { - char *src = bignum_low; - p = frag_more (nbytes); - if (target_big_endian) - { - int i; - for (i = nbytes - 1; i >= 0; i--) - p[i] = *src++; - } - else - memcpy (p, bignum_low, (unsigned int) nbytes); - } - /* C contains character after number. */ - SKIP_WHITESPACE (); - c = *input_line_pointer; - /* C contains 1st non-blank character after number. */ - } - demand_empty_rest_of_line (); -} /* big_cons() */ - -/* Extend bignum by 1 char. */ -static void -grow_bignum () -{ - register unsigned long length; - - bignum_high++; - if (bignum_high >= bignum_limit) - { - length = bignum_limit - bignum_low; - bignum_low = xrealloc (bignum_low, length + length); - bignum_high = bignum_low + length; - bignum_limit = bignum_low + length + length; - } -} /* grow_bignum(); */ - -/* * float_cons() * * CONStruct some more frag chars of .floats .ffloats etc. @@ -2162,7 +2097,7 @@ float_cons (float_type) err = md_atof (float_type, temp, &length); know (length <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT); know (length > 0); - if (err && *err) + if (err) { as_bad ("Bad floating literal: %s", err); ignore_rest_of_line (); @@ -2639,7 +2574,7 @@ s_ignore (arg) return; } /* s_ignore() */ - + /* * Handle .stabX directives, which used to be open-coded. * So much creeping featurism overloaded the semantics that we decided @@ -2655,34 +2590,6 @@ s_ignore (arg) * don't need and invent information they need that you didn't supply. */ -void -change_to_section (name, len, exp) - char *name; - unsigned int len; - unsigned int exp; -{ -#ifndef BFD_ASSEMBLER -#ifdef MANY_SEGMENTS - unsigned int i; - extern segment_info_type segment_info[]; - - /* Find out if we've already got a section of this name etc */ - for (i = SEG_E0; i < SEG_E9 && segment_info[i].scnhdr.s_name[0]; i++) - { - if (strncmp (segment_info[i].scnhdr.s_name, name, len) == 0) - { - subseg_set (i, exp); - return; - } - } - /* No section, add one */ - strncpy (segment_info[i].scnhdr.s_name, name, 8); - segment_info[i].scnhdr.s_flags = 0 /* STYP_NOLOAD */; - subseg_set (i, exp); -#endif -#endif -} - /* * Build a string dictionary entry for a .stabX symbol. * The symbol is added to the .<secname>str section. @@ -2690,73 +2597,60 @@ change_to_section (name, len, exp) #ifdef SEPARATE_STAB_SECTIONS -static unsigned int +unsigned int get_stab_string_offset (string, secname) - char *string, *secname; + const char *string; + const char *secname; { - segT save_seg; - segT seg; - subsegT save_subseg; unsigned int length; - unsigned int old_gdb_string_index; - char *clengthP; - int i; - char c; - /* @@FIXME -- there should be no static data here! - This also has the effect of making all stab string tables large enough - to contain all the contents written to any of them. This only matters - with the Solaris native compiler for the moment, but it should be fixed - anyways. */ - static unsigned int gdb_string_index = 0; - - old_gdb_string_index = 0; + unsigned int retval; + + retval = 0; length = strlen (string); - clengthP = (char *) &length; if (length > 0) { /* Ordinary case. */ + segT save_seg; + subsegT save_subseg; + char *newsecname; + segT seg; + int aligned; + char *p; + save_seg = now_seg; save_subseg = now_subseg; - /* Create the stabstr sections, if they are not already created. */ - { - char *newsecname = xmalloc (strlen (secname) + 4); - strcpy (newsecname, secname); - strcat (newsecname, "str"); + /* Create the stab string section. */ + newsecname = xmalloc ((unsigned long) (strlen (secname) + 4)); + strcpy (newsecname, secname); + strcat (newsecname, "str"); + + seg = subseg_new (newsecname, 0); + + retval = seg_info (seg)->stabu.stab_string_size; + if (retval > 0) + free (newsecname); + else + { + /* Make sure the first string is empty. */ + p = frag_more (1); + *p = 0; + retval = seg_info (seg)->stabu.stab_string_size = 1; #ifdef BFD_ASSEMBLER - seg = bfd_get_section_by_name (stdoutput, newsecname); - if (seg == 0) - { - seg = bfd_make_section_old_way (stdoutput, newsecname); - bfd_set_section_flags (stdoutput, seg, SEC_READONLY | SEC_ALLOC); - } + bfd_set_section_flags (stdoutput, seg, SEC_READONLY); #else - subseg_new (newsecname, 0); + free (newsecname); #endif -/* free (newsecname);*/ - } - subseg_set (seg, save_subseg); - old_gdb_string_index = gdb_string_index; - i = 0; - while ((c = *string++)) - { - i++; - gdb_string_index++; - FRAG_APPEND_1_CHAR (c); - } - { - FRAG_APPEND_1_CHAR ((char) 0); - i++; - gdb_string_index++; - } - while (i % 4 != 0) - { - FRAG_APPEND_1_CHAR ((char) 0); - i++; - gdb_string_index++; } + + p = frag_more (length + 1); + strcpy (p, string); + + seg_info (seg)->stabu.stab_string_size += length + 1; + subseg_set (save_seg, save_subseg); } - return old_gdb_string_index; + + return retval; } #endif /* SEPARATE_STAB_SECTIONS */ @@ -2769,227 +2663,187 @@ s_stab_generic (what, secname) int what; char *secname; { - extern int listing; - - symbolS *symbol; - char *string; - int saved_type = 0; - int length; - int goof = 0; long longint; - segT saved_seg = now_seg; - segT seg; - subsegT saved_subseg = now_subseg; - subsegT subseg; - valueT valu; -#ifdef SEPARATE_STAB_SECTIONS - int seg_is_new = 0; -#endif - - valu = ((char *) obstack_next_free (&frags)) - frag_now->fr_literal; - -#ifdef SEPARATE_STAB_SECTIONS -#ifdef BFD_ASSEMBLER - seg = bfd_get_section_by_name (stdoutput, secname); - if (seg == 0) + char *string; + int type; + int other; + int desc; + + /* The general format is: + .stabs "STRING",TYPE,OTHER,DESC,VALUE + .stabn TYPE,OTHER,DESC,VALUE + .stabd TYPE,OTHER,DESC + At this point input_line_pointer points after the pseudo-op and + any trailing whitespace. The argument what is one of 's', 'n' or + 'd' indicating which type of .stab this is. */ + + if (what != 's') + string = ""; + else { - seg = subseg_new (secname, 0); - bfd_set_section_flags (stdoutput, seg, - SEC_READONLY | SEC_ALLOC | SEC_RELOC); - subseg_set (saved_seg, subseg); - seg_is_new = 1; - } -#else - subseg_new (secname, 0); -#endif -#endif /* SEPARATE_STAB_SECTIONS */ + int length; - /* - * Enter with input_line_pointer pointing past .stabX and any following - * whitespace. - */ - if (what == 's') - { string = demand_copy_C_string (&length); SKIP_WHITESPACE (); if (*input_line_pointer == ',') input_line_pointer++; else { - as_bad ("I need a comma after symbol's name"); - goof = 1; + as_warn (".stabs: Missing comma"); + ignore_rest_of_line (); + return; } } - else - string = ""; - /* - * Input_line_pointer->after ','. String->symbol name. - */ - if (!goof) + if (get_absolute_expression_and_terminator (&longint) != ',') { -#ifdef MAKE_STAB_SYMBOL - MAKE_STAB_SYMBOL(symbol, string, secname); -#else - symbol = symbol_new (string, undefined_section, 0, (struct frag *) 0); -#endif - /* Make sure that the rest of this is going to work. */ - if (symbol == NULL) - as_fatal ("no stab symbol created"); - - switch (what) - { - case 'd': - S_SET_NAME (symbol, NULL); /* .stabd feature. */ -#ifdef STAB_SYMBOL_SET_VALUE - STAB_SYMBOL_SET_VALUE (symbol, valu); -#else - S_SET_VALUE (symbol, valu); -#endif -#if STAB_SYMBOL_SET_SEGMENT -#else - S_SET_SEGMENT (symbol, now_seg); -#endif - symbol->sy_frag = frag_now; - break; - - case 'n': - symbol->sy_frag = &zero_address_frag; - break; - - case 's': - symbol->sy_frag = &zero_address_frag; - break; - - default: - BAD_CASE (what); - break; - } - - if (get_absolute_expression_and_terminator (&longint) == ',') - { - saved_type = longint; - S_SET_TYPE (symbol, saved_type); - } - else - { - as_bad ("I want a comma after the n_type expression"); - goof = 1; - input_line_pointer--; /* Backup over a non-',' char. */ - } + as_warn (".stab%c: Missing comma", what); + ignore_rest_of_line (); + return; } + type = longint; - if (!goof) + if (get_absolute_expression_and_terminator (&longint) != ',') { - if (get_absolute_expression_and_terminator (&longint) == ',') - S_SET_OTHER (symbol, longint); - else - { - as_bad ("I want a comma after the n_other expression"); - goof = 1; - input_line_pointer--; /* Backup over a non-',' char. */ - } + as_warn (".stab%c: Missing comma", what); + ignore_rest_of_line (); + return; } + other = longint; - if (!goof) + desc = get_absolute_expression (); + if (what == 's' || what == 'n') { - S_SET_DESC (symbol, get_absolute_expression ()); - if (what == 's' || what == 'n') + if (*input_line_pointer != ',') { - if (*input_line_pointer != ',') - { - as_bad ("I want a comma after the n_desc expression"); - goof = 1; - } - else - { - input_line_pointer++; - } + as_warn (".stab%c: Missing comma", what); + ignore_rest_of_line (); + return; } + input_line_pointer++; + SKIP_WHITESPACE (); } - /* Line is messed up - ignore it and get out of here. */ - if (goof) - { - ignore_rest_of_line (); - subseg_set (saved_seg, saved_subseg); - return; - } - - subseg_set (seg, subseg); - -#if 0 /* needed for elf only? */ - if (seg_is_new) - /* allocate and discard -- filled in later */ - (void) frag_more (12); -#endif + /* We have not gathered the type, other, and desc information. For + .stabs or .stabn, input_line_pointer is now pointing at the + value. */ #ifdef SEPARATE_STAB_SECTIONS + /* Output the stab information in a separate section. This is used + at least for COFF and ELF. */ { - char *toP; - - subseg_new (secname, 0); - toP = frag_more (8); - /* the string index portion of the stab */ - md_number_to_chars (toP, (valueT) S_GET_OFFSET_2(symbol), 4); - md_number_to_chars (toP + 4, (valueT) S_GET_TYPE(symbol), 1); - md_number_to_chars (toP + 5, (valueT) S_GET_OTHER(symbol), 1); - md_number_to_chars (toP + 6, (valueT) S_GET_DESC(symbol), 2); - } + segT saved_seg = now_seg; + subsegT saved_subseg = now_subseg; + fragS *saved_frag = frag_now; + valueT dot; + segT seg; + unsigned int stroff; + char *p; + + dot = frag_now_fix (); + + seg = subseg_new (secname, 0); + + if (! seg_info (seg)->hadone) + { +#ifdef BFD_ASSEMBLER + bfd_set_section_flags (stdoutput, seg, SEC_READONLY | SEC_RELOC); +#endif +#ifdef INIT_STAB_SECTION + INIT_STAB_SECTION (seg); #endif + seg_info (seg)->hadone = 1; + } -#ifdef SEPARATE_STAB_SECTIONS - if (what == 's' || what == 'n') - { - cons (4); - input_line_pointer--; - } - else - { - char *p = frag_more (4); - md_number_to_chars (p, 0, 4); - } - subseg_set (saved_seg, subseg); + stroff = get_stab_string_offset (string, secname); + + /* At least for now, stabs in a special stab section are always + output as 12 byte blocks of information. */ + p = frag_more (8); + md_number_to_chars (p, (valueT) stroff, 4); + md_number_to_chars (p + 4, (valueT) type, 1); + md_number_to_chars (p + 5, (valueT) other, 1); + md_number_to_chars (p + 6, (valueT) desc, 2); + + if (what == 's' || what == 'n') + { + /* Pick up the value from the input line. */ + cons (4); + input_line_pointer--; + } + else + { + const char *fake; + symbolS *symbol; + expressionS exp; + + /* Arrange for a value representing the current location. */ +#ifdef DOT_LABEL_PREFIX + fake = ".L0\001"; #else - if (what == 's' || what == 'n') - { - pseudo_set (symbol); - S_SET_TYPE (symbol, saved_type); - } + fake = "L0\001"; #endif + symbol = symbol_new (fake, saved_seg, dot, saved_frag); -#if 0 /* for elf only? */ - if (what == 's' && S_GET_TYPE (symbol) == N_SO) - { - fragS *fragp = seg_info (seg)->frchainP->frch_root; - while (fragp - && fragp->fr_address + fragp->fr_fix < 12) - fragp = fragp->fr_next; - assert (fragp != 0); - assert (fragp->fr_type == rs_fill); - assert (fragp->fr_address == 0 && fragp->fr_fix >= 12); - md_number_to_chars (fragp->fr_literal, (valueT) symbol->sy_name_offset, - 4); - } + exp.X_op = O_symbol; + exp.X_add_symbol = symbol; + exp.X_add_number = 0; + + emit_expr (&exp, 4); + } + +#ifdef OBJ_PROCESS_STAB + OBJ_PROCESS_STAB (seg, string, stroff, type, other, desc); #endif -#ifndef NO_LISTING - if (listing) - switch (S_GET_TYPE (symbol)) + subseg_set (saved_seg, saved_subseg); + } +#else /* ! SEPARATE_STAB_SECTIONS */ +#ifdef OBJ_PROCESS_STAB + OBJ_PROCESS_STAB (what, string, type, other, desc); +#else + /* Put the stab information in the symbol table. */ + { + symbolS *symbol; + + symbol = symbol_new (string, undefined_section, 0, + (struct frag *) NULL); + if (what == 's' || what == 'n') + { + /* Pick up the value from the input line. */ + symbol->sy_frag = &zero_address_frag; + pseudo_set (symbol); + } + else { - case N_SLINE: - listing_source_line ((unsigned int) S_GET_DESC (symbol)); - break; - case N_SO: - case N_SOL: - listing_source_file (string); - break; + /* .stabd sets the name to NULL. Why? */ + S_SET_NAME (symbol, NULL); + symbol->sy_frag = frag_now; + S_SET_VALUE (symbol, (valueT) frag_now_fix ()); } -#endif /* !NO_LISTING */ -#ifdef SEPARATE_STAB_SECTIONS - subseg_set (saved_seg, saved_subseg); -#endif + S_SET_TYPE (symbol, type); + S_SET_OTHER (symbol, other); + S_SET_DESC (symbol, desc); + } +#endif /* ! OBJ_PROCESS_STAB */ +#endif /* ! SEPARATE_STAB_SECTIONS */ + +#ifndef NO_LISTING + if (listing) + { + switch (type) + { + case N_SLINE: + listing_source_line ((unsigned int) desc); + break; + case N_SO: + case N_SOL: + listing_source_file (string); + break; + } + } +#endif /* ! NO_LISTING */ demand_empty_rest_of_line (); } diff --git a/gas/write.c b/gas/write.c index 913146e..ea0349c 100644 --- a/gas/write.c +++ b/gas/write.c @@ -47,9 +47,12 @@ struct frag *data_last_frag; /* Last frag in segment. */ static struct frag *bss_last_frag; /* Last frag in segment. */ #endif +#if ! defined (BFD_ASSEMBLER) && ! defined (BFD) static object_headers headers; -long string_byte_count; static char *the_object_file; +#endif + +long string_byte_count; char *next_object_file_charP; /* Tracks object file bytes. */ #ifndef OBJ_VMS @@ -69,9 +72,10 @@ static fixS *fix_new_internal PARAMS ((fragS *, int where, int size, offsetT offset, int pcrel, int r_type)); #endif +#if defined (BFD_ASSEMBLER) || !defined (BFD) static long fixup_segment PARAMS ((fixS * fixP, segT this_segment_type)); +#endif static relax_addressT relax_align PARAMS ((relax_addressT addr, int align)); -void relax_segment PARAMS ((struct frag * seg_frag_root, segT seg_type)); /* * fix_new() @@ -234,7 +238,7 @@ append (charPP, fromP, length) if (length == 0) return; - memcpy (*charPP, fromP, (int) length); + memcpy (*charPP, fromP, length); *charPP += length; } @@ -318,6 +322,8 @@ remove_subsegs (head, seg, root, last) #endif /* BFD */ +#if defined (BFD_ASSEMBLER) || !defined (BFD) + #ifdef BFD_ASSEMBLER static void cvt_frag_to_fill (sec, fragP) @@ -391,6 +397,8 @@ cvt_frag_to_fill (headers, fragP) } } +#endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */ + #ifdef BFD_ASSEMBLER static void relax_and_size_seg (abfd, sec, xxx) @@ -514,18 +522,27 @@ adjust_reloc_syms (abfd, sec, xxx) if (symsec == &bfd_und_section || symsec == &bfd_abs_section || bfd_is_com_section (symsec)) - continue; + { + fixp->fx_addsy->sy_used_in_reloc = 1; + continue; + } /* Since we're reducing to section symbols, don't attempt to reduce anything that's already using one. */ if (sym->bsym == symsec->symbol) - continue; + { + fixp->fx_addsy->sy_used_in_reloc = 1; + continue; + } /* Is there some other reason we can't adjust this one? (E.g., call/bal links in i960-bout symbols.) */ #ifdef obj_fix_adjustable if (! obj_fix_adjustable (fixp)) - continue; + { + fixp->fx_addsy->sy_used_in_reloc = 1; + continue; + } #endif /* If the section symbol isn't going to be output, the relocs at least should still work. If not, figure out what to do @@ -545,6 +562,7 @@ adjust_reloc_syms (abfd, sec, xxx) } symseginfo->sym = fixp->fx_addsy; } + fixp->fx_addsy->sy_used_in_reloc = 1; } dump_section_relocs (abfd, sec, stderr); @@ -557,7 +575,8 @@ write_relocs (abfd, sec, xxx) char *xxx; { segment_info_type *seginfo = seg_info (sec); - int i, n; + int i; + unsigned int n; arelent **relocs; fixS *fixp; @@ -582,7 +601,6 @@ write_relocs (abfd, sec, xxx) for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next) { arelent *reloc; - extern arelent *tc_gen_reloc (); char *data; bfd_reloc_status_type s; @@ -628,7 +646,6 @@ write_relocs (abfd, sec, xxx) for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next) { arelent **reloc; - extern arelent **tc_gen_reloc (); char *data; bfd_reloc_status_type s; int j; @@ -671,7 +688,8 @@ write_relocs (abfd, sec, xxx) bfd_set_reloc (stdoutput, sec, relocs, n); else bfd_set_section_flags (abfd, sec, - bfd_get_section_flags (abfd, sec) & ~SEC_RELOC); + (bfd_get_section_flags (abfd, sec) + & (flagword) ~SEC_RELOC)); #ifdef DEBUG2 { int i; @@ -697,39 +715,39 @@ write_contents (abfd, sec, xxx) { segment_info_type *seginfo = seg_info (sec); unsigned long offset = 0; - fragS *frags; + fragS *f; /* Write out the frags. */ if (! (bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS)) return; - for (frags = seginfo->frchainP->frch_root; - frags; - frags = frags->fr_next) + for (f = seginfo->frchainP->frch_root; + f; + f = f->fr_next) { int x; unsigned long fill_size; char *fill_literal; long count; - assert (frags->fr_type == rs_fill); - if (frags->fr_fix) + assert (f->fr_type == rs_fill); + if (f->fr_fix) { x = bfd_set_section_contents (stdoutput, sec, - frags->fr_literal, offset, - frags->fr_fix); + f->fr_literal, (file_ptr) offset, + (bfd_size_type) f->fr_fix); assert (x == true); - offset += frags->fr_fix; + offset += f->fr_fix; } - fill_literal = frags->fr_literal + frags->fr_fix; - fill_size = frags->fr_var; - count = frags->fr_offset; + fill_literal = f->fr_literal + f->fr_fix; + fill_size = f->fr_var; + count = f->fr_offset; assert (count >= 0); if (fill_size && count) while (count--) { x = bfd_set_section_contents (stdoutput, sec, - fill_literal, offset, + fill_literal, (file_ptr) offset, (bfd_size_type) fill_size); assert (x == true); offset += fill_size; @@ -738,7 +756,7 @@ write_contents (abfd, sec, xxx) } #endif -#if defined(BFD_ASSEMBLER) || !defined (BFD) +#if defined(BFD_ASSEMBLER) || (!defined (BFD) && !defined(OBJ_AOUT)) static void merge_data_into_text () { @@ -766,7 +784,7 @@ merge_data_into_text () data_fix_root = NULL; #endif } -#endif /* BFD_ASSEMBLER || ! BFD */ +#endif /* BFD_ASSEMBLER || (! BFD && ! OBJ_AOUT) */ #if !defined (BFD_ASSEMBLER) && !defined (BFD) static void @@ -923,11 +941,7 @@ write_object_file () #endif for (frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next) { -#ifdef BFD_ASSEMBLER subseg_set (frchainP->frch_seg, frchainP->frch_subseg); -#else - subseg_new (frchainP->frch_seg, frchainP->frch_subseg); -#endif frag_align (SUB_SEGMENT_ALIGN (now_seg), NOP_OPCODE); /* frag_align will have left a new frag. Use this last frag for an empty ".fill". @@ -1259,7 +1273,8 @@ write_object_file () /* Set up symbol table, and write it out. */ if (symbol_rootP) { - int i = 0, n; + unsigned int i = 0; + unsigned int n; symbolS *symp; for (symp = symbol_rootP; symp; symp = symbol_next (symp)) @@ -1290,27 +1305,30 @@ write_object_file () symp->bsym->flags, segment_name (symp->bsym->section)); #endif - { -#ifdef obj_frob_symbol + if (! symp->sy_used_in_reloc) { - int punt = 0; - obj_frob_symbol (symp, punt); - if (punt) - goto punt_it; - } +#ifdef obj_frob_symbol + { + int punt = 0; + obj_frob_symbol (symp, punt); + if (punt) + goto punt_it; + } #endif #ifdef tc_frob_symbol - { - int punt = 0; - tc_frob_symbol (symp, punt); - if (punt) - goto punt_it; - } + { + int punt = 0; + tc_frob_symbol (symp, punt); + if (punt) + goto punt_it; + } #endif - } + } + /* If we don't want to keep this symbol, splice it out of the chain now. */ - if (S_IS_LOCAL (symp)) + if (! symp->sy_used_in_reloc + && S_IS_LOCAL (symp)) { symbolS *prev, *next; #if defined (obj_frob_symbol) || defined (tc_frob_symbol) @@ -1343,6 +1361,14 @@ write_object_file () continue; } + /* Make sure we really got a value for the symbol. */ + if (! symp->sy_resolved) + { + as_bad ("can't resolve value for symbol \"%s\"", + S_GET_NAME (symp)); + symp->sy_resolved = 1; + } + /* Set the value into the BFD symbol. Up til now the value has only been kept in the gas symbolS struct. */ symp->bsym->value = S_GET_VALUE (symp); @@ -1506,7 +1532,6 @@ relax_segment (segment_frag_root, segment) symbolS *symbolP; long target; long after; - long aim; was_address = fragP->fr_address; address = fragP->fr_address += stretch; @@ -1552,7 +1577,7 @@ relax_segment (segment_frag_root, segment) if (flagseen['K']) { char buf[50]; - sprint_value (buf, lie->addnum); + sprint_value (buf, (addressT) lie->addnum); as_warn (".word %s-%s+%s didn't fit", S_GET_NAME (lie->add), S_GET_NAME (lie->sub), @@ -1623,6 +1648,7 @@ relax_segment (segment_frag_root, segment) const relax_typeS *start_type; relax_substateT next_state; relax_substateT this_state; + long aim; this_state = fragP->fr_subtype; start_type = this_type = md_relax_table + this_state; @@ -1630,6 +1656,7 @@ relax_segment (segment_frag_root, segment) if (symbolP) { +#ifndef DIFF_EXPR_OK #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER) know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE) || (S_GET_SEGMENT (symbolP) == SEG_DATA) @@ -1637,6 +1664,7 @@ relax_segment (segment_frag_root, segment) || (S_GET_SEGMENT (symbolP) == SEG_TEXT)); #endif know (symbolP->sy_frag); +#endif know (!(S_GET_SEGMENT (symbolP) == absolute_section) || symbolP->sy_frag == &zero_address_frag); target += @@ -1733,6 +1761,8 @@ relax_segment (segment_frag_root, segment) */ } /* relax_segment() */ +#if defined (BFD_ASSEMBLER) || !defined (BFD) + /* fixup_segment() Go through all the fixS's in a segment and see which ones can be @@ -1806,6 +1836,7 @@ fixup_segment (fixP, this_segment_type) if (!add_symbolP) { /* Its just -sym */ + /* @@ Should try converting to pcrel ref to fixed addr. */ if (S_GET_SEGMENT (sub_symbolP) != absolute_section) as_bad ("Negative of non-absolute symbol %s", S_GET_NAME (sub_symbolP)); @@ -1843,6 +1874,19 @@ fixup_segment (fixP, this_segment_type) { add_number -= S_GET_VALUE (sub_symbolP); } +#ifdef DIFF_EXPR_OK + else if (!pcrel + && S_GET_SEGMENT (sub_symbolP) == this_segment_type) + { + /* Make it pc-relative. */ + add_number += (md_pcrel_from (fixP) + - S_GET_VALUE (sub_symbolP)); + pcrel = 1; + fixP->fx_pcrel = 1; + sub_symbolP = 0; + fixP->fx_subsy = 0; + } +#endif else { char buf[50]; @@ -1961,8 +2005,9 @@ fixup_segment (fixP, this_segment_type) 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); + as_bad ("Signed .word overflow; switch may be too large; %ld at 0x%lx", + (long) add_number, + (unsigned long) (fragP->fr_address + where)); #endif } /* not a bit fix */ @@ -1987,4 +2032,6 @@ fixup_segment (fixP, this_segment_type) return (seg_reloc_count); } +#endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */ + /* end of write.c */ |