void
print_dependencies (void)
{
FILE *f;
struct dependency *dep;
if (dep_file == NULL)
return;
f = fopen (dep_file, FOPEN_WT);
if (f == NULL)
{
as_warn (_("can't open `%s' for writing"), dep_file);
return;
}
column = 0;
wrap_output (f, out_file_name, ':');
for (dep = dep_chain; dep != NULL; dep = dep->next)
wrap_output (f, dep->file, ' ');
putc ('\n', f);
if (fclose (f))
as_warn (_("can't close `%s'"), dep_file);
}
static void
s_atmp()
{
register int temp;
if (strncmp(input_line_pointer, "sp", 2) == 0) {
input_line_pointer += 2;
atmp = 2;
}
else if (strncmp(input_line_pointer, "fp", 2) == 0) {
input_line_pointer += 2;
atmp = 3;
}
else if (strncmp(input_line_pointer, "r", 1) == 0) {
input_line_pointer += 1;
temp = get_absolute_expression();
if (temp >= 0 && temp <= 31)
atmp = temp;
else
as_warn("Unknown temporary pseudo register");
}
else {
as_warn("Unknown temporary pseudo register");
}
demand_empty_rest_of_line();
return;
}
static void
obj_coff_tag (int ignore ATTRIBUTE_UNUSED)
{
char *symbol_name;
char name_end;
if (def_symbol_in_progress == NULL)
{
as_warn (_(".tag pseudo-op used outside of .def/.endef ignored."));
demand_empty_rest_of_line ();
return;
}
S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
symbol_name = input_line_pointer;
name_end = get_symbol_end ();
#ifdef tc_canonicalize_symbol_name
symbol_name = tc_canonicalize_symbol_name (symbol_name);
#endif
/* Assume that the symbol referred to by .tag is always defined.
This was a bad assumption. I've added find_or_make. xoxorich. */
SA_SET_SYM_TAGNDX (def_symbol_in_progress,
tag_find_or_make (symbol_name));
if (SA_GET_SYM_TAGNDX (def_symbol_in_progress) == 0L)
as_warn (_("tag not found for .tag %s"), symbol_name);
SF_SET_TAGGED (def_symbol_in_progress);
*input_line_pointer = name_end;
demand_empty_rest_of_line ();
}
static void
s_common()
{
register char *name;
register char c;
register char *p;
register int temp;
register symbolS * symbolP;
name = input_line_pointer;
c = get_symbol_end();
/* just after name is now '\0' */
p = input_line_pointer;
*p = c;
SKIP_WHITESPACE();
if ( * input_line_pointer != ',' ) {
as_warn("Expected comma after symbol-name");
ignore_rest_of_line();
return;
}
input_line_pointer ++; /* skip ',' */
if ( (temp = get_absolute_expression ()) < 0 ) {
as_warn(".COMMon length (%d.) <0! Ignored.", temp);
ignore_rest_of_line();
return;
}
*p = 0;
symbolP = symbol_find_or_make (name);
*p = c;
if ( (symbolP->sy_type & N_TYPE) != N_UNDF ||
symbolP->sy_other != 0 || symbolP->sy_desc != 0) {
as_warn( "Ignoring attempt to re-define symbol");
ignore_rest_of_line();
return;
}
if (symbolP->sy_value) {
if (symbolP->sy_value != temp) {
as_warn( "Length of .comm \"%s\" is already %d. Not changed to %d.",
symbolP->sy_name, symbolP->sy_value, temp);
}
} else {
symbolP->sy_value = temp;
symbolP->sy_type |= N_EXT;
}
know(symbolP->sy_frag == &zero_address_frag);
if (strncmp(input_line_pointer, ",\"bss\"", 6) != 0) {
p=input_line_pointer;
while(*p && *p!='\n')
p++;
c= *p;
*p='\0';
as_warn("bad .common segment: `%s'", input_line_pointer);
*p=c;
return;
}
input_line_pointer += 6;
demand_empty_rest_of_line();
return;
}
/*
* sort of like s_lcomm
*
*/
static void
s_reserve()
{
char *name;
char c;
char *p;
int temp;
symbolS *symbolP;
name = input_line_pointer;
c = get_symbol_end();
p = input_line_pointer;
*p = c;
SKIP_WHITESPACE();
if ( * input_line_pointer != ',' ) {
as_warn("Expected comma after name");
ignore_rest_of_line();
return;
}
input_line_pointer ++;
if ((temp = get_absolute_expression()) < 0) {
as_warn("BSS length (%d.) <0! Ignored.", temp);
ignore_rest_of_line();
return;
}
*p = 0;
symbolP = symbol_find_or_make(name);
*p = c;
if (strncmp(input_line_pointer, ",\"bss\"", 6) != 0) {
as_warn("bad .reserve segment: `%s'", input_line_pointer);
return;
}
input_line_pointer += 6;
if (symbolP->sy_other == 0
&& symbolP->sy_desc == 0
&& ((symbolP->sy_type == N_BSS
&& symbolP->sy_value == local_bss_counter)
|| ((symbolP->sy_type & N_TYPE) == N_UNDF
&& symbolP->sy_value == 0))) {
symbolP->sy_value = local_bss_counter;
symbolP->sy_type = N_BSS;
symbolP->sy_frag = & bss_address_frag;
local_bss_counter += temp;
} else {
as_warn( "Ignoring attempt to re-define symbol from %d. to %d.",
symbolP->sy_value, local_bss_counter );
}
demand_empty_rest_of_line();
return;
}
static void
xc16xlmode (int arg ATTRIBUTE_UNUSED)
{
if (stdoutput != NULL)
if (!bfd_set_arch_mach (stdoutput, bfd_arch_xc16x, bfd_mach_xc16xl))
as_warn (_("could not set architecture and machine"));
}
static void
add_lineno (fragS * frag, addressT offset, int num)
{
struct line_no * new_line = xmalloc (sizeof (* new_line));
if (!current_lineno_sym)
abort ();
#ifndef OBJ_XCOFF
/* The native aix assembler accepts negative line number. */
if (num <= 0)
{
/* Zero is used as an end marker in the file. */
as_warn (_("Line numbers must be positive integers\n"));
num = 1;
}
#endif /* OBJ_XCOFF */
new_line->next = line_nos;
new_line->frag = frag;
new_line->l.line_number = num;
new_line->l.u.offset = offset;
line_nos = new_line;
coff_n_line_nos++;
}
char *
input_file_give_next_buffer (char *where /* Where to place 1st character of new buffer. */)
{
char *return_value; /* -> Last char of what we read, + 1. */
size_t size;
if (f_in == (FILE *) 0)
return 0;
/* fflush (stdin); could be done here if you want to synchronise
stdin and stdout, for the case where our input file is stdin.
Since the assembler shouldn't do any output to stdout, we
don't bother to synch output and input. */
if (preprocess)
size = do_scrub_chars (input_file_get, where, BUFFER_SIZE);
else
size = input_file_get (where, BUFFER_SIZE);
if (size)
return_value = where + size;
else
{
if (fclose (f_in))
as_warn (_("can't close %s: %s"), file_name, xstrerror (errno));
f_in = (FILE *) 0;
return_value = 0;
}
return return_value;
}
static void
obj_coff_loc (int ignore ATTRIBUTE_UNUSED)
{
int lineno;
/* FIXME: Why do we need this check? We need it for ECOFF, but why
do we need it for COFF? */
if (now_seg != text_section)
{
as_warn (_(".loc outside of .text"));
demand_empty_rest_of_line ();
return;
}
if (def_symbol_in_progress != NULL)
{
as_warn (_(".loc pseudo-op inside .def/.endef: ignored."));
demand_empty_rest_of_line ();
return;
}
/* Skip the file number. */
SKIP_WHITESPACE ();
get_absolute_expression ();
SKIP_WHITESPACE ();
lineno = get_absolute_expression ();
#ifndef NO_LISTING
{
extern int listing;
if (listing)
{
lineno += coff_line_base - 1;
listing_source_line (lineno);
}
}
#endif
demand_empty_rest_of_line ();
add_lineno (frag_now, frag_now_fix (), lineno);
}
static void
obj_coff_val (int ignore ATTRIBUTE_UNUSED)
{
if (def_symbol_in_progress == NULL)
{
as_warn (_(".val pseudo-op used outside of .def/.endef ignored."));
demand_empty_rest_of_line ();
return;
}
if (is_name_beginner (*input_line_pointer))
{
char *symbol_name = input_line_pointer;
char name_end = get_symbol_end ();
#ifdef tc_canonicalize_symbol_name
symbol_name = tc_canonicalize_symbol_name (symbol_name);
#endif
if (streq (symbol_name, "."))
{
/* If the .val is != from the .def (e.g. statics). */
symbol_set_frag (def_symbol_in_progress, frag_now);
S_SET_VALUE (def_symbol_in_progress, (valueT) frag_now_fix ());
}
else if (! streq (S_GET_NAME (def_symbol_in_progress), symbol_name))
{
expressionS exp;
exp.X_op = O_symbol;
exp.X_add_symbol = symbol_find_or_make (symbol_name);
exp.X_op_symbol = NULL;
exp.X_add_number = 0;
symbol_set_value_expression (def_symbol_in_progress, &exp);
/* If the segment is undefined when the forward reference is
resolved, then copy the segment id from the forward
symbol. */
SF_SET_GET_SEGMENT (def_symbol_in_progress);
/* FIXME: gcc can generate address expressions here in
unusual cases (search for "obscure" in sdbout.c). We
just ignore the offset here, thus generating incorrect
debugging information. We ignore the rest of the line
just below. */
}
/* Otherwise, it is the name of a non debug symbol and its value
will be calculated later. */
*input_line_pointer = name_end;
}
else
{
S_SET_VALUE (def_symbol_in_progress, get_absolute_expression ());
}
demand_empty_rest_of_line ();
}
static void
out_debug_line (segT line_seg)
{
expressionS exp;
symbolS *prologue_end;
symbolS *line_end;
struct line_seg *s;
int sizeof_offset;
sizeof_offset = out_header (line_seg, &exp);
line_end = exp.X_add_symbol;
/* Version. */
out_two (DWARF2_VERSION);
/* Length of the prologue following this length. */
prologue_end = symbol_temp_make ();
exp.X_add_symbol = prologue_end;
exp.X_add_number = - (4 + 2 + 4);
emit_expr (&exp, sizeof_offset);
/* Parameters of the state machine. */
out_byte (DWARF2_LINE_MIN_INSN_LENGTH);
out_byte (DWARF2_LINE_DEFAULT_IS_STMT);
out_byte (DWARF2_LINE_BASE);
out_byte (DWARF2_LINE_RANGE);
out_byte (DWARF2_LINE_OPCODE_BASE);
/* Standard opcode lengths. */
out_byte (0); /* DW_LNS_copy */
out_byte (1); /* DW_LNS_advance_pc */
out_byte (1); /* DW_LNS_advance_line */
out_byte (1); /* DW_LNS_set_file */
out_byte (1); /* DW_LNS_set_column */
out_byte (0); /* DW_LNS_negate_stmt */
out_byte (0); /* DW_LNS_set_basic_block */
out_byte (0); /* DW_LNS_const_add_pc */
out_byte (1); /* DW_LNS_fixed_advance_pc */
out_byte (0); /* DW_LNS_set_prologue_end */
out_byte (0); /* DW_LNS_set_epilogue_begin */
out_byte (1); /* DW_LNS_set_isa */
out_file_list ();
symbol_set_value_now (prologue_end);
/* For each section, emit a statement program. */
for (s = all_segs; s; s = s->next)
if (SEG_NORMAL (s->seg))
process_entries (s->seg, s->head->head);
else
as_warn ("dwarf line number information for %s ignored",
segment_name (s->seg));
symbol_set_value_now (line_end);
}
static symbolS *
obj_coff_common_parse (int ignore ATTRIBUTE_UNUSED, symbolS *symbolP, addressT size)
{
addressT align = 0;
if (*input_line_pointer == ',')
{
align = parse_align (0);
if (align == (addressT) -1)
return NULL;
}
S_SET_VALUE (symbolP, size);
S_SET_EXTERNAL (symbolP);
S_SET_SEGMENT (symbolP, bfd_com_section_ptr);
symbol_get_bfdsym (symbolP)->flags |= BSF_OBJECT;
/* There is no S_SET_ALIGN (symbolP, align) in COFF/PE.
Instead we must add a note to the .drectve section. */
if (align)
{
segT current_seg = now_seg;
subsegT current_subseg = now_subseg;
flagword oldflags;
asection *sec;
size_t pfxlen, numlen;
char *frag;
char numbuff[20];
sec = subseg_new (".drectve", 0);
oldflags = bfd_get_section_flags (stdoutput, sec);
if (oldflags == SEC_NO_FLAGS)
{
if (!bfd_set_section_flags (stdoutput, sec,
TC_COFF_SECTION_DEFAULT_ATTRIBUTES))
as_warn (_("error setting flags for \"%s\": %s"),
bfd_section_name (stdoutput, sec),
bfd_errmsg (bfd_get_error ()));
}
/* Emit a string. Note no NUL-termination. */
pfxlen = strlen (" -aligncomm:") + 2 + strlen (S_GET_NAME (symbolP)) + 1;
numlen = snprintf (numbuff, sizeof (numbuff), "%d", (int) align);
frag = frag_more (pfxlen + numlen);
(void) sprintf (frag, " -aligncomm:\"%s\",", S_GET_NAME (symbolP));
memcpy (frag + pfxlen, numbuff, numlen);
/* Restore original subseg. */
subseg_set (current_seg, current_subseg);
}
return symbolP;
}
static void
obj_coff_scl (int ignore ATTRIBUTE_UNUSED)
{
if (def_symbol_in_progress == NULL)
{
as_warn (_(".scl pseudo-op used outside of .def/.endef ignored."));
demand_empty_rest_of_line ();
return;
}
S_SET_STORAGE_CLASS (def_symbol_in_progress, get_absolute_expression ());
demand_empty_rest_of_line ();
}
static void
s_sparc_align()
{
register unsigned int temp;
register long int temp_fill;
unsigned int i;
temp = get_absolute_expression ();
#define MAX_ALIGNMENT (1 << 15)
if ( temp > MAX_ALIGNMENT ) {
as_warn("Alignment too large: %d. assumed.", temp = MAX_ALIGNMENT);
}
/*
* For the sparc, `.align (1<<n)' actually means `.align n'
* so we have to convert it.
*/
if (temp != 0) {
for (i = 0; (temp & 1) == 0; temp >>= 1, ++i)
;
}
if (temp != 1) {
as_warn("Alignment not a power of 2");
}
temp = i;
if (*input_line_pointer == ',') {
input_line_pointer ++;
temp_fill = get_absolute_expression ();
} else {
temp_fill = 0;
}
/* Only make a frag if we HAVE to. . . */
if (temp && ! need_pass_2) {
frag_align (temp, (int)temp_fill);
}
demand_empty_rest_of_line();
return;
}
static void
obj_coff_dim (int ignore ATTRIBUTE_UNUSED)
{
int dim_index;
if (def_symbol_in_progress == NULL)
{
as_warn (_(".dim pseudo-op used outside of .def/.endef: ignored."));
demand_empty_rest_of_line ();
return;
}
S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
for (dim_index = 0; dim_index < DIMNUM; dim_index++)
{
SKIP_WHITESPACES ();
SA_SET_SYM_DIMEN (def_symbol_in_progress, dim_index,
get_absolute_expression ());
switch (*input_line_pointer)
{
case ',':
input_line_pointer++;
break;
default:
as_warn (_("badly formed .dim directive ignored"));
/* Fall through. */
case '\n':
case ';':
dim_index = DIMNUM;
break;
}
}
demand_empty_rest_of_line ();
}
static void
get_interrupt_operand (char **ptr, struct z8k_op *mode, unsigned int dst ATTRIBUTE_UNUSED)
{
char *src = *ptr;
int i, l;
while (*src == ' ')
src++;
mode->mode = CLASS_IMM;
the_interrupt = 0;
while (*src)
{
for (i = 0; intr_table[i].name; i++)
{
l = strlen (intr_table[i].name);
if (! strncasecmp (intr_table[i].name, src, l))
{
the_interrupt |= intr_table[i].value;
if (*(src + l) && *(src + l) != ',')
{
*ptr = src + l;
invalid:
as_bad (_("unknown interrupt %s"), src);
while (**ptr && ! is_end_of_line[(unsigned char) **ptr])
(*ptr)++; /* Consume rest of line. */
return;
}
src += l;
if (! *src)
{
*ptr = src;
return;
}
}
}
if (*src == ',')
src++;
else
{
*ptr = src;
goto invalid;
}
}
/* No interrupt type specified, opcode won't do anything. */
as_warn (_("opcode has no effect"));
the_interrupt = 0x0;
}
static void
obj_coff_size (int ignore ATTRIBUTE_UNUSED)
{
if (def_symbol_in_progress == NULL)
{
as_warn (_(".size pseudo-op used outside of .def/.endef ignored."));
demand_empty_rest_of_line ();
return;
}
S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
SA_SET_SYM_SIZE (def_symbol_in_progress, get_absolute_expression ());
demand_empty_rest_of_line ();
}
static void
obj_coff_type (int ignore ATTRIBUTE_UNUSED)
{
if (def_symbol_in_progress == NULL)
{
as_warn (_(".type pseudo-op used outside of .def/.endef ignored."));
demand_empty_rest_of_line ();
return;
}
S_SET_DATA_TYPE (def_symbol_in_progress, get_absolute_expression ());
if (ISFCN (S_GET_DATA_TYPE (def_symbol_in_progress)) &&
S_GET_STORAGE_CLASS (def_symbol_in_progress) != C_TPDEF)
SF_SET_FUNCTION (def_symbol_in_progress);
demand_empty_rest_of_line ();
}
void
delete_macro (const char *name)
{
char *copy;
size_t i, len;
macro_entry *macro;
len = strlen (name);
copy = (char *) alloca (len + 1);
for (i = 0; i < len; ++i)
copy[i] = TOLOWER (name[i]);
copy[i] = '\0';
/* Since hash_delete doesn't free memory, just clear out the entry. */
if ((macro = hash_find (macro_hash, copy)) != NULL)
{
hash_jam (macro_hash, copy, NULL);
free_macro (macro);
}
else
as_warn (_("Attempt to purge non-existant macro `%s'"), copy);
}
static void
obj_coff_def (int what ATTRIBUTE_UNUSED)
{
char name_end; /* Char after the end of name. */
char *symbol_name; /* Name of the debug symbol. */
char *symbol_name_copy; /* Temporary copy of the name. */
unsigned int symbol_name_length;
if (def_symbol_in_progress != NULL)
{
as_warn (_(".def pseudo-op used inside of .def/.endef: ignored."));
demand_empty_rest_of_line ();
return;
}
SKIP_WHITESPACES ();
symbol_name = input_line_pointer;
name_end = get_symbol_end ();
symbol_name_length = strlen (symbol_name);
symbol_name_copy = xmalloc (symbol_name_length + 1);
strcpy (symbol_name_copy, symbol_name);
#ifdef tc_canonicalize_symbol_name
symbol_name_copy = tc_canonicalize_symbol_name (symbol_name_copy);
#endif
/* Initialize the new symbol. */
def_symbol_in_progress = symbol_make (symbol_name_copy);
symbol_set_frag (def_symbol_in_progress, &zero_address_frag);
S_SET_VALUE (def_symbol_in_progress, 0);
if (S_IS_STRING (def_symbol_in_progress))
SF_SET_STRING (def_symbol_in_progress);
*input_line_pointer = name_end;
demand_empty_rest_of_line ();
}
segT /* Return resultP -> X_seg */
expression(
expressionS *resultP) /* deliver result here */
{
segT segment;
segment = expr(0, resultP);
/* what about caller's that just want to ignore this and print the're own
error message? ok I guess */
if(segment == SEG_DIFFSECT &&
resultP->X_add_symbol == NULL &&
(resultP->X_subtract_symbol->sy_type & N_TYPE) != N_UNDF){
as_warn("Subtracting symbol \"%s\"(segment\"%s\") is too "
"hard. Absolute segment assumed.",
resultP->X_subtract_symbol->sy_name,
seg_name[(int)N_TYPE_seg[
resultP->X_subtract_symbol->sy_type & N_TYPE]]);
segment = SEG_ABSOLUTE;
/* Leave exp .X_add_number alone. */
}
return(segment);
}
static void
s_seg()
{
if (strncmp(input_line_pointer, "\"text\"", 6) == 0) {
input_line_pointer += 6;
s_text();
return;
}
if (strncmp(input_line_pointer, "\"data\"", 6) == 0) {
input_line_pointer += 6;
s_data();
return;
}
if (strncmp(input_line_pointer, "\"data1\"", 7) == 0) {
input_line_pointer += 7;
s_data1();
return;
}
as_warn("Unknown segment type");
demand_empty_rest_of_line();
return;
}
static void
obj_coff_weak (int ignore ATTRIBUTE_UNUSED)
{
char *name;
int c;
symbolS *symbolP;
do
{
name = input_line_pointer;
c = get_symbol_end ();
if (*name == 0)
{
as_warn (_("badly formed .weak directive ignored"));
ignore_rest_of_line ();
return;
}
c = 0;
symbolP = symbol_find_or_make (name);
*input_line_pointer = c;
SKIP_WHITESPACE ();
S_SET_WEAK (symbolP);
if (c == ',')
{
input_line_pointer++;
SKIP_WHITESPACE ();
if (*input_line_pointer == '\n')
c = '\n';
}
}
while (c == ',');
demand_empty_rest_of_line ();
}
static void
obj_coff_ln (int appline)
{
int l;
if (! appline && def_symbol_in_progress != NULL)
{
as_warn (_(".ln pseudo-op inside .def/.endef: ignored."));
demand_empty_rest_of_line ();
return;
}
l = get_absolute_expression ();
/* If there is no lineno symbol, treat a .ln
directive as if it were a .appline directive. */
if (appline || current_lineno_sym == NULL)
new_logical_line ((char *) NULL, l - 1);
else
add_lineno (frag_now, frag_now_fix (), l);
#ifndef NO_LISTING
{
extern int listing;
if (listing)
{
if (! appline)
l += coff_line_base - 1;
listing_source_line (l);
}
}
#endif
demand_empty_rest_of_line ();
}
void
delete_macro (const char *name)
{
char *copy;
size_t i, len;
macro_entry *macro;
len = strlen (name);
copy = (char *) alloca (len + 1);
for (i = 0; i < len; ++i)
copy[i] = TOLOWER (name[i]);
copy[i] = '\0';
/* We can only ask hash_delete to free memory if we are deleting
macros in reverse order to their definition.
So just clear out the entry. */
if ((macro = (macro_entry *) hash_find (macro_hash, copy)) != NULL)
{
hash_jam (macro_hash, copy, NULL);
free_macro (macro);
}
else
as_warn (_("Attempt to purge non-existant macro `%s'"), copy);
}
/*
* fixup_section() does the fixups of the frags and prepares the fixes so
* relocation entries can be created from them. The fixups cause the contents
* of the frag to have the value for the fixup expression. A fix structure that
* ends up with a non-NULL fx_addsy will have a relocation entry created for it.
*/
static
void
fixup_section(
fixS *fixP,
int nsect)
{
symbolS *add_symbolP;
symbolS *sub_symbolP;
signed_expr_t value;
int size;
char *place;
int32_t where;
char pcrel;
fragS *fragP;
int add_symbol_N_TYPE;
int add_symbol_nsect;
#ifndef SPARC
int sub_symbol_nsect;
#endif
/*
* The general fix expression is "fx_addsy - fx_subsy + fx_offset".
* The goal is to put the result of this expression into the frag at
* "place" for size "size". The value of the expression is calculated
* in the variable "value" and starts with just the fx_offset.
*/
for( ; fixP != NULL; fixP = fixP->fx_next){
fragP = fixP->fx_frag;
know(fragP);
where = fixP->fx_where;
place = fragP->fr_literal + where;
size = fixP->fx_size;
#ifdef TC_FIXUP_SYMBOL
fixP->fx_offset += TC_FIXUP_SYMBOL(fixP, nsect, &fixP->fx_addsy);
fixP->fx_offset -= TC_FIXUP_SYMBOL(fixP, nsect, &fixP->fx_subsy);
#endif
#if defined(I386) && defined(ARCH64)
if(fixP->fx_addsy == fixP->fx_subsy){
/*
* If we've fixed up both symbols to the same location,
* we don't need a relocation entry.
*/
fixP->fx_addsy = NULL;
fixP->fx_subsy = NULL;
}
#endif
add_symbolP = fixP->fx_addsy;
sub_symbolP = fixP->fx_subsy;
value = fixP->fx_offset;
pcrel = fixP->fx_pcrel;
#if ARM
/* If the symbol is defined in this file, the linker won't set the
low-order bit for a Thumb symbol, so we have to do it here. */
if(add_symbolP != NULL && add_symbolP->sy_desc & N_ARM_THUMB_DEF &&
!(sub_symbolP != NULL && sub_symbolP->sy_desc & N_ARM_THUMB_DEF) &&
!pcrel){
value |= 1;
}
#endif
add_symbol_N_TYPE = 0;
add_symbol_nsect = 0;
if(add_symbolP != NULL){
add_symbol_N_TYPE = add_symbolP->sy_type & N_TYPE;
if(add_symbol_N_TYPE == N_SECT)
add_symbol_nsect = add_symbolP->sy_other;
}
/*
* Is there a subtract symbol?
*/
if(sub_symbolP){
/* is it just -sym ? */
if(add_symbolP == NULL){
if(sub_symbolP->sy_type != N_ABS)
as_warn("Negative of non-absolute symbol %s",
sub_symbolP->sy_name);
#if !(defined(I386) && defined(ARCH64))
/* Symbol offsets are not part of fixups for x86_64. */
value -= sub_symbolP->sy_value;
#endif
fixP->fx_subsy = NULL;
}
/*
* There are both an add symbol and a subtract symbol at this
* point.
*
* If both symbols are absolute then just calculate the
* value of the fix expression and no relocation entry will be
* needed.
*/
else if((sub_symbolP->sy_type & N_TYPE) == N_ABS &&
(add_symbolP->sy_type & N_TYPE) == N_ABS){
value += add_symbolP->sy_value - sub_symbolP->sy_value;
add_symbolP = NULL;
fixP->fx_addsy = NULL; /* no relocation entry */
fixP->fx_subsy = NULL;
}
/*
* If both symbols are defined in a section then calculate the
* value of the fix expression and let a section difference
* relocation entry be created.
*/
else if((sub_symbolP->sy_type & N_TYPE) == N_SECT &&
(add_symbolP->sy_type & N_TYPE) == N_SECT){
/*
* We are use the new features that are incompatible with
* 3.2 then just calculate the value and let this create a
* SECTDIFF relocation type.
*/
#ifdef SPARC
/*
* Special case dealing with assembler internal relocation
* entries SPARC_RELOC_13 and RELOC_22. The can not be
* output and must be resolved.
*/
if((fixP->fx_r_type == SPARC_RELOC_13) ||
(fixP->fx_r_type == SPARC_RELOC_22)){
if(sub_symbolP->sy_other == add_symbolP->sy_other){
value += add_symbolP->sy_value -
sub_symbolP->sy_value;
add_symbolP = NULL;
fixP->fx_addsy = NULL; /* no relocation entry */
fixP->fx_subsy = NULL;
}
else{
as_warn("Can't emit reloc type %u {-symbol \"%s\"} "
"@ file address %llu (mode?).",
fixP->fx_r_type, sub_symbolP->sy_name,
fragP->fr_address + where);
}
}
else
value += add_symbolP->sy_value - sub_symbolP->sy_value;
#else
#if !(defined(I386) && defined(ARCH64))
/*
* Special case for x86_64. 'value' doesn't include
* the difference between the two symbols because
* that's handled by the subtractor/vanilla reloc pair.
*/
value += add_symbolP->sy_value;
value -= sub_symbolP->sy_value;
#else
/*
* But for x86_64 expressions in the debug section must
* be the actual value of the expression.
*/
if(is_section_debug(nsect)){
value += add_symbolP->sy_value;
value -= sub_symbolP->sy_value;
}
#endif
sub_symbol_nsect = sub_symbolP->sy_other;
/*
* If we have the special assembly time constant expression
* of the difference of two symbols defined in the same
* section then divided by exactly 2 adjust the value and
* make sure these symbols will produce an assembly time
* constant.
*/
if(fixP->fx_sectdiff_divide_by_two == 1){
value = value / 2;
if(is_assembly_time_constant_subtraction_expression(
add_symbolP, add_symbol_nsect,
sub_symbolP, sub_symbol_nsect) == TRUE){
fixP->fx_addsy = NULL; /* no relocation entry */
goto down;
}
else{
layout_line = fixP->line;
layout_file = fixP->file;
as_warn("section difference divide by two "
"expression, \"%s\" minus \"%s\" divide by "
"2 will not produce an assembly time "
"constant", add_symbolP->sy_name,
sub_symbolP->sy_name);
}
}
if(is_end_section_address(add_symbol_nsect,
add_symbolP->sy_value) ||
is_end_section_address(sub_symbol_nsect,
sub_symbolP->sy_value)){
if(is_assembly_time_constant_subtraction_expression(
add_symbolP, add_symbol_nsect,
sub_symbolP, sub_symbol_nsect) == TRUE){
fixP->fx_addsy = NULL; /* no relocation entry */
goto down;
}
if(is_section_debug(nsect) &&
strcmp(add_symbolP->sy_name, FAKE_LABEL_NAME) == 0 &&
strcmp(sub_symbolP->sy_name, FAKE_LABEL_NAME) == 0){
fixP->fx_addsy = NULL; /* no relocation entry */
goto down;
}
layout_line = fixP->line;
layout_file = fixP->file;
as_warn("section difference relocatable subtraction "
"expression, \"%s\" minus \"%s\" using a "
"symbol at the end of section will not "
"produce an assembly time constant",
add_symbolP->sy_name, sub_symbolP->sy_name);
as_warn("use a symbol with a constant value created "
"with an assignment instead of the expression, "
"L_const_sym = %s - %s", add_symbolP->sy_name,
sub_symbolP->sy_name);
layout_line = 0;
layout_file = NULL;
}
#endif
goto down;
}
/*
* If the subtract symbol is absolute subtract it's value from
* the fix expression and let a relocation entry get created
* that is not a section difference type.
*/
else if(sub_symbolP->sy_type == N_ABS){
value -= sub_symbolP->sy_value;
fixP->fx_subsy = NULL; /* no SECTDIFF relocation entry */
}
/*
* At this point we have something we can't generate a
* relocation entry for (two undefined symbols, etc.).
*/
else{
layout_line = fixP->line;
layout_file = fixP->file;
as_bad("non-relocatable subtraction expression, \"%s\" "
"minus \"%s\"", add_symbolP->sy_name,
sub_symbolP->sy_name);
if((add_symbolP->sy_type & N_TYPE) == N_UNDF)
as_bad("symbol: \"%s\" can't be undefined in a "
"subtraction expression", add_symbolP->sy_name);
if((sub_symbolP->sy_type & N_TYPE) == N_UNDF)
as_bad("symbol: \"%s\" can't be undefined in a "
"subtraction expression", sub_symbolP->sy_name);
layout_line = 0;
layout_file = NULL;
}
}
/*
* If a there is an add symbol in the fixup expression then add
* the symbol value into the fixup expression's value.
*/
if(add_symbolP){
/*
* If this symbol is in this section and is pc-relative and we
* do not want to force a pc-relative relocation entry (to
* support scattered loading) then just calculate the value.
*/
if(add_symbol_nsect == nsect
/* FROM write.c line 2659 */
#ifdef ARM
&& !TC_FORCE_RELOCATION_LOCAL (fixP)
#else
&& pcrel
#endif
&& !(fixP->fx_pcrel_reloc)){
/*
* This fixup was made when the symbol's section was
* unknown, but it is now in this section. So we know how
* to do the address without relocation.
*/
value += add_symbolP->sy_value;
#ifdef ARM
/* FROM write.c line 2667 */
value -= MD_PCREL_FROM_SECTION (fixP, nsect);
#else
value -= size + where + fragP->fr_address;
#endif
pcrel = 0; /* Lie. Don't want further pcrel processing. */
fixP->fx_addsy = NULL; /* No relocations please. */
/*
* It would be nice to check that the address does not
* overflow.
* I didn't do this check because:
* + It is machine dependent in the general case (eg 32032)
* + Compiler output will never need this checking, so why
* slow down the usual case?
*/
}
else{
switch(add_symbol_N_TYPE){
case N_ABS:
/*
* If the value of the symbol was an expression then
* now evaluate the expression now. This can happen
* when symbols like:
* .set x,a-b
* are used and the value of x is not known till all
* of the symbols are seen and had their values set.
*/
if(add_symbolP->expression != NULL){
expressionS *exp;
exp = (expressionS *)add_symbolP->expression;
value +=
exp->X_add_symbol->sy_value +
exp->X_add_number -
exp->X_subtract_symbol->sy_value;
}
else
{
value += add_symbolP->sy_value;
}
fixP->fx_addsy = NULL; /* no relocation entry */
add_symbolP = NULL;
break;
case N_SECT:
#if (defined(I386) && defined(ARCH64))
/*
* Symbol offsets are not part of fixups for external
* symbols for x86_64.
*/
if((is_section_debug(nsect) &&
add_symbol_N_TYPE != N_UNDF) ||
(add_symbol_N_TYPE == N_SECT &&
is_local_symbol(add_symbolP) &&
!is_section_cstring_literals(add_symbol_nsect)) )
#else
if(((add_symbolP->sy_type & N_EXT) != N_EXT ||
add_symbol_N_TYPE != N_SECT ||
!is_section_coalesced(add_symbol_nsect)) &&
(add_symbolP->sy_desc & N_WEAK_DEF) != N_WEAK_DEF)
#endif
value += add_symbolP->sy_value;
break;
case N_UNDF:
break;
default:
BAD_CASE(add_symbol_N_TYPE);
break;
}
}
}
down:
/*
* If the fixup expression is pc-relative then the value of the pc
* will be added to the expression when the machine executes the
* the instruction so we adjust the fixup expression's value by
* subtracting off the pc value (where) and adjust for insn size.
*/
if(pcrel){
#ifdef ARM
/* This should work for both */
/* FROM write.c line 2688 */
value -= MD_PCREL_FROM_SECTION (fixP, nsect);
#elif !(defined(I386) && defined(ARCH64))
/* Symbol offsets are not part of fixups for x86_64. */
value -= size + where + fragP->fr_address;
#endif
if(add_symbolP == NULL){
fixP->fx_addsy = &abs_symbol; /* force relocation entry */
}
}
if((size == 1 && (value & 0xffffff00) &&
((value & 0xffffff80) != 0xffffff80)) ||
(size == 2 && (value & 0xffff0000) &&
((value & 0xffff8000) != 0xffff8000))){
layout_line = fixP->line;
layout_file = fixP->file;
as_bad("Fixup of %lld too large for field width of %d",
value, size);
layout_line = 0;
layout_file = NULL;
}
/*
* Now place the fix expression's value in the place for the size.
* And save the fix expression's value to be used when creating
* a relocation entry if required.
*/
md_number_to_imm((unsigned char *)place, value, size, fixP, nsect);
fixP->fx_value = value;
/*
* If this is a non-lazy pointer section and this fix is for a
* local symbol without an subtract symbol then cause this not to
* generate a relocation entry. This is used with code gen for
* fix-n-continue where the compiler generates indirection for
* static data references. So the assembly looks like this:
*
* .non_lazy_symbol_pointer
* L_i$non_lazy_ptr:
* .indirect_symbol _i
* .long _i
*
* this allows the value of the symbol to be set into the pointer
* but not cause the relocation entry to be created. The code in
* write_object() then changes the indirect symbol table entry to
* INDIRECT_SYMBOL_LOCAL when the symbol is local. This is what
* the static and dynamic linkers expect and will then cause the
* pointer to be correctly relocated.
*/
if(is_section_non_lazy_symbol_pointers(nsect) &&
(add_symbolP->sy_type & N_EXT) != N_EXT &&
sub_symbolP == NULL){
fixP->fx_addsy = NULL; /* no relocation entry */
}
}
}
/*
* layout_addresses() is called after all the assembly code has been read and
* fragments, symbols and fixups have been created. This routine sets the
* address of the fragments and symbols. Then it does the fixups of the frags
* and prepares the fixes so relocation entries can be created from them.
*/
void
layout_addresses(
void)
{
struct frchain *frchainP;
fragS *fragP;
relax_addressT slide, tmp;
symbolS *symbolP;
uint32_t nbytes, fill_size, repeat_expression, partial_bytes, layout_pass;
relax_stateT old_fr_type;
int changed;
if(frchain_root == NULL)
return;
/*
* If there is any current frag close it off.
*/
if(frag_now != NULL && frag_now->fr_fix == 0){
frag_now->fr_fix = obstack_next_free(&frags) -
frag_now->fr_literal;
frag_wane(frag_now);
}
/*
* For every section, add a last ".fill 0" frag that will later be used
* as the ending address of that section.
*/
for(frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next){
/*
* We must do the obstack_finish(), so the next object we put on
* obstack frags will not appear to start at the fr_literal of the
* current frag. Also, it ensures that the next object will begin
* on a address that is aligned correctly for the engine that runs
* the assembler.
*/
(void)obstack_finish(&frags);
/*
* Make a fresh frag for the last frag.
*/
frag_now = (fragS *)obstack_alloc(&frags, SIZEOF_STRUCT_FRAG);
memset(frag_now, '\0', SIZEOF_STRUCT_FRAG);
frag_now->fr_next = NULL;
(void)obstack_finish(&frags);
/*
* Append the new frag to current frchain.
*/
frchainP->frch_last->fr_next = frag_now;
frchainP->frch_last = frag_now;
frag_wane(frag_now);
}
/*
* Now set the relative addresses of frags within the section by
* relaxing each section. That is all sections will start at address
* zero and addresses of the frags in that section will increase from
* there.
*
* The debug sections are done last as other section are needed to be
* done first becase debug sections may have line numbers with .loc
* directives in them and their sizes need to be set before processing
* the line number sections. We also do sections that have rs_leb128s
* in them before debug sections but after other sections since they
* are used for things like exception tables and they may be refering to
* sections such that their sizes too must be known first.
*/
for(frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next){
if((frchainP->frch_section.flags & S_ATTR_DEBUG) == S_ATTR_DEBUG)
frchainP->layout_pass = 2;
else if(frchainP->has_rs_leb128s == TRUE)
frchainP->layout_pass = 1;
else
frchainP->layout_pass = 0;
}
for(layout_pass = 0; layout_pass < 3; layout_pass++){
do{
changed = 0;
for(frchainP = frchain_root;
frchainP;
frchainP = frchainP->frch_next){
if(frchainP->layout_pass != layout_pass)
continue;
if((frchainP->frch_section.flags & SECTION_TYPE) ==
S_ZEROFILL)
continue;
/*
* This is done so in case md_estimate_size_before_relax()
* (called by relax_section) wants to make fixSs they are
* for this section.
*/
frchain_now = frchainP;
changed += relax_section(frchainP->frch_root,
frchainP->frch_nsect);
}
}
while(changed != 0);
}
/*
* Now set the absolute addresses of all frags by sliding the frags in
* each non-zerofill section by the address ranges taken up by the
* sections before it.
*/
slide = 0;
for(frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next){
if((frchainP->frch_section.flags & SECTION_TYPE) == S_ZEROFILL)
continue;
slide = round(slide, 1 << frchainP->frch_section.align);
tmp = frchainP->frch_last->fr_address;
if(slide != 0){
for(fragP = frchainP->frch_root; fragP; fragP = fragP->fr_next){
fragP->fr_address += slide;
}
}
slide += tmp;
}
/*
* Now with the non-zerofill section addresses set set all of the
* addresses of the zerofill sections. Comming in the fr_address is
* the size of the section and going out it is the start address. This
* will make layout_symbols() work out naturally. The only funky thing
* is that section numbers do not end up in address order.
*/
for(frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next){
if((frchainP->frch_section.flags & SECTION_TYPE) != S_ZEROFILL)
continue;
slide = round(slide, 1 << frchainP->frch_section.align);
tmp = frchainP->frch_root->fr_address;
frchainP->frch_root->fr_address = slide;
frchainP->frch_last->fr_address = tmp + slide;
slide += tmp;
}
/*
* Set the symbol addresses based on their frag's address.
* First forward references are handled.
*/
for(symbolP = symbol_rootP; symbolP; symbolP = symbolP->sy_next){
if(symbolP->sy_forward != NULL){
if(symbolP->sy_nlist.n_type & N_STAB)
symbolP->sy_other = symbolP->sy_forward->sy_other;
symbolP->sy_value += symbolP->sy_forward->sy_value +
symbolP->sy_forward->sy_frag->fr_address;
symbolP->sy_forward = 0;
}
}
for(symbolP = symbol_rootP; symbolP; symbolP = symbolP->sy_next){
symbolP->sy_value += symbolP->sy_frag->fr_address;
}
/*
* At this point the addresses of frags now reflect addresses we use in
* the object file and the symbol values are correct.
* Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
* Also converting any machine-dependent frags using md_convert_frag();
*/
for(frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next){
/*
* This is done so any fixes created by md_convert_frag() are for
* this section.
*/
frchain_now = frchainP;
for(fragP = frchainP->frch_root; fragP; fragP = fragP->fr_next){
switch(fragP->fr_type){
case rs_align:
case rs_org:
old_fr_type = fragP->fr_type;
/* convert this frag to an rs_fill type */
fragP->fr_type = rs_fill;
/*
* Calculate the number of bytes the variable part of the
* the rs_fill frag will need to fill. Then calculate this
* as the fill_size * repeat_expression + partial_bytes.
*/
know(fragP->fr_next != NULL);
nbytes = fragP->fr_next->fr_address -
fragP->fr_address -
fragP->fr_fix;
if(nbytes < 0){
as_warn("rs_org invalid, dot past value by %d bytes",
nbytes);
nbytes = 0;
}
fill_size = fragP->fr_var;
repeat_expression = nbytes / fill_size;
#ifdef I386
/*
* For x86 architecures in sections containing only
* instuctions being padded with nops that are aligned to 16
* bytes or less and are assembled with -dynamic we will
* actually end up padding with the optimal nop sequence.
* Previously there has been the maximum number of bytes
* allocated in the frag to use for this.
*/
if(old_fr_type == rs_align &&
(frchain_now->frch_section.flags &
S_ATTR_PURE_INSTRUCTIONS) != 0 &&
fill_size == 1 &&
fragP->fr_literal[fragP->fr_fix] == (char)0x90 &&
nbytes > 0 && nbytes < 16 &&
flagseen['k'] == TRUE){
i386_align_code(fragP, nbytes);
/*
* The call to i386_align_code() has set the fill_size
* in fragP->fr_var to nbytes. So we set the fr_offset
* to the fill repeat_expression to 1 to match for this
* now an rs_fill type frag.
*/
fragP->fr_offset = 1;
break;
}
#endif /* I386 */
partial_bytes = nbytes - (repeat_expression * fill_size);
/*
* Now set the fr_offset to the fill repeat_expression
* since this is now an rs_fill type. The fr_var is still
* the fill_size.
*/
fragP->fr_offset = repeat_expression;
/*
* For rs_align frags there may be partial_bytes to fill
* with zeros before we can fill with the fill_expression
* of fill_size. When the rs_align frag was created it was
* created with fill_size-1 extra bytes in the fixed part.
*/
if(partial_bytes != 0){
/* moved the fill_expression bytes foward */
memmove(fragP->fr_literal +fragP->fr_fix +partial_bytes,
fragP->fr_literal +fragP->fr_fix,
fragP->fr_var);
/* zero out the partial_bytes */
memset(fragP->fr_literal + fragP->fr_fix,
'\0',
partial_bytes);
/* adjust the fixed part of the frag */
fragP->fr_fix += partial_bytes;
}
break;
case rs_fill:
break;
case rs_machine_dependent:
md_convert_frag(fragP);
/*
* After md_convert_frag, we make the frag into a ".fill 0"
* md_convert_frag() should set up any fixSs and constants
* required.
*/
frag_wane(fragP);
break;
case rs_dwarf2dbg:
dwarf2dbg_convert_frag(fragP);
break;
case rs_leb128:
{
int size;
#ifdef OLD
valueT value = S_GET_VALUE (fragP->fr_symbol);
#else
valueT value;
expressionS *expression;
if(fragP->fr_symbol->expression != NULL){
expression =
(expressionS *)fragP->fr_symbol->expression;
value = 0;
if(expression->X_add_symbol != NULL)
value += expression->X_add_symbol->sy_nlist.n_value;
if(expression->X_subtract_symbol != NULL)
value -=
expression->X_subtract_symbol->sy_nlist.n_value;
value += expression->X_add_number;
}
else{
value = fragP->fr_symbol->sy_nlist.n_value +
fragP->fr_address;
}
#endif
size = output_leb128 (fragP->fr_literal + fragP->fr_fix,
value,
fragP->fr_subtype);
fragP->fr_fix += size;
fragP->fr_type = rs_fill;
fragP->fr_var = 0;
fragP->fr_offset = 0;
fragP->fr_symbol = NULL;
}
break;
default:
BAD_CASE(fragP->fr_type);
break;
}
}
}
/*
* For each section do the fixups for the frags.
*/
for(frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next){
now_seg = frchainP->frch_nsect;
fixup_section(frchainP->frch_fix_root, frchainP->frch_nsect);
}
}
/*
* section_new() (for non-zerofill sections) switches to a new section, creating
* it if needed, and creates a fresh fragment. If it is the current section
* nothing happens except checks to make sure the type, attributes and
* sizeof_stub are the same. The segment and section names will be trimed to
* fit in the section structure and is the responsiblity of the caller to
* report errors if they don't. For zerofill sections only the struct frchain
* for the section is returned after possibly being created (these section are
* never made the current section and no frags are ever touched).
*
* Globals on input:
* frchain_now points to the (possibly none) struct frchain for the current
* section.
* frag_now points at an incomplete frag for current section.
* If frag_now == NULL, then there is no old, incomplete frag, so the old
* frag is not closed off.
*
* Globals on output:
* frchain_now points to the (possibly new) struct frchain for this section.
* frchain_root updated if needed (for the first section created).
* frag_now is set to the last (possibly new) frag in the section.
* now_seg is set to the Mach-O section number (frch_nsect field) except
* it is not set for section types of S_ZEROFILL.
*/
frchainS *
section_new(
char *segname,
char *sectname,
uint32_t type,
uint32_t attributes,
uint32_t sizeof_stub)
{
frchainS *frcP;
frchainS **lastPP;
uint32_t last_nsect;
if(frags.chunk_size == 0)
/*
* This line is use instead of:
* obstack_begin(&frags, 5000);
* which the only difference is that frags are allocated on 4 byte
* boundaries instead of the default. The problem with the default
* is that on some RISC machines the obstack uses 8 (the alignment
* of a double after a char in a struct) and then the common use of:
* frag_now->fr_fix = obstack_next_free(&frags) -
* frag_now->fr_literal;
* can get an extra 4 bytes that are not in the frag because of the
* 8 byte alignment where only 4 byte alignment for frags are
* needed.
*/
_obstack_begin(&frags, 5000, 4,
obstack_chunk_alloc, obstack_chunk_free);
/*
* Determine if this section has been seen.
*/
last_nsect = 0;
for(frcP = *(lastPP = &frchain_root);
frcP != NULL;
frcP = *(lastPP = &frcP->frch_next)){
if(strncmp(frcP->frch_section.segname, segname,
sizeof(frcP->frch_section.segname)) == 0 &&
strncmp(frcP->frch_section.sectname, sectname,
sizeof(frcP->frch_section.sectname)) == 0)
break;
last_nsect = frcP->frch_nsect;
}
/*
* If this section has been seen make sure it's type and attributes
* for this call are the same as when the section was created.
*/
if(frcP != NULL){
if((frcP->frch_section.flags & SECTION_TYPE) != type){
as_warn("section type does not match previous section type");
}
if(type == S_SYMBOL_STUBS &&
frcP->frch_section.reserved2 != sizeof_stub){
as_warn("section stub size does not match previous section "
"stub size");
}
frcP->frch_section.flags |= attributes;
}
/*
* If the current section is the same as for this call there is nothing
* more to do.
*/
if(frcP != NULL && (frchain_now == frcP || type == S_ZEROFILL)){
if(type != S_ZEROFILL)
now_seg = frcP->frch_nsect;
return(frcP);
}
/*
* For non-zerofill sections it will be made the current section so deal
* with the current frag.
*/
if(type != S_ZEROFILL){
/*
* If there is any current frag in the old section close it off.
*/
if(frag_now != NULL){
frag_now->fr_fix = obstack_next_free(&frags) -
frag_now->fr_literal;
frag_wane(frag_now);
}
/*
* We must do the obstack_finish(), so the next object we put on
* obstack frags will not appear to start at the fr_literal of the
* current frag. Also, it ensures that the next object will begin
* on a address that is aligned correctly for the engine that runs
* the assembler.
*/
obstack_finish(&frags);
}
/*
* If this section exists since it is not the current section switch to
* it by making it the current chain and create a new frag in it.
*/
if(frcP != NULL){
if(type != S_ZEROFILL)
now_seg = frcP->frch_nsect;
/*
* For a zerofill section no frags are created here and since it
* exist just return a pointer to the section.
*/
if((frcP->frch_section.flags & SECTION_TYPE) == S_ZEROFILL){
return(frcP);
}
else{
/*
* Make this section the current section.
*/
frchain_now = frcP;
if(type != S_ZEROFILL)
now_seg = frchain_now->frch_nsect;
/*
* Make a fresh frag for the section.
*/
frag_now = (fragS *)obstack_alloc(&frags, SIZEOF_STRUCT_FRAG);
memset(frag_now, '\0', SIZEOF_STRUCT_FRAG);
frag_now->fr_next = NULL;
/*
* Append the new frag to the existing frchain.
*/
frchain_now->frch_last->fr_next = frag_now;
frchain_now->frch_last = frag_now;
}
}
else{
/*
* This section does not exist so create a new frchainS struct fill
* it in, link it to the chain
*/
frcP = (frchainS *)xmalloc(sizeof(frchainS));
memset(frcP, '\0', sizeof(frchainS));
strncpy(frcP->frch_section.segname, segname,
sizeof(frcP->frch_section.segname));
strncpy(frcP->frch_section.sectname, sectname,
sizeof(frcP->frch_section.sectname));
frcP->frch_section.flags = attributes | type;
frcP->frch_section.reserved2 = sizeof_stub;
frcP->frch_nsect = last_nsect + 1;
if(type != S_ZEROFILL)
now_seg = frcP->frch_nsect;
*lastPP = frcP;
/*
* For zerofill sections no frag is created here so just return.
* For non-zerofill section create the sections new frag and
* make the section the current chain.
*/
if(type == S_ZEROFILL){
return(frcP);
}
else{
/*
* Make a fresh frag for the new section.
*/
frag_now = (fragS *)obstack_alloc(&frags, SIZEOF_STRUCT_FRAG);
memset(frag_now, '\0', SIZEOF_STRUCT_FRAG);
frag_now->fr_next = NULL;
/*
* Append the new frag to new frchain.
*/
frcP->frch_root = frag_now;
frcP->frch_last = frag_now;
/*
* Make this section the current section.
*/
frchain_now = frcP;
}
}
return(frchain_now);
}
char *
input_scrub_next_buffer (char **bufp)
{
register char *limit; /*->just after last char of buffer. */
if (sb_index >= 0)
{
if (sb_index >= from_sb.len)
{
sb_kill (&from_sb);
if (from_sb_is_expansion
)
{
cond_finish_check (macro_nest);
#ifdef md_macro_end
/* Allow the target to clean up per-macro expansion
data. */
md_macro_end ();
#endif
}
--macro_nest;
partial_where = NULL;
if (next_saved_file != NULL)
*bufp = input_scrub_pop (next_saved_file);
return partial_where;
}
partial_where = from_sb.ptr + from_sb.len;
partial_size = 0;
*bufp = from_sb.ptr + sb_index;
sb_index = from_sb.len;
return partial_where;
}
*bufp = buffer_start + BEFORE_SIZE;
if (partial_size)
{
memmove (buffer_start + BEFORE_SIZE, partial_where,
(unsigned int) partial_size);
memcpy (buffer_start + BEFORE_SIZE, save_source, AFTER_SIZE);
}
limit = input_file_give_next_buffer (buffer_start
+ BEFORE_SIZE
+ partial_size);
if (limit)
{
register char *p; /* Find last newline. */
/* Terminate the buffer to avoid confusing TC_EOL_IN_INSN. */
*limit = '\0';
for (p = limit - 1; *p != '\n' || TC_EOL_IN_INSN (p); --p)
;
++p;
while (p <= buffer_start + BEFORE_SIZE)
{
int limoff;
limoff = limit - buffer_start;
buffer_length += input_file_buffer_size ();
buffer_start = (char *) xrealloc (buffer_start,
(BEFORE_SIZE
+ 2 * buffer_length
+ AFTER_SIZE));
*bufp = buffer_start + BEFORE_SIZE;
limit = input_file_give_next_buffer (buffer_start + limoff);
if (limit == NULL)
{
as_warn (_("partial line at end of file ignored"));
partial_where = NULL;
if (next_saved_file)
*bufp = input_scrub_pop (next_saved_file);
return NULL;
}
/* Terminate the buffer to avoid confusing TC_EOL_IN_INSN. */
*limit = '\0';
for (p = limit - 1; *p != '\n' || TC_EOL_IN_INSN (p); --p)
;
++p;
}
partial_where = p;
partial_size = limit - p;
memcpy (save_source, partial_where, (int) AFTER_SIZE);
memcpy (partial_where, AFTER_STRING, (int) AFTER_SIZE);
}
else
{
partial_where = 0;
if (partial_size > 0)
{
as_warn (_("partial line at end of file ignored"));
}
/* Tell the listing we've finished the file. */
LISTING_EOF ();
/* If we should pop to another file at EOF, do it. */
if (next_saved_file)
{
*bufp = input_scrub_pop (next_saved_file); /* Pop state */
/* partial_where is now correct to return, since we popped it. */
}
}
return (partial_where);
}
static const char *
macro_expand (int idx, sb *in, macro_entry *m, sb *out)
{
sb t;
formal_entry *ptr;
formal_entry *f;
int is_keyword = 0;
int narg = 0;
const char *err = NULL;
sb_new (&t);
/* Reset any old value the actuals may have. */
for (f = m->formals; f; f = f->next)
sb_reset (&f->actual);
f = m->formals;
while (f != NULL && f->index < 0)
f = f->next;
if (macro_mri)
{
/* The macro may be called with an optional qualifier, which may
be referred to in the macro body as \0. */
if (idx < in->len && in->ptr[idx] == '.')
{
/* The Microtec assembler ignores this if followed by a white space.
(Macro invocation with empty extension) */
idx++;
if ( idx < in->len
&& in->ptr[idx] != ' '
&& in->ptr[idx] != '\t')
{
formal_entry *n = new_formal ();
n->index = QUAL_INDEX;
n->next = m->formals;
m->formals = n;
idx = get_any_string (idx, in, &n->actual);
}
}
}
/* Peel off the actuals and store them away in the hash tables' actuals. */
idx = sb_skip_white (idx, in);
while (idx < in->len)
{
int scan;
/* Look and see if it's a positional or keyword arg. */
scan = idx;
while (scan < in->len
&& !ISSEP (in->ptr[scan])
&& !(macro_mri && in->ptr[scan] == '\'')
&& (!macro_alternate && in->ptr[scan] != '='))
scan++;
if (scan < in->len && !macro_alternate && in->ptr[scan] == '=')
{
is_keyword = 1;
/* It's OK to go from positional to keyword. */
/* This is a keyword arg, fetch the formal name and
then the actual stuff. */
sb_reset (&t);
idx = get_token (idx, in, &t);
if (in->ptr[idx] != '=')
{
err = _("confusion in formal parameters");
break;
}
/* Lookup the formal in the macro's list. */
ptr = (formal_entry *) hash_find (m->formal_hash, sb_terminate (&t));
if (!ptr)
as_bad (_("Parameter named `%s' does not exist for macro `%s'"),
t.ptr,
m->name);
else
{
/* Insert this value into the right place. */
if (ptr->actual.len)
{
as_warn (_("Value for parameter `%s' of macro `%s' was already specified"),
ptr->name.ptr,
m->name);
sb_reset (&ptr->actual);
}
idx = get_any_string (idx + 1, in, &ptr->actual);
if (ptr->actual.len > 0)
++narg;
}
}
else
{
if (is_keyword)
{
err = _("can't mix positional and keyword arguments");
break;
}
if (!f)
{
formal_entry **pf;
int c;
if (!macro_mri)
{
err = _("too many positional arguments");
break;
}
f = new_formal ();
c = -1;
for (pf = &m->formals; *pf != NULL; pf = &(*pf)->next)
if ((*pf)->index >= c)
c = (*pf)->index + 1;
if (c == -1)
c = 0;
*pf = f;
f->index = c;
}
if (f->type != FORMAL_VARARG)
idx = get_any_string (idx, in, &f->actual);
else
{
sb_add_buffer (&f->actual, in->ptr + idx, in->len - idx);
idx = in->len;
}
if (f->actual.len > 0)
++narg;
do
{
f = f->next;
}
while (f != NULL && f->index < 0);
}
if (! macro_mri)
idx = sb_skip_comma (idx, in);
else
{
if (in->ptr[idx] == ',')
++idx;
if (ISWHITE (in->ptr[idx]))
break;
}
}
if (! err)
{
for (ptr = m->formals; ptr; ptr = ptr->next)
{
if (ptr->type == FORMAL_REQUIRED && ptr->actual.len == 0)
as_bad (_("Missing value for required parameter `%s' of macro `%s'"),
ptr->name.ptr,
m->name);
}
if (macro_mri)
{
char buffer[20];
sb_reset (&t);
sb_add_string (&t, macro_strip_at ? "$NARG" : "NARG");
ptr = (formal_entry *) hash_find (m->formal_hash, sb_terminate (&t));
sprintf (buffer, "%d", narg);
sb_add_string (&ptr->actual, buffer);
}
err = macro_expand_body (&m->sub, out, m->formals, m->formal_hash, m);
}
/* Discard any unnamed formal arguments. */
if (macro_mri)
{
formal_entry **pf;
pf = &m->formals;
while (*pf != NULL)
{
if ((*pf)->name.len != 0)
pf = &(*pf)->next;
else
{
f = (*pf)->next;
del_formal (*pf);
*pf = f;
}
}
}
sb_kill (&t);
if (!err)
macro_number++;
return err;
}