gold/attributes.cc - third_party/binutils-gdb - Git at Google

 // attributes.cc -- object attributes for gold

 // Copyright (C) 2009-2016 Free Software Foundation, Inc.
 // Written by Doug Kwan <dougkwan@google.com>.
 // This file contains code adapted from BFD.

 // 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 <limits>

 #include "attributes.h"
 #include "elfcpp.h"
 #include "target.h"
 #include "parameters.h"
 #include "int_encoding.h"

 namespace gold
 {

 // Object_attribute methods.

 // Return size of attribute encode in ULEB128.

 size_t
 Object_attribute::size(int tag) const
 {
   // Attributes with default values are not written out.
   if (this->is_default_attribute())
     return 0;

   size_t size = get_length_as_unsigned_LEB_128(tag);
   if (Object_attribute::attribute_type_has_int_value(this->type_))
     size += get_length_as_unsigned_LEB_128(this->int_value_);
   if (Object_attribute::attribute_type_has_string_value(this->type_))
     size += this->string_value_.size() + 1;
   return size;
 }

 // Whether this has the default value (0/"").

 bool
 Object_attribute::is_default_attribute() const
 {
   if (Object_attribute::attribute_type_has_int_value(this->type_)
       && this->int_value_ != 0)
     return false;
   if (Object_attribute::attribute_type_has_string_value(this->type_)
       && !this->string_value_.empty())
     return false;
   if (Object_attribute::attribute_type_has_no_default(this->type_))
     return false;

   return true;
 }

 // Whether this matches another Object_attribute OA in merging.
 // Two Object_attributes match if they have the same values.

 bool
 Object_attribute::matches(const Object_attribute& oa) const
 {
   return ((this->int_value_ != oa.int_value_)
 	  && (this->string_value_ == oa.string_value_));
 }

 // Write this with TAG to a BUFFER.

 void
 Object_attribute::write(
     int tag,
     std::vector<unsigned char>* buffer) const
 {
   // No need to write default attributes.
   if (this->is_default_attribute())
     return;

   // Write tag.
   write_unsigned_LEB_128(buffer, convert_types<uint64_t, int>(tag));

   // Write integer value.
   if (Object_attribute::attribute_type_has_int_value(this->type_))
     write_unsigned_LEB_128(buffer,
 			   convert_types<uint64_t, int>(this->int_value_));

   // Write string value.
   if (Object_attribute::attribute_type_has_string_value(this->type_))
     {
       const unsigned char* start =
 	reinterpret_cast<const unsigned char*>(this->string_value_.c_str());
       const unsigned char* end = start + this->string_value_.size() + 1;
       buffer->insert(buffer->end(), start, end);
     }
 }

 // Vendor_object_attributes methods.

 // Copying constructor.

 Vendor_object_attributes::Vendor_object_attributes(
     const Vendor_object_attributes& voa)
 {
   this->vendor_ = voa.vendor_;

   for (int i = 0; i < NUM_KNOWN_ATTRIBUTES; ++i)
     this->known_attributes_[i] = voa.known_attributes_[i];

   // We do not handle attribute deletion.  So this must be empty.
   gold_assert(this->other_attributes_.empty());

   for (Other_attributes::const_iterator p = voa.other_attributes_.begin();
        p != voa.other_attributes_.end();
        ++p)
     this->other_attributes_[p->first] = new Object_attribute(*(p->second));
 }

 // Size of this in number of bytes.

 size_t
 Vendor_object_attributes::size() const
 {
   if (this->name() == NULL)
     return 0;

   size_t data_size = 0;
   for (int i = 4; i < NUM_KNOWN_ATTRIBUTES; ++i)
     data_size += this->known_attributes_[i].size(i);

   for (Other_attributes::const_iterator p = this->other_attributes_.begin();
        p != this->other_attributes_.end();
        ++p)
     data_size += p->second->size(p->first);

   // <size> <vendor_name> NUL 0x1 <size>
   return ((data_size != 0
 	   || this->vendor_ == Object_attribute::OBJ_ATTR_PROC)
 	  ? data_size + strlen(this->name()) + 2 + 2 * 4
 	  : 0);
 }

 // Return a new attribute associated with TAG.

 Object_attribute*
 Vendor_object_attributes::new_attribute(int tag)
 {
   int type = Object_attribute::arg_type(this->vendor_, tag);

   if (tag < NUM_KNOWN_ATTRIBUTES)
     {
       this->known_attributes_[tag].set_type(type);
       return &this->known_attributes_[tag];
     }
   else
     {
       Object_attribute* attr = new Object_attribute();

       // This should be the first time we insert this.
       std::pair<Other_attributes::iterator, bool> ins =
 	this->other_attributes_.insert(std::make_pair(tag, attr));
       gold_assert(ins.second);

       attr->set_type(type);
       return attr;
     }
 }

 // Return an attribute associated with TAG.

 Object_attribute*
 Vendor_object_attributes::get_attribute(int tag)
 {
   if (tag < NUM_KNOWN_ATTRIBUTES)
     return &this->known_attributes_[tag];
   else
     {
       Other_attributes::iterator p =
 	this->other_attributes_.find(tag);
       return p != this->other_attributes_.end() ? p->second : NULL;
     }
 }

 const Object_attribute*
 Vendor_object_attributes::get_attribute(int tag) const
 {
   if (tag < NUM_KNOWN_ATTRIBUTES)
     return &this->known_attributes_[tag];
   else
     {
       Other_attributes::const_iterator p =
 	this->other_attributes_.find(tag);
       return p != this->other_attributes_.end() ? p->second : NULL;
     }
 }

 // Write attributes to BUFFER.

 void
 Vendor_object_attributes::write(std::vector<unsigned char>* buffer) const
 {
   // Write subsection size.
   size_t voa_size = this->size();
   uint32_t voa_size_as_u32 = convert_types<uint32_t, size_t>(voa_size);
   insert_into_vector<32>(buffer, voa_size_as_u32);

   // Write vendor name.
   const unsigned char* vendor_start =
     reinterpret_cast<const unsigned char*>(this->name());
   size_t vendor_length = strlen(this->name()) + 1;
   const unsigned char* vendor_end = vendor_start + vendor_length;
   buffer->insert(buffer->end(), vendor_start, vendor_end);

   // Write file tag.
   buffer->push_back(Object_attribute::Tag_File);

   // Write attributes size.
   uint32_t attributes_size_as_u32 =
     convert_types<uint32_t, size_t>(voa_size - 4 - vendor_length);
   insert_into_vector<32>(buffer, attributes_size_as_u32);

   // Write known attributes, skipping any defaults.
   for (int i = 4; i < NUM_KNOWN_ATTRIBUTES; ++i)
     {
       // A target may write known attributes in a special order.
       // Call target hook to remap tags.  Attributes_order is the identity
       // function if no re-ordering is required.
       int tag = parameters->target().attributes_order(i);
       this->known_attributes_[tag].write(tag, buffer);
     }

   // Write other attributes.
   for (Other_attributes::const_iterator q = this->other_attributes_.begin();
        q != this->other_attributes_.end();
        ++q)
     q->second->write(q->first, buffer);
 }

 // Attributes_section_data methods.

 // Compute encoded size of this.

 size_t
 Attributes_section_data::size() const
 {
   size_t data_size = 0;
   for(int vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; ++vendor)
     data_size += this->vendor_object_attributes_[vendor]->size();

   // 'A' <sections for each vendor>
   return data_size != 0 ? data_size + 1 : 0;
 }

 // Construct an Attributes_section_data object by parsing section contents
 // specified by VIEW and SIZE.

 Attributes_section_data::Attributes_section_data(
     const unsigned char* view,
     section_size_type size)
 {
   for (int vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; ++vendor)
     this->vendor_object_attributes_[vendor] =
       new Vendor_object_attributes(vendor);

   const unsigned char* p = view;
   p = view;
   if (size > 0 && p != NULL && *(p++) == 'A')
     {
       size--;
       while (size > 0)
 	{
 	  // Size of vendor attributes section.
 	  section_size_type section_size =
 	    convert_to_section_size_type(read_from_pointer<32>(&p));

 	  if (section_size > size)
 	    section_size = size;
 	  size -= section_size;

 	  const char* section_name = reinterpret_cast<const char*>(p);
 	  section_size_type section_name_size = strlen(section_name) + 1;
 	  section_size -= section_name_size + 4;

 	  int vendor;
 	  const char* std_section = parameters->target().attributes_vendor();
 	  if (std_section != NULL && strcmp(section_name, std_section) == 0)
 	    vendor = Object_attribute::OBJ_ATTR_PROC;
 	  else if (strcmp(section_name, "gnu") == 0)
 	    vendor = Object_attribute::OBJ_ATTR_GNU;
 	  else
 	    {
 	      // Other vendor section.  Ignore it.
 	      p += section_name_size + section_size;
 	      continue;
 	    }
 	  p += section_name_size;

 	  while (section_size > 0)
 	    {
 	      const unsigned char* subsection_start = p;

 	      // Read vendor subsection index and size.
 	      size_t uleb128_len;
 	      uint64_t val = read_unsigned_LEB_128(p, &uleb128_len);
 	      p += uleb128_len;

 	      int tag = convert_types<int, uint64_t>(val);
 	      section_size_type subsection_size =
 		convert_to_section_size_type(read_from_pointer<32>(&p));
 	      section_size -= subsection_size;
 	      subsection_size -= (p - subsection_start);

 	      const unsigned char* end = p + subsection_size;
 	      switch (tag)
 		{
 		case Object_attribute::Tag_File:
 		  while (p < end)
 		    {
 		      val = read_unsigned_LEB_128(p, &uleb128_len);
 		      p += uleb128_len;
 		      tag = convert_types<int, uint64_t>(val);
 		      Vendor_object_attributes* pvoa =
 			this->vendor_object_attributes_[vendor];
 		      Object_attribute* attr = pvoa->new_attribute(tag);
 		      const char* string_arg;
 		      unsigned int int_arg;

 		      int type = Object_attribute::arg_type(vendor, tag);
 		      switch (type
 			      & (Object_attribute::ATTR_TYPE_FLAG_INT_VAL
 				 | Object_attribute::ATTR_TYPE_FLAG_STR_VAL))
 			{
 			case (Object_attribute::ATTR_TYPE_FLAG_INT_VAL
 			      | Object_attribute::ATTR_TYPE_FLAG_STR_VAL):
 			  val = read_unsigned_LEB_128(p, &uleb128_len);
 			  p += uleb128_len;
 			  int_arg = convert_types<unsigned int, uint64_t>(val);
 			  string_arg = reinterpret_cast<const char *>(p);
 			  attr->set_int_value(int_arg);
 			  p += strlen(string_arg) + 1;
 			  break;
 			case Object_attribute::ATTR_TYPE_FLAG_STR_VAL:
 			  string_arg = reinterpret_cast<const char *>(p);
 			  attr->set_string_value(string_arg);
 			  p += strlen(string_arg) + 1;
 			  break;
 			case Object_attribute::ATTR_TYPE_FLAG_INT_VAL:
 			  val = read_unsigned_LEB_128(p, &uleb128_len);
 			  p += uleb128_len;
 			  int_arg = convert_types<unsigned int, uint64_t>(val);
 			  attr->set_int_value(int_arg);
 			  break;
 			default:
 			  gold_unreachable();
 			}
 		    }
 		  break;
 		case Object_attribute::Tag_Section:
 		case Object_attribute::Tag_Symbol:
 		  // Don't have anywhere convenient to attach these.
 		  // Fall through for now.
 		default:
 		  // Ignore things we don't know about.
 		  p += subsection_size;
 		  subsection_size = 0;
 		  break;
 		}
 	    }
 	}
     }
 }

 // Merge target-independent attributes from another Attribute_section_data
 // ASD from an object called NAME into this.

 void
 Attributes_section_data::merge(
     const char* name,
     const Attributes_section_data* pasd)
 {
   // The only common attribute is currently Tag_compatibility,
   // accepted in both processor and "gnu" sections.
   for (int vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; ++vendor)
     {
       // Handle Tag_compatibility.  The tags are only compatible if the flags
       // are identical and, if the flags are '1', the strings are identical.
       // If the flags are non-zero, then we can only use the string "gnu".
       const Object_attribute* in_attr =
 	&pasd->known_attributes(vendor)[Object_attribute::Tag_compatibility];
       Object_attribute* out_attr =
 	&this->known_attributes(vendor)[Object_attribute::Tag_compatibility];

       if (in_attr->int_value() > 0
 	  && in_attr->string_value() != "gnu")
 	{
 	  gold_error(_("%s: must be processed by '%s' toolchain"),
 		     name, in_attr->string_value().c_str());
 	  return;
 	}

       if (in_attr->int_value() != out_attr->int_value()
 	  || in_attr->string_value() != out_attr->string_value())
 	{
 	  gold_error(_("%s: object tag '%d, %s' is "
 		       "incompatible with tag '%d, %s'"),
 		     name, in_attr->int_value(),
 		     in_attr->string_value().c_str(),
 		     out_attr->int_value(),
 		     out_attr->string_value().c_str());
 	}
     }
 }

 // Write to a buffer.

 void
 Attributes_section_data::write(std::vector<unsigned char>* buffer) const
 {
   buffer->push_back('A');
   for (int vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; ++vendor)
     if (this->vendor_object_attributes_[vendor]->size() != 0)
       this->vendor_object_attributes_[vendor]->write(buffer);
 }

 // Methods for Output_attributes_section_data.

 // Write attributes section data to file OF.

 void
 Output_attributes_section_data::do_write(Output_file* of)
 {
   off_t offset = this->offset();
   const section_size_type oview_size =
     convert_to_section_size_type(this->data_size());
   unsigned char* const oview = of->get_output_view(offset, oview_size);

   std::vector<unsigned char> buffer;
   this->attributes_section_data_.write(&buffer);
   gold_assert(convert_to_section_size_type(buffer.size()) == oview_size);
   memcpy(oview, &buffer.front(), buffer.size());
   of->write_output_view(this->offset(), oview_size, oview);
 }

 } // End namespace gold.
	// attributes.cc -- object attributes for gold

	// Copyright (C) 2009-2016 Free Software Foundation, Inc.
	// Written by Doug Kwan <dougkwan@google.com>.
	// This file contains code adapted from BFD.

	// 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 <limits>

	#include "attributes.h"
	#include "elfcpp.h"
	#include "target.h"
	#include "parameters.h"
	#include "int_encoding.h"

	namespace gold
	{

	// Object_attribute methods.

	// Return size of attribute encode in ULEB128.

	size_t
	Object_attribute::size(int tag) const
	{
	// Attributes with default values are not written out.
	if (this->is_default_attribute())
	return 0;

	size_t size = get_length_as_unsigned_LEB_128(tag);
	if (Object_attribute::attribute_type_has_int_value(this->type_))
	size += get_length_as_unsigned_LEB_128(this->int_value_);
	if (Object_attribute::attribute_type_has_string_value(this->type_))
	size += this->string_value_.size() + 1;
	return size;
	}

	// Whether this has the default value (0/"").

	bool
	Object_attribute::is_default_attribute() const
	{
	if (Object_attribute::attribute_type_has_int_value(this->type_)
	&& this->int_value_ != 0)
	return false;
	if (Object_attribute::attribute_type_has_string_value(this->type_)
	&& !this->string_value_.empty())
	return false;
	if (Object_attribute::attribute_type_has_no_default(this->type_))
	return false;

	return true;
	}

	// Whether this matches another Object_attribute OA in merging.
	// Two Object_attributes match if they have the same values.

	bool
	Object_attribute::matches(const Object_attribute& oa) const
	{
	return ((this->int_value_ != oa.int_value_)
	&& (this->string_value_ == oa.string_value_));
	}

	// Write this with TAG to a BUFFER.

	void
	Object_attribute::write(
	int tag,
	std::vector<unsigned char>* buffer) const
	{
	// No need to write default attributes.
	if (this->is_default_attribute())
	return;

	// Write tag.
	write_unsigned_LEB_128(buffer, convert_types<uint64_t, int>(tag));

	// Write integer value.
	if (Object_attribute::attribute_type_has_int_value(this->type_))
	write_unsigned_LEB_128(buffer,
	convert_types<uint64_t, int>(this->int_value_));

	// Write string value.
	if (Object_attribute::attribute_type_has_string_value(this->type_))
	{
	const unsigned char* start =
	reinterpret_cast<const unsigned char*>(this->string_value_.c_str());
	const unsigned char* end = start + this->string_value_.size() + 1;
	buffer->insert(buffer->end(), start, end);
	}
	}

	// Vendor_object_attributes methods.

	// Copying constructor.

	Vendor_object_attributes::Vendor_object_attributes(
	const Vendor_object_attributes& voa)
	{
	this->vendor_ = voa.vendor_;

	for (int i = 0; i < NUM_KNOWN_ATTRIBUTES; ++i)
	this->known_attributes_[i] = voa.known_attributes_[i];

	// We do not handle attribute deletion. So this must be empty.
	gold_assert(this->other_attributes_.empty());

	for (Other_attributes::const_iterator p = voa.other_attributes_.begin();
	p != voa.other_attributes_.end();
	++p)
	this->other_attributes_[p->first] = new Object_attribute(*(p->second));
	}

	// Size of this in number of bytes.

	size_t
	Vendor_object_attributes::size() const
	{
	if (this->name() == NULL)
	return 0;

	size_t data_size = 0;
	for (int i = 4; i < NUM_KNOWN_ATTRIBUTES; ++i)
	data_size += this->known_attributes_[i].size(i);

	for (Other_attributes::const_iterator p = this->other_attributes_.begin();
	p != this->other_attributes_.end();
	++p)
	data_size += p->second->size(p->first);

	// <size> <vendor_name> NUL 0x1 <size>
	return ((data_size != 0
	\|\| this->vendor_ == Object_attribute::OBJ_ATTR_PROC)
	? data_size + strlen(this->name()) + 2 + 2 * 4
	: 0);
	}

	// Return a new attribute associated with TAG.

	Object_attribute*
	Vendor_object_attributes::new_attribute(int tag)
	{
	int type = Object_attribute::arg_type(this->vendor_, tag);

	if (tag < NUM_KNOWN_ATTRIBUTES)
	{
	this->known_attributes_[tag].set_type(type);
	return &this->known_attributes_[tag];
	}
	else
	{
	Object_attribute* attr = new Object_attribute();

	// This should be the first time we insert this.
	std::pair<Other_attributes::iterator, bool> ins =
	this->other_attributes_.insert(std::make_pair(tag, attr));
	gold_assert(ins.second);

	attr->set_type(type);
	return attr;
	}
	}

	// Return an attribute associated with TAG.

	Object_attribute*
	Vendor_object_attributes::get_attribute(int tag)
	{
	if (tag < NUM_KNOWN_ATTRIBUTES)
	return &this->known_attributes_[tag];
	else
	{
	Other_attributes::iterator p =
	this->other_attributes_.find(tag);
	return p != this->other_attributes_.end() ? p->second : NULL;
	}
	}

	const Object_attribute*
	Vendor_object_attributes::get_attribute(int tag) const
	{
	if (tag < NUM_KNOWN_ATTRIBUTES)
	return &this->known_attributes_[tag];
	else
	{
	Other_attributes::const_iterator p =
	this->other_attributes_.find(tag);
	return p != this->other_attributes_.end() ? p->second : NULL;
	}
	}

	// Write attributes to BUFFER.

	void
	Vendor_object_attributes::write(std::vector<unsigned char>* buffer) const
	{
	// Write subsection size.
	size_t voa_size = this->size();
	uint32_t voa_size_as_u32 = convert_types<uint32_t, size_t>(voa_size);
	insert_into_vector<32>(buffer, voa_size_as_u32);

	// Write vendor name.
	const unsigned char* vendor_start =
	reinterpret_cast<const unsigned char*>(this->name());
	size_t vendor_length = strlen(this->name()) + 1;
	const unsigned char* vendor_end = vendor_start + vendor_length;
	buffer->insert(buffer->end(), vendor_start, vendor_end);

	// Write file tag.
	buffer->push_back(Object_attribute::Tag_File);

	// Write attributes size.
	uint32_t attributes_size_as_u32 =
	convert_types<uint32_t, size_t>(voa_size - 4 - vendor_length);
	insert_into_vector<32>(buffer, attributes_size_as_u32);

	// Write known attributes, skipping any defaults.
	for (int i = 4; i < NUM_KNOWN_ATTRIBUTES; ++i)
	{
	// A target may write known attributes in a special order.
	// Call target hook to remap tags. Attributes_order is the identity
	// function if no re-ordering is required.
	int tag = parameters->target().attributes_order(i);
	this->known_attributes_[tag].write(tag, buffer);
	}

	// Write other attributes.
	for (Other_attributes::const_iterator q = this->other_attributes_.begin();
	q != this->other_attributes_.end();
	++q)
	q->second->write(q->first, buffer);
	}

	// Attributes_section_data methods.

	// Compute encoded size of this.

	size_t
	Attributes_section_data::size() const
	{
	size_t data_size = 0;
	for(int vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; ++vendor)
	data_size += this->vendor_object_attributes_[vendor]->size();

	// 'A' <sections for each vendor>
	return data_size != 0 ? data_size + 1 : 0;
	}

	// Construct an Attributes_section_data object by parsing section contents
	// specified by VIEW and SIZE.

	Attributes_section_data::Attributes_section_data(
	const unsigned char* view,
	section_size_type size)
	{
	for (int vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; ++vendor)
	this->vendor_object_attributes_[vendor] =
	new Vendor_object_attributes(vendor);

	const unsigned char* p = view;
	p = view;
	if (size > 0 && p != NULL && *(p++) == 'A')
	{
	size--;
	while (size > 0)
	{
	// Size of vendor attributes section.
	section_size_type section_size =
	convert_to_section_size_type(read_from_pointer<32>(&p));

	if (section_size > size)
	section_size = size;
	size -= section_size;

	const char* section_name = reinterpret_cast<const char*>(p);
	section_size_type section_name_size = strlen(section_name) + 1;
	section_size -= section_name_size + 4;

	int vendor;
	const char* std_section = parameters->target().attributes_vendor();
	if (std_section != NULL && strcmp(section_name, std_section) == 0)
	vendor = Object_attribute::OBJ_ATTR_PROC;
	else if (strcmp(section_name, "gnu") == 0)
	vendor = Object_attribute::OBJ_ATTR_GNU;
	else
	{
	// Other vendor section. Ignore it.
	p += section_name_size + section_size;
	continue;
	}
	p += section_name_size;

	while (section_size > 0)
	{
	const unsigned char* subsection_start = p;

	// Read vendor subsection index and size.
	size_t uleb128_len;
	uint64_t val = read_unsigned_LEB_128(p, &uleb128_len);
	p += uleb128_len;

	int tag = convert_types<int, uint64_t>(val);
	section_size_type subsection_size =
	convert_to_section_size_type(read_from_pointer<32>(&p));
	section_size -= subsection_size;
	subsection_size -= (p - subsection_start);

	const unsigned char* end = p + subsection_size;
	switch (tag)
	{
	case Object_attribute::Tag_File:
	while (p < end)
	{
	val = read_unsigned_LEB_128(p, &uleb128_len);
	p += uleb128_len;
	tag = convert_types<int, uint64_t>(val);
	Vendor_object_attributes* pvoa =
	this->vendor_object_attributes_[vendor];
	Object_attribute* attr = pvoa->new_attribute(tag);
	const char* string_arg;
	unsigned int int_arg;

	int type = Object_attribute::arg_type(vendor, tag);
	switch (type
	& (Object_attribute::ATTR_TYPE_FLAG_INT_VAL
	\| Object_attribute::ATTR_TYPE_FLAG_STR_VAL))
	{
	case (Object_attribute::ATTR_TYPE_FLAG_INT_VAL
	\| Object_attribute::ATTR_TYPE_FLAG_STR_VAL):
	val = read_unsigned_LEB_128(p, &uleb128_len);
	p += uleb128_len;
	int_arg = convert_types<unsigned int, uint64_t>(val);
	string_arg = reinterpret_cast<const char *>(p);
	attr->set_int_value(int_arg);
	p += strlen(string_arg) + 1;
	break;
	case Object_attribute::ATTR_TYPE_FLAG_STR_VAL:
	string_arg = reinterpret_cast<const char *>(p);
	attr->set_string_value(string_arg);
	p += strlen(string_arg) + 1;
	break;
	case Object_attribute::ATTR_TYPE_FLAG_INT_VAL:
	val = read_unsigned_LEB_128(p, &uleb128_len);
	p += uleb128_len;
	int_arg = convert_types<unsigned int, uint64_t>(val);
	attr->set_int_value(int_arg);
	break;
	default:
	gold_unreachable();
	}
	}
	break;
	case Object_attribute::Tag_Section:
	case Object_attribute::Tag_Symbol:
	// Don't have anywhere convenient to attach these.
	// Fall through for now.
	default:
	// Ignore things we don't know about.
	p += subsection_size;
	subsection_size = 0;
	break;
	}
	}
	}
	}
	}

	// Merge target-independent attributes from another Attribute_section_data
	// ASD from an object called NAME into this.

	void
	Attributes_section_data::merge(
	const char* name,
	const Attributes_section_data* pasd)
	{
	// The only common attribute is currently Tag_compatibility,
	// accepted in both processor and "gnu" sections.
	for (int vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; ++vendor)
	{
	// Handle Tag_compatibility. The tags are only compatible if the flags
	// are identical and, if the flags are '1', the strings are identical.
	// If the flags are non-zero, then we can only use the string "gnu".
	const Object_attribute* in_attr =
	&pasd->known_attributes(vendor)[Object_attribute::Tag_compatibility];
	Object_attribute* out_attr =
	&this->known_attributes(vendor)[Object_attribute::Tag_compatibility];

	if (in_attr->int_value() > 0
	&& in_attr->string_value() != "gnu")
	{
	gold_error(_("%s: must be processed by '%s' toolchain"),
	name, in_attr->string_value().c_str());
	return;
	}

	if (in_attr->int_value() != out_attr->int_value()
	\|\| in_attr->string_value() != out_attr->string_value())
	{
	gold_error(_("%s: object tag '%d, %s' is "
	"incompatible with tag '%d, %s'"),
	name, in_attr->int_value(),
	in_attr->string_value().c_str(),
	out_attr->int_value(),
	out_attr->string_value().c_str());
	}
	}
	}

	// Write to a buffer.

	void
	Attributes_section_data::write(std::vector<unsigned char>* buffer) const
	{
	buffer->push_back('A');
	for (int vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; ++vendor)
	if (this->vendor_object_attributes_[vendor]->size() != 0)
	this->vendor_object_attributes_[vendor]->write(buffer);
	}

	// Methods for Output_attributes_section_data.

	// Write attributes section data to file OF.

	void
	Output_attributes_section_data::do_write(Output_file* of)
	{
	off_t offset = this->offset();
	const section_size_type oview_size =
	convert_to_section_size_type(this->data_size());
	unsigned char* const oview = of->get_output_view(offset, oview_size);

	std::vector<unsigned char> buffer;
	this->attributes_section_data_.write(&buffer);
	gold_assert(convert_to_section_size_type(buffer.size()) == oview_size);
	memcpy(oview, &buffer.front(), buffer.size());
	of->write_output_view(this->offset(), oview_size, oview);
	}

	} // End namespace gold.