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