1 /* simple-object.c -- simple routines to read and write object files. 2 Copyright (C) 2010-2018 Free Software Foundation, Inc. 3 Written by Ian Lance Taylor, Google. 4 5 This program is free software; you can redistribute it and/or modify it 6 under the terms of the GNU General Public License as published by the 7 Free Software Foundation; either version 2, or (at your option) any 8 later version. 9 10 This program is distributed in the hope that it will be useful, 11 but WITHOUT ANY WARRANTY; without even the implied warranty of 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 GNU General Public License for more details. 14 15 You should have received a copy of the GNU General Public License 16 along with this program; if not, write to the Free Software 17 Foundation, 51 Franklin Street - Fifth Floor, 18 Boston, MA 02110-1301, USA. */ 19 20 #include "config.h" 21 #include "libiberty.h" 22 #include "simple-object.h" 23 24 #include <errno.h> 25 #include <fcntl.h> 26 27 #ifdef HAVE_STDLIB_H 28 #include <stdlib.h> 29 #endif 30 31 #ifdef HAVE_STDINT_H 32 #include <stdint.h> 33 #endif 34 35 #ifdef HAVE_STRING_H 36 #include <string.h> 37 #endif 38 39 #ifdef HAVE_INTTYPES_H 40 #include <inttypes.h> 41 #endif 42 43 #ifndef SEEK_SET 44 #define SEEK_SET 0 45 #endif 46 47 #include "simple-object-common.h" 48 49 /* The known object file formats. */ 50 51 static const struct simple_object_functions * const format_functions[] = 52 { 53 &simple_object_elf_functions, 54 &simple_object_mach_o_functions, 55 &simple_object_coff_functions, 56 &simple_object_xcoff_functions 57 }; 58 59 /* Read data from a file using the simple_object error reporting 60 conventions. */ 61 62 int 63 simple_object_internal_read (int descriptor, off_t offset, 64 unsigned char *buffer, size_t size, 65 const char **errmsg, int *err) 66 { 67 if (lseek (descriptor, offset, SEEK_SET) < 0) 68 { 69 *errmsg = "lseek"; 70 *err = errno; 71 return 0; 72 } 73 74 do 75 { 76 ssize_t got = read (descriptor, buffer, size); 77 if (got == 0) 78 break; 79 else if (got > 0) 80 { 81 buffer += got; 82 size -= got; 83 } 84 else if (errno != EINTR) 85 { 86 *errmsg = "read"; 87 *err = errno; 88 return 0; 89 } 90 } 91 while (size > 0); 92 93 if (size > 0) 94 { 95 *errmsg = "file too short"; 96 *err = 0; 97 return 0; 98 } 99 100 return 1; 101 } 102 103 /* Write data to a file using the simple_object error reporting 104 conventions. */ 105 106 int 107 simple_object_internal_write (int descriptor, off_t offset, 108 const unsigned char *buffer, size_t size, 109 const char **errmsg, int *err) 110 { 111 if (lseek (descriptor, offset, SEEK_SET) < 0) 112 { 113 *errmsg = "lseek"; 114 *err = errno; 115 return 0; 116 } 117 118 do 119 { 120 ssize_t wrote = write (descriptor, buffer, size); 121 if (wrote == 0) 122 break; 123 else if (wrote > 0) 124 { 125 buffer += wrote; 126 size -= wrote; 127 } 128 else if (errno != EINTR) 129 { 130 *errmsg = "write"; 131 *err = errno; 132 return 0; 133 } 134 } 135 while (size > 0); 136 137 if (size > 0) 138 { 139 *errmsg = "short write"; 140 *err = 0; 141 return 0; 142 } 143 144 return 1; 145 } 146 147 /* Open for read. */ 148 149 simple_object_read * 150 simple_object_start_read (int descriptor, off_t offset, 151 const char *segment_name, const char **errmsg, 152 int *err) 153 { 154 unsigned char header[SIMPLE_OBJECT_MATCH_HEADER_LEN]; 155 size_t len, i; 156 157 if (!simple_object_internal_read (descriptor, offset, header, 158 SIMPLE_OBJECT_MATCH_HEADER_LEN, 159 errmsg, err)) 160 return NULL; 161 162 len = sizeof (format_functions) / sizeof (format_functions[0]); 163 for (i = 0; i < len; ++i) 164 { 165 void *data; 166 167 data = format_functions[i]->match (header, descriptor, offset, 168 segment_name, errmsg, err); 169 if (data != NULL) 170 { 171 simple_object_read *ret; 172 173 ret = XNEW (simple_object_read); 174 ret->descriptor = descriptor; 175 ret->offset = offset; 176 ret->functions = format_functions[i]; 177 ret->data = data; 178 return ret; 179 } 180 } 181 182 *errmsg = "file not recognized"; 183 *err = 0; 184 return NULL; 185 } 186 187 /* Find all sections. */ 188 189 const char * 190 simple_object_find_sections (simple_object_read *sobj, 191 int (*pfn) (void *, const char *, off_t, off_t), 192 void *data, 193 int *err) 194 { 195 return sobj->functions->find_sections (sobj, pfn, data, err); 196 } 197 198 /* Internal data passed to find_one_section. */ 199 200 struct find_one_section_data 201 { 202 /* The section we are looking for. */ 203 const char *name; 204 /* Where to store the section offset. */ 205 off_t *offset; 206 /* Where to store the section length. */ 207 off_t *length; 208 /* Set if the name is found. */ 209 int found; 210 }; 211 212 /* Internal function passed to find_sections. */ 213 214 static int 215 find_one_section (void *data, const char *name, off_t offset, off_t length) 216 { 217 struct find_one_section_data *fosd = (struct find_one_section_data *) data; 218 219 if (strcmp (name, fosd->name) != 0) 220 return 1; 221 222 *fosd->offset = offset; 223 *fosd->length = length; 224 fosd->found = 1; 225 226 /* Stop iteration. */ 227 return 0; 228 } 229 230 /* Find a section. */ 231 232 int 233 simple_object_find_section (simple_object_read *sobj, const char *name, 234 off_t *offset, off_t *length, 235 const char **errmsg, int *err) 236 { 237 struct find_one_section_data fosd; 238 239 fosd.name = name; 240 fosd.offset = offset; 241 fosd.length = length; 242 fosd.found = 0; 243 244 *errmsg = simple_object_find_sections (sobj, find_one_section, 245 (void *) &fosd, err); 246 if (*errmsg != NULL) 247 return 0; 248 if (!fosd.found) 249 return 0; 250 return 1; 251 } 252 253 /* Callback to identify and rename LTO debug sections by name. 254 Returns 1 if NAME is a LTO debug section, 0 if not. */ 255 256 static char * 257 handle_lto_debug_sections (const char *name) 258 { 259 char *newname = XCNEWVEC (char, strlen (name) + 1); 260 261 /* ??? So we can't use .gnu.lto_ prefixed sections as the assembler 262 complains about bogus section flags. Which means we need to arrange 263 for that to be fixed or .gnu.debuglto_ marked as SHF_EXCLUDE (to make 264 fat lto object tooling work for the fat part). */ 265 /* Also include corresponding reloc sections. */ 266 if (strncmp (name, ".rela", sizeof (".rela") - 1) == 0) 267 { 268 strncpy (newname, name, sizeof (".rela") - 1); 269 name += sizeof (".rela") - 1; 270 } 271 else if (strncmp (name, ".rel", sizeof (".rel") - 1) == 0) 272 { 273 strncpy (newname, name, sizeof (".rel") - 1); 274 name += sizeof (".rel") - 1; 275 } 276 /* ??? For now this handles both .gnu.lto_ and .gnu.debuglto_ prefixed 277 sections. */ 278 /* Copy LTO debug sections and rename them to their non-LTO name. */ 279 if (strncmp (name, ".gnu.debuglto_", sizeof (".gnu.debuglto_") - 1) == 0) 280 return strcat (newname, name + sizeof (".gnu.debuglto_") - 1); 281 else if (strncmp (name, ".gnu.lto_.debug_", 282 sizeof (".gnu.lto_.debug_") -1) == 0) 283 return strcat (newname, name + sizeof (".gnu.lto_") - 1); 284 /* Copy over .note.GNU-stack section under the same name if present. */ 285 else if (strcmp (name, ".note.GNU-stack") == 0) 286 return strcpy (newname, name); 287 /* Copy over .comment section under the same name if present. Solaris 288 ld uses them to relax its checking of ELF gABI access rules for 289 COMDAT sections in objects produced by GCC. */ 290 else if (strcmp (name, ".comment") == 0) 291 return strcpy (newname, name); 292 return NULL; 293 } 294 295 /* Copy LTO debug sections. */ 296 297 const char * 298 simple_object_copy_lto_debug_sections (simple_object_read *sobj, 299 const char *dest, int *err) 300 { 301 const char *errmsg; 302 simple_object_write *dest_sobj; 303 simple_object_attributes *attrs; 304 int outfd; 305 306 if (! sobj->functions->copy_lto_debug_sections) 307 { 308 *err = EINVAL; 309 return "simple_object_copy_lto_debug_sections not implemented"; 310 } 311 312 attrs = simple_object_fetch_attributes (sobj, &errmsg, err); 313 if (! attrs) 314 return errmsg; 315 dest_sobj = simple_object_start_write (attrs, NULL, &errmsg, err); 316 simple_object_release_attributes (attrs); 317 if (! dest_sobj) 318 return errmsg; 319 320 errmsg = sobj->functions->copy_lto_debug_sections (sobj, dest_sobj, 321 handle_lto_debug_sections, 322 err); 323 if (errmsg) 324 { 325 simple_object_release_write (dest_sobj); 326 return errmsg; 327 } 328 329 outfd = creat (dest, 00777); 330 if (outfd == -1) 331 { 332 *err = errno; 333 simple_object_release_write (dest_sobj); 334 return "open failed"; 335 } 336 337 errmsg = simple_object_write_to_file (dest_sobj, outfd, err); 338 close (outfd); 339 if (errmsg) 340 { 341 simple_object_release_write (dest_sobj); 342 return errmsg; 343 } 344 345 simple_object_release_write (dest_sobj); 346 return NULL; 347 } 348 349 /* Fetch attributes. */ 350 351 simple_object_attributes * 352 simple_object_fetch_attributes (simple_object_read *sobj, const char **errmsg, 353 int *err) 354 { 355 void *data; 356 simple_object_attributes *ret; 357 358 data = sobj->functions->fetch_attributes (sobj, errmsg, err); 359 if (data == NULL) 360 return NULL; 361 ret = XNEW (simple_object_attributes); 362 ret->functions = sobj->functions; 363 ret->data = data; 364 return ret; 365 } 366 367 /* Release an simple_object_read. */ 368 369 void 370 simple_object_release_read (simple_object_read *sobj) 371 { 372 sobj->functions->release_read (sobj->data); 373 XDELETE (sobj); 374 } 375 376 /* Merge attributes. */ 377 378 const char * 379 simple_object_attributes_merge (simple_object_attributes *to, 380 simple_object_attributes *from, 381 int *err) 382 { 383 if (to->functions != from->functions) 384 { 385 *err = 0; 386 return "different object file format"; 387 } 388 return to->functions->attributes_merge (to->data, from->data, err); 389 } 390 391 /* Release an attributes structure. */ 392 393 void 394 simple_object_release_attributes (simple_object_attributes *attrs) 395 { 396 attrs->functions->release_attributes (attrs->data); 397 XDELETE (attrs); 398 } 399 400 /* Start creating an object file. */ 401 402 simple_object_write * 403 simple_object_start_write (simple_object_attributes *attrs, 404 const char *segment_name, const char **errmsg, 405 int *err) 406 { 407 void *data; 408 simple_object_write *ret; 409 410 data = attrs->functions->start_write (attrs->data, errmsg, err); 411 if (data == NULL) 412 return NULL; 413 ret = XNEW (simple_object_write); 414 ret->functions = attrs->functions; 415 ret->segment_name = segment_name ? xstrdup (segment_name) : NULL; 416 ret->sections = NULL; 417 ret->last_section = NULL; 418 ret->data = data; 419 return ret; 420 } 421 422 /* Start creating a section. */ 423 424 simple_object_write_section * 425 simple_object_write_create_section (simple_object_write *sobj, const char *name, 426 unsigned int align, 427 const char **errmsg ATTRIBUTE_UNUSED, 428 int *err ATTRIBUTE_UNUSED) 429 { 430 simple_object_write_section *ret; 431 432 ret = XNEW (simple_object_write_section); 433 ret->next = NULL; 434 ret->name = xstrdup (name); 435 ret->align = align; 436 ret->buffers = NULL; 437 ret->last_buffer = NULL; 438 439 if (sobj->last_section == NULL) 440 { 441 sobj->sections = ret; 442 sobj->last_section = ret; 443 } 444 else 445 { 446 sobj->last_section->next = ret; 447 sobj->last_section = ret; 448 } 449 450 return ret; 451 } 452 453 /* Add data to a section. */ 454 455 const char * 456 simple_object_write_add_data (simple_object_write *sobj ATTRIBUTE_UNUSED, 457 simple_object_write_section *section, 458 const void *buffer, 459 size_t size, int copy, 460 int *err ATTRIBUTE_UNUSED) 461 { 462 struct simple_object_write_section_buffer *wsb; 463 464 wsb = XNEW (struct simple_object_write_section_buffer); 465 wsb->next = NULL; 466 wsb->size = size; 467 468 if (!copy) 469 { 470 wsb->buffer = buffer; 471 wsb->free_buffer = NULL; 472 } 473 else 474 { 475 wsb->free_buffer = (void *) XNEWVEC (char, size); 476 memcpy (wsb->free_buffer, buffer, size); 477 wsb->buffer = wsb->free_buffer; 478 } 479 480 if (section->last_buffer == NULL) 481 { 482 section->buffers = wsb; 483 section->last_buffer = wsb; 484 } 485 else 486 { 487 section->last_buffer->next = wsb; 488 section->last_buffer = wsb; 489 } 490 491 return NULL; 492 } 493 494 /* Write the complete object file. */ 495 496 const char * 497 simple_object_write_to_file (simple_object_write *sobj, int descriptor, 498 int *err) 499 { 500 return sobj->functions->write_to_file (sobj, descriptor, err); 501 } 502 503 /* Release an simple_object_write. */ 504 505 void 506 simple_object_release_write (simple_object_write *sobj) 507 { 508 simple_object_write_section *section; 509 510 free (sobj->segment_name); 511 512 section = sobj->sections; 513 while (section != NULL) 514 { 515 struct simple_object_write_section_buffer *buffer; 516 simple_object_write_section *next_section; 517 518 buffer = section->buffers; 519 while (buffer != NULL) 520 { 521 struct simple_object_write_section_buffer *next_buffer; 522 523 if (buffer->free_buffer != NULL) 524 XDELETEVEC (buffer->free_buffer); 525 next_buffer = buffer->next; 526 XDELETE (buffer); 527 buffer = next_buffer; 528 } 529 530 next_section = section->next; 531 free (section->name); 532 XDELETE (section); 533 section = next_section; 534 } 535 536 sobj->functions->release_write (sobj->data); 537 XDELETE (sobj); 538 } 539