/* tc-ppc.c -- Assemble for the PowerPC or POWER (RS/6000)
- Copyright (C) 1994, 95, 96, 97, 98, 1999 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
/* 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). */
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. */
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
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 (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
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);
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;
*input_line_pointer = endc;
- sym->sy_tc.output = 1;
+ symbol_get_tc (sym)->output = 1;
demand_empty_rest_of_line ();
}
}
++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 ();
}
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 ();
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);
}
}
}
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);
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
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);
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);
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);
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);
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);
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);
int ignore;
{
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;
+{
+ discard_rest_of_line();
+ /* What does aix use this for? */
+}
+
static void
ppc_vbyte (dummy)
int dummy;
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
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
&& 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:
arelent *
tc_gen_reloc (seg, fixp)
- asection *seg;
+ asection *seg ATTRIBUTE_UNUSED;
fixS *fixp;
{
arelent *reloc;