mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-03 04:12:10 +08:00
459 lines
13 KiB
C++
459 lines
13 KiB
C++
// attributes.cc -- object attributes for gold
|
|
|
|
// Copyright (C) 2009-2014 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.
|