/* tc-ppc.c -- Assemble for the PowerPC or POWER (RS/6000)
- Copyright (C) 1994, 1995, 1996, 1997, 1998 Free Software Foundation, Inc.
+ Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000
+ Free Software Foundation, Inc.
Written by Ian Lance Taylor, Cygnus Support.
This file is part of GAS, the GNU Assembler.
static void ppc_rename PARAMS ((int));
static void ppc_toc PARAMS ((int));
static void ppc_xcoff_cons PARAMS ((int));
+static void ppc_machine PARAMS ((int));
static void ppc_vbyte PARAMS ((int));
#endif
{ "text", ppc_section, 't' },
{ "toc", ppc_toc, 0 },
{ "long", ppc_xcoff_cons, 2 },
+ { "llong", ppc_xcoff_cons, 3 },
{ "word", ppc_xcoff_cons, 1 },
{ "short", ppc_xcoff_cons, 1 },
{ "vbyte", ppc_vbyte, 0 },
+ { "machine", ppc_machine, 0 },
#endif
#ifdef OBJ_ELF
1. r<reg_num> which has the value <reg_num>.
2. r.<reg_num> which has the value <reg_num>.
-
Each floating point register has predefined names of the form:
1. f<reg_num> which has the value <reg_num>.
2. f.<reg_num> which has the value <reg_num>.
+ Each vector unit register has predefined names of the form:
+ 1. v<reg_num> which has the value <reg_num>.
+ 2. v.<reg_num> which has the value <reg_num>.
+
Each condition register has predefined names of the form:
1. cr<reg_num> which has the value <reg_num>.
2. cr.<reg_num> which has the value <reg_num>.
{ "srr0", 26 }, /* Machine Status Save/Restore Register 0 */
{ "srr1", 27 }, /* Machine Status Save/Restore Register 1 */
+
+ { "v.0", 0 }, /* Vector registers */
+ { "v.1", 1 },
+ { "v.10", 10 },
+ { "v.11", 11 },
+ { "v.12", 12 },
+ { "v.13", 13 },
+ { "v.14", 14 },
+ { "v.15", 15 },
+ { "v.16", 16 },
+ { "v.17", 17 },
+ { "v.18", 18 },
+ { "v.19", 19 },
+ { "v.2", 2 },
+ { "v.20", 20 },
+ { "v.21", 21 },
+ { "v.22", 22 },
+ { "v.23", 23 },
+ { "v.24", 24 },
+ { "v.25", 25 },
+ { "v.26", 26 },
+ { "v.27", 27 },
+ { "v.28", 28 },
+ { "v.29", 29 },
+ { "v.3", 3 },
+ { "v.30", 30 },
+ { "v.31", 31 },
+ { "v.4", 4 },
+ { "v.5", 5 },
+ { "v.6", 6 },
+ { "v.7", 7 },
+ { "v.8", 8 },
+ { "v.9", 9 },
+
+ { "v0", 0 },
+ { "v1", 1 },
+ { "v10", 10 },
+ { "v11", 11 },
+ { "v12", 12 },
+ { "v13", 13 },
+ { "v14", 14 },
+ { "v15", 15 },
+ { "v16", 16 },
+ { "v17", 17 },
+ { "v18", 18 },
+ { "v19", 19 },
+ { "v2", 2 },
+ { "v20", 20 },
+ { "v21", 21 },
+ { "v22", 22 },
+ { "v23", 23 },
+ { "v24", 24 },
+ { "v25", 25 },
+ { "v26", 26 },
+ { "v27", 27 },
+ { "v28", 28 },
+ { "v29", 29 },
+ { "v3", 3 },
+ { "v30", 30 },
+ { "v31", 31 },
+ { "v4", 4 },
+ { "v5", 5 },
+ { "v6", 6 },
+ { "v7", 7 },
+ { "v8", 8 },
+ { "v9", 9 },
{ "xer", 1 },
/* The size of the processor we are assembling for. This is either
PPC_OPCODE_32 or PPC_OPCODE_64. */
-static int ppc_size = PPC_OPCODE_32;
+static unsigned long ppc_size = PPC_OPCODE_32;
+
+/* Whether to target xcoff64 */
+static int ppc_xcoff64 = 0;
/* Opcode hash table. */
static struct hash_control *ppc_hash;
break;
#endif
+ /* a64 and a32 determine whether to use XCOFF64 or XCOFF32. */
+ case 'a':
+ if (strcmp (arg, "64") == 0)
+ ppc_xcoff64 = 1;
+ else if (strcmp (arg, "32") == 0)
+ ppc_xcoff64 = 0;
+ else
+ return 0;
+ break;
+
case 'm':
/* -mpwrx and -mpwr2 mean to assemble for the IBM POWER/2
(RIOS2). */
|| strcmp (arg, "603") == 0
|| strcmp (arg, "604") == 0)
ppc_cpu = PPC_OPCODE_PPC;
+ else if (strcmp (arg, "7400") == 0)
+ ppc_cpu = PPC_OPCODE_PPC | PPC_OPCODE_ALTIVEC;
/* -mppc64 and -m620 mean to assemble for the 64-bit PowerPC
620. */
else if (strcmp (arg, "ppc64") == 0 || strcmp (arg, "620") == 0)
ppc_cpu = PPC_OPCODE_PPC;
ppc_size = PPC_OPCODE_64;
}
+ else if (strcmp (arg, "ppc64bridge") == 0)
+ {
+ ppc_cpu = PPC_OPCODE_PPC | PPC_OPCODE_64_BRIDGE;
+ ppc_size = PPC_OPCODE_64;
+ }
/* -mcom means assemble for the common intersection between Power
and PowerPC. At present, we just allow the union, rather
than the intersection. */
-mppc, -mppc32, -m403, -m603, -m604\n\
generate code for Motorola PowerPC 603/604\n\
-mppc64, -m620 generate code for Motorola PowerPC 620\n\
+-mppc64bridge generate code for PowerPC 64, including bridge insns\n\
-mcom generate code Power/PowerPC common instructions\n\
-many generate code for any architecture (PWR/PWRX/PPC)\n\
-mregnames Allow symbolic names for registers\n\
return bfd_arch_unknown;
}
+unsigned long
+ppc_mach ()
+{
+ return (ppc_size == PPC_OPCODE_64) ? 620 : 0;
+}
+
+int
+ppc_subseg_align()
+{
+ return (ppc_xcoff64) ? 3 : 2;
+}
+
+extern char*
+ppc_target_format()
+{
+#ifdef OBJ_COFF
+#ifdef TE_PE
+ return (target_big_endian ? "pe-powerpc" : "pe-powerpcle");
+#elif TE_POWERMAC
+#else
+ return (ppc_xcoff64 ? "aixcoff64-rs6000" : "aixcoff-rs6000");
+#endif
+#ifdef TE_POWERMAC
+ return "xcoff-powermac";
+#endif
+#endif
+#ifdef OBJ_ELF
+ return (target_big_endian ? "elf32-powerpc" : "elf32-powerpcle");
+#endif
+}
+
/* This function is called when the assembler starts up. It is called
after the options have been parsed and the output file has been
opened. */
if ((op->flags & ppc_cpu) != 0
&& ((op->flags & (PPC_OPCODE_32 | PPC_OPCODE_64)) == 0
- || (op->flags & (PPC_OPCODE_32 | PPC_OPCODE_64)) == ppc_size))
+ || (op->flags & (PPC_OPCODE_32 | PPC_OPCODE_64)) == ppc_size
+ || (ppc_cpu & PPC_OPCODE_64_BRIDGE) != 0))
{
const char *retval;
text csects to precede the data csects. These symbols will not
be output. */
ppc_text_csects = symbol_make ("dummy\001");
- ppc_text_csects->sy_tc.within = ppc_text_csects;
+ symbol_get_tc (ppc_text_csects)->within = ppc_text_csects;
ppc_data_csects = symbol_make ("dummy\001");
- ppc_data_csects->sy_tc.within = ppc_data_csects;
+ symbol_get_tc (ppc_data_csects)->within = ppc_data_csects;
#endif
#ifdef TE_PE
if ((operand->flags & PPC_OPERAND_SIGNED) != 0)
{
- if ((operand->flags & PPC_OPERAND_SIGNOPT) != 0
- && ppc_size == PPC_OPCODE_32)
+ if ((operand->flags & PPC_OPERAND_SIGNOPT) != 0)
max = (1 << operand->bits) - 1;
else
max = (1 << (operand->bits - 1)) - 1;
valid, but, to permit this code to assemble on a 64
bit host, we sign extend the 32 bit value. */
if (val > 0
- && (val & 0x80000000) != 0
- && (val & 0xffffffff) == val)
+ && (val & (offsetT) 0x80000000) != 0
+ && (val & (offsetT) 0xffffffff) == val)
{
val -= 0x80000000;
val -= 0x80000000;
/* Pseudo op to make file scope bss items */
static void
ppc_elf_lcomm(xxx)
- int xxx;
+ int xxx ATTRIBUTE_UNUSED;
{
register char *name;
register char c;
if (align2)
frag_align (align2, 0, 0);
if (S_GET_SEGMENT (symbolP) == bss_section)
- symbolP->sy_frag->fr_symbol = 0;
- symbolP->sy_frag = frag_now;
+ symbol_get_frag (symbolP)->fr_symbol = 0;
+ symbol_set_frag (symbolP, frag_now);
pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP, size,
(char *) 0);
*pfrag = 0;
if (ex.X_op == O_symbol)
{
assert (ex.X_add_symbol != NULL);
- if (ex.X_add_symbol->bsym->section != tocdata_section)
+ if (symbol_get_bfdsym (ex.X_add_symbol)->section
+ != tocdata_section)
{
as_bad(_("[tocv] symbol is not a toc symbol"));
}
break;
case BFD_RELOC_HI16_S:
- ex.X_add_number = (((ex.X_add_number >> 16) & 0xffff)
- + ((ex.X_add_number >> 15) & 1));
+ ex.X_add_number = ((((ex.X_add_number >> 16) & 0xffff)
+ + ((ex.X_add_number >> 15) & 1))
+ & 0xffff);
break;
}
#endif
}
int
-ppc_section_word (ptr_str)
- char **ptr_str;
+ppc_section_word (str, len)
+ char *str;
+ size_t len;
{
- if (strncmp (*ptr_str, "exclude", sizeof ("exclude")-1) == 0)
- {
- *ptr_str += sizeof ("exclude")-1;
- return SHF_EXCLUDE;
- }
+ if (len == 7 && strncmp (str, "exclude", 7) == 0)
+ return SHF_EXCLUDE;
- return 0;
+ return -1;
}
int
-ppc_section_type (ptr_str)
- char **ptr_str;
+ppc_section_type (str, len)
+ char *str;
+ size_t len;
{
- if (strncmp (*ptr_str, "ordered", sizeof ("ordered")-1) == 0)
- {
- *ptr_str += sizeof ("ordered")-1;
- return SHT_ORDERED;
- }
+ if (len == 7 && strncmp (str, "ordered", 7) == 0)
+ return SHT_ORDERED;
- return 0;
+ return -1;
}
int
static void
ppc_byte (ignore)
- int ignore;
+ int ignore ATTRIBUTE_UNUSED;
{
if (*input_line_pointer != '\"')
{
}
else
{
- lcomm_sym->sy_tc.output = 1;
+ symbol_get_tc (lcomm_sym)->output = 1;
def_sym = lcomm_sym;
def_size = 0;
}
subseg_set (bss_section, 1);
frag_align (align, 0, 0);
- def_sym->sy_frag = frag_now;
+ symbol_set_frag (def_sym, frag_now);
pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, def_sym,
def_size, (char *) NULL);
*pfrag = 0;
S_SET_SEGMENT (def_sym, bss_section);
- def_sym->sy_tc.align = align;
+ symbol_get_tc (def_sym)->align = align;
}
else if (lcomm)
{
/* Align the size of lcomm_sym. */
- lcomm_sym->sy_frag->fr_offset =
- ((lcomm_sym->sy_frag->fr_offset + (1 << align) - 1)
+ symbol_get_frag (lcomm_sym)->fr_offset =
+ ((symbol_get_frag (lcomm_sym)->fr_offset + (1 << align) - 1)
&~ ((1 << align) - 1));
- if (align > lcomm_sym->sy_tc.align)
- lcomm_sym->sy_tc.align = align;
+ if (align > symbol_get_tc (lcomm_sym)->align)
+ symbol_get_tc (lcomm_sym)->align = align;
}
if (lcomm)
{
/* Make sym an offset from lcomm_sym. */
S_SET_SEGMENT (sym, bss_section);
- sym->sy_frag = lcomm_sym->sy_frag;
- S_SET_VALUE (sym, lcomm_sym->sy_frag->fr_offset);
- lcomm_sym->sy_frag->fr_offset += size;
+ symbol_set_frag (sym, symbol_get_frag (lcomm_sym));
+ S_SET_VALUE (sym, symbol_get_frag (lcomm_sym)->fr_offset);
+ symbol_get_frag (lcomm_sym)->fr_offset += size;
}
subseg_set (current_seg, current_subseg);
static void
ppc_csect (ignore)
- int ignore;
+ int ignore ATTRIBUTE_UNUSED;
{
char *name;
char endc;
if (S_GET_NAME (sym)[0] == '\0')
{
/* An unnamed csect is assumed to be [PR]. */
- sym->sy_tc.class = XMC_PR;
+ symbol_get_tc (sym)->class = XMC_PR;
}
ppc_change_csect (sym);
if (*input_line_pointer == ',')
{
++input_line_pointer;
- sym->sy_tc.align = get_absolute_expression ();
+ symbol_get_tc (sym)->align = get_absolute_expression ();
}
demand_empty_rest_of_line ();
symbolS *sym;
{
if (S_IS_DEFINED (sym))
- subseg_set (S_GET_SEGMENT (sym), sym->sy_tc.subseg);
+ subseg_set (S_GET_SEGMENT (sym), symbol_get_tc (sym)->subseg);
else
{
symbolS **list_ptr;
figure out whether it should go in the text section or the
data section. */
after_toc = 0;
- switch (sym->sy_tc.class)
+ switch (symbol_get_tc (sym)->class)
{
case XMC_PR:
case XMC_RO:
case XMC_TI:
case XMC_TB:
S_SET_SEGMENT (sym, text_section);
- sym->sy_tc.subseg = ppc_text_subsegment;
+ symbol_get_tc (sym)->subseg = ppc_text_subsegment;
++ppc_text_subsegment;
list_ptr = &ppc_text_csects;
break;
case XMC_BS:
case XMC_UC:
if (ppc_toc_csect != NULL
- && ppc_toc_csect->sy_tc.subseg + 1 == ppc_data_subsegment)
+ && (symbol_get_tc (ppc_toc_csect)->subseg + 1
+ == ppc_data_subsegment))
after_toc = 1;
S_SET_SEGMENT (sym, data_section);
- sym->sy_tc.subseg = ppc_data_subsegment;
+ symbol_get_tc (sym)->subseg = ppc_data_subsegment;
++ppc_data_subsegment;
list_ptr = &ppc_data_csects;
break;
hold_chunksize = chunksize;
chunksize = 64;
- subseg_new (segment_name (S_GET_SEGMENT (sym)), sym->sy_tc.subseg);
+ subseg_new (segment_name (S_GET_SEGMENT (sym)),
+ symbol_get_tc (sym)->subseg);
chunksize = hold_chunksize;
if (after_toc)
ppc_after_toc_frag = frag_now;
- sym->sy_frag = frag_now;
+ symbol_set_frag (sym, frag_now);
S_SET_VALUE (sym, (valueT) frag_now_fix ());
- sym->sy_tc.align = 2;
- sym->sy_tc.output = 1;
- sym->sy_tc.within = sym;
+ symbol_get_tc (sym)->align = (ppc_xcoff64) ? 3 : 2;
+ symbol_get_tc (sym)->output = 1;
+ symbol_get_tc (sym)->within = sym;
for (list = *list_ptr;
- list->sy_tc.next != (symbolS *) NULL;
- list = list->sy_tc.next)
+ symbol_get_tc (list)->next != (symbolS *) NULL;
+ list = symbol_get_tc (list)->next)
;
- list->sy_tc.next = sym;
+ symbol_get_tc (list)->next = sym;
symbol_remove (sym, &symbol_rootP, &symbol_lastP);
- symbol_append (sym, list->sy_tc.within, &symbol_rootP, &symbol_lastP);
+ symbol_append (sym, symbol_get_tc (list)->within, &symbol_rootP,
+ &symbol_lastP);
}
ppc_current_csect = sym;
static void
ppc_named_section (ignore)
- int ignore;
+ int ignore ATTRIBUTE_UNUSED;
{
char *user_name;
const char *real_name;
static void
ppc_extern (ignore)
- int ignore;
+ int ignore ATTRIBUTE_UNUSED;
{
char *name;
char endc;
static void
ppc_lglobl (ignore)
- int ignore;
+ int ignore ATTRIBUTE_UNUSED;
{
char *name;
char endc;
*input_line_pointer = endc;
- sym->sy_tc.output = 1;
+ symbol_get_tc (sym)->output = 1;
demand_empty_rest_of_line ();
}
static void
ppc_rename (ignore)
- int ignore;
+ int ignore ATTRIBUTE_UNUSED;
{
char *name;
char endc;
}
++input_line_pointer;
- sym->sy_tc.real_name = demand_copy_C_string (&len);
+ symbol_get_tc (sym)->real_name = demand_copy_C_string (&len);
demand_empty_rest_of_line ();
}
static void
ppc_stabx (ignore)
- int ignore;
+ int ignore ATTRIBUTE_UNUSED;
{
char *name;
int len;
sym = symbol_make (name);
ppc_stab_symbol = false;
- sym->sy_tc.real_name = name;
+ symbol_get_tc (sym)->real_name = name;
(void) expression (&exp);
/* Fall through. */
case O_constant:
S_SET_VALUE (sym, (valueT) exp.X_add_number);
- sym->sy_frag = &zero_address_frag;
+ symbol_set_frag (sym, &zero_address_frag);
break;
case O_symbol:
if (S_GET_SEGMENT (exp.X_add_symbol) == undefined_section)
- sym->sy_value = exp;
+ symbol_set_value_expression (sym, &exp);
else
{
S_SET_VALUE (sym,
exp.X_add_number + S_GET_VALUE (exp.X_add_symbol));
- sym->sy_frag = exp.X_add_symbol->sy_frag;
+ symbol_set_frag (sym, symbol_get_frag (exp.X_add_symbol));
}
break;
/* The value is some complex expression. This will probably
fail at some later point, but this is probably the right
thing to do here. */
- sym->sy_value = exp;
+ symbol_set_value_expression (sym, &exp);
break;
}
S_SET_SEGMENT (sym, ppc_coff_debug_section);
- sym->bsym->flags |= BSF_DEBUGGING;
+ symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
if (*input_line_pointer != ',')
{
S_SET_DATA_TYPE (sym, get_absolute_expression ());
- sym->sy_tc.output = 1;
+ symbol_get_tc (sym)->output = 1;
if (S_GET_STORAGE_CLASS (sym) == C_STSYM)
- sym->sy_tc.within = ppc_current_block;
+ symbol_get_tc (sym)->within = ppc_current_block;
if (exp.X_op != O_symbol
|| ! S_IS_EXTERNAL (exp.X_add_symbol)
{
symbol_remove (sym, &symbol_rootP, &symbol_lastP);
symbol_append (sym, exp.X_add_symbol, &symbol_rootP, &symbol_lastP);
- if (ppc_current_csect->sy_tc.within == exp.X_add_symbol)
- ppc_current_csect->sy_tc.within = sym;
+ if (symbol_get_tc (ppc_current_csect)->within == exp.X_add_symbol)
+ symbol_get_tc (ppc_current_csect)->within = sym;
}
demand_empty_rest_of_line ();
static void
ppc_function (ignore)
- int ignore;
+ int ignore ATTRIBUTE_UNUSED;
{
char *name;
char endc;
if (ext_sym != lab_sym)
{
- ext_sym->sy_value.X_op = O_symbol;
- ext_sym->sy_value.X_add_symbol = lab_sym;
- ext_sym->sy_value.X_op_symbol = NULL;
- ext_sym->sy_value.X_add_number = 0;
+ expressionS exp;
+
+ exp.X_op = O_symbol;
+ exp.X_add_symbol = lab_sym;
+ exp.X_op_symbol = NULL;
+ exp.X_add_number = 0;
+ exp.X_unsigned = 0;
+ symbol_set_value_expression (ext_sym, &exp);
}
- if (ext_sym->sy_tc.class == -1)
- ext_sym->sy_tc.class = XMC_PR;
- ext_sym->sy_tc.output = 1;
+ if (symbol_get_tc (ext_sym)->class == -1)
+ symbol_get_tc (ext_sym)->class = XMC_PR;
+ symbol_get_tc (ext_sym)->output = 1;
if (*input_line_pointer == ',')
{
{
/* The fifth argument is the function size. */
++input_line_pointer;
- ext_sym->sy_tc.size = symbol_new ("L0\001",
- absolute_section,
- (valueT) 0,
- &zero_address_frag);
- pseudo_set (ext_sym->sy_tc.size);
+ symbol_get_tc (ext_sym)->size = symbol_new ("L0\001",
+ absolute_section,
+ (valueT) 0,
+ &zero_address_frag);
+ pseudo_set (symbol_get_tc (ext_sym)->size);
}
}
}
static void
ppc_bf (ignore)
- int ignore;
+ int ignore ATTRIBUTE_UNUSED;
{
symbolS *sym;
sym = symbol_make (".bf");
S_SET_SEGMENT (sym, text_section);
- sym->sy_frag = frag_now;
+ symbol_set_frag (sym, frag_now);
S_SET_VALUE (sym, frag_now_fix ());
S_SET_STORAGE_CLASS (sym, C_FCN);
S_SET_NUMBER_AUXILIARY (sym, 1);
SA_SET_SYM_LNNO (sym, coff_line_base);
- sym->sy_tc.output = 1;
+ symbol_get_tc (sym)->output = 1;
ppc_frob_label (sym);
static void
ppc_ef (ignore)
- int ignore;
+ int ignore ATTRIBUTE_UNUSED;
{
symbolS *sym;
sym = symbol_make (".ef");
S_SET_SEGMENT (sym, text_section);
- sym->sy_frag = frag_now;
+ symbol_set_frag (sym, frag_now);
S_SET_VALUE (sym, frag_now_fix ());
S_SET_STORAGE_CLASS (sym, C_FCN);
S_SET_NUMBER_AUXILIARY (sym, 1);
SA_SET_SYM_LNNO (sym, get_absolute_expression ());
- sym->sy_tc.output = 1;
+ symbol_get_tc (sym)->output = 1;
ppc_frob_label (sym);
.text section. */
S_SET_SEGMENT (sym, text_section);
S_SET_VALUE (sym, coff_n_line_nos);
- sym->bsym->flags |= BSF_DEBUGGING;
+ symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
S_SET_STORAGE_CLASS (sym, ei ? C_EINCL : C_BINCL);
- sym->sy_tc.output = 1;
+ symbol_get_tc (sym)->output = 1;
for (look = last_biei ? last_biei : symbol_rootP;
(look != (symbolS *) NULL
static void
ppc_bs (ignore)
- int ignore;
+ int ignore ATTRIBUTE_UNUSED;
{
char *name;
char endc;
sym = symbol_make (".bs");
S_SET_SEGMENT (sym, now_seg);
S_SET_STORAGE_CLASS (sym, C_BSTAT);
- sym->bsym->flags |= BSF_DEBUGGING;
- sym->sy_tc.output = 1;
+ symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
+ symbol_get_tc (sym)->output = 1;
- sym->sy_tc.within = csect;
+ symbol_get_tc (sym)->within = csect;
ppc_frob_label (sym);
static void
ppc_es (ignore)
- int ignore;
+ int ignore ATTRIBUTE_UNUSED;
{
symbolS *sym;
sym = symbol_make (".es");
S_SET_SEGMENT (sym, now_seg);
S_SET_STORAGE_CLASS (sym, C_ESTAT);
- sym->bsym->flags |= BSF_DEBUGGING;
- sym->sy_tc.output = 1;
+ symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
+ symbol_get_tc (sym)->output = 1;
ppc_frob_label (sym);
static void
ppc_bb (ignore)
- int ignore;
+ int ignore ATTRIBUTE_UNUSED;
{
symbolS *sym;
sym = symbol_make (".bb");
S_SET_SEGMENT (sym, text_section);
- sym->sy_frag = frag_now;
+ symbol_set_frag (sym, frag_now);
S_SET_VALUE (sym, frag_now_fix ());
S_SET_STORAGE_CLASS (sym, C_BLOCK);
S_SET_NUMBER_AUXILIARY (sym, 1);
SA_SET_SYM_LNNO (sym, get_absolute_expression ());
- sym->sy_tc.output = 1;
+ symbol_get_tc (sym)->output = 1;
SF_SET_PROCESS (sym);
static void
ppc_eb (ignore)
- int ignore;
+ int ignore ATTRIBUTE_UNUSED;
{
symbolS *sym;
sym = symbol_make (".eb");
S_SET_SEGMENT (sym, text_section);
- sym->sy_frag = frag_now;
+ symbol_set_frag (sym, frag_now);
S_SET_VALUE (sym, frag_now_fix ());
S_SET_STORAGE_CLASS (sym, C_BLOCK);
S_SET_NUMBER_AUXILIARY (sym, 1);
SA_SET_SYM_LNNO (sym, get_absolute_expression ());
- sym->sy_tc.output = 1;
+ symbol_get_tc (sym)->output = 1;
SF_SET_PROCESS (sym);
static void
ppc_bc (ignore)
- int ignore;
+ int ignore ATTRIBUTE_UNUSED;
{
char *name;
int len;
name = demand_copy_C_string (&len);
sym = symbol_make (name);
S_SET_SEGMENT (sym, ppc_coff_debug_section);
- sym->bsym->flags |= BSF_DEBUGGING;
+ symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
S_SET_STORAGE_CLASS (sym, C_BCOMM);
S_SET_VALUE (sym, 0);
- sym->sy_tc.output = 1;
+ symbol_get_tc (sym)->output = 1;
ppc_frob_label (sym);
static void
ppc_ec (ignore)
- int ignore;
+ int ignore ATTRIBUTE_UNUSED;
{
symbolS *sym;
sym = symbol_make (".ec");
S_SET_SEGMENT (sym, ppc_coff_debug_section);
- sym->bsym->flags |= BSF_DEBUGGING;
+ symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
S_SET_STORAGE_CLASS (sym, C_ECOMM);
S_SET_VALUE (sym, 0);
- sym->sy_tc.output = 1;
+ symbol_get_tc (sym)->output = 1;
ppc_frob_label (sym);
static void
ppc_toc (ignore)
- int ignore;
+ int ignore ATTRIBUTE_UNUSED;
{
if (ppc_toc_csect != (symbolS *) NULL)
- subseg_set (data_section, ppc_toc_csect->sy_tc.subseg);
+ subseg_set (data_section, symbol_get_tc (ppc_toc_csect)->subseg);
else
{
subsegT subseg;
ppc_toc_frag = frag_now;
sym = symbol_find_or_make ("TOC[TC0]");
- sym->sy_frag = frag_now;
+ symbol_set_frag (sym, frag_now);
S_SET_SEGMENT (sym, data_section);
S_SET_VALUE (sym, (valueT) frag_now_fix ());
- sym->sy_tc.subseg = subseg;
- sym->sy_tc.output = 1;
- sym->sy_tc.within = sym;
+ symbol_get_tc (sym)->subseg = subseg;
+ symbol_get_tc (sym)->output = 1;
+ symbol_get_tc (sym)->within = sym;
ppc_toc_csect = sym;
for (list = ppc_data_csects;
- list->sy_tc.next != (symbolS *) NULL;
- list = list->sy_tc.next)
+ symbol_get_tc (list)->next != (symbolS *) NULL;
+ list = symbol_get_tc (list)->next)
;
- list->sy_tc.next = sym;
+ symbol_get_tc (list)->next = sym;
symbol_remove (sym, &symbol_rootP, &symbol_lastP);
- symbol_append (sym, list->sy_tc.within, &symbol_rootP, &symbol_lastP);
+ symbol_append (sym, symbol_get_tc (list)->within, &symbol_rootP,
+ &symbol_lastP);
}
ppc_current_csect = ppc_toc_csect;
cons (1 << log_size);
}
+static void
+ppc_machine(dummy)
+ int dummy ATTRIBUTE_UNUSED;
+{
+ discard_rest_of_line();
+ /* What does aix use this for? */
+}
+
static void
ppc_vbyte (dummy)
- int dummy;
+ int dummy ATTRIBUTE_UNUSED;
{
expressionS exp;
int byte_count;
static void
ppc_tc (ignore)
- int ignore;
+ int ignore ATTRIBUTE_UNUSED;
{
#ifdef OBJ_XCOFF
{
symbolS *label;
- label = ppc_current_csect->sy_tc.within;
- if (label->sy_tc.class != XMC_TC0)
+ label = symbol_get_tc (ppc_current_csect)->within;
+ if (symbol_get_tc (label)->class != XMC_TC0)
{
as_bad (_(".tc with no label"));
ignore_rest_of_line ();
}
S_SET_SEGMENT (label, S_GET_SEGMENT (sym));
- label->sy_frag = sym->sy_frag;
+ symbol_set_frag (label, symbol_get_frag (sym));
S_SET_VALUE (label, S_GET_VALUE (sym));
while (! is_end_of_line[(unsigned char) *input_line_pointer])
}
S_SET_SEGMENT (sym, now_seg);
- sym->sy_frag = frag_now;
+ symbol_set_frag (sym, frag_now);
S_SET_VALUE (sym, (valueT) frag_now_fix ());
- sym->sy_tc.class = XMC_TC;
- sym->sy_tc.output = 1;
+ symbol_get_tc (sym)->class = XMC_TC;
+ symbol_get_tc (sym)->output = 1;
ppc_frob_label (sym);
}
else
{
++input_line_pointer;
- cons (4);
+ cons ((ppc_size == PPC_OPCODE_64) ? 8 : 4);
}
}
\f
*/
static void
ppc_previous(ignore)
- int ignore;
+ int ignore ATTRIBUTE_UNUSED;
{
symbolS *tmp;
*/
static void
ppc_pdata(ignore)
- int ignore;
+ int ignore ATTRIBUTE_UNUSED;
{
if (pdata_section == 0)
{
*/
static void
ppc_ydata(ignore)
- int ignore;
+ int ignore ATTRIBUTE_UNUSED;
{
if (ydata_section == 0)
{
*/
static void
ppc_reldata(ignore)
- int ignore;
+ int ignore ATTRIBUTE_UNUSED;
{
if (reldata_section == 0)
{
*/
static void
ppc_rdata(ignore)
- int ignore;
+ int ignore ATTRIBUTE_UNUSED;
{
if (rdata_section == 0)
{
*/
static void
ppc_ualong(ignore)
- int ignore;
+ int ignore ATTRIBUTE_UNUSED;
{
/* try for long */
cons ( 4 );
*/
static void
ppc_znop(ignore)
- int ignore;
+ int ignore ATTRIBUTE_UNUSED;
{
unsigned long insn;
const struct powerpc_opcode *opcode;
void
ppc_pe_section (ignore)
- int ignore;
+ int ignore ATTRIBUTE_UNUSED;
{
/* Strip out the section name */
char *section_name;
static void
ppc_pe_function (ignore)
- int ignore;
+ int ignore ATTRIBUTE_UNUSED;
{
char *name;
char endc;
static void
ppc_pe_tocd (ignore)
- int ignore;
+ int ignore ATTRIBUTE_UNUSED;
{
if (tocdata_section == 0)
{
ppc_symbol_new_hook (sym)
symbolS *sym;
{
+ struct ppc_tc_sy *tc;
const char *s;
- sym->sy_tc.next = NULL;
- sym->sy_tc.output = 0;
- sym->sy_tc.class = -1;
- sym->sy_tc.real_name = NULL;
- sym->sy_tc.subseg = 0;
- sym->sy_tc.align = 0;
- sym->sy_tc.size = NULL;
- sym->sy_tc.within = NULL;
+ tc = symbol_get_tc (sym);
+ tc->next = NULL;
+ tc->output = 0;
+ tc->class = -1;
+ tc->real_name = NULL;
+ tc->subseg = 0;
+ tc->align = 0;
+ tc->size = NULL;
+ tc->within = NULL;
if (ppc_stab_symbol)
return;
{
case 'B':
if (strcmp (s, "BS]") == 0)
- sym->sy_tc.class = XMC_BS;
+ tc->class = XMC_BS;
break;
case 'D':
if (strcmp (s, "DB]") == 0)
- sym->sy_tc.class = XMC_DB;
+ tc->class = XMC_DB;
else if (strcmp (s, "DS]") == 0)
- sym->sy_tc.class = XMC_DS;
+ tc->class = XMC_DS;
break;
case 'G':
if (strcmp (s, "GL]") == 0)
- sym->sy_tc.class = XMC_GL;
+ tc->class = XMC_GL;
break;
case 'P':
if (strcmp (s, "PR]") == 0)
- sym->sy_tc.class = XMC_PR;
+ tc->class = XMC_PR;
break;
case 'R':
if (strcmp (s, "RO]") == 0)
- sym->sy_tc.class = XMC_RO;
+ tc->class = XMC_RO;
else if (strcmp (s, "RW]") == 0)
- sym->sy_tc.class = XMC_RW;
+ tc->class = XMC_RW;
break;
case 'S':
if (strcmp (s, "SV]") == 0)
- sym->sy_tc.class = XMC_SV;
+ tc->class = XMC_SV;
break;
case 'T':
if (strcmp (s, "TC]") == 0)
- sym->sy_tc.class = XMC_TC;
+ tc->class = XMC_TC;
else if (strcmp (s, "TI]") == 0)
- sym->sy_tc.class = XMC_TI;
+ tc->class = XMC_TI;
else if (strcmp (s, "TB]") == 0)
- sym->sy_tc.class = XMC_TB;
+ tc->class = XMC_TB;
else if (strcmp (s, "TC0]") == 0 || strcmp (s, "T0]") == 0)
- sym->sy_tc.class = XMC_TC0;
+ tc->class = XMC_TC0;
break;
case 'U':
if (strcmp (s, "UA]") == 0)
- sym->sy_tc.class = XMC_UA;
+ tc->class = XMC_UA;
else if (strcmp (s, "UC]") == 0)
- sym->sy_tc.class = XMC_UC;
+ tc->class = XMC_UC;
break;
case 'X':
if (strcmp (s, "XO]") == 0)
- sym->sy_tc.class = XMC_XO;
+ tc->class = XMC_XO;
break;
}
- if (sym->sy_tc.class == -1)
+ if (tc->class == -1)
as_bad (_("Unrecognized symbol suffix"));
}
{
if (ppc_current_csect != (symbolS *) NULL)
{
- if (sym->sy_tc.class == -1)
- sym->sy_tc.class = ppc_current_csect->sy_tc.class;
+ if (symbol_get_tc (sym)->class == -1)
+ symbol_get_tc (sym)->class = symbol_get_tc (ppc_current_csect)->class;
symbol_remove (sym, &symbol_rootP, &symbol_lastP);
- symbol_append (sym, ppc_current_csect->sy_tc.within, &symbol_rootP,
- &symbol_lastP);
- ppc_current_csect->sy_tc.within = sym;
+ symbol_append (sym, symbol_get_tc (ppc_current_csect)->within,
+ &symbol_rootP, &symbol_lastP);
+ symbol_get_tc (ppc_current_csect)->within = sym;
}
}
/* Discard symbols that should not be included in the output symbol
table. */
- if (! sym->sy_used_in_reloc
- && ((sym->bsym->flags & BSF_SECTION_SYM) != 0
+ if (! symbol_used_in_reloc_p (sym)
+ && ((symbol_get_bfdsym (sym)->flags & BSF_SECTION_SYM) != 0
|| (! S_IS_EXTERNAL (sym)
- && ! sym->sy_tc.output
+ && ! symbol_get_tc (sym)->output
&& S_GET_STORAGE_CLASS (sym) != C_FILE)))
return 1;
- if (sym->sy_tc.real_name != (char *) NULL)
- S_SET_NAME (sym, sym->sy_tc.real_name);
+ if (symbol_get_tc (sym)->real_name != (char *) NULL)
+ S_SET_NAME (sym, symbol_get_tc (sym)->real_name);
else
{
const char *name;
if (ppc_last_function != (symbolS *) NULL)
as_bad (_("two .function pseudo-ops with no intervening .ef"));
ppc_last_function = sym;
- if (sym->sy_tc.size != (symbolS *) NULL)
+ if (symbol_get_tc (sym)->size != (symbolS *) NULL)
{
- resolve_symbol_value (sym->sy_tc.size, 1);
- SA_SET_SYM_FSIZE (sym, (long) S_GET_VALUE (sym->sy_tc.size));
+ resolve_symbol_value (symbol_get_tc (sym)->size, 1);
+ SA_SET_SYM_FSIZE (sym,
+ (long) S_GET_VALUE (symbol_get_tc (sym)->size));
}
}
else if (S_GET_STORAGE_CLASS (sym) == C_FCN
}
if (! S_IS_EXTERNAL (sym)
- && (sym->bsym->flags & BSF_SECTION_SYM) == 0
+ && (symbol_get_bfdsym (sym)->flags & BSF_SECTION_SYM) == 0
&& S_GET_STORAGE_CLASS (sym) != C_FILE
&& S_GET_STORAGE_CLASS (sym) != C_FCN
&& S_GET_STORAGE_CLASS (sym) != C_BLOCK
/* Create a csect aux. */
i = S_GET_NUMBER_AUXILIARY (sym);
S_SET_NUMBER_AUXILIARY (sym, i + 1);
- a = &coffsymbol (sym->bsym)->native[i + 1].u.auxent;
- if (sym->sy_tc.class == XMC_TC0)
+ a = &coffsymbol (symbol_get_bfdsym (sym))->native[i + 1].u.auxent;
+ if (symbol_get_tc (sym)->class == XMC_TC0)
{
/* This is the TOC table. */
know (strcmp (S_GET_NAME (sym), "TOC") == 0);
a->x_csect.x_scnlen.l = 0;
a->x_csect.x_smtyp = (2 << 3) | XTY_SD;
}
- else if (sym->sy_tc.subseg != 0)
+ else if (symbol_get_tc (sym)->subseg != 0)
{
/* This is a csect symbol. x_scnlen is the size of the
csect. */
- if (sym->sy_tc.next == (symbolS *) NULL)
+ if (symbol_get_tc (sym)->next == (symbolS *) NULL)
a->x_csect.x_scnlen.l = (bfd_section_size (stdoutput,
S_GET_SEGMENT (sym))
- S_GET_VALUE (sym));
else
{
- resolve_symbol_value (sym->sy_tc.next, 1);
- a->x_csect.x_scnlen.l = (S_GET_VALUE (sym->sy_tc.next)
+ resolve_symbol_value (symbol_get_tc (sym)->next, 1);
+ a->x_csect.x_scnlen.l = (S_GET_VALUE (symbol_get_tc (sym)->next)
- S_GET_VALUE (sym));
}
- a->x_csect.x_smtyp = (sym->sy_tc.align << 3) | XTY_SD;
+ a->x_csect.x_smtyp = (symbol_get_tc (sym)->align << 3) | XTY_SD;
}
else if (S_GET_SEGMENT (sym) == bss_section)
{
/* This is a common symbol. */
- a->x_csect.x_scnlen.l = sym->sy_frag->fr_offset;
- a->x_csect.x_smtyp = (sym->sy_tc.align << 3) | XTY_CM;
+ a->x_csect.x_scnlen.l = symbol_get_frag (sym)->fr_offset;
+ a->x_csect.x_smtyp = (symbol_get_tc (sym)->align << 3) | XTY_CM;
if (S_IS_EXTERNAL (sym))
- sym->sy_tc.class = XMC_RW;
+ symbol_get_tc (sym)->class = XMC_RW;
else
- sym->sy_tc.class = XMC_BS;
+ symbol_get_tc (sym)->class = XMC_BS;
}
else if (S_GET_SEGMENT (sym) == absolute_section)
{
ppc_adjust_symtab. */
ppc_saw_abs = true;
a->x_csect.x_smtyp = XTY_LD;
- if (sym->sy_tc.class == -1)
- sym->sy_tc.class = XMC_XO;
+ if (symbol_get_tc (sym)->class == -1)
+ symbol_get_tc (sym)->class = XMC_XO;
}
else if (! S_IS_DEFINED (sym))
{
a->x_csect.x_scnlen.l = 0;
a->x_csect.x_smtyp = XTY_ER;
}
- else if (sym->sy_tc.class == XMC_TC)
+ else if (symbol_get_tc (sym)->class == XMC_TC)
{
symbolS *next;
/* This is a TOC definition. x_scnlen is the size of the
TOC entry. */
next = symbol_next (sym);
- while (next->sy_tc.class == XMC_TC0)
+ while (symbol_get_tc (next)->class == XMC_TC0)
next = symbol_next (next);
if (next == (symbolS *) NULL
- || next->sy_tc.class != XMC_TC)
+ || symbol_get_tc (next)->class != XMC_TC)
{
if (ppc_after_toc_frag == (fragS *) NULL)
a->x_csect.x_scnlen.l = (bfd_section_size (stdoutput,
abort ();
/* Skip the initial dummy symbol. */
- csect = csect->sy_tc.next;
+ csect = symbol_get_tc (csect)->next;
if (csect == (symbolS *) NULL)
{
}
else
{
- while (csect->sy_tc.next != (symbolS *) NULL)
+ while (symbol_get_tc (csect)->next != (symbolS *) NULL)
{
- resolve_symbol_value (csect->sy_tc.next, 1);
- if (S_GET_VALUE (csect->sy_tc.next) > S_GET_VALUE (sym))
+ resolve_symbol_value (symbol_get_tc (csect)->next, 1);
+ if (S_GET_VALUE (symbol_get_tc (csect)->next)
+ > S_GET_VALUE (sym))
break;
- csect = csect->sy_tc.next;
+ csect = symbol_get_tc (csect)->next;
}
- a->x_csect.x_scnlen.p = coffsymbol (csect->bsym)->native;
- coffsymbol (sym->bsym)->native[i + 1].fix_scnlen = 1;
+ a->x_csect.x_scnlen.p =
+ coffsymbol (symbol_get_bfdsym (csect))->native;
+ coffsymbol (symbol_get_bfdsym (sym))->native[i + 1].fix_scnlen =
+ 1;
}
a->x_csect.x_smtyp = XTY_LD;
}
a->x_csect.x_parmhash = 0;
a->x_csect.x_snhash = 0;
- if (sym->sy_tc.class == -1)
+ if (symbol_get_tc (sym)->class == -1)
a->x_csect.x_smclas = XMC_PR;
else
- a->x_csect.x_smclas = sym->sy_tc.class;
+ a->x_csect.x_smclas = symbol_get_tc (sym)->class;
a->x_csect.x_stab = 0;
a->x_csect.x_snstab = 0;
/* Don't let the COFF backend resort these symbols. */
- sym->bsym->flags |= BSF_NOT_AT_END;
+ symbol_get_bfdsym (sym)->flags |= BSF_NOT_AT_END;
}
else if (S_GET_STORAGE_CLASS (sym) == C_BSTAT)
{
csect symbol. BFD will do that for us if we set the right
flags. */
S_SET_VALUE (sym,
- (valueT) coffsymbol (sym->sy_tc.within->bsym)->native);
- coffsymbol (sym->bsym)->native->fix_value = 1;
+ ((valueT)
+ coffsymbol (symbol_get_bfdsym
+ (symbol_get_tc (sym)->within))->native));
+ coffsymbol (symbol_get_bfdsym (sym))->native->fix_value = 1;
}
else if (S_GET_STORAGE_CLASS (sym) == C_STSYM)
{
symbolS *csect;
/* The value is the offset from the enclosing csect. */
- block = sym->sy_tc.within;
- csect = block->sy_tc.within;
+ block = symbol_get_tc (sym)->within;
+ csect = symbol_get_tc (block)->within;
resolve_symbol_value (csect, 1);
S_SET_VALUE (sym, S_GET_VALUE (sym) - S_GET_VALUE (csect));
}
/* We want the value to be a file offset into the line numbers.
BFD will do that for us if we set the right flags. We have
already set the value correctly. */
- coffsymbol (sym->bsym)->native->fix_line = 1;
+ coffsymbol (symbol_get_bfdsym (sym))->native->fix_line = 1;
}
return 0;
csect = symbol_create (".abs[XO]", absolute_section,
S_GET_VALUE (sym), &zero_address_frag);
- csect->bsym->value = S_GET_VALUE (sym);
+ symbol_get_bfdsym (csect)->value = S_GET_VALUE (sym);
S_SET_STORAGE_CLASS (csect, C_HIDEXT);
i = S_GET_NUMBER_AUXILIARY (csect);
S_SET_NUMBER_AUXILIARY (csect, i + 1);
- a = &coffsymbol (csect->bsym)->native[i + 1].u.auxent;
+ a = &coffsymbol (symbol_get_bfdsym (csect))->native[i + 1].u.auxent;
a->x_csect.x_scnlen.l = 0;
a->x_csect.x_smtyp = XTY_SD;
a->x_csect.x_parmhash = 0;
symbol_insert (csect, sym, &symbol_rootP, &symbol_lastP);
i = S_GET_NUMBER_AUXILIARY (sym);
- a = &coffsymbol (sym->bsym)->native[i].u.auxent;
- a->x_csect.x_scnlen.p = coffsymbol (csect->bsym)->native;
- coffsymbol (sym->bsym)->native[i].fix_scnlen = 1;
+ a = &coffsymbol (symbol_get_bfdsym (sym))->native[i].u.auxent;
+ a->x_csect.x_scnlen.p = coffsymbol (symbol_get_bfdsym (csect))->native;
+ coffsymbol (symbol_get_bfdsym (sym))->native[i].fix_scnlen = 1;
}
ppc_saw_abs = false;
int
md_estimate_size_before_relax (fragp, seg)
- fragS *fragp;
- asection *seg;
+ fragS *fragp ATTRIBUTE_UNUSED;
+ asection *seg ATTRIBUTE_UNUSED;
{
abort ();
return 0;
void
md_convert_frag (abfd, sec, fragp)
- bfd *abfd;
- asection *sec;
- fragS *fragp;
+ bfd *abfd ATTRIBUTE_UNUSED;
+ asection *sec ATTRIBUTE_UNUSED;
+ fragS *fragp ATTRIBUTE_UNUSED;
{
abort ();
}
/*ARGSUSED*/
symbolS *
md_undefined_symbol (name)
- char *name;
+ char *name ATTRIBUTE_UNUSED;
{
return 0;
}
long
md_pcrel_from_section (fixp, sec)
fixS *fixp;
- segT sec;
+ segT sec ATTRIBUTE_UNUSED;
{
return fixp->fx_frag->fr_address + fixp->fx_where;
}
sy != (symbolS *) NULL;
sy = symbol_next (sy))
{
- if (sy->sy_tc.class == XMC_TC0)
+ if (symbol_get_tc (sy)->class == XMC_TC0)
continue;
- if (sy->sy_tc.class != XMC_TC)
+ if (symbol_get_tc (sy)->class != XMC_TC)
break;
resolve_symbol_value (sy, 1);
if (val == S_GET_VALUE (sy))
/* Possibly adjust the reloc to be against the csect. */
if (fix->fx_addsy != (symbolS *) NULL
- && fix->fx_addsy->sy_tc.subseg == 0
- && fix->fx_addsy->sy_tc.class != XMC_TC0
- && fix->fx_addsy->sy_tc.class != XMC_TC
+ && symbol_get_tc (fix->fx_addsy)->subseg == 0
+ && symbol_get_tc (fix->fx_addsy)->class != XMC_TC0
+ && symbol_get_tc (fix->fx_addsy)->class != XMC_TC
&& S_GET_SEGMENT (fix->fx_addsy) != bss_section
/* Don't adjust if this is a reloc in the toc section. */
&& (S_GET_SEGMENT (fix->fx_addsy) != data_section
abort ();
/* Skip the initial dummy symbol. */
- csect = csect->sy_tc.next;
+ csect = symbol_get_tc (csect)->next;
if (csect != (symbolS *) NULL)
{
- while (csect->sy_tc.next != (symbolS *) NULL
- && (csect->sy_tc.next->sy_frag->fr_address
- <= fix->fx_addsy->sy_frag->fr_address))
+ while (symbol_get_tc (csect)->next != (symbolS *) NULL
+ && (symbol_get_frag (symbol_get_tc (csect)->next)->fr_address
+ <= val))
{
/* If the csect address equals the symbol value, then we
have to look through the full symbol table to see
whether this is the csect we want. Note that we will
only get here if the csect has zero length. */
- if ((csect->sy_frag->fr_address
- == fix->fx_addsy->sy_frag->fr_address)
+ if ((symbol_get_frag (csect)->fr_address == val)
&& S_GET_VALUE (csect) == S_GET_VALUE (fix->fx_addsy))
{
symbolS *scan;
- for (scan = csect->sy_next;
+ for (scan = symbol_next (csect);
scan != NULL;
- scan = scan->sy_next)
+ scan = symbol_next (scan))
{
- if (scan->sy_tc.subseg != 0)
+ if (symbol_get_tc (scan)->subseg != 0)
break;
if (scan == fix->fx_addsy)
break;
break;
}
- csect = csect->sy_tc.next;
+ csect = symbol_get_tc (csect)->next;
}
fix->fx_offset += (S_GET_VALUE (fix->fx_addsy)
- - csect->sy_frag->fr_address);
+ - symbol_get_frag (csect)->fr_address);
fix->fx_addsy = csect;
}
}
&& S_GET_SEGMENT (fix->fx_addsy) == bss_section
&& ! S_IS_EXTERNAL (fix->fx_addsy))
{
- resolve_symbol_value (fix->fx_addsy->sy_frag->fr_symbol, 1);
- fix->fx_offset += (S_GET_VALUE (fix->fx_addsy)
- - S_GET_VALUE (fix->fx_addsy->sy_frag->fr_symbol));
- fix->fx_addsy = fix->fx_addsy->sy_frag->fr_symbol;
+ resolve_symbol_value (symbol_get_frag (fix->fx_addsy)->fr_symbol, 1);
+ fix->fx_offset +=
+ (S_GET_VALUE (fix->fx_addsy)
+ - S_GET_VALUE (symbol_get_frag (fix->fx_addsy)->fr_symbol));
+ fix->fx_addsy = symbol_get_frag (fix->fx_addsy)->fr_symbol;
}
return 0;
we need to force the relocation. */
if (fix->fx_pcrel
&& fix->fx_addsy != NULL
- && fix->fx_addsy->sy_tc.subseg != 0
- && (fix->fx_addsy->sy_frag->fr_address > fix->fx_frag->fr_address
- || (fix->fx_addsy->sy_tc.next != NULL
- && (fix->fx_addsy->sy_tc.next->sy_frag->fr_address
+ && symbol_get_tc (fix->fx_addsy)->subseg != 0
+ && ((symbol_get_frag (fix->fx_addsy)->fr_address
+ > fix->fx_frag->fr_address)
+ || (symbol_get_tc (fix->fx_addsy)->next != NULL
+ && (symbol_get_frag (symbol_get_tc (fix->fx_addsy)->next)->fr_address
<= fix->fx_frag->fr_address))))
return 1;
symbolS *sym;
{
#ifdef OBJ_XCOFF
- return sym->sy_tc.class == XMC_TC;
+ return symbol_get_tc (sym)->class == XMC_TC;
#else
return strcmp (segment_name (S_GET_SEGMENT (sym)), ".got") == 0;
#endif
{
/* `*valuep' may contain the value of the symbol on which the reloc
will be based; we have to remove it. */
- if (fixp->fx_addsy->sy_used_in_reloc
+ if (symbol_used_in_reloc_p (fixp->fx_addsy)
&& S_GET_SEGMENT (fixp->fx_addsy) != absolute_section
&& S_GET_SEGMENT (fixp->fx_addsy) != undefined_section
&& ! bfd_is_com_section (S_GET_SEGMENT (fixp->fx_addsy)))
&& operand->shift == 0
&& operand->insert == NULL
&& fixp->fx_addsy != NULL
- && fixp->fx_addsy->sy_tc.subseg != 0
- && fixp->fx_addsy->sy_tc.class != XMC_TC
- && fixp->fx_addsy->sy_tc.class != XMC_TC0
+ && symbol_get_tc (fixp->fx_addsy)->subseg != 0
+ && symbol_get_tc (fixp->fx_addsy)->class != XMC_TC
+ && symbol_get_tc (fixp->fx_addsy)->class != XMC_TC0
&& S_GET_SEGMENT (fixp->fx_addsy) != bss_section)
{
value = fixp->fx_offset;
else if ((operand->flags & PPC_OPERAND_PARENS) != 0
&& operand->bits == 16
&& operand->shift == 0
- && operand->insert == NULL
&& fixp->fx_addsy != NULL
&& ppc_is_toc_sym (fixp->fx_addsy))
{
value, 4);
break;
+ case BFD_RELOC_64:
+ if (fixp->fx_pcrel)
+ fixp->fx_r_type = BFD_RELOC_64_PCREL;
+ /* fall through */
+ case BFD_RELOC_64_PCREL:
+ md_number_to_chars (fixp->fx_frag->fr_literal + fixp->fx_where,
+ value, 8);
+ break;
case BFD_RELOC_LO16:
case BFD_RELOC_16:
case BFD_RELOC_GPREL16:
if (fixp->fx_pcrel)
abort ();
md_number_to_chars (fixp->fx_frag->fr_literal + fixp->fx_where,
- value + 0x8000 >> 16, 2);
+ (value + 0x8000) >> 16, 2);
break;
/* Because SDA21 modifies the register field, the size is set to 4
arelent *
tc_gen_reloc (seg, fixp)
- asection *seg;
+ asection *seg ATTRIBUTE_UNUSED;
fixS *fixp;
{
arelent *reloc;
reloc = (arelent *) xmalloc (sizeof (arelent));
- reloc->sym_ptr_ptr = &fixp->fx_addsy->bsym;
+ reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
+ *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
if (reloc->howto == (reloc_howto_type *) NULL)
projects / deliverable / binutils-gdb.git / blobdiff