name_length = strlen (name) + 1; /* +1 for \0. */
obstack_grow (¬es, name, name_length);
- ret = obstack_finish (¬es);
+ ret = (char *) obstack_finish (¬es);
#ifdef tc_canonicalize_symbol_name
ret = tc_canonicalize_symbol_name (ret);
preserved_copy_of_name = save_symbol_name (name);
- symbolP = obstack_alloc (¬es, sizeof (symbolS));
+ symbolP = (symbolS *) obstack_alloc (¬es, sizeof (symbolS));
/* symbol must be born in some fixed state. This seems as good as any. */
memset (symbolP, 0, sizeof (symbolS));
/* Create a local symbol and insert it into the local hash table. */
static struct local_symbol *
-local_symbol_make (const char *name, segT section, valueT value, fragS *frag)
+local_symbol_make (const char *name, segT section, valueT val, fragS *frag)
{
char *name_copy;
struct local_symbol *ret;
name_copy = save_symbol_name (name);
- ret = obstack_alloc (¬es, sizeof *ret);
+ ret = (struct local_symbol *) obstack_alloc (¬es, sizeof *ret);
ret->lsy_marker = NULL;
ret->lsy_name = name_copy;
ret->lsy_section = section;
local_symbol_set_frag (ret, frag);
- ret->lsy_value = value;
+ ret->lsy_value = val;
hash_jam (local_hash, name_copy, (void *) ret);
return ret;
}
\f
+static void
+define_sym_at_dot (symbolS *symbolP)
+{
+ symbolP->sy_frag = frag_now;
+#ifdef OBJ_VMS
+ S_SET_OTHER (symbolP, const_flag);
+#endif
+ S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
+ S_SET_SEGMENT (symbolP, now_seg);
+}
+
/* We have just seen "<name>:".
Creates a struct symbol unless it already exists.
}
if (S_GET_VALUE (symbolP) == 0)
{
- symbolP->sy_frag = frag_now;
-#ifdef OBJ_VMS
- S_SET_OTHER (symbolP, const_flag);
-#endif
- S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
- S_SET_SEGMENT (symbolP, now_seg);
+ define_sym_at_dot (symbolP);
#ifdef N_UNDF
know (N_UNDF == 0);
#endif /* if we have one, it better be zero. */
{
/* It is a .comm/.lcomm being converted to initialized
data. */
- symbolP->sy_frag = frag_now;
-#ifdef OBJ_VMS
- S_SET_OTHER (symbolP, const_flag);
-#endif
- S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
- S_SET_SEGMENT (symbolP, now_seg); /* Keep N_EXT bit. */
+ define_sym_at_dot (symbolP);
}
}
else
{
as_bad (_("symbol `%s' is already defined"), sym_name);
symbolP = symbol_clone (symbolP, 0);
+ define_sym_at_dot (symbolP);
}
}
orgsymP = local_symbol_convert ((struct local_symbol *) orgsymP);
bsymorg = orgsymP->bsym;
- newsymP = obstack_alloc (¬es, sizeof (*newsymP));
+ newsymP = (symbolS *) obstack_alloc (¬es, sizeof (*newsymP));
*newsymP = *orgsymP;
bsymnew = bfd_make_empty_symbol (bfd_asymbol_bfd (bsymorg));
if (bsymnew == NULL)
as_fatal ("bfd_make_empty_symbol: %s", bfd_errmsg (bfd_get_error ()));
newsymP->bsym = bsymnew;
bsymnew->name = bsymorg->name;
- bsymnew->flags = bsymorg->flags;
- bsymnew->section = bsymorg->section;
+ bsymnew->flags = bsymorg->flags & ~BSF_SECTION_SYM;
+ bsymnew->section = bsymorg->section;
bfd_copy_private_symbol_data (bfd_asymbol_bfd (bsymorg), bsymorg,
bfd_asymbol_bfd (bsymnew), bsymnew);
resolve_local_symbol (const char *key ATTRIBUTE_UNUSED, void *value)
{
if (value != NULL)
- resolve_symbol_value (value);
+ resolve_symbol_value ((symbolS *) value);
}
/* Resolve all local symbols. */
}
else
{
- expressionS expr = symbolP->sy_value;
+ expressionS exp = symbolP->sy_value;
- if (!symbolP->sy_resolved && expr.X_op != O_illegal)
+ if (!symbolP->sy_resolved && exp.X_op != O_illegal)
{
int resolved;
if (symbolP->sy_resolving)
return 0;
symbolP->sy_resolving = 1;
- resolved = resolve_expression (&expr);
+ resolved = resolve_expression (&exp);
symbolP->sy_resolving = 0;
if (!resolved)
return 0;
- switch (expr.X_op)
+ switch (exp.X_op)
{
case O_constant:
case O_register:
/* Fall thru. */
case O_symbol:
case O_symbol_rva:
- symbolP = expr.X_add_symbol;
+ symbolP = exp.X_add_symbol;
break;
default:
return 0;
}
}
- /* Never change a defined symbol. */
- if (symbolP->bsym->section == undefined_section
- || symbolP->bsym->section == expr_section)
- *symbolPP = symbolP;
- *valueP = expr.X_add_number;
+ *symbolPP = symbolP;
+ *valueP = exp.X_add_number;
*segP = symbolP->bsym->section;
*fragPP = symbolP->sy_frag;
if (*segP == expr_section)
- switch (expr.X_op)
+ switch (exp.X_op)
{
case O_constant: *segP = absolute_section; break;
case O_register: *segP = reg_section; break;
{
dollar_labels = (long *) xmalloc (DOLLAR_LABEL_BUMP_BY * sizeof (long));
dollar_label_instances = (long *) xmalloc (DOLLAR_LABEL_BUMP_BY * sizeof (long));
- dollar_label_defines = xmalloc (DOLLAR_LABEL_BUMP_BY);
+ dollar_label_defines = (char *) xmalloc (DOLLAR_LABEL_BUMP_BY);
dollar_label_max = DOLLAR_LABEL_BUMP_BY;
dollar_label_count = 0;
}
dollar_label_max * sizeof (long));
dollar_label_instances = (long *) xrealloc ((char *) dollar_label_instances,
dollar_label_max * sizeof (long));
- dollar_label_defines = xrealloc (dollar_label_defines, dollar_label_max);
+ dollar_label_defines = (char *) xrealloc (dollar_label_defines, dollar_label_max);
} /* if we needed to grow */
dollar_labels[dollar_label_count] = label;
int instance_number;
char *type;
const char *message_format;
- int index = 0;
+ int lindex = 0;
#ifdef LOCAL_LABEL_PREFIX
- if (s[index] == LOCAL_LABEL_PREFIX)
- ++index;
+ if (s[lindex] == LOCAL_LABEL_PREFIX)
+ ++lindex;
#endif
- if (s[index] != 'L')
+ if (s[lindex] != 'L')
return s;
- for (label_number = 0, p = s + index + 1; ISDIGIT (*p); ++p)
+ for (label_number = 0, p = s + lindex + 1; ISDIGIT (*p); ++p)
label_number = (10 * label_number) + *p - '0';
if (*p == DOLLAR_LABEL_CHAR)
instance_number = (10 * instance_number) + *p - '0';
message_format = _("\"%d\" (instance number %d of a %s label)");
- symbol_decode = obstack_alloc (¬es, strlen (message_format) + 30);
+ symbol_decode = (char *) obstack_alloc (¬es, strlen (message_format) + 30);
sprintf (symbol_decode, message_format, label_number, instance_number, type);
return symbol_decode;
S_CLEAR_WEAKREFR (s);
}
+/* Return whether 2 symbols are the same. */
+
+int
+symbol_same_p (symbolS *s1, symbolS *s2)
+{
+ if (s1->bsym == NULL
+ && local_symbol_converted_p ((struct local_symbol *) s1))
+ s1 = local_symbol_get_real_symbol ((struct local_symbol *) s1);
+ if (s2->bsym == NULL
+ && local_symbol_converted_p ((struct local_symbol *) s2))
+ s2 = local_symbol_get_real_symbol ((struct local_symbol *) s2);
+ return s1 == s2;
+}
+
/* Return a pointer to the X_add_number component of a symbol. */
offsetT *