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