/* This module handles expression trees.
-Copyright (C) 1991, 1993, 1994, 1995, 1996 Free Software Foundation, Inc.
+Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 1998 Free Software Foundation, Inc.
Written by Steve Chamberlain of Cygnus Support (sac@cygnus.com).
This file is part of GLD, the Gnu Linker.
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
-along with GLD; see the file COPYING. If not, write to
-the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+along with GLD; see the file COPYING. If not, write to the Free
+Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+02111-1307, USA. */
/*
This module is in charge of working out the contents of expressions.
{ SEARCH_DIR,"SEARCH_DIR" },
{ MAP,"MAP" },
{ QUAD,"QUAD" },
+ { SQUAD,"SQUAD" },
{ LONG,"LONG" },
{ SHORT,"SHORT" },
{ BYTE,"BYTE" },
bfd_vma value;
{
etree_value_type new;
- new.valid = true;
+ new.valid_p = true;
new.section = abs_output_section;
new.value = value;
return new;
const char *op;
{
if (os == NULL)
- einfo ("%F%P: %s uses undefined section %s\n", op, name);
+ einfo (_("%F%P: %s uses undefined section %s\n"), op, name);
if (! os->processed)
- einfo ("%F%P: %s forward reference of section %s\n", op, name);
+ einfo (_("%F%P: %s forward reference of section %s\n"), op, name);
}
etree_type *
lang_output_section_statement_type *section;
{
etree_value_type new;
- new.valid = true;
+ new.valid_p = true;
new.value = value;
new.section = section;
return new;
lang_output_section_statement_type *section;
{
etree_value_type new;
- new.valid = true;
+ new.valid_p = true;
new.value = value;
new.section = section;
result = exp_fold_tree (tree->binary.lhs, current_section,
allocation_done, dot, dotp);
- if (result.valid)
+ if (result.valid_p)
{
etree_value_type other;
other = exp_fold_tree (tree->binary.rhs,
current_section,
allocation_done, dot,dotp) ;
- if (other.valid)
+ if (other.valid_p)
{
/* If the values are from different sections, or this is an
absolute expression, make both the source arguments
{
case '%':
if (other.value == 0)
- einfo ("%F%S %% by zero\n");
+ einfo (_("%F%S %% by zero\n"));
result.value = ((bfd_signed_vma) result.value
% (bfd_signed_vma) other.value);
break;
case '/':
if (other.value == 0)
- einfo ("%F%S / by zero\n");
+ einfo (_("%F%S / by zero\n"));
result.value = ((bfd_signed_vma) result.value
/ (bfd_signed_vma) other.value);
break;
BOP(ANDAND,&&);
BOP(OROR,||);
+ case MAX_K:
+ if (result.value < other.value)
+ result = other;
+ break;
+
+ case MIN_K:
+ if (result.value > other.value)
+ result = other;
+ break;
+
default:
FAIL();
}
}
else
{
- result.valid = false;
+ result.valid_p = false;
}
}
invalid ()
{
etree_value_type new;
- new.valid = false;
+ new.valid_p = false;
return new;
}
}
else
{
- result.valid = false;
+ result.valid_p = false;
}
break;
case DEFINED:
if (allocation_done == lang_first_phase_enum)
- result.valid = false;
+ result.valid_p = false;
else
{
struct bfd_link_hash_entry *h;
|| h->type == bfd_link_hash_defweak
|| h->type == bfd_link_hash_common));
result.section = 0;
- result.valid = true;
+ result.valid_p = true;
}
break;
case NAME:
- result.valid = false;
+ result.valid_p = false;
if (tree->name.name[0] == '.' && tree->name.name[1] == 0)
{
if (allocation_done != lang_first_phase_enum)
else if (allocation_done == lang_final_phase_enum
|| allocation_done == lang_allocating_phase_enum)
{
- lang_output_section_statement_type *os;
-
- os = (lang_output_section_statement_lookup
- (h->u.def.section->output_section->name));
-
- /* FIXME: Is this correct if this section is being
- linked with -R? */
- result = new_rel ((h->u.def.value
- + h->u.def.section->output_offset),
- os);
+ asection *output_section;
+
+ output_section = h->u.def.section->output_section;
+ if (output_section == NULL)
+ einfo (_("%X%S: unresolvable symbol `%s' referenced in expression\n"),
+ tree->name.name);
+ else
+ {
+ lang_output_section_statement_type *os;
+
+ os = (lang_output_section_statement_lookup
+ (bfd_get_section_name (output_bfd,
+ output_section)));
+
+ /* FIXME: Is this correct if this section is
+ being linked with -R? */
+ result = new_rel ((h->u.def.value
+ + h->u.def.section->output_offset),
+ os);
+ }
}
}
else if (allocation_done == lang_final_phase_enum)
- einfo ("%F%S: undefined symbol `%s' referenced in expression\n",
+ einfo (_("%F%S: undefined symbol `%s' referenced in expression\n"),
tree->name.name);
}
break;
if (tree == NULL)
{
- result.valid = false;
+ result.valid_p = false;
return result;
}
case etree_rel:
if (allocation_done != lang_final_phase_enum)
- result.valid = false;
+ result.valid_p = false;
else
result = new_rel ((tree->rel.value
+ tree->rel.section->output_section->vma
current_section);
break;
+ case etree_assert:
+ result = exp_fold_tree (tree->assert_s.child,
+ current_section,
+ allocation_done, dot, dotp);
+ if (result.valid_p)
+ {
+ if (! result.value)
+ einfo ("%F%P: %s\n", tree->assert_s.message);
+ return result;
+ }
+ break;
+
case etree_unary:
result = exp_fold_tree (tree->unary.child,
current_section,
allocation_done, dot, dotp);
- if (result.valid)
+ if (result.valid_p)
{
switch (tree->type.node_code)
{
result = new_rel_from_section (ALIGN_N (dot, result.value),
current_section);
else
- result.valid = false;
+ result.valid_p = false;
break;
case ABSOLUTE:
- if (allocation_done != lang_first_phase_enum && result.valid)
+ if (allocation_done != lang_first_phase_enum && result.valid_p)
{
result.value += result.section->bfd_section->vma;
result.section = abs_output_section;
}
else
- result.valid = false;
+ result.valid_p = false;
break;
case '~':
result.value = ALIGN_N (dot, result.value);
}
else
- result.valid = false;
+ result.valid_p = false;
break;
default:
case etree_trinary:
result = exp_fold_tree (tree->trinary.cond, current_section,
allocation_done, dot, dotp);
- if (result.valid)
+ if (result.valid_p)
result = exp_fold_tree ((result.value
? tree->trinary.lhs
: tree->trinary.rhs),
{
/* Assignment to dot can only be done during allocation */
if (tree->type.node_class == etree_provide)
- einfo ("%F%S can not PROVIDE assignment to location counter\n");
+ einfo (_("%F%S can not PROVIDE assignment to location counter\n"));
if (allocation_done == lang_allocating_phase_enum
|| (allocation_done == lang_final_phase_enum
&& current_section == abs_output_section))
current_section,
lang_allocating_phase_enum, dot,
dotp);
- if (! result.valid)
- einfo ("%F%S invalid assignment to location counter\n");
+ if (! result.valid_p)
+ einfo (_("%F%S invalid assignment to location counter\n"));
else
{
if (current_section == NULL)
- einfo ("%F%S assignment to location counter invalid outside of SECTION\n");
+ einfo (_("%F%S assignment to location counter invalid outside of SECTION\n"));
else
{
bfd_vma nextdot;
if (nextdot < dot
&& current_section != abs_output_section)
{
- einfo ("%F%S cannot move location counter backwards (from %V to %V)\n",
+ einfo (_("%F%S cannot move location counter backwards (from %V to %V)\n"),
dot, nextdot);
}
else
result = exp_fold_tree (tree->assign.src,
current_section, allocation_done,
dot, dotp);
- if (result.valid)
+ if (result.valid_p)
{
boolean create;
struct bfd_link_hash_entry *h;
if (h == (struct bfd_link_hash_entry *) NULL)
{
if (tree->type.node_class == etree_assign)
- einfo ("%P%F:%s: hash creation failed\n",
+ einfo (_("%P%F:%s: hash creation failed\n"),
tree->assign.dst);
}
else if (tree->type.node_class == etree_provide
r = exp_fold_tree_no_dot(&value,
abs_output_section,
lang_first_phase_enum );
- if (r.valid)
+ if (r.valid_p)
{
return exp_intop(r.value);
}
value.type.node_class = etree_trinary;
r= exp_fold_tree_no_dot(&value, (lang_output_section_statement_type
*)NULL,lang_first_phase_enum);
- if (r.valid) {
+ if (r.valid_p) {
return exp_intop(r.value);
}
new = (etree_type *) stat_alloc (sizeof (new->trinary));
value.unary.type.node_class = etree_unary;
r = exp_fold_tree_no_dot(&value,abs_output_section,
lang_first_phase_enum);
- if (r.valid) {
+ if (r.valid_p) {
return exp_intop(r.value);
}
new = (etree_type *) stat_alloc (sizeof (new->unary));
r = exp_fold_tree_no_dot(&value,
(lang_output_section_statement_type *)NULL,
lang_first_phase_enum);
- if (r.valid) {
+ if (r.valid_p) {
return exp_intop(r.value);
}
new = (etree_type *) stat_alloc (sizeof (new->name));
return n;
}
+/* Handle ASSERT. */
+
+etree_type *
+exp_assert (exp, message)
+ etree_type *exp;
+ const char *message;
+{
+ etree_type *n;
+
+ n = (etree_type *) stat_alloc (sizeof (n->assert_s));
+ n->assert_s.type.node_code = '!';
+ n->assert_s.type.node_class = etree_assert;
+ n->assert_s.child = exp;
+ n->assert_s.message = message;
+ return n;
+}
+
void
exp_print_tree (tree)
etree_type *tree;
exp_print_token(tree->unary.type.node_code);
if (tree->unary.child)
{
-
fprintf(config.map_file,"(");
exp_print_tree(tree->unary.child);
fprintf(config.map_file,")");
}
break;
+
+ case etree_assert:
+ fprintf (config.map_file, "ASSERT (");
+ exp_print_tree (tree->assert_s.child);
+ fprintf (config.map_file, ", %s)", tree->assert_s.message);
+ break;
+
case etree_undef:
fprintf(config.map_file,"????????");
break;
if (tree != NULL)
{
r = exp_fold_tree_no_dot (tree, abs_output_section, allocation_done);
- if (! r.valid && name != NULL)
- einfo ("%F%S nonconstant expression for %s\n", name);
+ if (! r.valid_p && name != NULL)
+ einfo (_("%F%S nonconstant expression for %s\n"), name);
return r.value;
}
else
etree_value_type res;
res = exp_fold_tree_no_dot (tree, abs_output_section, allocation_done);
- if (res.valid)
+ if (res.valid_p)
{
res.value += res.section->bfd_section->vma;
}
else {
- einfo ("%F%S non constant expression for %s\n",name);
+ einfo (_("%F%S non constant expression for %s\n"),name);
}
return res.value;
}