1 // attributes.cc -- object attributes for gold 2 3 // Copyright (C) 2009-2016 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. 459