@item .macro @var{macname}
@itemx .macro @var{macname} @var{macargs} @dots{}
@cindex @code{macro} directive
-Begin the definition of a macro called @var{macname}. If your macro
+Begin the definition of a macro called @var{macname}. Macro names are case
+insensitive. Macro definitions can be nested, although their behaviour is
+sometimes counter intuitive. Nested macros only have scope within their
+defining macro.
+
+If your macro
definition requires arguments, specify their names after the macro name,
separated by commas or spaces. You can qualify the macro argument to
indicate whether all invocations must specify a non-blank value (through
concatenated when determining macro arguments, even if they're only separated
by white space. This is unlike certain other pseudo ops, e.g. @code{.ascii}.
+Nested macros can access the arguments of their parents. But also if their
+argument names clash with those of their parents, their versions are used. So
+for example:
+
+@smallexample
+.macro OUTER arg1, arg2, arg3:vararg
+ .macro INNER arg4 arg2
+ .dc.a \arg2
+ .dc.a \arg3
+ .endm
+ INNER \arg1 bert
+ .dc.a \arg2
+.endm
+
+OUTER fred, jim, harry\arg4
+@end smallexample
+
+This will generate references to symbols called @samp{jim} - from the
+definition of the OUTER macro, @samp{bert} - from the definition in INNER
+where arg2 has been overridden and @samp{harryfred} - from the definition in
+INNER where the value of arg3 from OUTER is used, but with the value of arg4
+substituted into the symbol.
+
@item .endm
@cindex @code{endm} directive
Mark the end of a macro definition.
executed in this pseudo-variable; you can copy that number to your
output with @samp{\@@}, but @emph{only within a macro definition}.
+Note - the @samp{\@@} counter is incremented at the end of the expansion of a
+macro, but before the contents of any nested macros are evaluated. This can
+lead to counter-intuitive behaviour when nested macros are used. For example:
+
+@smallexample
+ .macro o
+ .macro i
+ _i\@@_:
+ .endm
+ i
+ _o\@@_:
+ .endm
+ o
+@end smallexample
+
+Produces two symbols @samp{_o0_} and @samp{_i1_}. This happens because the
+@samp{o} macro executes entirely first, putting the definition and invocation
+of the @samp{i} macro into the input buffer. It also puts the definition of
+the @samp{_o\@@_} symbol into the input buffer, evaluating the @samp{\@@}
+counter in the process and so generating a symbol called @samp{_o0_}.
+
+That finishes the invocation of @samp{o} so the @samp{\@@} counter is
+incremented. Then the input buffer is re-evaluated and the definition and
+invocation of macro @samp{i} is found. This results in @samp{_i\@@_} being put
+into the input buffer and this time @samp{\@@} evaluates to 1, so the symbol
+created is @samp{_i1_}.
+
@cindex number of times a macro has been executed
@cindex macro, execution count
@item \+
Undefine the macro @var{name}, so that later uses of the string will not be
expanded. @xref{Macro}.
+Note - nested macros are automatically purged at the end of the macro that
+defines them.
+
@ifset ELF
@node PushSection
@section @code{.pushsection @var{name} [, @var{subsection}] [, "@var{flags}"[, @@@var{type}[,@var{arguments}]]]}
/* The macro hash table. */
-htab_t macro_hash;
+/* Macro nesting depth. Similar to macro_nest defined in sb.c, but this
+ counter is specific to macros, whereas macro_nest also counts repeated
+ string blocks. */
+static unsigned int macro_nesting_depth;
-/* Whether any macros have been defined. */
+/* Maximum nesting depth. Ideally the same as the value of max_macro_nest
+ as defined in as.c (ie 100). But there is one test in the assembler
+ testsuite (bfin/allinsn16.s) that nests macros to a depth of 8192. So
+ we have a ridiculously large number here. */
+#define MAX_MACRO_DEPTH 8193
-int macro_defined;
+static htab_t macro_hash[MAX_MACRO_DEPTH];
+
+/* Whether any macros have been defined.
+ FIXME: This could be a counter that is incremented
+ with .macro and decremented with .purgem. */
+
+static bool macros_defined = false;
/* Whether we should strip '@' characters. */
static void free_macro (macro_entry *);
+bool
+add_macro (macro_entry * macro, bool replace)
+{
+ if (str_hash_insert (macro_hash [macro_nesting_depth],
+ macro->name, macro, replace) == NULL)
+ {
+ macros_defined = true;
+ return true;
+ }
+ return false;
+}
+
static void
macro_del_f (void *ent)
{
void
macro_init (void)
{
- macro_hash = htab_create_alloc (16, hash_string_tuple, eq_string_tuple,
- macro_del_f, notes_calloc, NULL);
- macro_defined = 0;
+ int i;
+
+ for (i = 0; i < MAX_MACRO_DEPTH; i++)
+ macro_hash[i] = htab_create_alloc (16, hash_string_tuple, eq_string_tuple,
+ macro_del_f, notes_calloc, NULL);
+ macros_defined = false;
}
void
macro_end (void)
{
- htab_delete (macro_hash);
+ int i;
+
+ for (i = MAX_MACRO_DEPTH; i--;)
+ htab_delete (macro_hash[i]);
+
+ macros_defined = false;
}
/* Read input lines till we get to a TO string.
free (macro);
}
+static macro_entry * last_recorded_macro = NULL;
+void
+macro_record_invocation (macro_entry * macro)
+{
+ last_recorded_macro = macro;
+}
+
/* Define a new macro. */
macro_entry *
/* And stick it in the macro hash table. */
for (idx = 0; idx < name.len; idx++)
name.ptr[idx] = TOLOWER (name.ptr[idx]);
+
+ if (macro_nesting_depth > 0)
+ macro->parent = last_recorded_macro;
+ else
+ macro->parent = NULL;
+
if (!error)
{
- if (str_hash_insert (macro_hash, macro->name, macro, 0) != NULL)
+ if (! add_macro (macro, false))
error = _("Macro `%s' was already defined");
}
- if (!error)
- macro_defined = 1;
- else
+ if (error != NULL)
{
as_bad_where (macro->file, macro->line, error, macro->name);
free_macro (macro);
return idx;
}
-/* Substitute the actual value for a formal parameter. */
+static const char *
+macro_expand_body (sb *, sb *, formal_entry *, struct htab *,
+ const macro_entry *, unsigned int);
+
+/* Find the actual value for a formal parameter starting at START inside IN.
+ Appends the value of parameter onto OUT.
+ The hash table of formal parameters is provided by FORMAL_HASH.
+ The character that indicated the presense of a formal parameter is passed
+ in KIND.
+ If COPYIFNOTTHERE is true and the parameter is not found in the hash table
+ then it is appended as plain text onto OUT.
+ The macro containing the formal parameters is passed in MACRO.
+ This can be empty.
+ Returns the offset inside IN after advanceing past the parameter.
+ Also stores the parameter's name into T. */
static size_t
sub_actual (size_t start, sb *in, sb *t, struct htab *formal_hash,
- int kind, sb *out, int copyifnotthere)
+ int kind, sb *out, int copyifnotthere, const macro_entry * macro)
{
size_t src;
formal_entry *ptr;
ptr = NULL;
else
ptr = str_hash_find (formal_hash, sb_terminate (t));
+
if (ptr)
{
- if (ptr->actual.len)
- {
- sb_add_sb (out, &ptr->actual);
- }
- else
- {
- sb_add_sb (out, &ptr->def);
- }
+ sb * add = ptr->actual.len ? &ptr->actual : &ptr->def;
+
+ sb_add_sb (out, add);
}
else if (kind == '&')
{
{
sb_add_sb (out, t);
}
+ else if (!macro_strip_at
+ && macro_nesting_depth > 0
+ && macro != NULL
+ && macro->parent != NULL)
+ {
+ const macro_entry * orig_macro = macro;
+ bool success = false;
+
+ /* We have failed to find T, but we are inside nested macros. So check
+ the parent macros so see if they have a FORMAL that matches T. */
+ while (macro->parent != NULL)
+ {
+ macro = macro->parent;
+
+ ptr = str_hash_find (macro->formal_hash, t->ptr);
+ if (ptr == NULL)
+ continue;
+
+ sb * add = ptr->actual.len ? &ptr->actual : &ptr->def;
+
+ /* The parent's FORMALs might contain parameters that need further
+ substitution. See gas/testsuite/gas/arm/macro-vld1.s for an
+ example of this. */
+ if (strchr (add->ptr, '\\'))
+ {
+ sb newadd;
+
+ sb_new (&newadd);
+ /* FIXME: Should we do something if the call to
+ macro_expand_body returns an error message ? */
+ (void) macro_expand_body (add, &newadd, NULL, NULL,
+ orig_macro, orig_macro->count);
+ sb_add_sb (out, &newadd);
+ }
+ else
+ {
+ sb_add_sb (out, add);
+ }
+ success = true;
+ break;
+ }
+ if (! success)
+ {
+ /* We reached the outermost macro and failed to find T, so
+ just copy the entire parameter as is. */
+ sb_add_char (out, '\\');
+ sb_add_sb (out, t);
+ }
+ }
else
{
sb_add_char (out, '\\');
return src;
}
-/* Expand the body of a macro. */
+/* Expands the body of a macro / block of text IN, copying it into OUT.
+ Parameters for substitution are found in FORMALS and FORMAL_HASH or
+ MACRO.
+ The number of times that this macro / block of text have already been
+ copied into the output is held in INSTANCE.
+ Returns NULL upon success or an error message otherwise. */
static const char *
macro_expand_body (sb *in, sb *out, formal_entry *formals,
int inquote = 0, macro_line = 0;
formal_entry *loclist = NULL;
const char *err = NULL;
+ int nesting = 0;
+ if (formals == NULL && macro != NULL)
+ formals = macro->formals;
+
+ if (formal_hash == NULL && macro != NULL)
+ formal_hash = macro->formal_hash;
+
sb_new (&t);
while (src < in->len && !err)
{
+ if (in->ptr[src] == '.')
+ {
+ /* Check to see if we have encountered ".macro" or ".endm" */
+ if (in->len > src + 5
+ && strncmp (in->ptr + src, ".macro", 6) == 0)
+ ++ nesting;
+
+ else if (in->len > src + 4
+ && strncmp (in->ptr + src, ".endm", 5) == 0)
+ -- nesting;
+ }
+
if (in->ptr[src] == '&')
{
sb_reset (&t);
if (flag_mri)
{
if (src + 1 < in->len && in->ptr[src + 1] == '&')
- src = sub_actual (src + 2, in, &t, formal_hash, '\'', out, 1);
+ src = sub_actual (src + 2, in, &t, formal_hash,
+ '\'', out, 1, macro);
else
sb_add_char (out, in->ptr[src++]);
}
{
/* Permit macro parameter substitution delineated with
an '&' prefix and optional '&' suffix. */
- src = sub_actual (src + 1, in, &t, formal_hash, '&', out, 0);
+ src = sub_actual (src + 1, in, &t, formal_hash,
+ '&', out, 0, macro);
}
}
else if (in->ptr[src] == '\\')
else
as_bad_where (macro->file, macro->line + macro_line, _("missing `)'"));
}
- else if (src < in->len && in->ptr[src] == '@')
+ else if (src < in->len
+ && in->ptr[src] == '@'
+ /* PR 32391: Do not perform the substition inside nested
+ macros. Instead wait until they are re-evaluated and
+ perform the substition then. */
+ && ! nesting)
{
/* Sub in the total macro invocation number. */
sprintf (buffer, "%u", macro_number);
sb_add_string (out, buffer);
}
- else if (src < in->len && in->ptr[src] == '+')
+ else if (src < in->len
+ && in->ptr[src] == '+'
+ /* PR 32391: Do not perform the substition inside nested
+ macros. Instead wait until they are re-evaluated and
+ perform the substition then. */
+ && ! nesting)
{
/* Sub in the current macro invocation number. */
else
{
sb_reset (&t);
- src = sub_actual (src, in, &t, formal_hash, '\'', out, 0);
+
+ if (nesting)
+ {
+ src = get_apost_token (src, in, &t, '\'');
+ sb_add_char (out, '\\');
+ sb_add_sb (out, &t);
+ }
+ else
+ {
+ src = sub_actual (src, in, &t, formal_hash,
+ '\'', out, 0, macro);
+ }
}
}
else if ((flag_macro_alternate || flag_mri)
sb_reset (&t);
src = sub_actual (src, in, &t, formal_hash,
(macro_strip_at && inquote) ? '@' : '\'',
- out, 1);
+ out, 1, macro);
}
else
{
if (!err && (out->len == 0 || out->ptr[out->len - 1] != '\n'))
sb_add_char (out, '\n');
+
return err;
}
}
}
- err = macro_expand_body (&m->sub, out, m->formals, m->formal_hash, m,
- m->count);
+ err = macro_expand_body (&m->sub, out, NULL, NULL, m, m->count);
}
/* Discard any unnamed formal arguments. */
}
/* Check for a macro. If one is found, put the expansion into
- *EXPAND. Return 1 if a macro is found, 0 otherwise. */
+ *EXPAND. Return TRUE if a macro is found, FALSE otherwise. */
-int
+bool
check_macro (const char *line, sb *expand,
const char **error, macro_entry **info)
{
macro_entry *macro;
sb line_sb;
+ if (! macros_defined)
+ return false;
+
if (! is_name_beginner (*line)
&& (! flag_mri || *line != '.'))
- return 0;
+ return false;
s = line + 1;
while (is_part_of_name (*s))
for (cls = copy; *cls != '\0'; cls ++)
*cls = TOLOWER (*cls);
- macro = str_hash_find (macro_hash, copy);
+ int i;
+ for (i = macro_nesting_depth; i >= 0; i--)
+ {
+ macro = str_hash_find (macro_hash[i], copy);
+ if (macro != NULL)
+ break;
+ }
free (copy);
if (macro == NULL)
- return 0;
+ return false;
/* Wrap the line up in an sb. */
sb_new (&line_sb);
if (info)
*info = macro;
- return 1;
+ return true;
}
/* Delete a macro. */
copy[i] = TOLOWER (name[i]);
copy[i] = '\0';
- macro = str_hash_find (macro_hash, copy);
- if (macro != NULL)
- str_hash_delete (macro_hash, copy);
- else
+ int j;
+ for (j = macro_nesting_depth; j >= 0; j--)
+ {
+ macro = str_hash_find (macro_hash [j], copy);
+ if (macro != NULL)
+ {
+ str_hash_delete (macro_hash[j], copy);
+ break;
+ }
+ }
+
+ if (macro == NULL)
as_warn (_("Attempt to purge non-existing macro `%s'"), copy);
+
free (copy);
}
return err;
}
+
+void
+increment_macro_nesting_depth (void)
+{
+ if (macro_nesting_depth >= (MAX_MACRO_DEPTH - 1))
+ as_fatal (_("macros nested too deeply"));
+ else
+ ++macro_nesting_depth;
+}
+
+void
+decrement_macro_nesting_depth (void)
+{
+ if (macro_nesting_depth == 0)
+ as_fatal (_("too much macro un-nesting"));
+ else
+ {
+ /* FIXME: Potential memory leak here. */
+ htab_empty (macro_hash [macro_nesting_depth]);
+ --macro_nesting_depth;
+ }
+}
projects / thirdparty / binutils-gdb.git / commitdiff
