// expression.cc -- expressions in linker scripts for gold
-// Copyright 2006, 2007, 2008 Free Software Foundation, Inc.
+// Copyright (C) 2006-2018 Free Software Foundation, Inc.
// Written by Ian Lance Taylor <iant@google.com>.
// This file is part of gold.
Output_section** result_section_pointer;
// Pointer to where the alignment of the result should be stored.
uint64_t* result_alignment_pointer;
+ // Pointer to where the type of the symbol on the RHS should be stored.
+ elfcpp::STT* type_pointer;
+ // Pointer to where the visibility of the symbol on the RHS should be stored.
+ elfcpp::STV* vis_pointer;
+ // Pointer to where the rest of the symbol's st_other field should be stored.
+ unsigned char* nonvis_pointer;
+ // Whether the value is valid. In Symbol_assignment::set_if_absolute, we
+ // may be trying to evaluate the address of a section whose address is not
+ // yet finalized, and we need to fail the evaluation gracefully.
+ bool *is_valid_pointer;
};
// Evaluate an expression.
Expression::eval(const Symbol_table* symtab, const Layout* layout,
bool check_assertions)
{
- return this->eval_maybe_dot(symtab, layout, check_assertions,
- false, 0, NULL, NULL, NULL, false);
+ return this->eval_maybe_dot(symtab, layout, check_assertions, false, 0,
+ NULL, NULL, NULL, NULL, NULL, NULL, false, NULL);
}
// Evaluate an expression which may refer to the dot symbol.
{
return this->eval_maybe_dot(symtab, layout, check_assertions, true,
dot_value, dot_section, result_section_pointer,
- result_alignment_pointer,
- is_section_dot_assignment);
+ result_alignment_pointer, NULL, NULL, NULL,
+ is_section_dot_assignment, NULL);
}
// Evaluate an expression which may or may not refer to the dot
uint64_t dot_value, Output_section* dot_section,
Output_section** result_section_pointer,
uint64_t* result_alignment_pointer,
- bool is_section_dot_assignment)
+ elfcpp::STT* type_pointer,
+ elfcpp::STV* vis_pointer,
+ unsigned char* nonvis_pointer,
+ bool is_section_dot_assignment,
+ bool* is_valid_pointer)
{
Expression_eval_info eei;
eei.symtab = symtab;
*result_section_pointer = NULL;
eei.result_section_pointer = result_section_pointer;
+ // For symbol=symbol assignments, we need to track the type, visibility,
+ // and remaining st_other bits.
+ eei.type_pointer = type_pointer;
+ eei.vis_pointer = vis_pointer;
+ eei.nonvis_pointer = nonvis_pointer;
+
eei.result_alignment_pointer = result_alignment_pointer;
+ // Assume the value is valid until we try to evaluate an expression
+ // that can't be evaluated yet.
+ bool is_valid = true;
+ eei.is_valid_pointer = &is_valid;
+
uint64_t val = this->value(&eei);
+ if (is_valid_pointer != NULL)
+ *is_valid_pointer = is_valid;
+ else
+ gold_assert(is_valid);
+
// If this is an assignment to dot within a section, and the value
// is absolute, treat it as a section-relative offset.
if (is_section_dot_assignment && *result_section_pointer == NULL)
value(const Expression_eval_info*);
void
+ set_expr_sym_in_real_elf(Symbol_table* symtab) const
+ {
+ Symbol* sym = symtab->lookup(this->name_.c_str());
+ if (sym != NULL)
+ sym->set_in_real_elf();
+ }
+
+ void
print(FILE* f) const
{ fprintf(f, "%s", this->name_.c_str()); }
if (eei->result_section_pointer != NULL)
*eei->result_section_pointer = sym->output_section();
+ if (eei->type_pointer != NULL)
+ *eei->type_pointer = sym->type();
+ if (eei->vis_pointer != NULL)
+ *eei->vis_pointer = sym->visibility();
+ if (eei->nonvis_pointer != NULL)
+ *eei->nonvis_pointer = sym->nonvis();
if (parameters->target().get_size() == 32)
return eei->symtab->get_sized_symbol<32>(sym)->value();
eei->dot_section,
arg_section_pointer,
eei->result_alignment_pointer,
- false);
+ NULL,
+ NULL,
+ NULL,
+ false,
+ eei->is_valid_pointer);
}
void
arg_print(FILE* f) const
{ this->arg_->print(f); }
+ void
+ set_expr_sym_in_real_elf(Symbol_table* symtab) const
+ { return this->arg_->set_expr_sym_in_real_elf(symtab); }
+
private:
Expression* arg_;
};
eei->dot_section,
section_pointer,
alignment_pointer,
- false);
+ NULL,
+ NULL,
+ NULL,
+ false,
+ eei->is_valid_pointer);
}
uint64_t
eei->dot_section,
section_pointer,
alignment_pointer,
- false);
+ NULL,
+ NULL,
+ NULL,
+ false,
+ eei->is_valid_pointer);
}
void
fprintf(f, ")");
}
+ void
+ set_expr_sym_in_real_elf(Symbol_table* symtab) const
+ {
+ this->left_->set_expr_sym_in_real_elf(symtab);
+ this->right_->set_expr_sym_in_real_elf(symtab);
+ }
+
private:
Expression* left_;
Expression* right_;
eei->dot_section,
section_pointer,
NULL,
- false);
+ NULL,
+ NULL,
+ NULL,
+ false,
+ eei->is_valid_pointer);
}
uint64_t
eei->dot_section,
section_pointer,
alignment_pointer,
- false);
+ NULL,
+ NULL,
+ NULL,
+ false,
+ eei->is_valid_pointer);
}
uint64_t
eei->dot_section,
section_pointer,
alignment_pointer,
- false);
+ NULL,
+ NULL,
+ NULL,
+ false,
+ eei->is_valid_pointer);
}
void
arg3_print(FILE* f) const
{ this->arg3_->print(f); }
+ void
+ set_expr_sym_in_real_elf(Symbol_table* symtab) const
+ {
+ this->arg1_->set_expr_sym_in_real_elf(symtab);
+ this->arg2_->set_expr_sym_in_real_elf(symtab);
+ this->arg3_->set_expr_sym_in_real_elf(symtab);
+ }
+
private:
Expression* arg1_;
Expression* arg2_;
{
if (eei->result_section_pointer != NULL)
*eei->result_section_pointer = os;
- return os->address();
+ if (os->is_address_valid())
+ return os->address();
+ *eei->is_valid_pointer = false;
+ return 0;
}
uint64_t