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.
26 #include "incremental.h"
28 using elfcpp::Convert
;
32 // Version information. Will change frequently during the development, later
33 // we could think about backward (and forward?) compatibility.
34 const int INCREMENTAL_LINK_VERSION
= 1;
38 // Header of the .gnu_incremental_input section.
39 struct Incremental_inputs_header_data
41 // Incremental linker version.
42 elfcpp::Elf_Word version
;
44 // Numer of input files in the link.
45 elfcpp::Elf_Word input_file_count
;
47 // Offset of command line options in .gnu_incremental_strtab.
48 elfcpp::Elf_Word command_line_offset
;
51 elfcpp::Elf_Word reserved
;
54 // Data stored in .gnu_incremental_input after the header for each of the
55 // Incremental_input_header_data::input_file_count input entries.
56 struct Incremental_inputs_entry_data
58 // Offset of file name in .gnu_incremental_strtab section.
59 elfcpp::Elf_Word filename_offset
;
61 // Offset of data in .gnu_incremental_input.
62 elfcpp::Elf_Word data_offset
;
64 // Timestamp (in seconds).
65 elfcpp::Elf_Xword timestamp_sec
;
67 // Nano-second part of timestamp (if supported).
68 elfcpp::Elf_Word timestamp_usec
;
70 // Type of the input entry.
71 elfcpp::Elf_Half input_type
;
74 elfcpp::Elf_Half reserved
;
81 // See internal::Incremental_input_header for fields descriptions.
82 template<int size
, bool big_endian
>
83 class Incremental_inputs_header_write
86 Incremental_inputs_header_write(unsigned char *p
)
87 : p_(reinterpret_cast<internal::Incremental_inputs_header_data
*>(p
))
90 static const int data_size
= sizeof(internal::Incremental_inputs_header_data
);
93 put_version(elfcpp::Elf_Word v
)
94 { this->p_
->version
= Convert
<32, big_endian
>::convert_host(v
); }
97 put_input_file_count(elfcpp::Elf_Word v
)
98 { this->p_
->input_file_count
= Convert
<32, big_endian
>::convert_host(v
); }
101 put_command_line_offset(elfcpp::Elf_Word v
)
102 { this->p_
->command_line_offset
= Convert
<32, big_endian
>::convert_host(v
); }
105 put_reserved(elfcpp::Elf_Word v
)
106 { this->p_
->reserved
= Convert
<32, big_endian
>::convert_host(v
); }
109 internal::Incremental_inputs_header_data
* p_
;
112 // See internal::Incremental_input_entry for fields descriptions.
113 template<int size
, bool big_endian
>
114 class Incremental_inputs_entry_write
117 Incremental_inputs_entry_write(unsigned char *p
)
118 : p_(reinterpret_cast<internal::Incremental_inputs_entry_data
*>(p
))
121 static const int data_size
= sizeof(internal::Incremental_inputs_entry_data
);
124 put_filename_offset(elfcpp::Elf_Word v
)
125 { this->p_
->filename_offset
= Convert
<32, big_endian
>::convert_host(v
); }
128 put_data_offset(elfcpp::Elf_Word v
)
129 { this->p_
->data_offset
= Convert
<32, big_endian
>::convert_host(v
); }
132 put_timestamp_sec(elfcpp::Elf_Word v
)
133 { this->p_
->timestamp_sec
= Convert
<32, big_endian
>::convert_host(v
); }
136 put_timestamp_usec(elfcpp::Elf_Word v
)
137 { this->p_
->timestamp_usec
= Convert
<32, big_endian
>::convert_host(v
); }
140 put_input_type(elfcpp::Elf_Word v
)
141 { this->p_
->input_type
= Convert
<32, big_endian
>::convert_host(v
); }
144 put_reserved(elfcpp::Elf_Word v
)
145 { this->p_
->reserved
= Convert
<32, big_endian
>::convert_host(v
); }
148 internal::Incremental_inputs_entry_data
* p_
;
151 // Add the command line to the string table, setting
152 // command_line_key_. In incremental builds, the command line is
153 // stored in .gnu_incremental_inputs so that the next linker run can
154 // check if the command line options didn't change.
157 Incremental_inputs::report_command_line(int argc
, const char* const* argv
)
159 // Always store 'gold' as argv[0] to avoid a full relink if the user used a
160 // different path to the linker.
161 std::string
args("gold");
162 // Copied from collect_argv in main.cc.
163 for (int i
= 1; i
< argc
; ++i
)
166 // Now append argv[i], but with all single-quotes escaped
167 const char* argpos
= argv
[i
];
170 const int len
= strcspn(argpos
, "'");
171 args
.append(argpos
, len
);
172 if (argpos
[len
] == '\0')
174 args
.append("'\"'\"'");
179 this->strtab_
->add(args
.c_str(), true, &this->command_line_key_
);
182 // Record that the input argument INPUT is an achive ARCHIVE. This is
183 // called by Read_symbols after finding out the type of the file.
186 Incremental_inputs::report_archive(const Input_argument
* input
,
189 Hold_lock
hl(*this->lock_
);
192 info
.type
= INCREMENTAL_INPUT_ARCHIVE
;
193 info
.archive
= archive
;
194 inputs_map_
.insert(std::make_pair(input
, info
));
197 // Record that the input argument INPUT is an object OBJ. This is
198 // called by Read_symbols after finding out the type of the file.
201 Incremental_inputs::report_object(const Input_argument
* input
,
204 Hold_lock
hl(*this->lock_
);
207 info
.type
= (obj
->is_dynamic()
208 ? INCREMENTAL_INPUT_SHARED_LIBRARY
209 : INCREMENTAL_INPUT_OBJECT
);
211 inputs_map_
.insert(std::make_pair(input
, info
));
214 // Record that the input argument INPUT is an script SCRIPT. This is
215 // called by read_script after parsing the script and reading the list
216 // of inputs added by this script.
219 Incremental_inputs::report_script(const Input_argument
* input
,
222 Hold_lock
hl(*this->lock_
);
225 info
.type
= INCREMENTAL_INPUT_SCRIPT
;
226 info
.script
= script
;
227 inputs_map_
.insert(std::make_pair(input
, info
));
230 // Compute indexes in the order in which the inputs should appear in
231 // .gnu_incremental_inputs. This needs to be done after all the
232 // scripts are parsed. The function is first called for the command
233 // line inputs arguments and may call itself recursively for e.g. a
234 // list of elements of a group or a list of inputs added by a script.
235 // The [BEGIN; END) interval to analyze and *INDEX is the current
236 // value of the index (that will be updated).
239 Incremental_inputs::finalize_inputs(
240 Input_argument_list::const_iterator begin
,
241 Input_argument_list::const_iterator end
,
244 for (Input_argument_list::const_iterator p
= begin
; p
!= end
; ++p
)
248 finalize_inputs(p
->group()->begin(), p
->group()->end(), index
);
252 Inputs_info_map::iterator it
= inputs_map_
.find(&(*p
));
253 // TODO: turn it into an assert when the code will be more stable.
254 if (it
== inputs_map_
.end())
256 gold_error("internal error: %s: incremental build info not provided",
257 (p
->is_file() ? p
->file().name() : "[group]"));
260 Input_info
* info
= &it
->second
;
261 info
->index
= *index
;
263 this->strtab_
->add(p
->file().name(), false, &info
->filename_key
);
264 if (info
->type
== INCREMENTAL_INPUT_SCRIPT
)
266 finalize_inputs(info
->script
->inputs()->begin(),
267 info
->script
->inputs()->end(),
273 // Finalize the incremental link information. Called from
277 Incremental_inputs::finalize()
279 unsigned int index
= 0;
280 finalize_inputs(this->inputs_
->begin(), this->inputs_
->end(), &index
);
283 for (Inputs_info_map::const_iterator p
= inputs_map_
.begin();
284 p
!= inputs_map_
.end();
287 gold_assert(p
->second
.filename_key
!= 0);
290 this->strtab_
->set_string_offsets();
293 // Create the content of the .gnu_incremental_inputs section.
296 Incremental_inputs::create_incremental_inputs_section_data()
298 switch (parameters
->size_and_endianness())
300 #ifdef HAVE_TARGET_32_LITTLE
301 case Parameters::TARGET_32_LITTLE
:
302 return this->sized_create_inputs_section_data
<32, false>();
304 #ifdef HAVE_TARGET_32_BIG
305 case Parameters::TARGET_32_BIG
:
306 return this->sized_create_inputs_section_data
<32, true>();
308 #ifdef HAVE_TARGET_64_LITTLE
309 case Parameters::TARGET_64_LITTLE
:
310 return this->sized_create_inputs_section_data
<64, false>();
312 #ifdef HAVE_TARGET_64_BIG
313 case Parameters::TARGET_64_BIG
:
314 return this->sized_create_inputs_section_data
<64, true>();
321 // Sized creation of .gnu_incremental_inputs section.
323 template<int size
, bool big_endian
>
325 Incremental_inputs::sized_create_inputs_section_data()
327 const int entry_size
=
328 Incremental_inputs_entry_write
<size
, big_endian
>::data_size
;
329 const int header_size
=
330 Incremental_inputs_header_write
<size
, big_endian
>::data_size
;
332 unsigned int sz
= header_size
+ entry_size
* this->inputs_map_
.size();
333 unsigned char* buffer
= new unsigned char[sz
];
334 unsigned char* inputs_base
= buffer
+ header_size
;
336 Incremental_inputs_header_write
<size
, big_endian
> header_writer(buffer
);
337 gold_assert(this->command_line_key_
> 0);
338 int cmd_offset
= this->strtab_
->get_offset_from_key(this->command_line_key_
);
340 header_writer
.put_version(INCREMENTAL_LINK_VERSION
);
341 header_writer
.put_input_file_count(this->inputs_map_
.size());
342 header_writer
.put_command_line_offset(cmd_offset
);
343 header_writer
.put_reserved(0);
345 for (Inputs_info_map::const_iterator it
= this->inputs_map_
.begin();
346 it
!= this->inputs_map_
.end();
349 gold_assert(it
->second
.index
< this->inputs_map_
.size());
351 unsigned char* entry_buffer
=
352 inputs_base
+ it
->second
.index
* entry_size
;
353 Incremental_inputs_entry_write
<size
, big_endian
> entry(entry_buffer
);
354 int filename_offset
=
355 this->strtab_
->get_offset_from_key(it
->second
.filename_key
);
356 entry
.put_filename_offset(filename_offset
);
357 // TODO: add per input data and timestamp. Currently we store
358 // an out-of-bounds offset for future version of gold to reject
359 // such an incremental_inputs section.
360 entry
.put_data_offset(0xffffffff);
361 entry
.put_timestamp_sec(0);
362 entry
.put_timestamp_usec(0);
363 entry
.put_input_type(it
->second
.type
);
364 entry
.put_reserved(0);
367 return new Output_data_const_buffer(buffer
, sz
, 8,
368 "** incremental link inputs list");
371 } // End namespace gold.