This is the mail archive of the
binutils@sources.redhat.com
mailing list for the binutils project.
gas/config/tc-cris.[ch]: Mostly PIC support.
- To: binutils at sources dot redhat dot com
- Subject: gas/config/tc-cris.[ch]: Mostly PIC support.
- From: Hans-Peter Nilsson <hans-peter dot nilsson at axis dot com>
- Date: Fri, 23 Mar 2001 06:31:50 +0100
Committed.
2001-03-23 Hans-Peter Nilsson <hp@axis.com>
* config/tc-cris.c: Tweak attribution. Fix typos. PIC support.
(PIC_SUFFIX_CHAR): New macro.
(cris_get_pic_suffix, cris_get_pic_reloc_size): New functions.
(pic): New variable.
(md_longopts): New option --pic.
(OPTION_PIC): Define.
(md_estimate_size_before_relax): Tweak longish comment.
(md_create_long_jump): Make the long jumps generate ADD.D offset,PC.
(md_assemble): Handle a PIC relocation on prefix and normal
instruction operands.
<output_instruction.insn_type == CRIS_INSN_BRANCH>: Handle
"complex" operand expressions. Call frag_more outside
gen_cond_branch_32 parameter list.
(cris_process_instruction): Handle PIC relocs on parsed
operand expressions. Validize PIC reloc sizes.
(get_autoinc_prefix_or_indir_op): Handle PIC suffix.
(gen_bdap): Handle "complex" operand expressions.
(gen_cond_branch_32): Use as_warn_where, not as_warn. Use
ADD.D offset,PC as jump instruction if generating PIC. Generate
error instead of crashing on complex expressions.
(cris_number_to_imm): Add segT parameter. All callers changed.
Use segT parameter, not now_seg, for segment of fixup. Handle
PCREL relocations but check that they are fully resolved.
(md_parse_option): Handle OPTION_PIC.
(tc_gen_reloc): Handle PIC relocs.
(md_show_usage): Update for --pic.
(md_apply_fix3): Renamed from md_apply_fix.
(md_pcrel_from): Accept emitting PCREL relocs when ELF.
(md_cris_force_relocation): Force relocation for PIC relocs.
* config/tc-cris.h: Tweak attribution.
(MD_APPLY_FIX3): Define.
(IS_CRIS_PIC_RELOC): New macro.
(TC_RELOC_RTSYM_LOC_FIXUP): Define.
(tc_fix_adjustable): Don't adjust a globally visible symbol when
generating ELF.
(tc_frob_symbol): Avoid emitting undefined symbols.
Index: tc-cris.c
===================================================================
RCS file: /cvs/src/src/gas/config/tc-cris.c,v
retrieving revision 1.10
diff -p -c -r1.10 tc-cris.c
*** tc-cris.c 2001/03/08 23:24:23 1.10
--- tc-cris.c 2001/03/23 04:21:54
***************
*** 1,9 ****
/* tc-cris.c -- Assembler code for the CRIS CPU core.
! Copyright 2000 Free Software Foundation, Inc.
Contributed by Axis Communications AB, Lund, Sweden.
Originally written for GAS 1.38.1 by Mikael Asker.
! Updated, BFDized and GNUified by Hans-Peter Nilsson.
This file is part of GAS, the GNU Assembler.
--- 1,9 ----
/* tc-cris.c -- Assembler code for the CRIS CPU core.
! Copyright 2000, 2001 Free Software Foundation, Inc.
Contributed by Axis Communications AB, Lund, Sweden.
Originally written for GAS 1.38.1 by Mikael Asker.
! Updates, BFDizing, GNUifying and ELF support by Hans-Peter Nilsson.
This file is part of GAS, the GNU Assembler.
***************
*** 43,48 ****
--- 43,52 ----
#define SYNTAX_USER_SYM_NO_LEADING_UNDERSCORE "no_leading_underscore"
#define REGISTER_PREFIX_CHAR '$'
+ /* Like in ":GOT", ":GOTOFF" etc. Other ports use '@', but that's in
+ line_separator_chars for CRIS, so we avoid it. */
+ #define PIC_SUFFIX_CHAR ':'
+
/* This might be CRIS_INSN_NONE if we're assembling a prefix-insn only.
Note that some prefix-insns might be assembled as CRIS_INSN_NORMAL. */
enum cris_insn_kind
*************** struct cris_instruction
*** 97,103 ****
relaxation with. */
enum bfd_reloc_code_real reloc;
! /* The size in bytes of an immediate expression, or zero in
nonapplicable. */
int imm_oprnd_size;
};
--- 101,107 ----
relaxation with. */
enum bfd_reloc_code_real reloc;
! /* The size in bytes of an immediate expression, or zero if
nonapplicable. */
int imm_oprnd_size;
};
*************** static void gen_bdap PARAMS ((int, expre
*** 122,134 ****
static int branch_disp PARAMS ((int));
static void gen_cond_branch_32 PARAMS ((char *, char *, fragS *,
symbolS *, symbolS *, long int));
! static void cris_number_to_imm PARAMS ((char *, long, int, fixS *));
static void cris_create_short_jump PARAMS ((char *, addressT, addressT,
fragS *, symbolS *));
static void s_syntax PARAMS ((int));
static void s_cris_file PARAMS ((int));
static void s_cris_loc PARAMS ((int));
/* All the .syntax functions. */
static void cris_force_reg_prefix PARAMS ((void));
static void cris_relax_reg_prefix PARAMS ((void));
--- 126,145 ----
static int branch_disp PARAMS ((int));
static void gen_cond_branch_32 PARAMS ((char *, char *, fragS *,
symbolS *, symbolS *, long int));
! static void cris_number_to_imm PARAMS ((char *, long, int, fixS *, segT));
static void cris_create_short_jump PARAMS ((char *, addressT, addressT,
fragS *, symbolS *));
static void s_syntax PARAMS ((int));
static void s_cris_file PARAMS ((int));
static void s_cris_loc PARAMS ((int));
+ /* Get ":GOT", ":GOTOFF", ":PLT" etc. suffixes. */
+ static void cris_get_pic_suffix PARAMS ((char **,
+ bfd_reloc_code_real_type *,
+ expressionS *));
+ static unsigned int cris_get_pic_reloc_size
+ PARAMS ((bfd_reloc_code_real_type));
+
/* All the .syntax functions. */
static void cris_force_reg_prefix PARAMS ((void));
static void cris_relax_reg_prefix PARAMS ((void));
*************** static boolean demand_register_prefix =
*** 144,149 ****
--- 155,163 ----
/* Whether global user symbols have a leading underscore. Default here. */
static boolean symbols_have_leading_underscore = true;
+ /* Whether or not we allow PIC, and expand to PIC-friendly constructs. */
+ static boolean pic = false;
+
const pseudo_typeS md_pseudo_table[] =
{
{"dword", cons, 4},
*************** struct option md_longopts[] =
*** 270,275 ****
--- 284,291 ----
{"no-underscore", no_argument, NULL, OPTION_NO_US},
#define OPTION_US (OPTION_MD_BASE + 1)
{"underscore", no_argument, NULL, OPTION_US},
+ #define OPTION_PIC (OPTION_MD_BASE + 2)
+ {"pic", no_argument, NULL, OPTION_PIC},
{NULL, no_argument, NULL, 0}
};
*************** const int md_short_jump_size = 6;
*** 291,297 ****
const int md_long_jump_size = 6;
/* Report output format. Small changes in output format (like elf
! variants below) can happen until all options are parsed. */
const char *
cris_target_format ()
--- 307,314 ----
const int md_long_jump_size = 6;
/* Report output format. Small changes in output format (like elf
! variants below) can happen until all options are parsed, but after
! that, the output format must remain fixed. */
const char *
cris_target_format ()
*************** md_estimate_size_before_relax (fragP, se
*** 375,397 ****
value.
We could play tricks with managing a constant pool and make
! a_known_symbol_in_text a "bdap [pc + offset]" pointing there, but
! that's pointless, it can only be longer and slower.
- Off-topic: If PIC becomes *really* important, and has to be done
- in the assembler and linker only (which would be weird or
- clueless), we can so something. Imagine:
- move.x [r + 32_bit_symbol],r
- move.x [32_bit_symbol],r
- move.x 32_bit_symbol,r
- can be shortened by a word (8-bit offset) if we are close to the
- symbol or keep its length (16-bit offset) or be a word longer
- (32-bit offset). Then change the 32_bit_symbol into a "bdap [pc
- + offset]", and put the offset to the 32_bit_symbol in "offset".
- Weird, to say the least, and we still have to add support for a
- PC-relative relocation in the loader (shared libraries). But
- it's an interesting thought. */
-
if (S_GET_SEGMENT (fragP->fr_symbol) != absolute_section)
{
/* Go for dword if not absolute or same segment. */
--- 392,402 ----
value.
We could play tricks with managing a constant pool and make
! a_known_symbol_in_text a "bdap [pc + offset]" pointing there
! (like the GOT for ELF shared libraries), but that's no use, it
! would in general be no shorter or faster code, only more
! complicated. */
if (S_GET_SEGMENT (fragP->fr_symbol) != absolute_section)
{
/* Go for dword if not absolute or same segment. */
*************** md_create_long_jump (storep, from_addr,
*** 641,652 ****
}
else
{
! /* We have a "long" long jump: "JUMP (PC+)". */
! md_number_to_chars (storep, JUMP_PC_INCR_OPCODE, 2);
! /* Follow with a ".DWORD to_addr". */
fix_new (fragP, storep + 2 - fragP->fr_literal, 4, to_symbol,
! 0, 0, BFD_RELOC_32);
}
}
--- 646,659 ----
}
else
{
! /* We have a "long" long jump: "JUMP [PC+]".
! Make it an "ADD [PC+],PC" if we're supposed to emit PIC code. */
! md_number_to_chars (storep,
! pic ? ADD_PC_INCR_OPCODE : JUMP_PC_INCR_OPCODE, 2);
! /* Follow with a ".DWORD to_addr", PC-relative for PIC. */
fix_new (fragP, storep + 2 - fragP->fr_literal, 4, to_symbol,
! 0, pic ? 1 : 0, pic ? BFD_RELOC_32_PCREL : BFD_RELOC_32);
}
}
*************** md_assemble (str)
*** 711,719 ****
/* When the expression is unknown for a BDAP, it can need 0, 2 or 4
extra bytes, so we handle it separately. */
case PREFIX_BDAP_IMM:
! gen_bdap (prefix.base_reg_number, &prefix.expr);
! break;
!
case PREFIX_BDAP:
case PREFIX_BIAP:
case PREFIX_DIP:
--- 718,731 ----
/* When the expression is unknown for a BDAP, it can need 0, 2 or 4
extra bytes, so we handle it separately. */
case PREFIX_BDAP_IMM:
! /* We only do it if the relocation is unspecified, i.e. not a PIC
! relocation. */
! if (prefix.reloc == BFD_RELOC_NONE)
! {
! gen_bdap (prefix.base_reg_number, &prefix.expr);
! break;
! }
! /* Fall through. */
case PREFIX_BDAP:
case PREFIX_BIAP:
case PREFIX_DIP:
*************** md_assemble (str)
*** 723,736 ****
/* Output the prefix opcode. */
md_number_to_chars (opcodep, (long) prefix.opcode, 2);
! /* This only happens for DIP, but is ok for the others as they have
! no reloc. */
if (prefix.reloc != BFD_RELOC_NONE)
{
! /* Output an absolute mode address. */
! insn_size += 4;
! p = frag_more (4);
! fix_new_exp (frag_now, (p - frag_now->fr_literal), 4,
&prefix.expr, 0, prefix.reloc);
}
break;
--- 735,752 ----
/* Output the prefix opcode. */
md_number_to_chars (opcodep, (long) prefix.opcode, 2);
! /* Having a specified reloc only happens for DIP and for BDAP with
! PIC operands, but it is ok to drop through here for the other
! prefixes as they can have no relocs specified. */
if (prefix.reloc != BFD_RELOC_NONE)
{
! unsigned int relocsize
! = (prefix.kind == PREFIX_DIP
! ? 4 : cris_get_pic_reloc_size (prefix.reloc));
!
! insn_size += relocsize;
! p = frag_more (relocsize);
! fix_new_exp (frag_now, (p - frag_now->fr_literal), relocsize,
&prefix.expr, 0, prefix.reloc);
}
break;
*************** md_assemble (str)
*** 787,801 ****
if (output_instruction.expr.X_op == O_constant
|| to_seg == now_seg || is_undefined)
{
/* If is_undefined, then the expression may BECOME now_seg. */
length_code = is_undefined ? STATE_UNDF : STATE_BYTE;
/* Make room for max ten bytes of variable length. */
frag_var (rs_machine_dependent, 10, 0,
ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, length_code),
! output_instruction.expr.X_add_symbol,
! output_instruction.expr.X_add_number,
! opcodep);
}
else
{
--- 803,824 ----
if (output_instruction.expr.X_op == O_constant
|| to_seg == now_seg || is_undefined)
{
+ /* Handle complex expressions. */
+ valueT addvalue
+ = (output_instruction.expr.X_op_symbol != NULL
+ ? 0 : output_instruction.expr.X_add_number);
+ symbolS *sym
+ = (output_instruction.expr.X_op_symbol != NULL
+ ? make_expr_symbol (&output_instruction.expr)
+ : output_instruction.expr.X_add_symbol);
+
/* If is_undefined, then the expression may BECOME now_seg. */
length_code = is_undefined ? STATE_UNDF : STATE_BYTE;
/* Make room for max ten bytes of variable length. */
frag_var (rs_machine_dependent, 10, 0,
ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, length_code),
! sym, addvalue, opcodep);
}
else
{
*************** md_assemble (str)
*** 803,810 ****
This means it is a branch to a known symbol in another
section. Code in data? Weird but valid. Emit a 32-bit
branch. */
insn_size += 10;
! gen_cond_branch_32 (opcodep, frag_more (10), frag_now,
output_instruction.expr.X_add_symbol,
(symbolS *) NULL,
output_instruction.expr.X_add_number);
--- 826,835 ----
This means it is a branch to a known symbol in another
section. Code in data? Weird but valid. Emit a 32-bit
branch. */
+ char *cond_jump = frag_more (10);
+
insn_size += 10;
! gen_cond_branch_32 (opcodep, cond_jump, frag_now,
output_instruction.expr.X_add_symbol,
(symbolS *) NULL,
output_instruction.expr.X_add_number);
*************** md_assemble (str)
*** 815,821 ****
if (output_instruction.imm_oprnd_size > 0)
{
/* The intruction has an immediate operand. */
! enum bfd_reloc_code_real reloc = 0;
switch (output_instruction.imm_oprnd_size)
{
--- 840,846 ----
if (output_instruction.imm_oprnd_size > 0)
{
/* The intruction has an immediate operand. */
! enum bfd_reloc_code_real reloc = BFD_RELOC_NONE;
switch (output_instruction.imm_oprnd_size)
{
*************** md_assemble (str)
*** 824,834 ****
correctly. */
case 2:
! reloc = BFD_RELOC_16;
break;
case 4:
! reloc = BFD_RELOC_32;
break;
default:
--- 849,868 ----
correctly. */
case 2:
! /* Note that size-check for the explicit reloc has already
! been done when we get here. */
! if (output_instruction.reloc != BFD_RELOC_NONE)
! reloc = output_instruction.reloc;
! else
! reloc = BFD_RELOC_16;
break;
case 4:
! /* Allow a relocation specified in the operand. */
! if (output_instruction.reloc != BFD_RELOC_NONE)
! reloc = output_instruction.reloc;
! else
! reloc = BFD_RELOC_32;
break;
default:
*************** cris_process_instruction (insn_text, out
*** 1137,1142 ****
--- 1171,1179 ----
/* Since 'O' is used with an explicit bdap, we have no
"real" instruction. */
prefixp->kind = PREFIX_BDAP_IMM;
+ prefixp->opcode
+ = BDAP_QUICK_OPCODE | (prefixp->base_reg_number << 12);
+
out_insnp->insn_type = CRIS_INSN_NONE;
continue;
}
*************** cris_process_instruction (insn_text, out
*** 1217,1225 ****
out_insnp->opcode |= (AUTOINCR_BIT << 8);
}
else
! /* No prefix. The "mode" variable contains bits like
! whether or not this is autoincrement mode. */
! out_insnp->opcode |= (mode << 10);
out_insnp->opcode |= regno /* << 0 */ ;
continue;
--- 1254,1271 ----
out_insnp->opcode |= (AUTOINCR_BIT << 8);
}
else
! {
! /* No prefix. The "mode" variable contains bits like
! whether or not this is autoincrement mode. */
! out_insnp->opcode |= (mode << 10);
!
! /* If there was a PIC reloc specifier, then it was
! attached to the prefix. Note that we can't check
! that the reloc size matches, since we don't have
! all the operands yet in all cases. */
! if (prefixp->reloc != BFD_RELOC_NONE)
! out_insnp->reloc = prefixp->reloc;
! }
out_insnp->opcode |= regno /* << 0 */ ;
continue;
*************** cris_process_instruction (insn_text, out
*** 1317,1323 ****
{
/* There was an immediate mode operand, so we must check
that it has an appropriate size. */
-
switch (instruction->imm_oprnd_size)
{
default:
--- 1363,1368 ----
*************** cris_process_instruction (insn_text, out
*** 1389,1394 ****
--- 1434,1448 ----
BAD_CASE (out_insnp->spec_reg->reg_size);
}
}
+
+ /* If there was a relocation specified for the immediate
+ expression (i.e. it had a PIC modifier) check that the
+ size of the PIC relocation matches the size specified by
+ the opcode. */
+ if (out_insnp->reloc != BFD_RELOC_NONE
+ && (cris_get_pic_reloc_size (out_insnp->reloc)
+ != (unsigned int) out_insnp->imm_oprnd_size))
+ as_bad (_("PIC relocation size does not match operand size"));
}
}
break;
*************** get_autoinc_prefix_or_indir_op (cPP, pre
*** 1823,1828 ****
--- 1877,1913 ----
in the blanks and break out to match the
final ']'. */
prefixp->kind = PREFIX_BDAP_IMM;
+
+ /* We tentatively put an opcode corresponding to
+ a 32-bit operand here, although it may be
+ relaxed when there's no PIC specifier for the
+ operand. */
+ prefixp->opcode
+ = (BDAP_INDIR_OPCODE
+ | (prefixp->base_reg_number << 12)
+ | (AUTOINCR_BIT << 8)
+ | (2 << 4)
+ | REG_PC /* << 0 */);
+
+ /* This can have a PIC suffix, specifying reloc
+ type to use. */
+ if (pic && **cPP == PIC_SUFFIX_CHAR)
+ {
+ unsigned int relocsize;
+
+ cris_get_pic_suffix (cPP, &prefixp->reloc,
+ &prefixp->expr);
+
+ /* Tweak the size of the immediate operand
+ in the prefix opcode if it isn't what we
+ set. */
+ relocsize
+ = cris_get_pic_reloc_size (prefixp->reloc);
+ if (relocsize != 4)
+ prefixp->opcode
+ = ((prefixp->opcode & ~(3 << 4))
+ | ((relocsize >> 1) << 4));
+ }
break;
}
else
*************** get_autoinc_prefix_or_indir_op (cPP, pre
*** 1841,1847 ****
{
/* We've got offset with assign mode. Fill
in the blanks and break out to match the
! final ']'. */
prefixp->kind = PREFIX_BDAP_IMM;
break;
}
--- 1926,1935 ----
{
/* We've got offset with assign mode. Fill
in the blanks and break out to match the
! final ']'.
!
! Note that we don't allow a PIC suffix for an
! operand with a minus sign. */
prefixp->kind = PREFIX_BDAP_IMM;
break;
}
*************** get_autoinc_prefix_or_indir_op (cPP, pre
*** 1876,1881 ****
--- 1964,1975 ----
*is_autoincp = 1;
*src_regnop = REG_PC;
*imm_foundp = 1;
+
+ /* This can have a PIC suffix, specifying reloc type to use. The
+ caller must check that the reloc size matches the operand size. */
+ if (pic && **cPP == PIC_SUFFIX_CHAR)
+ cris_get_pic_suffix (cPP, &prefixp->reloc, imm_exprP);
+
return 1;
}
*************** get_3op_or_dip_prefix_op (cPP, prefixp)
*** 1950,1957 ****
"[rN+rM.S]" or "[rN+[rM].S]" or "[rN+[rM+].S]". */
if (**cPP == '+')
{
- /* Not the first alternative, must be one of the last
- three. */
int index_reg_number;
(*cPP)++;
--- 2044,2049 ----
*************** get_3op_or_dip_prefix_op (cPP, prefixp)
*** 2028,2033 ****
--- 2120,2151 ----
/* Expression found, so fill in the bits of offset
mode and drop down to check the closing ']'. */
prefixp->kind = PREFIX_BDAP_IMM;
+
+ /* We tentatively put an opcode corresponding to a 32-bit
+ operand here, although it may be relaxed when there's no
+ PIC specifier for the operand. */
+ prefixp->opcode
+ = (BDAP_INDIR_OPCODE
+ | (prefixp->base_reg_number << 12)
+ | (AUTOINCR_BIT << 8)
+ | (2 << 4)
+ | REG_PC /* << 0 */);
+
+ /* This can have a PIC suffix, specifying reloc type to use. */
+ if (pic && **cPP == PIC_SUFFIX_CHAR)
+ {
+ unsigned int relocsize;
+
+ cris_get_pic_suffix (cPP, &prefixp->reloc, &prefixp->expr);
+
+ /* Tweak the size of the immediate operand in the prefix
+ opcode if it isn't what we set. */
+ relocsize = cris_get_pic_reloc_size (prefixp->reloc);
+ if (relocsize != 4)
+ prefixp->opcode
+ = ((prefixp->opcode & ~(3 << 4))
+ | ((relocsize >> 1) << 4));
+ }
}
else
/* Nothing valid here: lose. */
*************** get_3op_or_dip_prefix_op (cPP, prefixp)
*** 2044,2050 ****
{
/* Expression found to make this offset mode, so
fill those bits and drop down to check the
! closing ']'. */
prefixp->kind = PREFIX_BDAP_IMM;
}
}
--- 2162,2171 ----
{
/* Expression found to make this offset mode, so
fill those bits and drop down to check the
! closing ']'.
!
! Note that we don't allow a PIC suffix for
! an operand with a minus sign like this. */
prefixp->kind = PREFIX_BDAP_IMM;
}
}
*************** gen_bdap (base_regno, exprP)
*** 2260,2270 ****
}
}
else
! /* The expression is not defined yet but may become absolute. We make
! it a relocation to be relaxed. */
! frag_var (rs_machine_dependent, 4, 0,
! ENCODE_RELAX (STATE_BASE_PLUS_DISP_PREFIX, STATE_UNDF),
! exprP->X_add_symbol, exprP->X_add_number, opcodep);
}
/* Encode a branch displacement in the range -256..254 into the form used
--- 2381,2400 ----
}
}
else
! {
! /* Handle complex expressions. */
! valueT addvalue
! = exprP->X_op_symbol != NULL ? 0 : exprP->X_add_number;
! symbolS *sym
! = (exprP->X_op_symbol != NULL
! ? make_expr_symbol (exprP) : exprP->X_add_symbol);
!
! /* The expression is not defined yet but may become absolute. We
! make it a relocation to be relaxed. */
! frag_var (rs_machine_dependent, 4, 0,
! ENCODE_RELAX (STATE_BASE_PLUS_DISP_PREFIX, STATE_UNDF),
! sym, addvalue, opcodep);
! }
}
/* Encode a branch displacement in the range -256..254 into the form used
*************** gen_cond_branch_32 (opcodep, writep, fra
*** 2311,2320 ****
long int add_num;
{
if (warn_for_branch_expansion)
! {
! /* FIXME: Find out and change to as_warn_where. Add testcase. */
! as_warn (_("32-bit conditional branch generated"));
! }
/* Here, writep points to what will be opcodep + 2. First, we change
the actual branch in opcodep[0] and opcodep[1], so that in the
--- 2441,2448 ----
long int add_num;
{
if (warn_for_branch_expansion)
! as_warn_where (fragP->fr_file, fragP->fr_line,
! _("32-bit conditional branch generated"));
/* Here, writep points to what will be opcodep + 2. First, we change
the actual branch in opcodep[0] and opcodep[1], so that in the
*************** gen_cond_branch_32 (opcodep, writep, fra
*** 2322,2328 ****
opcodep+10: Bcc .-6
This means we don't have to worry about changing the opcode or
! messing with te delay-slot instruction. So, we move it to last in
the "extended" branch, and just change the displacement. Admittedly,
it's not the optimal extended construct, but we should get this
rarely enough that it shouldn't matter. */
--- 2450,2456 ----
opcodep+10: Bcc .-6
This means we don't have to worry about changing the opcode or
! messing with the delay-slot instruction. So, we move it to last in
the "extended" branch, and just change the displacement. Admittedly,
it's not the optimal extended construct, but we should get this
rarely enough that it shouldn't matter. */
*************** gen_cond_branch_32 (opcodep, writep, fra
*** 2342,2367 ****
md_number_to_chars (writep, NOP_OPCODE, 2);
/* Then the extended thing, the 32-bit jump insn.
! opcodep+4: JUMP [PC+] */
! md_number_to_chars (writep + 2, JUMP_PC_INCR_OPCODE, 2);
/* We have to fill in the actual value too.
opcodep+6: .DWORD
This is most probably an expression, but we can cope with an absolute
! value too. FIXME: Testcase needed. */
if (add_symP == NULL && sub_symP == NULL)
! /* An absolute address. */
! md_number_to_chars (writep + 4, add_num, 4);
else
{
! /* Not absolute, we have to make it a frag for later evaluation. */
! know (sub_symP == 0);
fix_new (fragP, writep + 4 - fragP->fr_literal, 4, add_symP,
! add_num, 0, BFD_RELOC_32);
}
}
/* This *could* be:
--- 2470,2592 ----
md_number_to_chars (writep, NOP_OPCODE, 2);
/* Then the extended thing, the 32-bit jump insn.
! opcodep+4: JUMP [PC+]
! or, in the PIC case,
! opcodep+4: ADD [PC+],PC. */
! md_number_to_chars (writep + 2,
! pic ? ADD_PC_INCR_OPCODE : JUMP_PC_INCR_OPCODE, 2);
/* We have to fill in the actual value too.
opcodep+6: .DWORD
This is most probably an expression, but we can cope with an absolute
! value too. FIXME: Testcase needed with and without pic. */
if (add_symP == NULL && sub_symP == NULL)
! {
! /* An absolute address. */
! if (pic)
! fix_new (fragP, writep + 4 - fragP->fr_literal, 4,
! section_symbol (absolute_section),
! add_num, 1, BFD_RELOC_32_PCREL);
! else
! md_number_to_chars (writep + 4, add_num, 4);
! }
else
{
! if (sub_symP != NULL)
! as_bad_where (fragP->fr_file, fragP->fr_line,
! _("Complex expression not supported"));
+ /* Not absolute, we have to make it a frag for later evaluation. */
fix_new (fragP, writep + 4 - fragP->fr_literal, 4, add_symP,
! add_num, pic ? 1 : 0, pic ? BFD_RELOC_32_PCREL : BFD_RELOC_32);
! }
! }
!
! /* Get the size of an immediate-reloc in bytes. Only valid for PIC
! relocs. */
!
! static unsigned int
! cris_get_pic_reloc_size (reloc)
! bfd_reloc_code_real_type reloc;
! {
! return reloc == BFD_RELOC_CRIS_16_GOTPLT || reloc == BFD_RELOC_CRIS_16_GOT
! ? 2 : 4;
! }
!
! /* Store a reloc type at *RELOCP corresponding to the PIC suffix at *CPP.
! Adjust *EXPRP with any addend found after the PIC suffix. */
!
! static void
! cris_get_pic_suffix (cPP, relocp, exprP)
! char **cPP;
! bfd_reloc_code_real_type *relocp;
! expressionS *exprP;
! {
! char *s = *cPP;
! unsigned int i;
! expressionS const_expr;
!
! const struct pic_suffixes_struct
! {
! const char *const suffix;
! unsigned int len;
! bfd_reloc_code_real_type reloc;
! } pic_suffixes[] =
! {
! #undef PICMAP
! #define PICMAP(s, r) {s, sizeof (s) - 1, r}
! /* Keep this in order with longest unambiguous prefix first. */
! PICMAP ("GOTPLT16", BFD_RELOC_CRIS_16_GOTPLT),
! PICMAP ("GOTPLT", BFD_RELOC_CRIS_32_GOTPLT),
! PICMAP ("PLTG", BFD_RELOC_CRIS_32_PLT_GOTREL),
! PICMAP ("PLT", BFD_RELOC_CRIS_32_PLT_PCREL),
! PICMAP ("GOTOFF", BFD_RELOC_CRIS_32_GOTREL),
! PICMAP ("GOT16", BFD_RELOC_CRIS_16_GOT),
! PICMAP ("GOT", BFD_RELOC_CRIS_32_GOT)
! };
!
! /* We've already seen the ':', so consume it. */
! s++;
!
! for (i = 0; i < sizeof (pic_suffixes)/sizeof (pic_suffixes[0]); i++)
! {
! if (strncmp (s, pic_suffixes[i].suffix, pic_suffixes[i].len) == 0
! && ! is_part_of_name (s[pic_suffixes[i].len]))
! {
! /* We have a match. Consume the suffix and set the relocation
! type. */
! s += pic_suffixes[i].len;
!
! /* There can be a constant term appended. If so, we will add it
! to *EXPRP. */
! if (*s == '+' || *s == '-')
! {
! if (! cris_get_expression (&s, &const_expr))
! /* There was some kind of syntax error. Bail out. */
! break;
!
! /* Allow complex expressions as the constant part. It still
! has to be a assembly-time constant or there will be an
! error emitting the reloc. This makes the PIC qualifiers
! idempotent; foo:GOT+32 == foo+32:GOT. The former we
! recognize here; the latter is parsed in the incoming
! expression. */
! exprP->X_add_symbol = make_expr_symbol (exprP);
! exprP->X_op = O_add;
! exprP->X_add_number = 0;
! exprP->X_op_symbol = make_expr_symbol (&const_expr);
! }
!
! *relocp = pic_suffixes[i].reloc;
! *cPP = s;
! return;
! }
}
+
+ /* No match. Don't consume anything; fall back and there will be a
+ syntax error. */
}
/* This *could* be:
*************** md_atof (type, litp, sizep)
*** 2406,2419 ****
n The number of bytes in "val" that should be stored.
! fixP The fix to be applied to the bit field starting at bufp. */
static void
! cris_number_to_imm (bufp, val, n, fixP)
char *bufp;
long val;
int n;
fixS *fixP;
{
segT sym_seg;
--- 2631,2647 ----
n The number of bytes in "val" that should be stored.
! fixP The fix to be applied to the bit field starting at bufp.
+ seg The segment containing this number. */
+
static void
! cris_number_to_imm (bufp, val, n, fixP, seg)
char *bufp;
long val;
int n;
fixS *fixP;
+ segT seg;
{
segT sym_seg;
*************** cris_number_to_imm (bufp, val, n, fixP)
*** 2425,2433 ****
uninteresting old version) for the relocation.
Maybe delete some day. */
if (fixP->fx_addsy
! && (sym_seg = S_GET_SEGMENT (fixP->fx_addsy)) != now_seg)
val += sym_seg->vma;
switch (fixP->fx_r_type)
{
/* Ditto here, we put the addend into the object code as
--- 2653,2674 ----
uninteresting old version) for the relocation.
Maybe delete some day. */
if (fixP->fx_addsy
! && (sym_seg = S_GET_SEGMENT (fixP->fx_addsy)) != seg)
val += sym_seg->vma;
+ if (fixP->fx_addsy != NULL || fixP->fx_pcrel)
+ switch (fixP->fx_r_type)
+ {
+ /* These must be fully resolved when getting here. */
+ case BFD_RELOC_32_PCREL:
+ case BFD_RELOC_16_PCREL:
+ case BFD_RELOC_8_PCREL:
+ as_bad_where (fixP->fx_frag->fr_file, fixP->fx_frag->fr_line,
+ _("PC-relative relocation must be trivially resolved"));
+ default:
+ ;
+ }
+
switch (fixP->fx_r_type)
{
/* Ditto here, we put the addend into the object code as
*************** cris_number_to_imm (bufp, val, n, fixP)
*** 2435,2441 ****
--- 2676,2694 ----
regression tests on the object file contents. FIXME: Seems
uninteresting now that we have a test suite. */
+ case BFD_RELOC_CRIS_16_GOT:
+ case BFD_RELOC_CRIS_32_GOT:
+ case BFD_RELOC_CRIS_32_GOTREL:
+ case BFD_RELOC_CRIS_16_GOTPLT:
+ case BFD_RELOC_CRIS_32_GOTPLT:
+ case BFD_RELOC_CRIS_32_PLT_GOTREL:
+ case BFD_RELOC_CRIS_32_PLT_PCREL:
+ /* We don't want to put in any kind of non-zero bits in the data
+ being relocated for these. */
+ break;
+
case BFD_RELOC_32:
+ case BFD_RELOC_32_PCREL:
/* No use having warnings here, since most hosts have a 32-bit type
for "long" (which will probably change soon, now that I wrote
this). */
*************** cris_number_to_imm (bufp, val, n, fixP)
*** 2452,2457 ****
--- 2705,2711 ----
or should we change them into as_bad_where? */
case BFD_RELOC_16:
+ case BFD_RELOC_16_PCREL:
if (val > 0xffff || val < -32768)
as_bad (_("Value not in 16 bit range: %ld"), val);
if (! fixP->fx_addsy)
*************** cris_number_to_imm (bufp, val, n, fixP)
*** 2462,2467 ****
--- 2716,2722 ----
break;
case BFD_RELOC_8:
+ case BFD_RELOC_8_PCREL:
if (val > 255 || val < -128)
as_bad (_("Value not in 8 bit range: %ld"), val);
if (! fixP->fx_addsy)
*************** md_parse_option (arg, argp)
*** 2551,2557 ****
demand_register_prefix = true;
if (OUTPUT_FLAVOR == bfd_target_aout_flavour)
! as_bad (_("--no-underscore is invalid with a.out format"), arg);
else
symbols_have_leading_underscore = false;
return 1;
--- 2806,2812 ----
demand_register_prefix = true;
if (OUTPUT_FLAVOR == bfd_target_aout_flavour)
! as_bad (_("--no-underscore is invalid with a.out format"));
else
symbols_have_leading_underscore = false;
return 1;
*************** md_parse_option (arg, argp)
*** 2561,2566 ****
--- 2816,2825 ----
symbols_have_leading_underscore = true;
return 1;
+ case OPTION_PIC:
+ pic = true;
+ return 1;
+
default:
return 0;
}
*************** tc_gen_reloc (section, fixP)
*** 2607,2612 ****
--- 2866,2878 ----
switch (fixP->fx_r_type)
{
+ case BFD_RELOC_CRIS_16_GOT:
+ case BFD_RELOC_CRIS_32_GOT:
+ case BFD_RELOC_CRIS_16_GOTPLT:
+ case BFD_RELOC_CRIS_32_GOTPLT:
+ case BFD_RELOC_CRIS_32_GOTREL:
+ case BFD_RELOC_CRIS_32_PLT_GOTREL:
+ case BFD_RELOC_CRIS_32_PLT_PCREL:
case BFD_RELOC_32:
case BFD_RELOC_16:
case BFD_RELOC_8:
*************** void
*** 2683,2688 ****
--- 2949,2955 ----
md_show_usage (stream)
FILE *stream;
{
+ /* The messages are formatted to line up with the generic options. */
fprintf (stream, _("CRIS-specific options:\n"));
fprintf (stream, "%s",
_(" -h, -H Don't execute, print this help text. Deprecated.\n"));
*************** md_show_usage (stream)
*** 2696,2710 ****
_(" --no-underscore User symbols do not have any prefix.\n"));
fprintf (stream, "%s",
_(" Registers will require a `$'-prefix.\n"));
}
/* Apply a fixS (fixup of an instruction or data that we didn't have
enough info to complete immediately) to the data in a frag. */
int
! md_apply_fix (fixP, valP)
fixS *fixP;
valueT *valP;
{
long val = *valP;
--- 2963,2980 ----
_(" --no-underscore User symbols do not have any prefix.\n"));
fprintf (stream, "%s",
_(" Registers will require a `$'-prefix.\n"));
+ fprintf (stream, "%s",
+ _(" --pic Enable generation of position-independent code.\n"));
}
/* Apply a fixS (fixup of an instruction or data that we didn't have
enough info to complete immediately) to the data in a frag. */
int
! md_apply_fix3 (fixP, valP, seg)
fixS *fixP;
valueT *valP;
+ segT seg;
{
long val = *valP;
*************** md_apply_fix (fixP, valP)
*** 2734,2740 ****
}
}
! cris_number_to_imm (buf, val, fixP->fx_size, fixP);
}
return 1;
--- 3004,3010 ----
}
}
! cris_number_to_imm (buf, val, fixP->fx_size, fixP, seg);
}
return 1;
*************** md_pcrel_from (fixP)
*** 2750,2761 ****
valueT addr = fixP->fx_where + fixP->fx_frag->fr_address;
/* FIXME: We get here only at the end of assembly, when X in ".-X" is
! still unknown. Since we don't have pc-relative relocations, this
! is invalid. What to do if anything for a.out, is to add
pc-relative relocations everywhere including the elinux program
! loader. */
! as_bad_where (fixP->fx_file, fixP->fx_line,
! _("Invalid pc-relative relocation"));
return fixP->fx_size + addr;
}
--- 3020,3036 ----
valueT addr = fixP->fx_where + fixP->fx_frag->fr_address;
/* FIXME: We get here only at the end of assembly, when X in ".-X" is
! still unknown. Since we don't have pc-relative relocations in a.out,
! this is invalid. What to do if anything for a.out, is to add
pc-relative relocations everywhere including the elinux program
! loader. For ELF, allow straight-forward PC-relative relocations,
! which are always relative to the location after the relocation. */
! if (OUTPUT_FLAVOR != bfd_target_elf_flavour
! || (fixP->fx_r_type != BFD_RELOC_8_PCREL
! && fixP->fx_r_type != BFD_RELOC_16_PCREL
! && fixP->fx_r_type != BFD_RELOC_32_PCREL))
! as_bad_where (fixP->fx_file, fixP->fx_line,
! _("Invalid pc-relative relocation"));
return fixP->fx_size + addr;
}
*************** int
*** 2775,2783 ****
md_cris_force_relocation (fixp)
struct fix *fixp;
{
! if (fixp->fx_r_type == BFD_RELOC_VTABLE_INHERIT
! || fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
! return 1;
return 0;
}
--- 3050,3071 ----
md_cris_force_relocation (fixp)
struct fix *fixp;
{
! switch (fixp->fx_r_type)
! {
! case BFD_RELOC_VTABLE_INHERIT:
! case BFD_RELOC_VTABLE_ENTRY:
! case BFD_RELOC_CRIS_16_GOT:
! case BFD_RELOC_CRIS_32_GOT:
! case BFD_RELOC_CRIS_16_GOTPLT:
! case BFD_RELOC_CRIS_32_GOTPLT:
! case BFD_RELOC_CRIS_32_GOTREL:
! case BFD_RELOC_CRIS_32_PLT_GOTREL:
! case BFD_RELOC_CRIS_32_PLT_PCREL:
! return 1;
! default:
! ;
! }
!
return 0;
}
Index: tc-cris.h
===================================================================
RCS file: /cvs/src/src/gas/config/tc-cris.h,v
retrieving revision 1.3
diff -p -c -r1.3 tc-cris.h
*** tc-cris.h 2001/03/08 23:24:23 1.3
--- tc-cris.h 2001/03/23 04:21:54
***************
*** 1,9 ****
/* tc-cris.h -- Header file for tc-cris.c, the CRIS GAS port.
! Copyright 2000 Free Software Foundation, Inc.
Contributed by Axis Communications AB, Lund, Sweden.
Originally written for GAS 1.38.1 by Mikael Asker.
! Updated, BFDized and GNUified by Hans-Peter Nilsson.
This file is part of GAS, the GNU Assembler.
--- 1,9 ----
/* tc-cris.h -- Header file for tc-cris.c, the CRIS GAS port.
! Copyright 2000, 2001 Free Software Foundation, Inc.
Contributed by Axis Communications AB, Lund, Sweden.
Originally written for GAS 1.38.1 by Mikael Asker.
! Updates, BFDizing, GNUifying and ELF by Hans-Peter Nilsson.
This file is part of GAS, the GNU Assembler.
*************** extern const struct relax_type md_cris_r
*** 80,101 ****
#define TC_FORCE_RELOCATION(fixp) md_cris_force_relocation (fixp)
extern int md_cris_force_relocation PARAMS ((struct fix *));
/* This is really a workaround for a bug in write.c that resolves relocs
for weak symbols - it should be postponed to the link stage or later.
! */
#define tc_fix_adjustable(X) \
! ((! (X)->fx_addsy || ! S_IS_WEAK((X)->fx_addsy)) \
&& (X)->fx_r_type != BFD_RELOC_VTABLE_INHERIT \
&& (X)->fx_r_type != BFD_RELOC_VTABLE_ENTRY)
/* When we have fixups against constant expressions, we get a GAS-specific
section symbol at no extra charge for obscure reasons in
adjust_reloc_syms. Since ELF outputs section symbols, it gladly
! outputs this "*ABS*" symbol in every object. Avoid that. */
#define tc_frob_symbol(symp, punt) \
do { \
! if (OUTPUT_FLAVOR == bfd_target_elf_flavour \
! && (symp) == section_symbol (absolute_section)) \
(punt) = 1; \
} while (0)
--- 80,131 ----
#define TC_FORCE_RELOCATION(fixp) md_cris_force_relocation (fixp)
extern int md_cris_force_relocation PARAMS ((struct fix *));
+ #define MD_APPLY_FIX3
+
+ #define IS_CRIS_PIC_RELOC(X) \
+ ((X) == BFD_RELOC_CRIS_16_GOT \
+ || (X) == BFD_RELOC_CRIS_32_GOT \
+ || (X) == BFD_RELOC_CRIS_16_GOTPLT \
+ || (X) == BFD_RELOC_CRIS_32_GOTPLT \
+ || (X) == BFD_RELOC_CRIS_32_GOTREL \
+ || (X) == BFD_RELOC_CRIS_32_PLT_GOTREL \
+ || (X) == BFD_RELOC_CRIS_32_PLT_PCREL)
+
+
+ /* FIXME: Undocumented macro. Make sure we don't resolve fixups for which
+ we want to emit dynamic relocations. */
+
+ #define TC_RELOC_RTSYM_LOC_FIXUP(FIX) \
+ ((FIX)->fx_addsy == NULL \
+ || (! S_IS_EXTERNAL ((FIX)->fx_addsy) \
+ && ! S_IS_WEAK ((FIX)->fx_addsy) \
+ && S_IS_DEFINED ((FIX)->fx_addsy) \
+ && ! S_IS_COMMON ((FIX)->fx_addsy) \
+ /* FIXME: Set fx_plt instead of this check. */ \
+ && ! IS_CRIS_PIC_RELOC ((FIX)->fx_r_type)))
+
/* This is really a workaround for a bug in write.c that resolves relocs
for weak symbols - it should be postponed to the link stage or later.
! Also don't adjust fixups for global symbols for ELF. */
#define tc_fix_adjustable(X) \
! (((X)->fx_addsy == NULL \
! || (! S_IS_WEAK ((X)->fx_addsy) \
! && ! (OUTPUT_FLAVOR == bfd_target_elf_flavour \
! && S_IS_EXTERNAL ((X)->fx_addsy)))) \
&& (X)->fx_r_type != BFD_RELOC_VTABLE_INHERIT \
&& (X)->fx_r_type != BFD_RELOC_VTABLE_ENTRY)
/* When we have fixups against constant expressions, we get a GAS-specific
section symbol at no extra charge for obscure reasons in
adjust_reloc_syms. Since ELF outputs section symbols, it gladly
! outputs this "*ABS*" symbol in every object. Avoid that.
! Also, don't emit undefined symbols (that aren't used in relocations).
! They pop up when tentatively parsing register names as symbols. */
#define tc_frob_symbol(symp, punt) \
do { \
! if ((OUTPUT_FLAVOR == bfd_target_elf_flavour \
! && (symp) == section_symbol (absolute_section)) \
! || ! S_IS_DEFINED (symp)) \
(punt) = 1; \
} while (0)
brgds, H-P