Merge branch 'vendor/GCC50'
[dragonfly.git] / contrib / binutils-2.25 / gold / attributes.h
1 // attributes.h -- object attributes for gold   -*- C++ -*-
2
3 // Copyright (C) 2009-2014 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 // Handle object attributes.
25
26 #ifndef GOLD_ATTRIBUTES_H
27 #define GOLD_ATTRIBUTES_H
28
29 #include <map>
30
31 #include "parameters.h"
32 #include "target.h"
33 #include "output.h"
34 #include "reduced_debug_output.h"
35
36 namespace gold
37 {
38
39 // Object attribute values.  The attribute tag is not stored in this object.
40
41 class Object_attribute
42 {
43  public:
44   // The value of an object attribute.  The type indicates whether the
45   // attribute holds and integer, a string, or both.  It can also indicate that
46   // there can be no default (i.e. all values must be written to file, even
47   // zero).
48   enum
49   {
50     ATTR_TYPE_FLAG_INT_VAL = (1 << 0),
51     ATTR_TYPE_FLAG_STR_VAL = (1 << 1),
52     ATTR_TYPE_FLAG_NO_DEFAULT = (1 << 2)
53   };
54
55   // Object attributes may either be defined by the processor ABI, index
56   // OBJ_ATTR_PROC in the *_obj_attributes arrays, or be GNU-specific
57   // (and possibly also processor-specific), index OBJ_ATTR_GNU.
58   enum
59   {
60     OBJ_ATTR_PROC,
61     OBJ_ATTR_GNU,
62     OBJ_ATTR_FIRST = OBJ_ATTR_PROC,
63     OBJ_ATTR_LAST = OBJ_ATTR_GNU
64   };
65
66   // The following object attribute tags are taken as generic, for all
67   // targets and for "gnu" where there is no target standard. 
68   enum
69   {
70     Tag_NULL = 0,
71     Tag_File = 1,
72     Tag_Section = 2,
73     Tag_Symbol = 3,
74     Tag_compatibility = 32
75   };
76
77   Object_attribute()
78    : type_(0), int_value_(0), string_value_()
79   { }
80
81   // Copying constructor.  We need to implement this to copy the string value.
82   Object_attribute(const Object_attribute& oa)
83    : type_(oa.type_), int_value_(oa.int_value_), string_value_(oa.string_value_)
84   { }
85
86   ~Object_attribute()
87   { }
88
89   // Assignment operator.  We need to implement this to copy the string value.
90   Object_attribute&
91   operator=(const Object_attribute& source)
92   {
93     this->type_ = source.type_;
94     this->int_value_ = source.int_value_;
95     this->string_value_ = source.string_value_;
96     return *this;
97   }
98
99   // Return attribute type.
100   int
101   type() const
102   { return this->type_; }
103
104   // Set attribute type.
105   void
106   set_type(int type)
107   { this->type_ = type; }
108
109   // Return integer value.
110   unsigned int
111   int_value() const
112   { return this->int_value_; }
113
114   // Set integer value.
115   void
116   set_int_value(unsigned int i)
117   { this->int_value_ = i; }
118
119   // Return string value.
120   const std::string&
121   string_value() const
122   { return this->string_value_; }
123
124   // Set string value.
125   void
126   set_string_value(const std::string& s)
127   { this->string_value_ = s; }
128
129   void
130   set_string_value(const char* s)
131   { this->string_value_ = s; }
132
133   // Whether attribute type has integer value.
134   static bool
135   attribute_type_has_int_value(int type)
136   { return (type & ATTR_TYPE_FLAG_INT_VAL) != 0; }
137
138   // Whether attribute type has string value.
139   static bool
140   attribute_type_has_string_value(int type)
141   { return (type & ATTR_TYPE_FLAG_STR_VAL) != 0; }
142
143   // Whether attribute type has no default value.
144   static bool
145   attribute_type_has_no_default(int type)
146   { return (type & ATTR_TYPE_FLAG_NO_DEFAULT) != 0; }
147
148   // Whether this has default value (0/"").
149   bool
150   is_default_attribute() const;
151
152   // Return ULEB128 encoded size of tag and attribute.  
153   size_t
154   size(int tag) const;
155
156   // Whether this matches another object attribute in merging.
157   bool
158   matches(const Object_attribute& oa) const;
159   
160   // Write to attribute with tag to BUFFER.
161   void
162   write(int tag, std::vector<unsigned char>* buffer) const;
163
164   // Determine what arguments an attribute tag takes.
165   static int
166   arg_type(int vendor, int tag)
167   {
168     switch (vendor)
169       {
170       case OBJ_ATTR_PROC:
171         return parameters->target().attribute_arg_type(tag);
172       case OBJ_ATTR_GNU:
173         return Object_attribute::gnu_arg_type(tag);
174       default:
175         gold_unreachable();
176      }
177   }
178
179  private:
180   // Determine whether a GNU object attribute tag takes an integer, a
181   // string or both.  */
182   static int
183   gnu_arg_type(int tag)
184   {
185     // Except for Tag_compatibility, for GNU attributes we follow the
186     // same rule ARM ones > 32 follow: odd-numbered tags take strings
187     // and even-numbered tags take integers.  In addition, tag & 2 is
188     // nonzero for architecture-independent tags and zero for
189     // architecture-dependent ones.
190     if (tag == Object_attribute::Tag_compatibility)
191       return ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL;
192     else
193       return (tag & 1) != 0 ? ATTR_TYPE_FLAG_STR_VAL : ATTR_TYPE_FLAG_INT_VAL;
194   }
195
196   // Attribute type.
197   int type_;
198   // Integer value.
199   int int_value_;
200   // String value.
201   std::string string_value_;
202 };
203
204 // This class contains attributes of a particular vendor.
205
206 class Vendor_object_attributes
207 {
208  public:
209   // The maximum number of known object attributes for any target.
210   static const int NUM_KNOWN_ATTRIBUTES = 71;
211
212   Vendor_object_attributes(int vendor)
213     : vendor_(vendor), other_attributes_() 
214   { }
215
216   // Copying constructor.
217   Vendor_object_attributes(const Vendor_object_attributes&);
218
219   ~Vendor_object_attributes()
220   {
221     for (Other_attributes::iterator p = this->other_attributes_.begin();
222          p != this->other_attributes_.end();
223          ++p)
224       delete p->second;
225   }
226
227   // Size of this in number of bytes.
228   size_t
229   size() const;
230   
231   // Name of this written vendor subsection.
232   const char*
233   name() const
234   {
235     return (this->vendor_ == Object_attribute::OBJ_ATTR_PROC
236             ? parameters->target().attributes_vendor()
237             : "gnu");
238   }
239
240   // Return an array of known attributes.
241   Object_attribute*
242   known_attributes()
243   { return &this->known_attributes_[0]; }
244
245   const Object_attribute*
246   known_attributes() const
247   { return &this->known_attributes_[0]; }
248
249   typedef std::map<int, Object_attribute*> Other_attributes;
250
251   // Return attributes other than the known ones.
252   Other_attributes*
253   other_attributes()
254   { return &this->other_attributes_; }
255
256   const Other_attributes*
257   other_attributes() const
258   { return &this->other_attributes_; }
259
260   // Return a new attribute associated with TAG.
261   Object_attribute*
262   new_attribute(int tag);
263
264   // Get an attribute
265   Object_attribute*
266   get_attribute(int tag);
267
268   const Object_attribute*
269   get_attribute(int tag) const;
270
271   // Write to BUFFER.
272   void
273   write(std::vector<unsigned char>* buffer) const;
274
275  private:
276   // Vendor of the object attributes.
277   int vendor_;
278   // Attributes with known tags.  There are store in an array for fast
279   // access.
280   Object_attribute known_attributes_[NUM_KNOWN_ATTRIBUTES];
281   // Attributes with known tags.  There are stored in a sorted container.
282   Other_attributes other_attributes_;
283 };
284
285 // This class contains contents of an attributes section.
286
287 class Attributes_section_data
288 {
289  public:
290   // Construct an Attributes_section_data object by parsing section contents
291   // in VIEW of SIZE.
292   Attributes_section_data(const unsigned char* view, section_size_type size);
293
294   // Copying constructor.
295   Attributes_section_data(const Attributes_section_data& asd)
296   {
297     for (int vendor = Object_attribute::OBJ_ATTR_FIRST;
298          vendor <= Object_attribute::OBJ_ATTR_LAST;
299          ++vendor)
300       this->vendor_object_attributes_[vendor] =
301         new Vendor_object_attributes(*asd.vendor_object_attributes_[vendor]);
302   }
303   
304   ~Attributes_section_data()
305   {
306     for (int vendor = Object_attribute::OBJ_ATTR_FIRST;
307          vendor <= Object_attribute::OBJ_ATTR_LAST;
308          ++vendor)
309       delete this->vendor_object_attributes_[vendor];
310   }
311  
312   // Return the size of this as number of bytes.
313   size_t
314   size() const;
315
316   // Return an array of known attributes.
317   Object_attribute*
318   known_attributes(int vendor)
319   {
320     gold_assert(vendor >= OBJ_ATTR_FIRST && vendor <= OBJ_ATTR_LAST);
321     return this->vendor_object_attributes_[vendor]->known_attributes();
322   }
323
324   const Object_attribute*
325   known_attributes(int vendor) const
326   {
327     gold_assert(vendor >= OBJ_ATTR_FIRST && vendor <= OBJ_ATTR_LAST);
328     return this->vendor_object_attributes_[vendor]->known_attributes();
329   }
330
331   // Return the other attributes.
332   Vendor_object_attributes::Other_attributes*
333   other_attributes(int vendor)
334   {
335     gold_assert(vendor >= OBJ_ATTR_FIRST && vendor <= OBJ_ATTR_LAST);
336     return this->vendor_object_attributes_[vendor]->other_attributes();
337   }
338
339   // Return the other attributes.
340   const Vendor_object_attributes::Other_attributes*
341   other_attributes(int vendor) const
342   {
343     gold_assert(vendor >= OBJ_ATTR_FIRST && vendor <= OBJ_ATTR_LAST);
344     return this->vendor_object_attributes_[vendor]->other_attributes();
345   }
346
347   // Return an attribute.
348   Object_attribute*
349   get_attribute(int vendor, int tag)
350   {
351     gold_assert(vendor >= OBJ_ATTR_FIRST && vendor <= OBJ_ATTR_LAST);
352     return this->vendor_object_attributes_[vendor]->get_attribute(tag);
353   }
354   
355   const Object_attribute*
356   get_attribute(int vendor, int tag) const
357   {
358     gold_assert(vendor >= OBJ_ATTR_FIRST && vendor <= OBJ_ATTR_LAST);
359     return this->vendor_object_attributes_[vendor]->get_attribute(tag);
360   }
361   
362   // Merge target-independent attributes from another Attributes_section_data
363   // of an object called NAME.
364   void
365   merge(const char* name, const Attributes_section_data* pasd);
366
367   // Write to byte stream in an unsigned char vector.
368   void
369   write(std::vector<unsigned char>*) const;
370
371  private:
372   // For convenience.
373   static const int OBJ_ATTR_FIRST = Object_attribute::OBJ_ATTR_FIRST;
374   static const int OBJ_ATTR_LAST = Object_attribute::OBJ_ATTR_LAST;
375
376   // Vendor object attributes.
377   Vendor_object_attributes* vendor_object_attributes_[OBJ_ATTR_LAST+1];
378 };
379
380 // This class is used for writing out an Attribute_section_data.
381
382 class Output_attributes_section_data : public Output_section_data
383 {
384  public:
385   Output_attributes_section_data(const Attributes_section_data& asd)
386     : Output_section_data(1), attributes_section_data_(asd)
387   { }
388
389  protected:
390   // Write the data to the output file.
391   void
392   do_write(Output_file*);
393   
394   // Set final data size.
395   void
396   set_final_data_size()
397   { this->set_data_size(attributes_section_data_.size()); }
398
399  private:
400   // Attributes_section_data corresponding to this.
401   const Attributes_section_data& attributes_section_data_;
402 };
403
404 } // End namespace gold.
405
406 #endif  // !defined(GOLD_ATTRIBUTES_H)