Common Var(flag_non_call_exceptions) Optimization
Support synchronous non-call exceptions.
+; -foffload=<targets> is documented
+; -foffload=<targets>=<options> is supported for backward compatibility
foffload=
-Common Driver Joined MissingArgError(options or targets missing after %qs)
--foffload=<targets>=<options> Specify offloading targets and options for them.
+Driver Joined MissingArgError(targets missing after %qs)
+-foffload=<targets> Specify offloading targets
+
+foffload-options=
+Common Driver Joined MissingArgError(options or targets=options missing after %qs)
+-foffload=<targets>=<options> Specify options for the offloading targets
foffload-abi=
Common Joined RejectNegative Enum(offload_abi) Var(flag_offload_abi) Init(OFFLOAD_ABI_UNSET)
-fno-builtin -fno-builtin-@var{function} -fcond-mismatch @gol
-ffreestanding -fgimple -fgnu-tm -fgnu89-inline -fhosted @gol
-flax-vector-conversions -fms-extensions @gol
+-foffload=@var{arg} -foffload-options=@var{arg} @gol
-fopenacc -fopenacc-dim=@var{geom} @gol
-fopenmp -fopenmp-simd @gol
-fpermitted-flt-eval-methods=@var{standard} @gol
Note that this option is off for all targets except for x86
targets using ms-abi.
+@item -foffload=disable
+@itemx -foffload=default
+@itemx -foffload=@var{target-list}
+@opindex foffload
+@cindex Offloading targets
+@cindex OpenACC offloading targets
+@cindex OpenMP offloading targets
+Specify for which OpenMP and OpenACC offload targets code should be generated.
+The default behavior, equivalent to @option{-foffload=default}, is to generate
+code for all supported offload targets. The @option{-foffload=disable} form
+generates code only for the host fallback, while
+@option{-foffload=@var{target-list}} generates code only for the specified
+comma-separated list of offload targets.
+
+Offload targets are specified in GCC's internal target-triplet format. You can
+run the compiler with @option{-v} to show the list of configured offload targets
+under @code{OFFLOAD_TARGET_NAMES}.
+
+@item -foffload-options=@var{options}
+@itemx -foffload-options=@var{target-triplet-list}=@var{options}
+@opindex foffload
+@cindex Offloading options
+@cindex OpenACC offloading options
+@cindex OpenMP offloading options
+
+With @option{-foffload-options=@var{options}}, GCC passes the specified
+@var{options} to the compilers for all enabled offloading targets. You can
+specify options that apply only to a specific target or targets by using
+the @option{-foffload-options=@var{target-list}=@var{options}} form. The
+@var{target-list} is a comma-separated list in the same format as for the
+@option{-foffload=} option.
+
+Typical command lines are
+
+@smallexample
+-foffload-options=-lgfortran -foffload-options=-lm
+-foffload-options="-lgfortran -lm" -foffload-options=nvptx-none=-latomic
+-foffload-options=amdgcn-amdhsa=-march=gfx906 -foffload-options=-lm
+@end smallexample
+
@item -fopenacc
@opindex fopenacc
@cindex OpenACC accelerator programming
static const char *spec_lang = 0;
static int last_language_n_infiles;
+
+/* Check that GCC is configured to support the offload target. */
+
+static bool
+check_offload_target_name (const char *target, ptrdiff_t len)
+{
+ const char *n, *c = OFFLOAD_TARGETS;
+ while (c)
+ {
+ n = strchr (c, ',');
+ if (n == NULL)
+ n = strchr (c, '\0');
+ if (len == n - c && strncmp (target, c, n - c) == 0)
+ break;
+ c = *n ? n + 1 : NULL;
+ }
+ if (!c)
+ {
+ char *s;
+ auto_vec<const char*> candidates;
+ char *cand = (char *) alloca (strlen (OFFLOAD_TARGETS) + 1);
+ c = OFFLOAD_TARGETS;
+ while (c)
+ {
+ n = strchr (c, ',');
+ if (n == NULL)
+ n = strchr (c, '\0');
+ strncpy (cand, c, n - c);
+ cand[n - c] = '\0';
+ candidates.safe_push (cand);
+ c = *n ? n + 1 : NULL;
+ }
+ error ("GCC is not configured to support %q.*s as offload target",
+ len, target);
+ const char *hint = candidates_list_and_hint (target, s, candidates);
+ if (hint)
+ inform (UNKNOWN_LOCATION,
+ "valid offload targets are: %s; did you mean %qs?", s, hint);
+ else
+ inform (UNKNOWN_LOCATION, "valid offload targets are: %s", s);
+ XDELETEVEC (s);
+ return false;
+ }
+ return true;
+}
+
+/* Sanity check for -foffload-options. */
+
+static void
+check_foffload_target_names (const char *arg)
+{
+ const char *cur, *next, *end;
+ /* If option argument starts with '-' then no target is specified and we
+ do not need to parse it. */
+ if (arg[0] == '-')
+ return;
+ end = strchr (arg, '=');
+ if (end == NULL)
+ {
+ error ("%<=%>options missing after %<-foffload-options=%>target");
+ return;
+ }
+
+ cur = arg;
+ while (cur < end)
+ {
+ next = strchr (cur, ',');
+ if (next == NULL)
+ next = end;
+ next = (next > end) ? end : next;
+
+ /* Retain non-supported targets after printing an error as those will not
+ be processed; each enabled target only processes its triplet. */
+ check_offload_target_name (cur, next - cur);
+ cur = next + 1;
+ }
+}
+
/* Parse -foffload option argument. */
static void
memcpy (target, cur, next - cur);
target[next - cur] = '\0';
- /* If 'disable' is passed to the option, stop parsing the option and clean
- the list of offload targets. */
- if (strcmp (target, "disable") == 0)
+ /* Reset offloading list and continue. */
+ if (strcmp (target, "default") == 0)
{
free (offload_targets);
- offload_targets = xstrdup ("");
- break;
+ offload_targets = NULL;
+ goto next_item;
}
- /* Check that GCC is configured to support the offload target. */
- c = OFFLOAD_TARGETS;
- while (c)
+ /* If 'disable' is passed to the option, clean the list of
+ offload targets and return, even if more targets follow.
+ Likewise if GCC is not configured to support that offload target. */
+ if (strcmp (target, "disable") == 0
+ || !check_offload_target_name (target, next - cur))
{
- n = strchr (c, ',');
- if (n == NULL)
- n = strchr (c, '\0');
-
- if (next - cur == n - c && strncmp (target, c, n - c) == 0)
- break;
-
- c = *n ? n + 1 : NULL;
+ free (offload_targets);
+ offload_targets = xstrdup ("");
+ return;
}
- if (!c)
- fatal_error (input_location,
- "GCC is not configured to support %s as offload target",
- target);
-
if (!offload_targets)
{
offload_targets = target;
memcpy (offload_targets + offload_targets_len, target, next - cur + 1);
}
}
-
+next_item:
cur = next + 1;
XDELETEVEC (target);
}
flag_wpa = "";
break;
+ case OPT_foffload_options_:
+ check_foffload_target_names (arg);
+ break;
+
case OPT_foffload_:
handle_foffload_option (arg);
+ if (arg[0] == '-' || NULL != strchr (arg, '='))
+ save_switch (concat ("-foffload-options=", arg, NULL),
+ 0, NULL, validated, true);
+ do_save = false;
break;
default:
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))
- && (!lto_stream_offload_p || option->opt_index != OPT_foffload_))
+ && (!lto_stream_offload_p
+ || option->opt_index != OPT_foffload_options_))
continue;
for (j = 0; j < option->canonical_option_num_elements; ++j)
break;
- case OPT_foffload_:
+ case OPT_foffload_options_:
decoded_options.safe_push (*foption);
break;
unsigned argc;
cl_decoded_option *option = &options[i];
- if (option->opt_index != OPT_foffload_)
+ if (option->opt_index != OPT_foffload_options_)
continue;
/* If option argument starts with '-' then no target is specified. That
else
{
opts = strchr (option->arg, '=');
- /* If there are offload targets specified, but no actual options,
- there is nothing to do here. */
- if (!opts)
- continue;
-
+ gcc_assert (opts);
cur = option->arg;
while (cur < opts)
/* Deferred. */
break;
- case OPT_foffload_:
+ case OPT_foffload_options_:
/* Deferred. */
break;
/* { dg-do run } */
-/* { dg-additional-options "-foffload=nvptx-none=-latomic" { target offload_target_nvptx } } */
+/* { dg-additional-options "-foffload-options=nvptx-none=-latomic" { target offload_target_nvptx } } */
#include <stdlib.h>
-/* { dg-additional-options "-foffload=nvptx-none=-latomic" { target { offload_target_nvptx } } } */
+/* { dg-additional-options "-foffload-options=nvptx-none=-latomic" { target { offload_target_nvptx } } } */
/* C / C++'s logical AND and OR operators take any scalar argument
which compares (un)equal to 0 - the result 1 or 0 and of type int.
-/* { dg-additional-options "-foffload=nvptx-none=-latomic" { target { offload_target_nvptx } } } */
+/* { dg-additional-options "-foffload-options=nvptx-none=-latomic" { target { offload_target_nvptx } } } */
/* C / C++'s logical AND and OR operators take any scalar argument
which compares (un)equal to 0 - the result 1 or 0 and of type int.
-/* { dg-additional-options "-foffload=nvptx-none=-latomic" { target { offload_target_nvptx } } } */
+/* { dg-additional-options "-foffload-options=nvptx-none=-latomic" { target { offload_target_nvptx } } } */
#include <stdlib.h>
projects / platform / upstream / gcc.git / commitdiff