Merge branch 'vendor/GCC44'
[dragonfly.git] / contrib / binutils-2.22 / gold / attributes.cc
1 // attributes.cc -- object attributes for gold
2
3 // Copyright 2009 Free Software Foundation, Inc.
4 // Written by Doug Kwan <dougkwan@google.com>.
5 // This file contains code adapted from BFD.
6
7 // This file is part of gold.
8
9 // This program is free software; you can redistribute it and/or modify
10 // it under the terms of the GNU General Public License as published by
11 // the Free Software Foundation; either version 3 of the License, or
12 // (at your option) any later version.
13
14 // This program is distributed in the hope that it will be useful,
15 // but WITHOUT ANY WARRANTY; without even the implied warranty of
16 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 // GNU General Public License for more details.
18
19 // You should have received a copy of the GNU General Public License
20 // along with this program; if not, write to the Free Software
21 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 // MA 02110-1301, USA.
23
24 #include "gold.h"
25
26 #include <limits>
27
28 #include "attributes.h"
29 #include "elfcpp.h"
30 #include "target.h"
31 #include "parameters.h"
32 #include "int_encoding.h"
33
34 namespace gold
35 {
36
37 // Object_attribute methods.
38
39 // Return size of attribute encode in ULEB128.
40
41 size_t
42 Object_attribute::size(int tag) const
43 {
44   // Attributes with default values are not written out.
45   if (this->is_default_attribute())
46     return 0;
47
48   size_t size = get_length_as_unsigned_LEB_128(tag);
49   if (Object_attribute::attribute_type_has_int_value(this->type_))
50     size += get_length_as_unsigned_LEB_128(this->int_value_);
51   if (Object_attribute::attribute_type_has_string_value(this->type_))
52     size += this->string_value_.size() + 1;
53   return size;
54 }
55
56 // Whether this has the default value (0/"").
57
58 bool
59 Object_attribute::is_default_attribute() const
60 {
61   if (Object_attribute::attribute_type_has_int_value(this->type_)
62       && this->int_value_ != 0)
63     return false;
64   if (Object_attribute::attribute_type_has_string_value(this->type_)
65       && !this->string_value_.empty())
66     return false;
67   if (Object_attribute::attribute_type_has_no_default(this->type_))
68     return false;
69
70   return true;
71 }
72
73 // Whether this matches another Object_attribute OA in merging.
74 // Two Object_attributes match if they have the same values.
75
76 bool
77 Object_attribute::matches(const Object_attribute& oa) const
78 {
79   return ((this->int_value_ != oa.int_value_)
80           && (this->string_value_ == oa.string_value_));
81 }
82
83 // Write this with TAG to a BUFFER.
84
85 void
86 Object_attribute::write(
87     int tag,
88     std::vector<unsigned char>* buffer) const
89 {
90   // No need to write default attributes.
91   if (this->is_default_attribute())
92     return;
93   
94   // Write tag.
95   write_unsigned_LEB_128(buffer, convert_types<uint64_t, int>(tag));
96
97   // Write integer value.
98   if (Object_attribute::attribute_type_has_int_value(this->type_))
99     write_unsigned_LEB_128(buffer,
100                            convert_types<uint64_t, int>(this->int_value_));
101
102   // Write string value.
103   if (Object_attribute::attribute_type_has_string_value(this->type_))
104     {
105       const unsigned char* start =
106         reinterpret_cast<const unsigned char*>(this->string_value_.c_str());
107       const unsigned char* end = start + this->string_value_.size() + 1;
108       buffer->insert(buffer->end(), start, end); 
109     }
110 }
111
112 // Vendor_object_attributes methods.
113
114 // Copying constructor.
115
116 Vendor_object_attributes::Vendor_object_attributes(
117     const Vendor_object_attributes& voa)
118 {
119   this->vendor_ = voa.vendor_;
120
121   for (int i = 0; i < NUM_KNOWN_ATTRIBUTES; ++i)
122     this->known_attributes_[i] = voa.known_attributes_[i];
123
124   // We do not handle attribute deletion.  So this must be empty.
125   gold_assert(this->other_attributes_.empty());
126
127   for (Other_attributes::const_iterator p = voa.other_attributes_.begin();
128        p != voa.other_attributes_.end();
129        ++p)
130     this->other_attributes_[p->first] = new Object_attribute(*(p->second));
131 }
132
133 // Size of this in number of bytes.
134
135 size_t
136 Vendor_object_attributes::size() const
137 {
138   if (this->name() == NULL)
139     return 0;
140
141   size_t data_size = 0;
142   for (int i = 4; i < NUM_KNOWN_ATTRIBUTES; ++i)
143     data_size += this->known_attributes_[i].size(i);
144
145   for (Other_attributes::const_iterator p = this->other_attributes_.begin();
146        p != this->other_attributes_.end();
147        ++p)
148     data_size += p->second->size(p->first);
149
150   // <size> <vendor_name> NUL 0x1 <size>
151   return ((data_size != 0
152            || this->vendor_ == Object_attribute::OBJ_ATTR_PROC)
153           ? data_size + strlen(this->name()) + 2 + 2 * 4
154           : 0);
155 }
156
157 // Return a new attribute associated with TAG.
158
159 Object_attribute*
160 Vendor_object_attributes::new_attribute(int tag)
161 {
162   int type = Object_attribute::arg_type(this->vendor_, tag);
163
164   if (tag < NUM_KNOWN_ATTRIBUTES)
165     {
166       this->known_attributes_[tag].set_type(type);
167       return &this->known_attributes_[tag];
168     }
169   else
170     {
171       Object_attribute* attr = new Object_attribute();
172
173       // This should be the first time we insert this.
174       std::pair<Other_attributes::iterator, bool> ins =
175         this->other_attributes_.insert(std::make_pair(tag, attr));
176       gold_assert(ins.second);
177
178       attr->set_type(type);
179       return attr;
180     }
181 }
182
183 // Return an attribute associated with TAG.
184
185 Object_attribute*
186 Vendor_object_attributes::get_attribute(int tag)
187 {
188   if (tag < NUM_KNOWN_ATTRIBUTES)
189     return &this->known_attributes_[tag];
190   else
191     {
192       Other_attributes::iterator p =
193         this->other_attributes_.find(tag);
194       return p != this->other_attributes_.end() ? p->second : NULL;
195     }
196 }
197
198 const Object_attribute*
199 Vendor_object_attributes::get_attribute(int tag) const
200 {
201   if (tag < NUM_KNOWN_ATTRIBUTES)
202     return &this->known_attributes_[tag];
203   else
204     {
205       Other_attributes::const_iterator p =
206         this->other_attributes_.find(tag);
207       return p != this->other_attributes_.end() ? p->second : NULL;
208     }
209 }
210
211 // Write attributes to BUFFER.
212
213 void
214 Vendor_object_attributes::write(std::vector<unsigned char>* buffer) const
215 {
216   // Write subsection size.
217   size_t voa_size = this->size();
218   uint32_t voa_size_as_u32 = convert_types<uint32_t, size_t>(voa_size);
219   insert_into_vector<32>(buffer, voa_size_as_u32);
220
221   // Write vendor name.
222   const unsigned char* vendor_start =
223     reinterpret_cast<const unsigned char*>(this->name());
224   size_t vendor_length = strlen(this->name()) + 1;
225   const unsigned char* vendor_end = vendor_start + vendor_length;
226   buffer->insert(buffer->end(), vendor_start, vendor_end);
227
228   // Write file tag.
229   buffer->push_back(Object_attribute::Tag_File);
230
231   // Write attributes size.
232   uint32_t attributes_size_as_u32 =
233     convert_types<uint32_t, size_t>(voa_size - 4 - vendor_length);
234   insert_into_vector<32>(buffer, attributes_size_as_u32);
235
236   // Write known attributes, skipping any defaults.
237   for (int i = 4; i < NUM_KNOWN_ATTRIBUTES; ++i)
238     {
239       // A target may write known attributes in a special order. 
240       // Call target hook to remap tags.  Attributes_order is the identity
241       // function if no re-ordering is required.
242       int tag = parameters->target().attributes_order(i);
243       this->known_attributes_[tag].write(tag, buffer);
244     }
245
246   // Write other attributes.
247   for (Other_attributes::const_iterator q = this->other_attributes_.begin();
248        q != this->other_attributes_.end();
249        ++q)
250     q->second->write(q->first, buffer);
251 }
252
253 // Attributes_section_data methods.
254
255 // Compute encoded size of this.
256
257 size_t
258 Attributes_section_data::size() const
259 {
260   size_t data_size = 0;
261   for(int vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; ++vendor)
262     data_size += this->vendor_object_attributes_[vendor]->size();
263
264   // 'A' <sections for each vendor>
265   return data_size != 0 ? data_size + 1 : 0;
266 }
267
268 // Construct an Attributes_section_data object by parsing section contents
269 // specified by VIEW and SIZE.
270
271 Attributes_section_data::Attributes_section_data(
272     const unsigned char* view,
273     section_size_type size)
274 {
275   for (int vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; ++vendor)
276     this->vendor_object_attributes_[vendor] =
277       new Vendor_object_attributes(vendor);
278
279   const unsigned char* p = view;
280   p = view;
281   if (size > 0 && p != NULL && *(p++) == 'A')
282     {
283       size--;
284       while (size > 0)
285         {
286           // Size of vendor attributes section.
287           section_size_type section_size =
288             convert_to_section_size_type(read_from_pointer<32>(&p));
289
290           if (section_size > size)
291             section_size = size;
292           size -= section_size;
293
294           const char* section_name = reinterpret_cast<const char*>(p);
295           section_size_type section_name_size = strlen(section_name) + 1;
296           section_size -= section_name_size + 4;
297
298           int vendor;
299           const char* std_section = parameters->target().attributes_vendor();
300           if (std_section != NULL && strcmp(section_name, std_section) == 0)
301             vendor = Object_attribute::OBJ_ATTR_PROC;
302           else if (strcmp(section_name, "gnu") == 0)
303             vendor = Object_attribute::OBJ_ATTR_GNU;
304           else
305             {
306               // Other vendor section.  Ignore it.
307               p += section_name_size + section_size;
308               continue;
309             }
310           p += section_name_size;
311
312           while (section_size > 0)
313             {
314               const unsigned char* subsection_start = p;
315
316               // Read vendor subsection index and size.
317               size_t uleb128_len;
318               uint64_t val = read_unsigned_LEB_128(p, &uleb128_len);
319               p += uleb128_len;
320
321               int tag = convert_types<int, uint64_t>(val);
322               section_size_type subsection_size =
323                 convert_to_section_size_type(read_from_pointer<32>(&p));
324               section_size -= subsection_size;
325               subsection_size -= (p - subsection_start);
326
327               const unsigned char* end = p + subsection_size;
328               switch (tag)
329                 {
330                 case Object_attribute::Tag_File:
331                   while (p < end)
332                     {
333                       val = read_unsigned_LEB_128(p, &uleb128_len);
334                       p += uleb128_len;
335                       tag = convert_types<int, uint64_t>(val);
336                       Vendor_object_attributes* pvoa =
337                         this->vendor_object_attributes_[vendor];
338                       Object_attribute* attr = pvoa->new_attribute(tag);
339                       const char* string_arg;
340                       unsigned int int_arg;
341
342                       int type = Object_attribute::arg_type(vendor, tag);
343                       switch (type
344                               & (Object_attribute::ATTR_TYPE_FLAG_INT_VAL
345                                  | Object_attribute::ATTR_TYPE_FLAG_STR_VAL))
346                         {
347                         case (Object_attribute::ATTR_TYPE_FLAG_INT_VAL
348                               | Object_attribute::ATTR_TYPE_FLAG_STR_VAL):
349                           val = read_unsigned_LEB_128(p, &uleb128_len);
350                           p += uleb128_len;
351                           int_arg = convert_types<unsigned int, uint64_t>(val);
352                           string_arg = reinterpret_cast<const char *>(p);
353                           attr->set_int_value(int_arg);
354                           p += strlen(string_arg) + 1;
355                           break;
356                         case Object_attribute::ATTR_TYPE_FLAG_STR_VAL:
357                           string_arg = reinterpret_cast<const char *>(p);
358                           attr->set_string_value(string_arg);
359                           p += strlen(string_arg) + 1;
360                           break;
361                         case Object_attribute::ATTR_TYPE_FLAG_INT_VAL:
362                           val = read_unsigned_LEB_128(p, &uleb128_len);
363                           p += uleb128_len;
364                           int_arg = convert_types<unsigned int, uint64_t>(val);
365                           attr->set_int_value(int_arg);
366                           break;
367                         default:
368                           gold_unreachable();
369                         }
370                     }
371                   break;
372                 case Object_attribute::Tag_Section:
373                 case Object_attribute::Tag_Symbol:
374                   // Don't have anywhere convenient to attach these.
375                   // Fall through for now.
376                 default:
377                   // Ignore things we don't know about.
378                   p += subsection_size;
379                   subsection_size = 0;
380                   break;
381                 }
382             }
383         }
384     }
385 }
386
387 // Merge target-independent attributes from another Attribute_section_data
388 // ASD from an object called NAME into this.
389
390 void
391 Attributes_section_data::merge(
392     const char* name,
393     const Attributes_section_data* pasd)
394 {
395   // The only common attribute is currently Tag_compatibility,
396   // accepted in both processor and "gnu" sections.
397   for (int vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; ++vendor)
398     {
399       // Handle Tag_compatibility.  The tags are only compatible if the flags
400       // are identical and, if the flags are '1', the strings are identical.
401       // If the flags are non-zero, then we can only use the string "gnu".
402       const Object_attribute* in_attr =
403         &pasd->known_attributes(vendor)[Object_attribute::Tag_compatibility];
404       Object_attribute* out_attr =
405         &this->known_attributes(vendor)[Object_attribute::Tag_compatibility];
406
407       if (in_attr->int_value() > 0
408           && in_attr->string_value() != "gnu")
409         {
410           gold_error(_("%s: must be processed by '%s' toolchain"),
411                      name, in_attr->string_value().c_str());
412           return;
413         }
414
415       if (in_attr->int_value() != out_attr->int_value()
416           || in_attr->string_value() != out_attr->string_value())
417         {
418           gold_error(_("%s: object tag '%d, %s' is "
419                        "incompatible with tag '%d, %s'"),
420                      name, in_attr->int_value(),
421                      in_attr->string_value().c_str(),
422                      out_attr->int_value(),
423                      out_attr->string_value().c_str());
424         }
425     }
426 }
427
428 // Write to a buffer.
429
430 void
431 Attributes_section_data::write(std::vector<unsigned char>* buffer) const
432 {
433   buffer->push_back('A');
434   for (int vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; ++vendor)
435     if (this->vendor_object_attributes_[vendor]->size() != 0)
436       this->vendor_object_attributes_[vendor]->write(buffer);
437 }
438
439 // Methods for Output_attributes_section_data.
440
441 // Write attributes section data to file OF.
442
443 void
444 Output_attributes_section_data::do_write(Output_file* of)
445 {
446   off_t offset = this->offset();
447   const section_size_type oview_size =
448     convert_to_section_size_type(this->data_size());
449   unsigned char* const oview = of->get_output_view(offset, oview_size);
450
451   std::vector<unsigned char> buffer;
452   this->attributes_section_data_.write(&buffer);
453   gold_assert(convert_to_section_size_type(buffer.size()) == oview_size);
454   memcpy(oview, &buffer.front(), buffer.size());
455   of->write_output_view(this->offset(), oview_size, oview);
456 }
457
458 } // End namespace gold.