/* LTO IL options.
- Copyright 2009, 2010 Free Software Foundation, Inc.
+ Copyright (C) 2009-2014 Free Software Foundation, Inc.
Contributed by Simon Baldwin <simonb@google.com>
This file is part of GCC.
#include "system.h"
#include "coretypes.h"
#include "tree.h"
-#include "hashtab.h"
-#include "ggc.h"
+#include "predict.h"
#include "vec.h"
+#include "hashtab.h"
+#include "hash-set.h"
+#include "machmode.h"
+#include "tm.h"
+#include "hard-reg-set.h"
+#include "input.h"
+#include "function.h"
+#include "basic-block.h"
+#include "tree-ssa-alias.h"
+#include "internal-fn.h"
+#include "gimple-expr.h"
+#include "is-a.h"
+#include "gimple.h"
#include "bitmap.h"
#include "flags.h"
#include "opts.h"
#include "options.h"
-#include "target.h"
-#include "diagnostic-core.h"
-#include "toplev.h"
+#include "common/common-target.h"
+#include "diagnostic.h"
+#include "hash-map.h"
+#include "plugin-api.h"
+#include "ipa-ref.h"
+#include "cgraph.h"
#include "lto-streamer.h"
+#include "lto-section-names.h"
+#include "toplev.h"
-/* When a file is initially compiled, the options used when generating
- the IL are not necessarily the same as those used when linking the
- objects into the final executable. In general, most build systems
- will proceed with something along the lines of:
-
- $ gcc <cc-flags> -flto -c f1.c -o f1.o
- $ gcc <cc-flags> -flto -c f2.c -o f2.o
- ...
- $ gcc <cc-flags> -flto -c fN.c -o fN.o
-
- And the final link may or may not include the same <cc-flags> used
- to generate the initial object files:
-
- $ gcc <ld-flags> -flto -o prog f1.o ... fN.o
-
- Since we will be generating final code during the link step, some
- of the flags used during the compile step need to be re-applied
- during the link step. For instance, flags in the -m family.
-
- The idea is to save a selected set of <cc-flags> in a special
- section of the initial object files. This section is then read
- during linking and the options re-applied.
-
- FIXME lto. Currently the scheme is limited in that only the
- options saved on the first object file (f1.o) are read back during
- the link step. This means that the options used to compile f1.o
- will be applied to ALL the object files in the final link step.
- More work needs to be done to implement a merging and validation
- mechanism, as this will not be enough for all cases. */
-
-/* Saved options hold the type of the option (currently CL_TARGET or
- CL_COMMON), and the code, argument, and value. */
-
-typedef struct GTY(()) opt_d
-{
- unsigned int type;
- size_t code;
- char *arg;
- int value;
-} opt_t;
-
-DEF_VEC_O (opt_t);
-DEF_VEC_ALLOC_O (opt_t, heap);
-
-
-/* Options are held in two vectors, one for those registered by
- command line handling code, and the other for those read in from
- any LTO IL input. */
-static VEC(opt_t, heap) *user_options = NULL;
-static VEC(opt_t, heap) *file_options = NULL;
-
-/* Iterate FROM in reverse, writing option codes not yet in CODES into *TO.
- Mark each new option code encountered in CODES. */
-
-static void
-reverse_iterate_options (VEC(opt_t, heap) *from, VEC(opt_t, heap) **to,
- bitmap codes)
-{
- int i;
-
- for (i = VEC_length (opt_t, from); i > 0; i--)
- {
- const opt_t *const o = VEC_index (opt_t, from, i - 1);
-
- if (bitmap_set_bit (codes, o->code))
- VEC_safe_push (opt_t, heap, *to, o);
- }
-}
-
-/* Concatenate options vectors FIRST and SECOND, rationalize so that only the
- final of any given option remains, and return the result. */
-
-static VEC(opt_t, heap) *
-concatenate_options (VEC(opt_t, heap) *first, VEC(opt_t, heap) *second)
-{
- VEC(opt_t, heap) *results = NULL;
- bitmap codes = lto_bitmap_alloc ();
-
- reverse_iterate_options (second, &results, codes);
- reverse_iterate_options (first, &results, codes);
-
- lto_bitmap_free (codes);
- return results;
-}
-
-/* Clear the options vector in *OPTS_P and set it to NULL. */
-
-static void
-clear_options (VEC(opt_t, heap) **opts_p)
-{
- int i;
- opt_t *o;
-
- FOR_EACH_VEC_ELT (opt_t, *opts_p, i, o)
- free (o->arg);
-
- VEC_free (opt_t, heap, *opts_p);
-}
-
-/* Write LENGTH bytes from ADDR to STREAM. */
-
-static void
-output_data_stream (struct lto_output_stream *stream,
- const void *addr, size_t length)
-{
- lto_output_data_stream (stream, addr, length);
-}
-
-/* Write string STRING to STREAM. */
-
-static void
-output_string_stream (struct lto_output_stream *stream, const char *string)
-{
- bool flag = false;
-
- if (string != NULL)
- {
- const size_t length = strlen (string);
-
- flag = true;
- output_data_stream (stream, &flag, sizeof (flag));
- output_data_stream (stream, &length, sizeof (length));
- output_data_stream (stream, string, length);
- }
- else
- output_data_stream (stream, &flag, sizeof (flag));
-}
-
-/* Read LENGTH bytes from STREAM to ADDR. */
-
-static void
-input_data_block (struct lto_input_block *ib, void *addr, size_t length)
-{
- size_t i;
- unsigned char *const buffer = (unsigned char *const) addr;
-
- for (i = 0; i < length; i++)
- buffer[i] = lto_input_1_unsigned (ib);
-}
-
-/* Return a string from IB. The string is allocated, and the caller is
- responsible for freeing it. */
-
-static char *
-input_string_block (struct lto_input_block *ib)
-{
- bool flag;
-
- input_data_block (ib, &flag, sizeof (flag));
- if (flag)
- {
- size_t length;
- char *string;
-
- input_data_block (ib, &length, sizeof (length));
- string = (char *) xcalloc (1, length + 1);
- input_data_block (ib, string, length);
-
- return string;
- }
- else
- return NULL;
-}
-
-/* Return true if this option is one we need to save in LTO output files.
- At present, we pass along all target options, and common options that
- involve position independent code.
-
- TODO This list of options requires expansion and rationalization.
- Among others, optimization options may well be appropriate here. */
-
-static bool
-register_user_option_p (size_t code, int type)
-{
- if (type == CL_TARGET)
- return true;
- else if (type == CL_COMMON)
- {
- return (code == OPT_fPIC
- || code == OPT_fpic
- || code == OPT_fPIE
- || code == OPT_fpie
- || code == OPT_fcommon
- || code == OPT_fexceptions);
- }
-
- return false;
-}
-
-/* Note command line option with the given TYPE and CODE, ARG, and VALUE.
- If relevant to LTO, save it in the user options vector. */
-
-void
-lto_register_user_option (size_t code, const char *arg, int value, int type)
-{
- if (register_user_option_p (code, type))
- {
- opt_t o;
-
- o.type = type;
- o.code = code;
- if (arg != NULL)
- {
- o.arg = (char *) xmalloc (strlen (arg) + 1);
- strcpy (o.arg, arg);
- }
- else
- o.arg = NULL;
- o.value = value;
- VEC_safe_push (opt_t, heap, user_options, &o);
- }
-}
-
-/* Empty the saved user options vector. */
-
-void
-lto_clear_user_options (void)
-{
- clear_options (&user_options);
-}
-
-/* Empty the saved file options vector. */
-
-void
-lto_clear_file_options (void)
-{
- clear_options (&file_options);
-}
-
-/* Concatenate the user options and any file options read from an LTO IL
- file, and serialize them to STREAM. File options precede user options
- so that the latter override the former when reissued. */
+/* Append the option piece OPT to the COLLECT_GCC_OPTIONS string
+ set up by OB, appropriately quoted and separated by spaces
+ (if !*FIRST_P). */
static void
-output_options (struct lto_output_stream *stream)
-{
- VEC(opt_t, heap) *opts = concatenate_options (file_options, user_options);
- const size_t length = VEC_length (opt_t, opts);
- int i;
- opt_t *o;
-
- output_data_stream (stream, &length, sizeof (length));
-
- FOR_EACH_VEC_ELT (opt_t, opts, i, o)
+append_to_collect_gcc_options (struct obstack *ob,
+ bool *first_p, const char *opt)
+{
+ const char *p, *q = opt;
+ if (!*first_p)
+ obstack_grow (ob, " ", 1);
+ obstack_grow (ob, "'", 1);
+ while ((p = strchr (q, '\'')))
{
- output_data_stream (stream, &o->type, sizeof (o->type));
- output_data_stream (stream, &o->code, sizeof (o->code));
- output_string_stream (stream, o->arg);
- output_data_stream (stream, &o->value, sizeof (o->value));
+ obstack_grow (ob, q, p - q);
+ obstack_grow (ob, "'\\''", 4);
+ q = ++p;
}
-
- VEC_free (opt_t, heap, opts);
+ obstack_grow (ob, q, strlen (q));
+ obstack_grow (ob, "'", 1);
+ *first_p = false;
}
/* Write currently held options to an LTO IL section. */
void
lto_write_options (void)
{
- char *const section_name = lto_get_section_name (LTO_section_opts, NULL, NULL);
- struct lto_output_stream stream;
- struct lto_simple_header header;
- struct lto_output_stream *header_stream;
-
- lto_begin_section (section_name, !flag_wpa);
- free (section_name);
-
- memset (&stream, 0, sizeof (stream));
- output_options (&stream);
-
- memset (&header, 0, sizeof (header));
- header.lto_header.major_version = LTO_major_version;
- header.lto_header.minor_version = LTO_minor_version;
- header.lto_header.section_type = LTO_section_opts;
-
- header.compressed_size = 0;
- header.main_size = stream.total_size;
-
- header_stream = ((struct lto_output_stream *)
- xcalloc (1, sizeof (*header_stream)));
- lto_output_data_stream (header_stream, &header, sizeof (header));
- lto_write_stream (header_stream);
- free (header_stream);
-
- lto_write_stream (&stream);
- lto_end_section ();
-}
-
-/* Unserialize an options vector from IB, and append to file_options. */
-
-static void
-input_options (struct lto_input_block *ib)
-{
- size_t length, i;
-
- input_data_block (ib, &length, sizeof (length));
-
- for (i = 0; i < length; i++)
+ char *section_name;
+ struct obstack temporary_obstack;
+ unsigned int i, j;
+ char *args;
+ bool first_p = true;
+
+ section_name = lto_get_section_name (LTO_section_opts, NULL, NULL);
+ lto_begin_section (section_name, false);
+
+ obstack_init (&temporary_obstack);
+
+ /* Output options that affect GIMPLE IL semantics and are implicitly
+ enabled by the frontend.
+ This for now includes an explicit set of options that we also handle
+ explicitly in lto-wrapper.c. In the end the effects on GIMPLE IL
+ semantics should be explicitely encoded in the IL or saved per
+ function rather than per compilation unit. */
+ /* -fexceptions causes the EH machinery to be initialized, enabling
+ generation of unwind data so that explicit throw() calls work. */
+ if (!global_options_set.x_flag_exceptions
+ && global_options.x_flag_exceptions)
+ append_to_collect_gcc_options (&temporary_obstack, &first_p,
+ "-fexceptions");
+ /* -fnon-call-exceptions changes the generation of exception
+ regions. It is enabled implicitly by the Go frontend. */
+ if (!global_options_set.x_flag_non_call_exceptions
+ && global_options.x_flag_non_call_exceptions)
+ append_to_collect_gcc_options (&temporary_obstack, &first_p,
+ "-fnon-call-exceptions");
+ /* The default -ffp-contract changes depending on the language
+ standard. Pass thru conservative standard settings. */
+ if (!global_options_set.x_flag_fp_contract_mode)
+ switch (global_options.x_flag_fp_contract_mode)
+ {
+ case FP_CONTRACT_OFF:
+ append_to_collect_gcc_options (&temporary_obstack, &first_p,
+ "-ffp-contract=off");
+ break;
+ case FP_CONTRACT_ON:
+ append_to_collect_gcc_options (&temporary_obstack, &first_p,
+ "-ffp-contract=on");
+ break;
+ case FP_CONTRACT_FAST:
+ /* Nothing. That merges conservatively and is the default for LTO. */
+ break;
+ default:
+ gcc_unreachable ();
+ }
+ /* The default -fmath-errno, -fsigned-zeros and -ftrapping-math change
+ depending on the language (they can be disabled by the Ada and Java
+ front-ends). Pass thru conservative standard settings. */
+ if (!global_options_set.x_flag_errno_math)
+ append_to_collect_gcc_options (&temporary_obstack, &first_p,
+ global_options.x_flag_errno_math
+ ? "-fmath-errno"
+ : "-fno-math-errno");
+ if (!global_options_set.x_flag_signed_zeros)
+ append_to_collect_gcc_options (&temporary_obstack, &first_p,
+ global_options.x_flag_signed_zeros
+ ? "-fsigned-zeros"
+ : "-fno-signed-zeros");
+ if (!global_options_set.x_flag_trapping_math)
+ append_to_collect_gcc_options (&temporary_obstack, &first_p,
+ global_options.x_flag_trapping_math
+ ? "-ftrapping-math"
+ : "-fno-trapping-math");
+ /* We need to merge -f[no-]strict-overflow, -f[no-]wrapv and -f[no-]trapv
+ conservatively, so stream out their defaults. */
+ if (!global_options_set.x_flag_wrapv
+ && global_options.x_flag_wrapv)
+ append_to_collect_gcc_options (&temporary_obstack, &first_p, "-fwrapv");
+ if (!global_options_set.x_flag_trapv
+ && !global_options.x_flag_trapv)
+ append_to_collect_gcc_options (&temporary_obstack, &first_p, "-fno-trapv");
+ if (!global_options_set.x_flag_strict_overflow
+ && !global_options.x_flag_strict_overflow)
+ append_to_collect_gcc_options (&temporary_obstack, &first_p,
+ "-fno-strict-overflow");
+
+ /* Append options from target hook and store them to offload_lto section. */
+ if (strcmp (section_name_prefix, OFFLOAD_SECTION_NAME_PREFIX) == 0)
{
- opt_t o;
-
- input_data_block (ib, &o.type, sizeof (o.type));
- input_data_block (ib, &o.code, sizeof (o.code));
- o.arg = input_string_block (ib);
- input_data_block (ib, &o.value, sizeof (o.value));
- VEC_safe_push (opt_t, heap, file_options, &o);
+ char *offload_opts = targetm.offload_options ();
+ char *offload_ptr = offload_opts;
+ while (offload_ptr)
+ {
+ char *next = strchr (offload_ptr, ' ');
+ if (next)
+ *next++ = '\0';
+ append_to_collect_gcc_options (&temporary_obstack, &first_p,
+ offload_ptr);
+ offload_ptr = next;
+ }
+ free (offload_opts);
}
-}
-/* Read options from an LTO IL section. */
-
-void
-lto_read_file_options (struct lto_file_decl_data *file_data)
-{
- size_t len, l, skip;
- const char *data, *p;
- const struct lto_simple_header *header;
- int32_t opts_offset;
- struct lto_input_block ib;
-
- data = lto_get_section_data (file_data, LTO_section_opts, NULL, &len);
- if (!data)
- return;
-
- /* Option could be multiple sections merged (through ld -r)
- Keep reading all options. This is ok right now because
- the options just get mashed together anyways.
- This will have to be done differently once lto-opts knows
- how to associate options with different files. */
- l = len;
- p = data;
- do
- {
- header = (const struct lto_simple_header *) p;
- opts_offset = sizeof (*header);
-
- lto_check_version (header->lto_header.major_version,
- header->lto_header.minor_version);
-
- LTO_INIT_INPUT_BLOCK (ib, p + opts_offset, 0, header->main_size);
- input_options (&ib);
-
- skip = header->main_size + opts_offset;
- l -= skip;
- p += skip;
- }
- while (l > 0);
-
- lto_free_section_data (file_data, LTO_section_opts, 0, data, len);
-}
-
-/* Concatenate the user options and any file options read from an LTO IL
- file, and reissue them as if all had just been read in from the command
- line. As with serialization, file options precede user options. */
-
-void
-lto_reissue_options (void)
-{
- VEC(opt_t, heap) *opts = concatenate_options (file_options, user_options);
- int i;
- opt_t *o;
-
- FOR_EACH_VEC_ELT (opt_t, opts, i, o)
+ /* Output explicitly passed options. */
+ for (i = 1; i < save_decoded_options_count; ++i)
{
- void *flag_var = option_flag_var (o->code, &global_options);
-
- if (flag_var)
- set_option (&global_options, o->code, o->value, o->arg,
- 0 /*DK_UNSPECIFIED*/);
-
- if (o->type == CL_TARGET)
- targetm.handle_option (o->code, o->arg, o->value);
- else if (o->type == CL_COMMON)
- gcc_assert (flag_var);
- else
- gcc_unreachable ();
+ struct cl_decoded_option *option = &save_decoded_options[i];
+
+ /* Skip explicitly some common options that we do not need. */
+ switch (option->opt_index)
+ {
+ case OPT_dumpbase:
+ case OPT_SPECIAL_unknown:
+ case OPT_SPECIAL_ignore:
+ case OPT_SPECIAL_program_name:
+ case OPT_SPECIAL_input_file:
+ continue;
+
+ default:
+ break;
+ }
+
+ /* Skip frontend and driver specific options here. */
+ if (!(cl_options[option->opt_index].flags & (CL_COMMON|CL_TARGET|CL_LTO)))
+ continue;
+
+ /* Do not store target-specific options in offload_lto section. */
+ if ((cl_options[option->opt_index].flags & CL_TARGET)
+ && strcmp (section_name_prefix, OFFLOAD_SECTION_NAME_PREFIX) == 0)
+ continue;
+
+ /* Drop options created from the gcc driver that will be rejected
+ when passed on to the driver again. */
+ if (cl_options[option->opt_index].cl_reject_driver)
+ continue;
+
+ /* Also drop all options that are handled by the driver as well,
+ which includes things like -o and -v or -fhelp for example.
+ We do not need those. The only exception is -foffload option, if we
+ write it in offload_lto section. Also drop all diagnostic options. */
+ if ((cl_options[option->opt_index].flags & (CL_DRIVER|CL_WARNING))
+ && (strcmp (section_name_prefix, OFFLOAD_SECTION_NAME_PREFIX) != 0
+ || option->opt_index != OPT_foffload_))
+ continue;
+
+ for (j = 0; j < option->canonical_option_num_elements; ++j)
+ append_to_collect_gcc_options (&temporary_obstack, &first_p,
+ option->canonical_option[j]);
}
+ obstack_grow (&temporary_obstack, "\0", 1);
+ args = XOBFINISH (&temporary_obstack, char *);
+ lto_write_data (args, strlen (args) + 1);
+ lto_end_section ();
- VEC_free (opt_t, heap, opts);
+ obstack_free (&temporary_obstack, NULL);
+ free (section_name);
}
projects / thirdparty / gcc.git / blobdiff