1/* LTO IL options.
2
3   Copyright 2009 Free Software Foundation, Inc.
4   Contributed by Simon Baldwin <simonb@google.com>
5
6This file is part of GCC.
7
8GCC is free software; you can redistribute it and/or modify it under
9the terms of the GNU General Public License as published by the Free
10Software Foundation; either version 3, or (at your option) any later
11version.
12
13GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14WARRANTY; without even the implied warranty of MERCHANTABILITY or
15FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
16for more details.
17
18You should have received a copy of the GNU General Public License
19along with GCC; see the file COPYING3.  If not see
20<http://www.gnu.org/licenses/>.  */
21
22#include "config.h"
23#include "system.h"
24#include "coretypes.h"
25#include "tree.h"
26#include "hashtab.h"
27#include "ggc.h"
28#include "vec.h"
29#include "bitmap.h"
30#include "flags.h"
31#include "opts.h"
32#include "options.h"
33#include "target.h"
34#include "toplev.h"
35#include "lto-streamer.h"
36
37/* When a file is initially compiled, the options used when generating
38   the IL are not necessarily the same as those used when linking the
39   objects into the final executable.  In general, most build systems
40   will proceed with something along the lines of:
41
42   	$ gcc <cc-flags> -flto -c f1.c -o f1.o
43	$ gcc <cc-flags> -flto -c f2.c -o f2.o
44	...
45	$ gcc <cc-flags> -flto -c fN.c -o fN.o
46
47   And the final link may or may not include the same <cc-flags> used
48   to generate the initial object files:
49
50   	$ gcc <ld-flags> -flto -o prog f1.o ... fN.o
51
52   Since we will be generating final code during the link step, some
53   of the flags used during the compile step need to be re-applied
54   during the link step.  For instance, flags in the -m family.
55
56   The idea is to save a selected set of <cc-flags> in a special
57   section of the initial object files.  This section is then read
58   during linking and the options re-applied.
59
60   FIXME lto.  Currently the scheme is limited in that only the
61   options saved on the first object file (f1.o) are read back during
62   the link step.  This means that the options used to compile f1.o
63   will be applied to ALL the object files in the final link step.
64   More work needs to be done to implement a merging and validation
65   mechanism, as this will not be enough for all cases.  */
66
67/* Saved options hold the type of the option (currently CL_TARGET or
68   CL_COMMON), and the code, argument, and value.  */
69
70typedef struct GTY(()) opt_d
71{
72  unsigned int type;
73  size_t code;
74  char *arg;
75  int value;
76} opt_t;
77
78DEF_VEC_O (opt_t);
79DEF_VEC_ALLOC_O (opt_t, heap);
80
81
82/* Options are held in two vectors, one for those registered by
83   command line handling code, and the other for those read in from
84   any LTO IL input.  */
85static VEC(opt_t, heap) *user_options = NULL;
86static VEC(opt_t, heap) *file_options = NULL;
87
88/* Iterate FROM in reverse, writing option codes not yet in CODES into *TO.
89   Mark each new option code encountered in CODES.  */
90
91static void
92reverse_iterate_options (VEC(opt_t, heap) *from, VEC(opt_t, heap) **to,
93			 bitmap codes)
94{
95  int i;
96
97  for (i = VEC_length (opt_t, from); i > 0; i--)
98    {
99      const opt_t *const o = VEC_index (opt_t, from, i - 1);
100
101      if (bitmap_set_bit (codes, o->code))
102	VEC_safe_push (opt_t, heap, *to, o);
103    }
104}
105
106/* Concatenate options vectors FIRST and SECOND, rationalize so that only the
107   final of any given option remains, and return the result.  */
108
109static VEC(opt_t, heap) *
110concatenate_options (VEC(opt_t, heap) *first, VEC(opt_t, heap) *second)
111{
112  VEC(opt_t, heap) *results = NULL;
113  bitmap codes = lto_bitmap_alloc ();
114
115  reverse_iterate_options (second, &results, codes);
116  reverse_iterate_options (first, &results, codes);
117
118  lto_bitmap_free (codes);
119  return results;
120}
121
122/* Clear the options vector in *OPTS_P and set it to NULL.  */
123
124static void
125clear_options (VEC(opt_t, heap) **opts_p)
126{
127  int i;
128  opt_t *o;
129
130  for (i = 0; VEC_iterate (opt_t, *opts_p, i, o); i++)
131    free (o->arg);
132
133  VEC_free (opt_t, heap, *opts_p);
134}
135
136/* Write LENGTH bytes from ADDR to STREAM.  */
137
138static void
139output_data_stream (struct lto_output_stream *stream,
140                    const void *addr, size_t length)
141{
142  lto_output_data_stream (stream, addr, length);
143}
144
145/* Write string STRING to STREAM.  */
146
147static void
148output_string_stream (struct lto_output_stream *stream, const char *string)
149{
150  bool flag = false;
151
152  if (string != NULL)
153    {
154      const size_t length = strlen (string);
155
156      flag = true;
157      output_data_stream (stream, &flag, sizeof (flag));
158      output_data_stream (stream, &length, sizeof (length));
159      output_data_stream (stream, string, length);
160    }
161  else
162    output_data_stream (stream, &flag, sizeof (flag));
163}
164
165/* Read LENGTH bytes from STREAM to ADDR.  */
166
167static void
168input_data_block (struct lto_input_block *ib, void *addr, size_t length)
169{
170  size_t i;
171  unsigned char *const buffer = (unsigned char *const) addr;
172
173  for (i = 0; i < length; i++)
174    buffer[i] = lto_input_1_unsigned (ib);
175}
176
177/* Return a string from IB.  The string is allocated, and the caller is
178   responsible for freeing it.  */
179
180static char *
181input_string_block (struct lto_input_block *ib)
182{
183  bool flag;
184
185  input_data_block (ib, &flag, sizeof (flag));
186  if (flag)
187    {
188      size_t length;
189      char *string;
190
191      input_data_block (ib, &length, sizeof (length));
192      string = (char *) xcalloc (1, length + 1);
193      input_data_block (ib, string, length);
194
195      return string;
196    }
197  else
198    return NULL;
199}
200
201/* Return true if this option is one we need to save in LTO output files.
202   At present, we pass along all target options, and common options that
203   involve position independent code.
204
205   TODO This list of options requires expansion and rationalization.
206   Among others, optimization options may well be appropriate here.  */
207
208static bool
209register_user_option_p (size_t code, int type)
210{
211  if (type == CL_TARGET)
212    return true;
213  else if (type == CL_COMMON)
214    {
215      return (code == OPT_fPIC
216	      || code == OPT_fpic
217	      || code == OPT_fPIE
218	      || code == OPT_fpie
219	      || code == OPT_fcommon
220	      || code == OPT_fexceptions);
221    }
222
223  return false;
224}
225
226/* Note command line option with the given TYPE and CODE, ARG, and VALUE.
227   If relevant to LTO, save it in the user options vector.  */
228
229void
230lto_register_user_option (size_t code, const char *arg, int value, int type)
231{
232  if (register_user_option_p (code, type))
233    {
234      opt_t o;
235
236      o.type = type;
237      o.code = code;
238      if (arg != NULL)
239	{
240	  o.arg = (char *) xmalloc (strlen (arg) + 1);
241	  strcpy (o.arg, arg);
242	}
243      else
244	o.arg = NULL;
245      o.value = value;
246      VEC_safe_push (opt_t, heap, user_options, &o);
247    }
248}
249
250/* Empty the saved user options vector.  */
251
252void
253lto_clear_user_options (void)
254{
255  clear_options (&user_options);
256}
257
258/* Empty the saved file options vector.  */
259
260void
261lto_clear_file_options (void)
262{
263  clear_options (&file_options);
264}
265
266/* Concatenate the user options and any file options read from an LTO IL
267   file, and serialize them to STREAM.  File options precede user options
268   so that the latter override the former when reissued.  */
269
270static void
271output_options (struct lto_output_stream *stream)
272{
273  VEC(opt_t, heap) *opts = concatenate_options (file_options, user_options);
274  const size_t length = VEC_length (opt_t, opts);
275  int i;
276  opt_t *o;
277
278  output_data_stream (stream, &length, sizeof (length));
279
280  for (i = 0; VEC_iterate (opt_t, opts, i, o); i++)
281    {
282      output_data_stream (stream, &o->type, sizeof (o->type));
283      output_data_stream (stream, &o->code, sizeof (o->code));
284      output_string_stream (stream, o->arg);
285      output_data_stream (stream, &o->value, sizeof (o->value));
286    }
287
288  VEC_free (opt_t, heap, opts);
289}
290
291/* Write currently held options to an LTO IL section.  */
292
293void
294lto_write_options (void)
295{
296  char *const section_name = lto_get_section_name (LTO_section_opts, NULL);
297  struct lto_output_stream stream;
298  struct lto_simple_header header;
299  struct lto_output_stream *header_stream;
300
301  lto_begin_section (section_name, !flag_wpa);
302  free (section_name);
303
304  memset (&stream, 0, sizeof (stream));
305  output_options (&stream);
306
307  memset (&header, 0, sizeof (header));
308  header.lto_header.major_version = LTO_major_version;
309  header.lto_header.minor_version = LTO_minor_version;
310  header.lto_header.section_type = LTO_section_opts;
311
312  header.compressed_size = 0;
313  header.main_size = stream.total_size;
314
315  header_stream = ((struct lto_output_stream *)
316		   xcalloc (1, sizeof (*header_stream)));
317  lto_output_data_stream (header_stream, &header, sizeof (header));
318  lto_write_stream (header_stream);
319  free (header_stream);
320
321  lto_write_stream (&stream);
322  lto_end_section ();
323}
324
325/* Unserialize an options vector from IB, and append to file_options.  */
326
327static void
328input_options (struct lto_input_block *ib)
329{
330  size_t length, i;
331
332  input_data_block (ib, &length, sizeof (length));
333
334  for (i = 0; i < length; i++)
335    {
336      opt_t o;
337
338      input_data_block (ib, &o.type, sizeof (o.type));
339      input_data_block (ib, &o.code, sizeof (o.code));
340      o.arg = input_string_block (ib);
341      input_data_block (ib, &o.value, sizeof (o.value));
342      VEC_safe_push (opt_t, heap, file_options, &o);
343    }
344}
345
346/* Read options from an LTO IL section.  */
347
348void
349lto_read_file_options (struct lto_file_decl_data *file_data)
350{
351  size_t len;
352  const char *data;
353  const struct lto_simple_header *header;
354  int32_t opts_offset;
355  struct lto_input_block ib;
356
357  data = lto_get_section_data (file_data, LTO_section_opts, NULL, &len);
358  header = (const struct lto_simple_header *) data;
359  opts_offset = sizeof (*header);
360
361  lto_check_version (header->lto_header.major_version,
362		     header->lto_header.minor_version);
363
364  LTO_INIT_INPUT_BLOCK (ib, data + opts_offset, 0, header->main_size);
365  input_options (&ib);
366
367  lto_free_section_data (file_data, LTO_section_opts, 0, data, len);
368}
369
370/* Concatenate the user options and any file options read from an LTO IL
371   file, and reissue them as if all had just been read in from the command
372   line.  As with serialization, file options precede user options.  */
373
374void
375lto_reissue_options (void)
376{
377  VEC(opt_t, heap) *opts = concatenate_options (file_options, user_options);
378  int i;
379  opt_t *o;
380
381  for (i = 0; VEC_iterate (opt_t, opts, i, o); i++)
382    {
383      const struct cl_option *option = &cl_options[o->code];
384
385      if (option->flag_var)
386	set_option (option, o->value, o->arg);
387
388      if (o->type == CL_TARGET)
389	targetm.handle_option (o->code, o->arg, o->value);
390      else if (o->type == CL_COMMON)
391	gcc_assert (option->flag_var);
392      else
393	gcc_unreachable ();
394    }
395
396  VEC_free (opt_t, heap, opts);
397}
398