1 // inremental.cc -- incremental linking support for gold
3 // Copyright 2009 Free Software Foundation, Inc.
4 // Written by Mikolaj Zalewski <mikolajz@google.com>.
6 // This file is part of gold.
8 // This program is free software; you can redistribute it and/or modify
9 // it under the terms of the GNU General Public License as published by
10 // the Free Software Foundation; either version 3 of the License, or
11 // (at your option) any later version.
13 // This program is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 // GNU General Public License for more details.
18 // You should have received a copy of the GNU General Public License
19 // along with this program; if not, write to the Free Software
20 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 // MA 02110-1301, USA.
29 #include "incremental.h"
32 #include "target-select.h"
34 using elfcpp::Convert
;
38 // Version information. Will change frequently during the development, later
39 // we could think about backward (and forward?) compatibility.
40 const unsigned int INCREMENTAL_LINK_VERSION
= 1;
44 // Header of the .gnu_incremental_input section.
45 struct Incremental_inputs_header_data
47 // Incremental linker version.
48 elfcpp::Elf_Word version
;
50 // Numer of input files in the link.
51 elfcpp::Elf_Word input_file_count
;
53 // Offset of command line options in .gnu_incremental_strtab.
54 elfcpp::Elf_Word command_line_offset
;
57 elfcpp::Elf_Word reserved
;
60 // Data stored in .gnu_incremental_input after the header for each of the
61 // Incremental_input_header_data::input_file_count input entries.
62 struct Incremental_inputs_entry_data
64 // Offset of file name in .gnu_incremental_strtab section.
65 elfcpp::Elf_Word filename_offset
;
67 // Offset of data in .gnu_incremental_input.
68 elfcpp::Elf_Word data_offset
;
70 // Timestamp (in seconds).
71 elfcpp::Elf_Xword timestamp_sec
;
73 // Nano-second part of timestamp (if supported).
74 elfcpp::Elf_Word timestamp_nsec
;
76 // Type of the input entry.
77 elfcpp::Elf_Half input_type
;
80 elfcpp::Elf_Half reserved
;
87 // Reader class for .gnu_incremental_inputs header. See
88 // internal::Incremental_inputs_header_data for fields descriptions.
90 template<int size
, bool big_endian
>
91 class Incremental_inputs_header
94 typedef internal::Incremental_inputs_header_data Data_type
;
97 Incremental_inputs_header(const unsigned char *p
)
98 : p_(reinterpret_cast<const Data_type
*>(p
))
101 static const int data_size
= sizeof(Data_type
);
105 { return Convert
<32, big_endian
>::convert_host(this->p_
->version
); }
108 get_input_file_count() const
109 { return Convert
<32, big_endian
>::convert_host(this->p_
->input_file_count
); }
112 get_command_line_offset() const
113 { return Convert
<32, big_endian
>::convert_host(this->p_
->command_line_offset
); }
117 { return Convert
<32, big_endian
>::convert_host(this->p_
->reserved
); }
123 // Writer class for .gnu_incremental_inputs header. See
124 // internal::Incremental_inputs_header_data for fields descriptions.
126 template<int size
, bool big_endian
>
127 class Incremental_inputs_header_write
130 typedef internal::Incremental_inputs_header_data Data_type
;
133 Incremental_inputs_header_write(unsigned char *p
)
134 : p_(reinterpret_cast<Data_type
*>(p
))
137 static const int data_size
= sizeof(Data_type
);
140 put_version(elfcpp::Elf_Word v
)
141 { this->p_
->version
= Convert
<32, big_endian
>::convert_host(v
); }
144 put_input_file_count(elfcpp::Elf_Word v
)
145 { this->p_
->input_file_count
= Convert
<32, big_endian
>::convert_host(v
); }
148 put_command_line_offset(elfcpp::Elf_Word v
)
149 { this->p_
->command_line_offset
= Convert
<32, big_endian
>::convert_host(v
); }
152 put_reserved(elfcpp::Elf_Word v
)
153 { this->p_
->reserved
= Convert
<32, big_endian
>::convert_host(v
); }
159 // Reader class for an .gnu_incremental_inputs entry. See
160 // internal::Incremental_inputs_entry_data for fields descriptions.
161 template<int size
, bool big_endian
>
162 class Incremental_inputs_entry
165 typedef internal::Incremental_inputs_entry_data Data_type
;
168 Incremental_inputs_entry(const unsigned char *p
)
169 : p_(reinterpret_cast<const Data_type
*>(p
))
172 static const int data_size
= sizeof(Data_type
);
175 get_filename_offset(elfcpp::Elf_Word v
)
176 { return Convert
<32, big_endian
>::convert_host(this->p_
->filename_offset
); }
179 get_data_offset(elfcpp::Elf_Word v
)
180 { return Convert
<32, big_endian
>::convert_host(this->p_
->data_offset
); }
183 get_timestamp_sec(elfcpp::Elf_Xword v
)
184 { return Convert
<64, big_endian
>::convert_host(this->p_
->timestamp_sec
); }
187 get_timestamp_nsec(elfcpp::Elf_Word v
)
188 { return Convert
<32, big_endian
>::convert_host(this->p_
->timestamp_nsec
); }
191 get_input_type(elfcpp::Elf_Word v
)
192 { return Convert
<32, big_endian
>::convert_host(this->p_
->input_type
); }
195 get_reserved(elfcpp::Elf_Word v
)
196 { return Convert
<32, big_endian
>::convert_host(this->p_
->reserved
); }
202 // Writer class for an .gnu_incremental_inputs entry. See
203 // internal::Incremental_inputs_entry_data for fields descriptions.
204 template<int size
, bool big_endian
>
205 class Incremental_inputs_entry_write
208 typedef internal::Incremental_inputs_entry_data Data_type
;
211 Incremental_inputs_entry_write(unsigned char *p
)
212 : p_(reinterpret_cast<Data_type
*>(p
))
215 static const int data_size
= sizeof(Data_type
);
218 put_filename_offset(elfcpp::Elf_Word v
)
219 { this->p_
->filename_offset
= Convert
<32, big_endian
>::convert_host(v
); }
222 put_data_offset(elfcpp::Elf_Word v
)
223 { this->p_
->data_offset
= Convert
<32, big_endian
>::convert_host(v
); }
226 put_timestamp_sec(elfcpp::Elf_Xword v
)
227 { this->p_
->timestamp_sec
= Convert
<64, big_endian
>::convert_host(v
); }
230 put_timestamp_nsec(elfcpp::Elf_Word v
)
231 { this->p_
->timestamp_nsec
= Convert
<32, big_endian
>::convert_host(v
); }
234 put_input_type(elfcpp::Elf_Word v
)
235 { this->p_
->input_type
= Convert
<32, big_endian
>::convert_host(v
); }
238 put_reserved(elfcpp::Elf_Word v
)
239 { this->p_
->reserved
= Convert
<32, big_endian
>::convert_host(v
); }
245 // Inform the user why we don't do an incremental link. Not called in
246 // the obvious case of missing output file. TODO: Is this helpful?
249 vexplain_no_incremental(const char* format
, va_list args
)
252 if (vasprintf(&buf
, format
, args
) < 0)
254 gold_info(_("the link might take longer: "
255 "cannot perform incremental link: %s"), buf
);
260 explain_no_incremental(const char* format
, ...)
263 va_start(args
, format
);
264 vexplain_no_incremental(format
, args
);
271 Incremental_binary::error(const char* format
, ...) const
274 va_start(args
, format
);
275 // Current code only checks if the file can be used for incremental linking,
276 // so errors shouldn't fail the build, but only result in a fallback to a
278 // TODO: when we implement incremental editing of the file, we may need a
279 // flag that will cause errors to be treated seriously.
280 vexplain_no_incremental(format
, args
);
284 template<int size
, bool big_endian
>
286 Sized_incremental_binary
<size
, big_endian
>::do_find_incremental_inputs_section(
288 unsigned int* strtab_shndx
)
290 unsigned int shndx
= this->elf_file_
.find_section_by_type(
291 elfcpp::SHT_GNU_INCREMENTAL_INPUTS
);
292 if (shndx
== elfcpp::SHN_UNDEF
) // Not found.
294 *strtab_shndx
= this->elf_file_
.section_link(shndx
);
295 *location
= this->elf_file_
.section_contents(shndx
);
299 template<int size
, bool big_endian
>
301 Sized_incremental_binary
<size
, big_endian
>::do_check_inputs(
302 Incremental_inputs
* incremental_inputs
)
304 const int entry_size
=
305 Incremental_inputs_entry_write
<size
, big_endian
>::data_size
;
306 const int header_size
=
307 Incremental_inputs_header_write
<size
, big_endian
>::data_size
;
309 unsigned int strtab_shndx
;
312 if (!do_find_incremental_inputs_section(&location
, &strtab_shndx
))
314 explain_no_incremental(_("no incremental data from previous build"));
317 if (location
.data_size
< header_size
318 || strtab_shndx
>= this->elf_file_
.shnum()
319 || this->elf_file_
.section_type(strtab_shndx
) != elfcpp::SHT_STRTAB
)
321 explain_no_incremental(_("invalid incremental build data"));
325 Location
strtab_location(this->elf_file_
.section_contents(strtab_shndx
));
326 View
data_view(view(location
));
327 View
strtab_view(view(strtab_location
));
328 elfcpp::Elf_strtab
strtab(strtab_view
.data(), strtab_location
.data_size
);
329 Incremental_inputs_header
<size
, big_endian
> header(data_view
.data());
331 if (header
.get_version() != INCREMENTAL_LINK_VERSION
)
333 explain_no_incremental(_("different version of incremental build data"));
337 const char* command_line
;
338 // We divide instead of multiplying to make sure there is no integer
340 size_t max_input_entries
= (location
.data_size
- header_size
) / entry_size
;
341 if (header
.get_input_file_count() > max_input_entries
342 || !strtab
.get_c_string(header
.get_command_line_offset(), &command_line
))
344 explain_no_incremental(_("invalid incremental build data"));
348 if (incremental_inputs
->command_line() != command_line
)
350 explain_no_incremental(_("command line changed"));
354 // TODO: compare incremental_inputs->inputs() with entries in data_view.
361 // Create a Sized_incremental_binary object of the specified size and
362 // endianness. Fails if the target architecture is not supported.
364 template<int size
, bool big_endian
>
366 make_sized_incremental_binary(Output_file
* file
,
367 const elfcpp::Ehdr
<size
, big_endian
>& ehdr
)
369 Target
* target
= select_target(ehdr
.get_e_machine(), size
, big_endian
,
370 ehdr
.get_e_ident()[elfcpp::EI_OSABI
],
371 ehdr
.get_e_ident()[elfcpp::EI_ABIVERSION
]);
374 explain_no_incremental(_("unsupported ELF machine number %d"),
375 ehdr
.get_e_machine());
379 return new Sized_incremental_binary
<size
, big_endian
>(file
, ehdr
, target
);
382 } // End of anonymous namespace.
384 // Create an Incremental_binary object for FILE. Returns NULL is this is not
385 // possible, e.g. FILE is not an ELF file or has an unsupported target. FILE
389 open_incremental_binary(Output_file
* file
)
391 off_t filesize
= file
->filesize();
392 int want
= elfcpp::Elf_recognizer::max_header_size
;
396 const unsigned char* p
= file
->get_input_view(0, want
);
397 if (!elfcpp::Elf_recognizer::is_elf_file(p
, want
))
399 explain_no_incremental(_("output is not an ELF file."));
404 bool big_endian
= false;
406 if (!elfcpp::Elf_recognizer::is_valid_header(p
, want
, &size
, &big_endian
,
409 explain_no_incremental(error
.c_str());
413 Incremental_binary
* result
= NULL
;
418 #ifdef HAVE_TARGET_32_BIG
419 result
= make_sized_incremental_binary
<32, true>(
420 file
, elfcpp::Ehdr
<32, true>(p
));
422 explain_no_incremental(_("unsupported file: 32-bit, big-endian"));
427 #ifdef HAVE_TARGET_32_LITTLE
428 result
= make_sized_incremental_binary
<32, false>(
429 file
, elfcpp::Ehdr
<32, false>(p
));
431 explain_no_incremental(_("unsupported file: 32-bit, little-endian"));
439 #ifdef HAVE_TARGET_64_BIG
440 result
= make_sized_incremental_binary
<64, true>(
441 file
, elfcpp::Ehdr
<64, true>(p
));
443 explain_no_incremental(_("unsupported file: 64-bit, big-endian"));
448 #ifdef HAVE_TARGET_64_LITTLE
449 result
= make_sized_incremental_binary
<64, false>(
450 file
, elfcpp::Ehdr
<64, false>(p
));
452 explain_no_incremental(_("unsupported file: 64-bit, little-endian"));
462 // Analyzes the output file to check if incremental linking is possible and
463 // (to be done) what files need to be relinked.
466 Incremental_checker::can_incrementally_link_output_file()
468 Output_file
output(this->output_name_
);
469 if (!output
.open_for_modification())
471 Incremental_binary
* binary
= open_incremental_binary(&output
);
474 return binary
->check_inputs(this->incremental_inputs_
);
477 // Add the command line to the string table, setting
478 // command_line_key_. In incremental builds, the command line is
479 // stored in .gnu_incremental_inputs so that the next linker run can
480 // check if the command line options didn't change.
483 Incremental_inputs::report_command_line(int argc
, const char* const* argv
)
485 // Always store 'gold' as argv[0] to avoid a full relink if the user used a
486 // different path to the linker.
487 std::string
args("gold");
488 // Copied from collect_argv in main.cc.
489 for (int i
= 1; i
< argc
; ++i
)
491 // Adding/removing these options should result in a full relink.
492 if (strcmp(argv
[i
], "--incremental-changed") == 0
493 || strcmp(argv
[i
], "--incremental-unchanged") == 0
494 || strcmp(argv
[i
], "--incremental-unknown") == 0)
498 // Now append argv[i], but with all single-quotes escaped
499 const char* argpos
= argv
[i
];
502 const int len
= strcspn(argpos
, "'");
503 args
.append(argpos
, len
);
504 if (argpos
[len
] == '\0')
506 args
.append("'\"'\"'");
512 this->command_line_
= args
;
513 this->strtab_
->add(this->command_line_
.c_str(), false,
514 &this->command_line_key_
);
517 // Record that the input argument INPUT is an achive ARCHIVE. This is
518 // called by Read_symbols after finding out the type of the file.
521 Incremental_inputs::report_archive(const Input_argument
* input
,
524 Hold_lock
hl(*this->lock_
);
527 info
.type
= INCREMENTAL_INPUT_ARCHIVE
;
528 info
.archive
= archive
;
529 info
.mtime
= archive
->file().get_mtime();
530 this->inputs_map_
.insert(std::make_pair(input
, info
));
533 // Record that the input argument INPUT is an object OBJ. This is
534 // called by Read_symbols after finding out the type of the file.
537 Incremental_inputs::report_object(const Input_argument
* input
,
540 Hold_lock
hl(*this->lock_
);
543 info
.type
= (obj
->is_dynamic()
544 ? INCREMENTAL_INPUT_SHARED_LIBRARY
545 : INCREMENTAL_INPUT_OBJECT
);
547 info
.mtime
= obj
->input_file()->file().get_mtime();
548 this->inputs_map_
.insert(std::make_pair(input
, info
));
551 // Record that the input argument INPUT is an script SCRIPT. This is
552 // called by read_script after parsing the script and reading the list
553 // of inputs added by this script.
556 Incremental_inputs::report_script(const Input_argument
* input
,
560 Hold_lock
hl(*this->lock_
);
563 info
.type
= INCREMENTAL_INPUT_SCRIPT
;
564 info
.script
= script
;
566 this->inputs_map_
.insert(std::make_pair(input
, info
));
569 // Compute indexes in the order in which the inputs should appear in
570 // .gnu_incremental_inputs. This needs to be done after all the
571 // scripts are parsed. The function is first called for the command
572 // line inputs arguments and may call itself recursively for e.g. a
573 // list of elements of a group or a list of inputs added by a script.
574 // The [BEGIN; END) interval to analyze and *INDEX is the current
575 // value of the index (that will be updated).
578 Incremental_inputs::finalize_inputs(
579 Input_argument_list::const_iterator begin
,
580 Input_argument_list::const_iterator end
,
583 for (Input_argument_list::const_iterator p
= begin
; p
!= end
; ++p
)
587 finalize_inputs(p
->group()->begin(), p
->group()->end(), index
);
591 Inputs_info_map::iterator it
= this->inputs_map_
.find(&(*p
));
592 // TODO: turn it into an assert when the code will be more stable.
593 if (it
== this->inputs_map_
.end())
595 gold_error("internal error: %s: incremental build info not provided",
596 (p
->is_file() ? p
->file().name() : "[group]"));
599 Input_info
* info
= &it
->second
;
600 info
->index
= *index
;
602 this->strtab_
->add(p
->file().name(), false, &info
->filename_key
);
603 if (info
->type
== INCREMENTAL_INPUT_SCRIPT
)
605 finalize_inputs(info
->script
->inputs()->begin(),
606 info
->script
->inputs()->end(),
612 // Finalize the incremental link information. Called from
616 Incremental_inputs::finalize()
618 unsigned int index
= 0;
619 finalize_inputs(this->inputs_
->begin(), this->inputs_
->end(), &index
);
622 for (Inputs_info_map::const_iterator p
= this->inputs_map_
.begin();
623 p
!= this->inputs_map_
.end();
626 gold_assert(p
->second
.filename_key
!= 0);
629 this->strtab_
->set_string_offsets();
632 // Create the content of the .gnu_incremental_inputs section.
635 Incremental_inputs::create_incremental_inputs_section_data()
637 switch (parameters
->size_and_endianness())
639 #ifdef HAVE_TARGET_32_LITTLE
640 case Parameters::TARGET_32_LITTLE
:
641 return this->sized_create_inputs_section_data
<32, false>();
643 #ifdef HAVE_TARGET_32_BIG
644 case Parameters::TARGET_32_BIG
:
645 return this->sized_create_inputs_section_data
<32, true>();
647 #ifdef HAVE_TARGET_64_LITTLE
648 case Parameters::TARGET_64_LITTLE
:
649 return this->sized_create_inputs_section_data
<64, false>();
651 #ifdef HAVE_TARGET_64_BIG
652 case Parameters::TARGET_64_BIG
:
653 return this->sized_create_inputs_section_data
<64, true>();
660 // Sized creation of .gnu_incremental_inputs section.
662 template<int size
, bool big_endian
>
664 Incremental_inputs::sized_create_inputs_section_data()
666 const int entry_size
=
667 Incremental_inputs_entry_write
<size
, big_endian
>::data_size
;
668 const int header_size
=
669 Incremental_inputs_header_write
<size
, big_endian
>::data_size
;
671 unsigned int sz
= header_size
+ entry_size
* this->inputs_map_
.size();
672 unsigned char* buffer
= new unsigned char[sz
];
673 unsigned char* inputs_base
= buffer
+ header_size
;
675 Incremental_inputs_header_write
<size
, big_endian
> header_writer(buffer
);
676 gold_assert(this->command_line_key_
> 0);
677 int cmd_offset
= this->strtab_
->get_offset_from_key(this->command_line_key_
);
679 header_writer
.put_version(INCREMENTAL_LINK_VERSION
);
680 header_writer
.put_input_file_count(this->inputs_map_
.size());
681 header_writer
.put_command_line_offset(cmd_offset
);
682 header_writer
.put_reserved(0);
684 for (Inputs_info_map::const_iterator it
= this->inputs_map_
.begin();
685 it
!= this->inputs_map_
.end();
688 gold_assert(it
->second
.index
< this->inputs_map_
.size());
690 unsigned char* entry_buffer
=
691 inputs_base
+ it
->second
.index
* entry_size
;
692 Incremental_inputs_entry_write
<size
, big_endian
> entry(entry_buffer
);
693 int filename_offset
=
694 this->strtab_
->get_offset_from_key(it
->second
.filename_key
);
695 entry
.put_filename_offset(filename_offset
);
696 // TODO: add per input data and timestamp. Currently we store
697 // an out-of-bounds offset for future version of gold to reject
698 // such an incremental_inputs section.
699 entry
.put_data_offset(0xffffffff);
700 entry
.put_timestamp_sec(it
->second
.mtime
.seconds
);
701 entry
.put_timestamp_nsec(it
->second
.mtime
.nanoseconds
);
702 entry
.put_input_type(it
->second
.type
);
703 entry
.put_reserved(0);
706 return new Output_data_const_buffer(buffer
, sz
, 8,
707 "** incremental link inputs list");
710 // Instantiate the templates we need.
712 #ifdef HAVE_TARGET_32_LITTLE
714 class Sized_incremental_binary
<32, false>;
717 #ifdef HAVE_TARGET_32_BIG
719 class Sized_incremental_binary
<32, true>;
722 #ifdef HAVE_TARGET_64_LITTLE
724 class Sized_incremental_binary
<64, false>;
727 #ifdef HAVE_TARGET_64_BIG
729 class Sized_incremental_binary
<64, true>;
732 } // End namespace gold.