Parse a SECTIONS clause in a linker script.

1 files changed, 738 insertions, 0 deletions

diff --git a/gold/script-sections.cc b/gold/script-sections.cc
new file mode 100644
index 0000000..de6da30
--- /dev/null
+++ b/gold/script-sections.cc
@@ -0,0 +1,738 @@
+// script-sections.cc -- linker script SECTIONS for gold
+
+// Copyright 2008 Free Software Foundation, Inc.
+// Written by Ian Lance Taylor <iant@google.com>.
+
+// This file is part of gold.
+
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
+// MA 02110-1301, USA.
+
+#include "gold.h"
+
+#include <string>
+#include <vector>
+
+#include "script-c.h"
+#include "script.h"
+#include "script-sections.h"
+
+// Support for the SECTIONS clause in linker scripts.
+
+namespace gold
+{
+
+// An element in a SECTIONS clause.
+
+class Sections_element
+{
+ public:
+  Sections_element()
+  { }
+
+  virtual ~Sections_element()
+  { }
+
+  virtual void
+  print(FILE* f) const = 0;
+};
+
+// An assignment in a SECTIONS clause outside of an output section.
+
+class Sections_element_assignment : public Sections_element
+{
+ public:
+  Sections_element_assignment(const char* name, size_t namelen,
+			      Expression* val, bool provide, bool hidden)
+    : assignment_(name, namelen, val, provide, hidden)
+  { }
+
+  void
+  print(FILE* f) const
+  {
+    fprintf(f, "  ");
+    this->assignment_.print(f);
+  }
+
+ private:
+  Symbol_assignment assignment_;
+};
+
+// An assertion in a SECTIONS clause outside of an output section.
+
+class Sections_element_assertion : public Sections_element
+{
+ public:
+  Sections_element_assertion(Expression* check, const char* message,
+			     size_t messagelen)
+    : assertion_(check, message, messagelen)
+  { }
+
+  void
+  print(FILE* f) const
+  {
+    fprintf(f, "  ");
+    this->assertion_.print(f);
+  }
+
+ private:
+  Script_assertion assertion_;
+};
+
+// An element in an output section in a SECTIONS clause.
+
+class Output_section_element
+{
+ public:
+  Output_section_element()
+  { }
+
+  virtual ~Output_section_element()
+  { }
+
+  virtual void
+  print(FILE* f) const = 0;
+};
+
+// A symbol assignment in an output section.
+
+class Output_section_element_assignment : public Output_section_element
+{
+ public:
+  Output_section_element_assignment(const char* name, size_t namelen,
+				    Expression* val, bool provide,
+				    bool hidden)
+    : assignment_(name, namelen, val, provide, hidden)
+  { }
+
+  void
+  print(FILE* f) const
+  {
+    fprintf(f, "    ");
+    this->assignment_.print(f);
+  }
+
+ private:
+  Symbol_assignment assignment_;
+};
+
+// An assertion in an output section.
+
+class Output_section_element_assertion : public Output_section_element
+{
+ public:
+  Output_section_element_assertion(Expression* check, const char* message,
+				   size_t messagelen)
+    : assertion_(check, message, messagelen)
+  { }
+
+  void
+  print(FILE* f) const
+  {
+    fprintf(f, "    ");
+    this->assertion_.print(f);
+  }
+
+ private:
+  Script_assertion assertion_;
+};
+
+// A data item in an output section.
+
+class Output_section_element_data : public Output_section_element
+{
+ public:
+  Output_section_element_data(int size, bool is_signed, Expression* val)
+    : size_(size), is_signed_(is_signed), val_(val)
+  { }
+
+  void
+  print(FILE*) const;
+
+ private:
+  // The size in bytes.
+  int size_;
+  // Whether the value is signed.
+  bool is_signed_;
+  // The value.
+  Expression* val_;
+};
+
+// Print for debugging.
+
+void
+Output_section_element_data::print(FILE* f) const
+{
+  const char* s;
+  switch (this->size_)
+    {
+    case 1:
+      s = "BYTE";
+      break;
+    case 2:
+      s = "SHORT";
+      break;
+    case 4:
+      s = "LONG";
+      break;
+    case 8:
+      if (this->is_signed_)
+	s = "SQUAD";
+      else
+	s = "QUAD";
+      break;
+    default:
+      gold_unreachable();
+    }
+  fprintf(f, "    %s(", s);
+  this->val_->print(f);
+  fprintf(f, ")\n");
+}
+
+// A fill value setting in an output section.
+
+class Output_section_element_fill : public Output_section_element
+{
+ public:
+  Output_section_element_fill(Expression* val)
+    : val_(val)
+  { }
+
+  void
+  print(FILE* f) const
+  {
+    fprintf(f, "    FILL(");
+    this->val_->print(f);
+    fprintf(f, ")\n");
+  }
+
+ private:
+  // The new fill value.
+  Expression* val_;
+};
+
+// An input section specification in an output section
+
+class Output_section_element_input : public Output_section_element
+{
+ public:
+  // Note that an Input_section_spec holds some pointers to vectors.
+  // This constructor takes ownership of them.  The parser is
+  // implemented such that this works.
+  Output_section_element_input(const Input_section_spec* spec, bool keep);
+
+  void
+  print(FILE* f) const;
+
+ private:
+  // An input section pattern.
+  struct Input_section_pattern
+  {
+    std::string pattern;
+    Sort_wildcard sort;
+
+    Input_section_pattern(const char* patterna, size_t patternlena,
+			  Sort_wildcard sorta)
+      : pattern(patterna, patternlena), sort(sorta)
+    { }
+  };
+
+  typedef std::vector<Input_section_pattern> Input_section_patterns;
+
+  typedef std::vector<std::string> Filename_exclusions;
+
+  // The file name pattern.
+  std::string filename_pattern_;
+  // How the file names should be sorted.  This may only be
+  // SORT_WILDCARD_NONE or SORT_WILDCARD_BY_NAME.
+  Sort_wildcard filename_sort_;
+  // The list of file names to exclude.
+  Filename_exclusions filename_exclusions_;
+  // The list of input section patterns.
+  Input_section_patterns input_section_patterns_;
+  // Whether to keep this section when garbage collecting.
+  bool keep_;
+};
+
+// Construct Output_section_element_input.  The parser records strings
+// as pointers into a copy of the script file, which will go away when
+// parsing is complete.  We make sure they are in std::string objects.
+
+Output_section_element_input::Output_section_element_input(
+    const Input_section_spec* spec,
+    bool keep)
+  : filename_pattern_(spec->file.name.value, spec->file.name.length),
+    filename_sort_(spec->file.sort),
+    filename_exclusions_(),
+    input_section_patterns_(),
+    keep_(keep)
+{
+  if (spec->input_sections.exclude != NULL)
+    {
+      for (String_list::const_iterator p =
+	     spec->input_sections.exclude->begin();
+	   p != spec->input_sections.exclude->end();
+	   ++p)
+	this->filename_exclusions_.push_back(*p);
+    }
+
+  if (spec->input_sections.sections != NULL)
+    {
+      Input_section_patterns& isp(this->input_section_patterns_);
+      for (String_sort_list::const_iterator p =
+	     spec->input_sections.sections->begin();
+	   p != spec->input_sections.sections->end();
+	   ++p)
+	isp.push_back(Input_section_pattern(p->name.value, p->name.length,
+					    p->sort));
+    }
+}
+
+// Print for debugging.
+
+void
+Output_section_element_input::print(FILE* f) const
+{
+  fprintf(f, "    ");
+
+  if (this->keep_)
+    fprintf(f, "KEEP(");
+
+  if (!this->filename_pattern_.empty())
+    {
+      bool need_close_paren = false;
+      switch (this->filename_sort_)
+	{
+	case SORT_WILDCARD_NONE:
+	  break;
+	case SORT_WILDCARD_BY_NAME:
+	  fprintf(f, "SORT_BY_NAME(");
+	  need_close_paren = true;
+	  break;
+	default:
+	  gold_unreachable();
+	}
+
+      fprintf(f, "%s", this->filename_pattern_.c_str());
+
+      if (need_close_paren)
+	fprintf(f, ")");
+    }
+
+  if (!this->input_section_patterns_.empty()
+      || !this->filename_exclusions_.empty())
+    {
+      fprintf(f, "(");
+
+      bool need_space = false;
+      if (!this->filename_exclusions_.empty())
+	{
+	  fprintf(f, "EXCLUDE_FILE(");
+	  bool need_comma = false;
+	  for (Filename_exclusions::const_iterator p =
+		 this->filename_exclusions_.begin();
+	       p != this->filename_exclusions_.end();
+	       ++p)
+	    {
+	      if (need_comma)
+		fprintf(f, ", ");
+	      fprintf(f, "%s", p->c_str());
+	      need_comma = true;
+	    }
+	  fprintf(f, ")");
+	  need_space = true;
+	}
+
+      for (Input_section_patterns::const_iterator p =
+	     this->input_section_patterns_.begin();
+	   p != this->input_section_patterns_.end();
+	   ++p)
+	{
+	  if (need_space)
+	    fprintf(f, " ");
+
+	  int close_parens = 0;
+	  switch (p->sort)
+	    {
+	    case SORT_WILDCARD_NONE:
+	      break;
+	    case SORT_WILDCARD_BY_NAME:
+	      fprintf(f, "SORT_BY_NAME(");
+	      close_parens = 1;
+	      break;
+	    case SORT_WILDCARD_BY_ALIGNMENT:
+	      fprintf(f, "SORT_BY_ALIGNMENT(");
+	      close_parens = 1;
+	      break;
+	    case SORT_WILDCARD_BY_NAME_BY_ALIGNMENT:
+	      fprintf(f, "SORT_BY_NAME(SORT_BY_ALIGNMENT(");
+	      close_parens = 2;
+	      break;
+	    case SORT_WILDCARD_BY_ALIGNMENT_BY_NAME:
+	      fprintf(f, "SORT_BY_ALIGNMENT(SORT_BY_NAME(");
+	      close_parens = 2;
+	      break;
+	    default:
+	      gold_unreachable();
+	    }
+
+	  fprintf(f, "%s", p->pattern.c_str());
+
+	  for (int i = 0; i < close_parens; ++i)
+	    fprintf(f, ")");
+
+	  need_space = true;
+	}
+
+      fprintf(f, ")");
+    }
+
+  if (this->keep_)
+    fprintf(f, ")");
+
+  fprintf(f, "\n");
+}
+
+// An output section.
+
+class Output_section_definition : public Sections_element
+{
+ public:
+  Output_section_definition(const char* name, size_t namelen,
+			    const Parser_output_section_header* header);
+
+  // Finish the output section with the information in the trailer.
+  void
+  finish(const Parser_output_section_trailer* trailer);
+
+  // Add a symbol to be defined.
+  void
+  add_symbol_assignment(const char* name, size_t length, Expression* value,
+			bool provide, bool hidden);
+  // Add an assertion.
+  void
+  add_assertion(Expression* check, const char* message, size_t messagelen);
+
+  // Add a data item to the current output section.
+  void
+  add_data(int size, bool is_signed, Expression* val);
+
+  // Add a setting for the fill value.
+  void
+  add_fill(Expression* val);
+
+  // Add an input section specification.
+  void
+  add_input_section(const Input_section_spec* spec, bool keep);
+
+  // Print the contents to the FILE.  This is for debugging.
+  void
+  print(FILE*) const;
+
+ private:
+  typedef std::vector<Output_section_element*> Output_section_elements;
+
+  // The output section name.
+  std::string name_;
+  // The address.  This may be NULL.
+  Expression* address_;
+  // The load address.  This may be NULL.
+  Expression* load_address_;
+  // The alignment.  This may be NULL.
+  Expression* align_;
+  // The input section alignment.  This may be NULL.
+  Expression* subalign_;
+  // The fill value.  This may be NULL.
+  Expression* fill_;
+  // The list of elements defining the section.
+  Output_section_elements elements_;
+};
+
+// Constructor.
+
+Output_section_definition::Output_section_definition(
+    const char* name,
+    size_t namelen,
+    const Parser_output_section_header* header)
+  : name_(name, namelen),
+    address_(header->address),
+    load_address_(header->load_address),
+    align_(header->align),
+    subalign_(header->subalign),
+    fill_(NULL),
+    elements_()
+{
+}
+
+// Finish an output section.
+
+void
+Output_section_definition::finish(const Parser_output_section_trailer* trailer)
+{
+  this->fill_ = trailer->fill;
+}
+
+// Add a symbol to be defined.
+
+void
+Output_section_definition::add_symbol_assignment(const char* name,
+						 size_t length,
+						 Expression* value,
+						 bool provide,
+						 bool hidden)
+{
+  Output_section_element* p = new Output_section_element_assignment(name,
+								    length,
+								    value,
+								    provide,
+								    hidden);
+  this->elements_.push_back(p);
+}
+
+// Add an assertion.
+
+void
+Output_section_definition::add_assertion(Expression* check,
+					 const char* message,
+					 size_t messagelen)
+{
+  Output_section_element* p = new Output_section_element_assertion(check,
+								   message,
+								   messagelen);
+  this->elements_.push_back(p);
+}
+
+// Add a data item to the current output section.
+
+void
+Output_section_definition::add_data(int size, bool is_signed, Expression* val)
+{
+  Output_section_element* p = new Output_section_element_data(size, is_signed,
+							      val);
+  this->elements_.push_back(p);
+}
+
+// Add a setting for the fill value.
+
+void
+Output_section_definition::add_fill(Expression* val)
+{
+  Output_section_element* p = new Output_section_element_fill(val);
+  this->elements_.push_back(p);
+}
+
+// Add an input section specification.
+
+void
+Output_section_definition::add_input_section(const Input_section_spec* spec,
+					     bool keep)
+{
+  Output_section_element* p = new Output_section_element_input(spec, keep);
+  this->elements_.push_back(p);
+}
+
+// Print for debugging.
+
+void
+Output_section_definition::print(FILE* f) const
+{
+  fprintf(f, "  %s ", this->name_.c_str());
+
+  if (this->address_ != NULL)
+    {
+      this->address_->print(f);
+      fprintf(f, " ");
+    }
+
+  fprintf(f, ": ");
+
+  if (this->load_address_ != NULL)
+    {
+      fprintf(f, "AT(");
+      this->load_address_->print(f);
+      fprintf(f, ") ");
+    }
+
+  if (this->align_ != NULL)
+    {
+      fprintf(f, "ALIGN(");
+      this->align_->print(f);
+      fprintf(f, ") ");
+    }
+
+  if (this->subalign_ != NULL)
+    {
+      fprintf(f, "SUBALIGN(");
+      this->subalign_->print(f);
+      fprintf(f, ") ");
+    }
+
+  fprintf(f, "{\n");
+
+  for (Output_section_elements::const_iterator p = this->elements_.begin();
+       p != this->elements_.end();
+       ++p)
+    (*p)->print(f);
+
+  fprintf(f, "  }");
+
+  if (this->fill_ != NULL)
+    {
+      fprintf(f, " = ");
+      this->fill_->print(f);
+    }
+
+  fprintf(f, "\n");
+}
+
+// Class Script_sections.
+
+Script_sections::Script_sections()
+  : saw_sections_clause_(false),
+    in_sections_clause_(false),
+    sections_elements_(NULL),
+    output_section_(NULL)
+{
+}
+
+// Start a SECTIONS clause.
+
+void
+Script_sections::start_sections()
+{
+  gold_assert(!this->in_sections_clause_ && this->output_section_ == NULL);
+  this->saw_sections_clause_ = true;
+  this->in_sections_clause_ = true;
+  if (this->sections_elements_ == NULL)
+    this->sections_elements_ = new Sections_elements;
+}
+
+// Finish a SECTIONS clause.
+
+void
+Script_sections::finish_sections()
+{
+  gold_assert(this->in_sections_clause_ && this->output_section_ == NULL);
+  this->in_sections_clause_ = false;
+}
+
+// Add a symbol to be defined.
+
+void
+Script_sections::add_symbol_assignment(const char* name, size_t length,
+				       Expression* val, bool provide,
+				       bool hidden)
+{
+  if (this->output_section_ != NULL)
+    this->output_section_->add_symbol_assignment(name, length, val,
+						 provide, hidden);
+  else
+    {
+      Sections_element* p = new Sections_element_assignment(name, length,
+							    val, provide,
+							    hidden);
+      this->sections_elements_->push_back(p);
+    }
+}
+
+// Add an assertion.
+
+void
+Script_sections::add_assertion(Expression* check, const char* message,
+			       size_t messagelen)
+{
+  if (this->output_section_ != NULL)
+    this->output_section_->add_assertion(check, message, messagelen);
+  else
+    {
+      Sections_element* p = new Sections_element_assertion(check, message,
+							   messagelen);
+      this->sections_elements_->push_back(p);
+    }
+}
+
+// Start processing entries for an output section.
+
+void
+Script_sections::start_output_section(
+    const char* name,
+    size_t namelen,
+    const Parser_output_section_header *header)
+{
+  Output_section_definition* posd = new Output_section_definition(name,
+								  namelen,
+								  header);
+  this->sections_elements_->push_back(posd);
+  gold_assert(this->output_section_ == NULL);
+  this->output_section_ = posd;
+}
+
+// Stop processing entries for an output section.
+
+void
+Script_sections::finish_output_section(
+    const Parser_output_section_trailer* trailer)
+{
+  gold_assert(this->output_section_ != NULL);
+  this->output_section_->finish(trailer);
+  this->output_section_ = NULL;
+}
+
+// Add a data item to the current output section.
+
+void
+Script_sections::add_data(int size, bool is_signed, Expression* val)
+{
+  gold_assert(this->output_section_ != NULL);
+  this->output_section_->add_data(size, is_signed, val);
+}
+
+// Add a fill value setting to the current output section.
+
+void
+Script_sections::add_fill(Expression* val)
+{
+  gold_assert(this->output_section_ != NULL);
+  this->output_section_->add_fill(val);
+}
+
+// Add an input section specification to the current output section.
+
+void
+Script_sections::add_input_section(const Input_section_spec* spec, bool keep)
+{
+  gold_assert(this->output_section_ != NULL);
+  this->output_section_->add_input_section(spec, keep);
+}
+
+// Print the SECTIONS clause to F for debugging.
+
+void
+Script_sections::print(FILE* f) const
+{
+  if (!this->saw_sections_clause_)
+    return;
+
+  fprintf(f, "SECTIONS {\n");
+
+  for (Sections_elements::const_iterator p = this->sections_elements_->begin();
+       p != this->sections_elements_->end();
+       ++p)
+    (*p)->print(f);
+
+  fprintf(f, "}\n");
+}
+
+} // End namespace gold.