1 // attributes.h -- object attributes for gold -*- C++ -*- 2 3 // Copyright (C) 2009-2014 Free Software Foundation, Inc. 4 // Written by Doug Kwan <dougkwan (at) 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 to a map file. 391 void 392 do_print_to_mapfile(Mapfile* mapfile) const 393 { mapfile->print_output_data(this, _("** attributes")); } 394 395 // Write the data to the output file. 396 void 397 do_write(Output_file*); 398 399 // Set final data size. 400 void 401 set_final_data_size() 402 { this->set_data_size(attributes_section_data_.size()); } 403 404 private: 405 // Attributes_section_data corresponding to this. 406 const Attributes_section_data& attributes_section_data_; 407 }; 408 409 } // End namespace gold. 410 411 #endif // !defined(GOLD_ATTRIBUTES_H) 412
