%{ /* deffilep.y - parser for .def files */
-/* Copyright (C) 1995-2015 Free Software Foundation, Inc.
+/* Copyright (C) 1995-2023 Free Software Foundation, Inc.
This file is part of GNU Binutils.
#include "libiberty.h"
#include "safe-ctype.h"
#include "bfd.h"
+#include "bfdlink.h"
#include "ld.h"
#include "ldmisc.h"
#include "deffile.h"
#define ROUND_UP(a, b) (((a)+((b)-1))&~((b)-1))
+#define SYMBOL_LIST_ARRAY_GROW 64
+
/* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
as well as gratuitiously global symbol names, so we can have multiple
yacc generated parsers in ld. Note that these are only the variables
static void def_version (int, int);
static void def_directive (char *);
static void def_aligncomm (char *str, int align);
+static void def_exclude_symbols (char *str);
static int def_parse (void);
-static int def_error (const char *);
+static void def_error (const char *);
static int def_lex (void);
static int lex_forced_token = 0;
%token NAME LIBRARY DESCRIPTION STACKSIZE_K HEAPSIZE CODE DATAU DATAL
%token SECTIONS EXPORTS IMPORTS VERSIONK BASE CONSTANTU CONSTANTL
-%token PRIVATEU PRIVATEL ALIGNCOMM
-%token READ WRITE EXECUTE SHARED NONAMEU NONAMEL DIRECTIVE EQUAL
+%token PRIVATEU PRIVATEL ALIGNCOMM EXCLUDE_SYMBOLS
+%token READ WRITE EXECUTE SHARED_K NONAMEU NONAMEL DIRECTIVE EQUAL
%token <id> ID
%token <digits> DIGITS
%type <number> NUMBER
%type <number> opt_ordinal
%type <number> attr attr_list opt_number exp_opt_list exp_opt
%type <id> opt_name opt_name2 opt_equal_name anylang_id opt_id
-%type <id> opt_equalequal_name
+%type <id> opt_equalequal_name symbol_list
%type <id_const> keyword_as_name
%%
| VERSIONK NUMBER '.' NUMBER { def_version ($2, $4);}
| DIRECTIVE ID { def_directive ($2);}
| ALIGNCOMM anylang_id ',' NUMBER { def_aligncomm ($2, $4);}
+ | EXCLUDE_SYMBOLS symbol_list
;
;
impline:
- ID '=' ID '.' ID '.' ID opt_equalequal_name
- { def_import ($1, $3, $5, $7, -1, $8); }
+ ID '=' ID '.' ID '.' ID opt_equalequal_name
+ { def_import ($1, $3, $5, $7, -1, $8); }
| ID '=' ID '.' ID '.' NUMBER opt_equalequal_name
{ def_import ($1, $3, $5, 0, $7, $8); }
| ID '=' ID '.' ID opt_equalequal_name
- { def_import ($1, $3, 0, $5, -1, $6); }
+ { def_import ($1, $3, 0, $5, -1, $6); }
| ID '=' ID '.' NUMBER opt_equalequal_name
- { def_import ($1, $3, 0, 0, $5, $6); }
+ { def_import ($1, $3, 0, 0, $5, $6); }
| ID '.' ID '.' ID opt_equalequal_name
- { def_import( 0, $1, $3, $5, -1, $6); }
+ { def_import( 0, $1, $3, $5, -1, $6); }
| ID '.' ID opt_equalequal_name
- { def_import ( 0, $1, 0, $3, -1, $4); }
+ { def_import ( 0, $1, 0, $3, -1, $4); }
;
seclist:
READ { $$ = 1;}
| WRITE { $$ = 2;}
| EXECUTE { $$=4;}
- | SHARED { $$=8;}
+ | SHARED_K { $$=8;}
;
| DATAL { $$ = "data"; }
| DESCRIPTION { $$ = "DESCRIPTION"; }
| DIRECTIVE { $$ = "DIRECTIVE"; }
+ | EXCLUDE_SYMBOLS { $$ = "EXCLUDE_SYMBOLS"; }
| EXECUTE { $$ = "EXECUTE"; }
| EXPORTS { $$ = "EXPORTS"; }
| HEAPSIZE { $$ = "HEAPSIZE"; }
| PRIVATEU { $$ = "PRIVATE"; }
| PRIVATEL { $$ = "private"; }
| READ { $$ = "READ"; }
- | SHARED { $$ = "SHARED"; }
+ | SHARED_K { $$ = "SHARED"; }
| STACKSIZE_K { $$ = "STACKSIZE"; }
| VERSIONK { $$ = "VERSION"; }
| WRITE { $$ = "WRITE"; }
;
opt_equal_name:
- '=' opt_name2 { $$ = $2; }
- | { $$ = 0; }
+ '=' opt_name2 { $$ = $2; }
+ | { $$ = 0; }
;
opt_base: BASE '=' VMA { $$ = $3;}
}
;
+symbol_list:
+ anylang_id { def_exclude_symbols ($1); }
+ | symbol_list anylang_id { def_exclude_symbols ($2); }
+ | symbol_list ',' anylang_id { def_exclude_symbols ($3); }
+ ;
+
opt_digits: DIGITS { $$ = $1; }
| { $$ = ""; }
;
def_file_free (def_file *fdef)
{
int i;
+ unsigned int ui;
if (!fdef)
return;
- if (fdef->name)
- free (fdef->name);
- if (fdef->description)
- free (fdef->description);
+ free (fdef->name);
+ free (fdef->description);
if (fdef->section_defs)
{
for (i = 0; i < fdef->num_section_defs; i++)
{
- if (fdef->section_defs[i].name)
- free (fdef->section_defs[i].name);
- if (fdef->section_defs[i].class)
- free (fdef->section_defs[i].class);
+ free (fdef->section_defs[i].name);
+ free (fdef->section_defs[i].class);
}
free (fdef->section_defs);
}
- if (fdef->exports)
+ for (i = 0; i < fdef->num_exports; i++)
{
- for (i = 0; i < fdef->num_exports; i++)
- {
- if (fdef->exports[i].internal_name
- && fdef->exports[i].internal_name != fdef->exports[i].name)
- free (fdef->exports[i].internal_name);
- if (fdef->exports[i].name)
- free (fdef->exports[i].name);
- if (fdef->exports[i].its_name)
- free (fdef->exports[i].its_name);
- }
- free (fdef->exports);
+ if (fdef->exports[i].internal_name != fdef->exports[i].name)
+ free (fdef->exports[i].internal_name);
+ free (fdef->exports[i].name);
+ free (fdef->exports[i].its_name);
}
+ free (fdef->exports);
- if (fdef->imports)
+ for (i = 0; i < fdef->num_imports; i++)
{
- for (i = 0; i < fdef->num_imports; i++)
- {
- if (fdef->imports[i].internal_name
- && fdef->imports[i].internal_name != fdef->imports[i].name)
- free (fdef->imports[i].internal_name);
- if (fdef->imports[i].name)
- free (fdef->imports[i].name);
- if (fdef->imports[i].its_name)
- free (fdef->imports[i].its_name);
- }
- free (fdef->imports);
+ if (fdef->imports[i].internal_name != fdef->imports[i].name)
+ free (fdef->imports[i].internal_name);
+ free (fdef->imports[i].name);
+ free (fdef->imports[i].its_name);
}
+ free (fdef->imports);
while (fdef->modules)
{
free (c);
}
+ for (ui = 0; ui < fdef->num_exclude_symbols; ui++)
+ {
+ free (fdef->exclude_symbols[ui].symbol_name);
+ }
+ free (fdef->exclude_symbols);
+
free (fdef);
}
if (fdef->is_dll != -1)
fprintf (file, " is dll: %s\n", fdef->is_dll ? "yes" : "no");
if (fdef->base_address != (bfd_vma) -1)
- {
- fprintf (file, " base address: 0x");
- fprintf_vma (file, fdef->base_address);
- fprintf (file, "\n");
- }
+ fprintf (file, " base address: 0x%" PRIx64 "\n",
+ (uint64_t) fdef->base_address);
if (fdef->description)
fprintf (file, " description: `%s'\n", fdef->description);
if (fdef->stack_reserve != -1)
/* Search the position of the identical element, or returns the position
of the next higher element. If last valid element is smaller, then MAX
- is returned. */
+ is returned. The max parameter indicates the number of elements in the
+ array. On return, *is_ident indicates whether the returned array index
+ points at an element which is identical to the one searched for. */
-static int
-find_export_in_list (def_file_export *b, int max,
+static unsigned int
+find_export_in_list (def_file_export *b, unsigned int max,
const char *ex_name, const char *in_name,
- const char *its_name, int ord, int *is_ident)
+ const char *its_name, int ord, bool *is_ident)
{
- int e, l, r, p;
+ int e;
+ unsigned int l, r, p;
- *is_ident = 0;
+ *is_ident = false;
if (!max)
return 0;
if ((e = cmp_export_elem (b, ex_name, in_name, its_name, ord)) <= 0)
{
if (!e)
- *is_ident = 1;
+ *is_ident = true;
return 0;
}
if (max == 1)
else if (!e || max == 2)
{
if (!e)
- *is_ident = 1;
+ *is_ident = true;
return max - 1;
}
l = 0; r = max - 1;
p = (l + r) / 2;
e = cmp_export_elem (b + p, ex_name, in_name, its_name, ord);
if (!e)
- {
- *is_ident = 1;
- return p;
- }
+ {
+ *is_ident = true;
+ return p;
+ }
else if (e < 0)
- r = p - 1;
+ r = p - 1;
else if (e > 0)
- l = p + 1;
+ l = p + 1;
}
if ((e = cmp_export_elem (b + l, ex_name, in_name, its_name, ord)) > 0)
++l;
else if (!e)
- *is_ident = 1;
+ *is_ident = true;
return l;
}
const char *internal_name,
int ordinal,
const char *its_name,
- int *is_dup)
+ bool *is_dup)
{
def_file_export *e;
- int pos;
- int max_exports = ROUND_UP(fdef->num_exports, 32);
+ unsigned int pos;
if (internal_name && !external_name)
external_name = internal_name;
internal_name = external_name;
/* We need to avoid duplicates. */
- *is_dup = 0;
+ *is_dup = false;
pos = find_export_in_list (fdef->exports, fdef->num_exports,
external_name, internal_name,
its_name, ordinal, is_dup);
- if (*is_dup != 0)
+ if (*is_dup)
return (fdef->exports + pos);
- if (fdef->num_exports >= max_exports)
+ if ((unsigned)fdef->num_exports >= fdef->max_exports)
{
- max_exports = ROUND_UP(fdef->num_exports + 1, 32);
- if (fdef->exports)
- fdef->exports = xrealloc (fdef->exports,
- max_exports * sizeof (def_file_export));
- else
- fdef->exports = xmalloc (max_exports * sizeof (def_file_export));
+ fdef->max_exports += SYMBOL_LIST_ARRAY_GROW;
+ fdef->exports = xrealloc (fdef->exports,
+ fdef->max_exports * sizeof (def_file_export));
}
e = fdef->exports + pos;
- if (pos != fdef->num_exports)
+ /* If we're inserting in the middle of the array, we need to move the
+ following elements forward. */
+ if (pos != (unsigned)fdef->num_exports)
memmove (&e[1], e, (sizeof (def_file_export) * (fdef->num_exports - pos)));
+ /* Wipe the element for use as a new entry. */
memset (e, 0, sizeof (def_file_export));
e->name = xstrdup (external_name);
e->internal_name = xstrdup (internal_name);
/* Search the position of the identical element, or returns the position
of the next higher element. If last valid element is smaller, then MAX
- is returned. */
+ is returned. The max parameter indicates the number of elements in the
+ array. On return, *is_ident indicates whether the returned array index
+ points at an element which is identical to the one searched for. */
-static int
-find_import_in_list (def_file_import *b, int max,
+static unsigned int
+find_import_in_list (def_file_import *b, unsigned int max,
const char *ex_name, const char *in_name,
- const char *module, int ord, int *is_ident)
+ const char *module, int ord, bool *is_ident)
{
- int e, l, r, p;
+ int e;
+ unsigned int l, r, p;
- *is_ident = 0;
+ *is_ident = false;
if (!max)
return 0;
if ((e = cmp_import_elem (b, ex_name, in_name, module, ord)) <= 0)
{
if (!e)
- *is_ident = 1;
+ *is_ident = true;
return 0;
}
if (max == 1)
else if (!e || max == 2)
{
if (!e)
- *is_ident = 1;
+ *is_ident = true;
return max - 1;
}
l = 0; r = max - 1;
p = (l + r) / 2;
e = cmp_import_elem (b + p, ex_name, in_name, module, ord);
if (!e)
- {
- *is_ident = 1;
- return p;
- }
+ {
+ *is_ident = true;
+ return p;
+ }
else if (e < 0)
- r = p - 1;
+ r = p - 1;
else if (e > 0)
- l = p + 1;
+ l = p + 1;
}
if ((e = cmp_import_elem (b + l, ex_name, in_name, module, ord)) > 0)
++l;
else if (!e)
- *is_ident = 1;
+ *is_ident = true;
return l;
}
+static void
+fill_in_import (def_file_import *i,
+ const char *name,
+ def_file_module *module,
+ int ordinal,
+ const char *internal_name,
+ const char *its_name)
+{
+ memset (i, 0, sizeof (def_file_import));
+ if (name)
+ i->name = xstrdup (name);
+ i->module = module;
+ i->ordinal = ordinal;
+ if (internal_name)
+ i->internal_name = xstrdup (internal_name);
+ else
+ i->internal_name = i->name;
+ i->its_name = (its_name ? xstrdup (its_name) : NULL);
+}
+
def_file_import *
def_file_add_import (def_file *fdef,
const char *name,
int ordinal,
const char *internal_name,
const char *its_name,
- int *is_dup)
+ bool *is_dup)
{
def_file_import *i;
- int pos;
- int max_imports = ROUND_UP (fdef->num_imports, 16);
+ unsigned int pos;
/* We need to avoid here duplicates. */
- *is_dup = 0;
+ *is_dup = false;
pos = find_import_in_list (fdef->imports, fdef->num_imports,
name,
(!internal_name ? name : internal_name),
module, ordinal, is_dup);
- if (*is_dup != 0)
+ if (*is_dup)
return fdef->imports + pos;
- if (fdef->num_imports >= max_imports)
+ if ((unsigned)fdef->num_imports >= fdef->max_imports)
{
- max_imports = ROUND_UP (fdef->num_imports+1, 16);
+ fdef->max_imports += SYMBOL_LIST_ARRAY_GROW;
+ fdef->imports = xrealloc (fdef->imports,
+ fdef->max_imports * sizeof (def_file_import));
+ }
+ i = fdef->imports + pos;
+ /* If we're inserting in the middle of the array, we need to move the
+ following elements forward. */
+ if (pos != (unsigned)fdef->num_imports)
+ memmove (i + 1, i, sizeof (def_file_import) * (fdef->num_imports - pos));
- if (fdef->imports)
- fdef->imports = xrealloc (fdef->imports,
- max_imports * sizeof (def_file_import));
- else
- fdef->imports = xmalloc (max_imports * sizeof (def_file_import));
+ fill_in_import (i, name, def_stash_module (fdef, module), ordinal,
+ internal_name, its_name);
+ fdef->num_imports++;
+
+ return i;
+}
+
+int
+def_file_add_import_from (def_file *fdef,
+ int num_imports,
+ const char *name,
+ const char *module,
+ int ordinal,
+ const char *internal_name,
+ const char *its_name ATTRIBUTE_UNUSED)
+{
+ def_file_import *i;
+ bool is_dup;
+ unsigned int pos;
+
+ /* We need to avoid here duplicates. */
+ is_dup = false;
+ pos = find_import_in_list (fdef->imports, fdef->num_imports,
+ name, internal_name ? internal_name : name,
+ module, ordinal, &is_dup);
+ if (is_dup)
+ return -1;
+ if (fdef->imports && pos != (unsigned)fdef->num_imports)
+ {
+ i = fdef->imports + pos;
+ if (i->module && strcmp (i->module->name, module) == 0)
+ return -1;
+ }
+
+ if ((unsigned)fdef->num_imports + num_imports - 1 >= fdef->max_imports)
+ {
+ fdef->max_imports = fdef->num_imports + num_imports +
+ SYMBOL_LIST_ARRAY_GROW;
+
+ fdef->imports = xrealloc (fdef->imports,
+ fdef->max_imports * sizeof (def_file_import));
}
i = fdef->imports + pos;
- if (pos != fdef->num_imports)
- memmove (&i[1], i, (sizeof (def_file_import) * (fdef->num_imports - pos)));
- memset (i, 0, sizeof (def_file_import));
- if (name)
- i->name = xstrdup (name);
- if (module)
- i->module = def_stash_module (fdef, module);
- i->ordinal = ordinal;
- if (internal_name)
- i->internal_name = xstrdup (internal_name);
- else
- i->internal_name = i->name;
- i->its_name = (its_name ? xstrdup (its_name) : NULL);
+ /* If we're inserting in the middle of the array, we need to move the
+ following elements forward. */
+ if (pos != (unsigned)fdef->num_imports)
+ memmove (i + num_imports, i,
+ sizeof (def_file_import) * (fdef->num_imports - pos));
+
+ return pos;
+}
+
+def_file_import *
+def_file_add_import_at (def_file *fdef,
+ int pos,
+ const char *name,
+ const char *module,
+ int ordinal,
+ const char *internal_name,
+ const char *its_name)
+{
+ def_file_import *i = fdef->imports + pos;
+
+ fill_in_import (i, name, def_stash_module (fdef, module), ordinal,
+ internal_name, its_name);
fdef->num_imports++;
return i;
}
+/* Search the position of the identical element, or returns the position
+ of the next higher element. If last valid element is smaller, then MAX
+ is returned. The max parameter indicates the number of elements in the
+ array. On return, *is_ident indicates whether the returned array index
+ points at an element which is identical to the one searched for. */
+
+static unsigned int
+find_exclude_in_list (def_file_exclude_symbol *b, unsigned int max,
+ const char *name, bool *is_ident)
+{
+ int e;
+ unsigned int l, r, p;
+
+ *is_ident = false;
+ if (!max)
+ return 0;
+ if ((e = strcmp (b[0].symbol_name, name)) <= 0)
+ {
+ if (!e)
+ *is_ident = true;
+ return 0;
+ }
+ if (max == 1)
+ return 1;
+ if ((e = strcmp (b[max - 1].symbol_name, name)) > 0)
+ return max;
+ else if (!e || max == 2)
+ {
+ if (!e)
+ *is_ident = true;
+ return max - 1;
+ }
+ l = 0; r = max - 1;
+ while (l < r)
+ {
+ p = (l + r) / 2;
+ e = strcmp (b[p].symbol_name, name);
+ if (!e)
+ {
+ *is_ident = true;
+ return p;
+ }
+ else if (e < 0)
+ r = p - 1;
+ else if (e > 0)
+ l = p + 1;
+ }
+ if ((e = strcmp (b[l].symbol_name, name)) > 0)
+ ++l;
+ else if (!e)
+ *is_ident = true;
+ return l;
+}
+
+static def_file_exclude_symbol *
+def_file_add_exclude_symbol (def_file *fdef, const char *name)
+{
+ def_file_exclude_symbol *e;
+ unsigned pos;
+ bool is_dup = false;
+
+ pos = find_exclude_in_list (fdef->exclude_symbols, fdef->num_exclude_symbols,
+ name, &is_dup);
+
+ /* We need to avoid duplicates. */
+ if (is_dup)
+ return (fdef->exclude_symbols + pos);
+
+ if (fdef->num_exclude_symbols >= fdef->max_exclude_symbols)
+ {
+ fdef->max_exclude_symbols += SYMBOL_LIST_ARRAY_GROW;
+ fdef->exclude_symbols = xrealloc (fdef->exclude_symbols,
+ fdef->max_exclude_symbols * sizeof (def_file_exclude_symbol));
+ }
+
+ e = fdef->exclude_symbols + pos;
+ /* If we're inserting in the middle of the array, we need to move the
+ following elements forward. */
+ if (pos != fdef->num_exclude_symbols)
+ memmove (&e[1], e, (sizeof (def_file_exclude_symbol) * (fdef->num_exclude_symbols - pos)));
+ /* Wipe the element for use as a new entry. */
+ memset (e, 0, sizeof (def_file_exclude_symbol));
+ e->symbol_name = xstrdup (name);
+ fdef->num_exclude_symbols++;
+ return e;
+}
+
struct
{
char *param;
{ "-attr", SECTIONS },
{ "-export", EXPORTS },
{ "-aligncomm", ALIGNCOMM },
+ { "-exclude-symbols", EXCLUDE_SYMBOLS },
{ 0, 0 }
};
break;
/* Scan forward until we encounter any of:
- - the end of the buffer
+ - the end of the buffer
- the start of a new option
- - a newline seperating options
- - a NUL seperating options. */
+ - a newline separating options
+ - a NUL separating options. */
for (tend = (char *) (param + 1);
(tend < pend
&& !(ISSPACE (tend[-1]) && *tend == '-')
einfo ("%s:%d: Warning: path components stripped from %s, '%s'\n",
def_filename, linenumber, is_dll ? "LIBRARY" : "NAME",
name);
- if (def->name)
- free (def->name);
+ free (def->name);
/* Append the default suffix, if none specified. */
if (strchr (image_name, '.') == 0)
{
def->name = xmalloc (strlen (image_name) + strlen (suffix) + 1);
sprintf (def->name, "%s%s", image_name, suffix);
- }
+ }
else
def->name = xstrdup (image_name);
}
const char *its_name)
{
def_file_export *dfe;
- int is_dup = 0;
+ bool is_dup = false;
if (!internal_name && external_name)
internal_name = external_name;
{
char *buf = 0;
const char *ext = dllext ? dllext : "dll";
- int is_dup = 0;
+ bool is_dup = false;
buf = xmalloc (strlen (module) + strlen (ext) + 2);
sprintf (buf, "%s.%s", module, ext);
return;
}
if (e > 0)
- break;
+ break;
c = (p = c)->next;
}
}
}
-static int
+static void
+def_exclude_symbols (char *str)
+{
+ def_file_add_exclude_symbol (def, str);
+}
+
+static void
def_error (const char *err)
{
einfo ("%P: %s:%d: %s\n",
def_filename ? def_filename : "<unknown-file>", linenumber, err);
- return 0;
}
{ "data", DATAL },
{ "DESCRIPTION", DESCRIPTION },
{ "DIRECTIVE", DIRECTIVE },
+ { "EXCLUDE_SYMBOLS", EXCLUDE_SYMBOLS },
{ "EXECUTE", EXECUTE },
{ "EXPORTS", EXPORTS },
{ "HEAPSIZE", HEAPSIZE },
{ "READ", READ },
{ "SECTIONS", SECTIONS },
{ "SEGMENTS", SECTIONS },
- { "SHARED", SHARED },
+ { "SHARED", SHARED_K },
{ "STACKSIZE", STACKSIZE_K },
{ "VERSION", VERSIONK },
{ "WRITE", WRITE },
if (q == '@')
{
- if (ISBLANK (c) ) /* '@' followed by whitespace. */
+ if (ISBLANK (c) ) /* '@' followed by whitespace. */
return (q);
- else if (ISDIGIT (c)) /* '@' followed by digit. */
- {
+ else if (ISDIGIT (c)) /* '@' followed by digit. */
+ {
def_ungetc (c);
- return (q);
+ return (q);
}
#if TRACE
printf ("lex: @ returns itself\n");
def_ungetc (c);
if (ISALPHA (q)) /* Check for tokens. */
{
- for (i = 0; tokens[i].name; i++)
+ for (i = 0; tokens[i].name; i++)
if (strcmp (tokens[i].name, buffer) == 0)
{
#if TRACE
{
c = def_getc ();
if (c == '=')
- {
+ {
#if TRACE
- printf ("lex: `==' returns EQUAL\n");
+ printf ("lex: `==' returns EQUAL\n");
#endif
- return EQUAL;
- }
+ return EQUAL;
+ }
def_ungetc (c);
#if TRACE
printf ("lex: `=' returns itself\n");
projects / binutils-gdb.git / blobdiff