libjava/classpath/lib/java/util/AbstractMap$SimpleEntry.class

/* Wrapper to call lto.  Used by collect2 and the linker plugin.
   Copyright (C) 2009-2021 Free Software Foundation, Inc.

   Factored out of collect2 by Rafael Espindola <espindola@google.com>

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.  */


/* This program is passed a gcc, a list of gcc arguments and a list of
   object files containing IL. It scans the argument list to check if
   we are in whopr mode or not modifies the arguments and needed and
   prints a list of output files on stdout.

   Example:

   $ lto-wrapper gcc/xgcc -B gcc a.o b.o -o test -flto

   The above will print something like
   /tmp/ccwbQ8B2.lto.o

   If WHOPR is used instead, more than one file might be produced
   ./ccXj2DTk.lto.ltrans.o
   ./ccCJuXGv.lto.ltrans.o
*/

#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "intl.h"
#include "diagnostic.h"
#include "obstack.h"
#include "opts.h"
#include "options.h"
#include "simple-object.h"
#include "lto-section-names.h"
#include "collect-utils.h"
#include "opts-diagnostic.h"

/* Environment variable, used for passing the names of offload targets from GCC
   driver to lto-wrapper.  */
#define OFFLOAD_TARGET_NAMES_ENV	"OFFLOAD_TARGET_NAMES"
#define OFFLOAD_TARGET_DEFAULT_ENV	"OFFLOAD_TARGET_DEFAULT"

/* By default there is no special suffix for target executables.  */
#ifdef TARGET_EXECUTABLE_SUFFIX
#define HAVE_TARGET_EXECUTABLE_SUFFIX
#else
#define TARGET_EXECUTABLE_SUFFIX ""
#endif

enum lto_mode_d {
  LTO_MODE_NONE,			/* Not doing LTO.  */
  LTO_MODE_LTO,				/* Normal LTO.  */
  LTO_MODE_WHOPR			/* WHOPR.  */
};

/* Current LTO mode.  */
static enum lto_mode_d lto_mode = LTO_MODE_NONE;

static char *ltrans_output_file;
static char *flto_out;
static unsigned int nr;
static int *ltrans_priorities;
static char **input_names;
static char **output_names;
static char **offload_names;
static char *offload_objects_file_name;
static char *makefile;
static unsigned int num_deb_objs;
static const char **early_debug_object_names;
static bool xassembler_options_error = false;

const char tool_name[] = "lto-wrapper";

/* Delete tempfiles.  Called from utils_cleanup.  */

void
tool_cleanup (bool)
{
  unsigned int i;

  if (ltrans_output_file)
    maybe_unlink (ltrans_output_file);
  if (flto_out)
    maybe_unlink (flto_out);
  if (offload_objects_file_name)
    maybe_unlink (offload_objects_file_name);
  if (makefile)
    maybe_unlink (makefile);
  if (early_debug_object_names)
    for (i = 0; i < num_deb_objs; ++i)
      if (early_debug_object_names[i])
	maybe_unlink (early_debug_object_names[i]);
  for (i = 0; i < nr; ++i)
    {
      maybe_unlink (input_names[i]);
      if (output_names[i])
	maybe_unlink (output_names[i]);
    }
}

static void
lto_wrapper_cleanup (void)
{
  utils_cleanup (false);
}

/* Unlink a temporary LTRANS file unless requested otherwise.  */

void
maybe_unlink (const char *file)
{
  if (!save_temps)
    {
      if (unlink_if_ordinary (file)
	  && errno != ENOENT)
	fatal_error (input_location, "deleting LTRANS file %s: %m", file);
    }
  else if (verbose)
    fprintf (stderr, "[Leaving LTRANS %s]\n", file);
}

/* Template of LTRANS dumpbase suffix.  */
#define DUMPBASE_SUFFIX "ltrans18446744073709551615"

/* Create decoded options from the COLLECT_GCC and COLLECT_GCC_OPTIONS
   environment.  */

static vec<cl_decoded_option>
get_options_from_collect_gcc_options (const char *collect_gcc,
				      const char *collect_gcc_options)
{
  cl_decoded_option *decoded_options;
  unsigned int decoded_options_count;
  struct obstack argv_obstack;
  const char **argv;
  int argc;

  obstack_init (&argv_obstack);
  obstack_ptr_grow (&argv_obstack, collect_gcc);

  parse_options_from_collect_gcc_options (collect_gcc_options,
					  &argv_obstack, &argc);
  argv = XOBFINISH (&argv_obstack, const char **);

  decode_cmdline_options_to_array (argc, (const char **)argv, CL_DRIVER,
				   &decoded_options, &decoded_options_count);
  vec<cl_decoded_option> decoded;
  decoded.create (decoded_options_count);
  for (unsigned i = 0; i < decoded_options_count; ++i)
    decoded.quick_push (decoded_options[i]);
  free (decoded_options);

  obstack_free (&argv_obstack, NULL);

  return decoded;
}

/* Find option in OPTIONS based on OPT_INDEX.  -1 value is returned
   if the option is not present.  */

static int
find_option (vec<cl_decoded_option> &options, size_t opt_index)
{
  for (unsigned i = 0; i < options.length (); ++i)
    if (options[i].opt_index == opt_index)
      return i;

  return -1;
}

static int
find_option (vec<cl_decoded_option> &options, cl_decoded_option *option)
{
  return find_option (options, option->opt_index);
}

/* Merge -flto FOPTION into vector of DECODED_OPTIONS.  */

static void
merge_flto_options (vec<cl_decoded_option> &decoded_options,
		    cl_decoded_option *foption)
{
  int existing_opt = find_option (decoded_options, foption);
  if (existing_opt == -1)
    decoded_options.safe_push (*foption);
  else
    {
      if (strcmp (foption->arg, decoded_options[existing_opt].arg) != 0)
	{
	  /* -flto=auto is preferred.  */
	  if (strcmp (decoded_options[existing_opt].arg, "auto") == 0)
	    ;
	  else if (strcmp (foption->arg, "auto") == 0
		   || strcmp (foption->arg, "jobserver") == 0)
	    decoded_options[existing_opt].arg = foption->arg;
	  else if (strcmp (decoded_options[existing_opt].arg,
			   "jobserver") != 0)
	    {
	      int n = atoi (foption->arg);
	      int original_n = atoi (decoded_options[existing_opt].arg);
	      if (n > original_n)
		decoded_options[existing_opt].arg = foption->arg;
	    }
	}
    }
}

/* Try to merge and complain about options FDECODED_OPTIONS when applied
   ontop of DECODED_OPTIONS.  */

static void
merge_and_complain (vec<cl_decoded_option> decoded_options,
		    vec<cl_decoded_option> fdecoded_options,
		    vec<cl_decoded_option> decoded_cl_options)
{
  unsigned int i, j;
  cl_decoded_option *pic_option = NULL;
  cl_decoded_option *pie_option = NULL;
  cl_decoded_option *cf_protection_option = NULL;

  /* ???  Merge options from files.  Most cases can be
     handled by either unioning or intersecting
     (for example -fwrapv is a case for unioning,
     -ffast-math is for intersection).  Most complaints
     about real conflicts between different options can
     be deferred to the compiler proper.  Options that
     we can neither safely handle by intersection nor
     unioning would need to be complained about here.
     Ideally we'd have a flag in the opt files that
     tells whether to union or intersect or reject.
     In absence of that it's unclear what a good default is.
     It's also difficult to get positional handling correct.  */

  /* Look for a -fcf-protection option in the link-time options
     which overrides any -fcf-protection from the lto sections.  */
  for (i = 0; i < decoded_cl_options.length (); ++i)
    {
      cl_decoded_option *foption = &decoded_cl_options[i];
      if (foption->opt_index == OPT_fcf_protection_)
	{
	  cf_protection_option = foption;
	}
    }
  
  /* The following does what the old LTO option code did,
     union all target and a selected set of common options.  */
  for (i = 0; i < fdecoded_options.length (); ++i)
    {
      cl_decoded_option *foption = &fdecoded_options[i];
      int existing_opt = find_option (decoded_options, foption);
      switch (foption->opt_index)
	{
	case OPT_SPECIAL_unknown:
	case OPT_SPECIAL_ignore:
	case OPT_SPECIAL_warn_removed:
	case OPT_SPECIAL_program_name:
	case OPT_SPECIAL_input_file:
	  break;

	default:
	  if (!(cl_options[foption->opt_index].flags & CL_TARGET))
	    break;

	  /* Fallthru.  */
	case OPT_fdiagnostics_show_caret:
	case OPT_fdiagnostics_show_labels:
	case OPT_fdiagnostics_show_line_numbers:
	case OPT_fdiagnostics_show_option:
	case OPT_fdiagnostics_show_location_:
	case OPT_fshow_column:
	case OPT_fcommon:
	case OPT_fgnu_tm:
	case OPT_g:
	  /* Do what the old LTO code did - collect exactly one option
	     setting per OPT code, we pick the first we encounter.
	     ???  This doesn't make too much sense, but when it doesn't
	     then we should complain.  */
	  if (existing_opt == -1)
	    decoded_options.safe_push (*foption);
	  break;

	/* Figure out what PIC/PIE level wins and merge the results.  */
	case OPT_fPIC:
	case OPT_fpic:
	  pic_option = foption;
	  break;
	case OPT_fPIE:
	case OPT_fpie:
	  pie_option = foption;
	  break;

	case OPT_fopenmp:
	case OPT_fopenacc:
	  /* For selected options we can merge conservatively.  */
	  if (existing_opt == -1)
	    decoded_options.safe_push (*foption);
	  /* -fopenmp > -fno-openmp,
	     -fopenacc > -fno-openacc  */
	  else if (foption->value > decoded_options[existing_opt].value)
	    decoded_options[existing_opt] = *foption;
	  break;

	case OPT_fopenacc_dim_:
	  /* Append or check identical.  */
	  if (existing_opt == -1)
	    decoded_options.safe_push (*foption);
	  else if (strcmp (decoded_options[existing_opt].arg, foption->arg))
	    fatal_error (input_location,
			 "option %s with different values",
			 foption->orig_option_with_args_text);
	  break;

	case OPT_fcf_protection_:
	  /* Default to link-time option, else append or check identical.  */
	  if (!cf_protection_option
	      || cf_protection_option->value == CF_CHECK)
	    {
	      if (existing_opt == -1)
		decoded_options.safe_push (*foption);
	      else if (decoded_options[existing_opt].value != foption->value)
		{
		  if (cf_protection_option
		      && cf_protection_option->value == CF_CHECK)
		    fatal_error (input_location,
				 "option %qs with mismatching values"
				 " (%s, %s)",
				 "-fcf-protection",
				 decoded_options[existing_opt].arg,
				 foption->arg);
		  else
		    {
		      /* Merge and update the -fcf-protection option.  */
		      decoded_options[existing_opt].value
			&= (foption->value & CF_FULL);
		      switch (decoded_options[existing_opt].value)
			{
			case CF_NONE:
			  decoded_options[existing_opt].arg = "none";
			  break;
			case CF_BRANCH:
			  decoded_options[existing_opt].arg = "branch";
			  break;
			case CF_RETURN:
			  decoded_options[existing_opt].arg = "return";
			  break;
			default:
			  gcc_unreachable ();
			}
		    }
		}
	    }
	  break;

	case OPT_O:
	case OPT_Ofast:
	case OPT_Og:
	case OPT_Os:
	  existing_opt = -1;
	  for (j = 0; j < decoded_options.length (); ++j)
	    if (decoded_options[j].opt_index == OPT_O
		|| decoded_options[j].opt_index == OPT_Ofast
		|| decoded_options[j].opt_index == OPT_Og
		|| decoded_options[j].opt_index == OPT_Os)
	      {
		existing_opt = j;
		break;
	      }
	  if (existing_opt == -1)
	    decoded_options.safe_push (*foption);
	  else if (decoded_options[existing_opt].opt_index == foption->opt_index
		   && foption->opt_index != OPT_O)
	    /* Exact same options get merged.  */
	    ;
	  else
	    {
	      /* For mismatched option kinds preserve the optimization
	         level only, thus merge it as -On.  This also handles
		 merging of same optimization level -On.  */
	      int level = 0;
	      switch (foption->opt_index)
		{
		case OPT_O:
		  if (foption->arg[0] == '\0')
		    level = MAX (level, 1);
		  else
		    level = MAX (level, atoi (foption->arg));
		  break;
		case OPT_Ofast:
		  level = MAX (level, 3);
		  break;
		case OPT_Og:
		  level = MAX (level, 1);
		  break;
		case OPT_Os:
		  level = MAX (level, 2);
		  break;
		default:
		  gcc_unreachable ();
		}
	      switch (decoded_options[existing_opt].opt_index)
		{
		case OPT_O:
		  if (decoded_options[existing_opt].arg[0] == '\0')
		    level = MAX (level, 1);
		  else
		    level = MAX (level,
				 atoi (decoded_options[existing_opt].arg));
		  break;
		case OPT_Ofast:
		  level = MAX (level, 3);
		  break;
		case OPT_Og:
		  level = MAX (level, 1);
		  break;
		case OPT_Os:
		  level = MAX (level, 2);
		  break;
		default:
		  gcc_unreachable ();
		}
	      decoded_options[existing_opt].opt_index = OPT_O;
	      char *tem;
	      tem = xasprintf ("-O%d", level);
	      decoded_options[existing_opt].arg = &tem[2];
	      decoded_options[existing_opt].canonical_option[0] = tem;
	      decoded_options[existing_opt].value = 1;
	    }
	  break;
 

	case OPT_foffload_abi_:
	  if (existing_opt == -1)
	    decoded_options.safe_push (*foption);
	  else if (foption->value != decoded_options[existing_opt].value)
	    fatal_error (input_location,
			 "option %s not used consistently in all LTO input"
			 " files", foption->orig_option_with_args_text);
	  break;


	case OPT_foffload_options_:
	  decoded_options.safe_push (*foption);
	  break;

	case OPT_flto_:
	  merge_flto_options (decoded_options, foption);
	  break;
	}
    }

  /* Merge PIC options:
      -fPIC + -fpic = -fpic
      -fPIC + -fno-pic = -fno-pic
      -fpic/-fPIC + nothing = nothing.
     It is a common mistake to mix few -fPIC compiled objects into otherwise
     non-PIC code.  We do not want to build everything with PIC then.

     Similarly we merge PIE options, however in addition we keep
      -fPIC + -fPIE = -fPIE
      -fpic + -fPIE = -fpie
      -fPIC/-fpic + -fpie = -fpie

     It would be good to warn on mismatches, but it is bit hard to do as
     we do not know what nothing translates to.  */
    
  for (unsigned int j = 0; j < decoded_options.length ();)
    if (decoded_options[j].opt_index == OPT_fPIC
	|| decoded_options[j].opt_index == OPT_fpic)
      {
	/* -fno-pic in one unit implies -fno-pic everywhere.  */
	if (decoded_options[j].value == 0)
	  j++;
	/* If we have no pic option or merge in -fno-pic, we still may turn
	   existing pic/PIC mode into pie/PIE if -fpie/-fPIE is present.  */
	else if ((pic_option && pic_option->value == 0)
		 || !pic_option)
	  {
	    if (pie_option)
	      {
		bool big = decoded_options[j].opt_index == OPT_fPIC
			   && pie_option->opt_index == OPT_fPIE;
		decoded_options[j].opt_index = big ? OPT_fPIE : OPT_fpie;
		if (pie_option->value)
		  decoded_options[j].canonical_option[0]
		    = big ? "-fPIE" : "-fpie";
		else
		  decoded_options[j].canonical_option[0] = "-fno-pie";
		decoded_options[j].value = pie_option->value;
		j++;
	      }
	    else if (pic_option)
	      {
		decoded_options[j] = *pic_option;
		j++;
	      }
	    /* We do not know if target defaults to pic or not, so just remove
	       option if it is missing in one unit but enabled in other.  */
	    else
	      decoded_options.ordered_remove (j);
	  }
	else if (pic_option->opt_index == OPT_fpic
		 && decoded_options[j].opt_index == OPT_fPIC)
	  {
	    decoded_options[j] = *pic_option;
	    j++;
	  }
	else
	  j++;
      }
   else if (decoded_options[j].opt_index == OPT_fPIE
	    || decoded_options[j].opt_index == OPT_fpie)
      {
	/* -fno-pie in one unit implies -fno-pie everywhere.  */
	if (decoded_options[j].value == 0)
	  j++;
	/* If we have no pie option or merge in -fno-pie, we still preserve
	   PIE/pie if pic/PIC is present.  */
	else if ((pie_option && pie_option->value == 0)
		 || !pie_option)
	  {
	    /* If -fPIC/-fpic is given, merge it with -fPIE/-fpie.  */
	    if (pic_option)
	      {
		if (pic_option->opt_index == OPT_fpic
		    && decoded_options[j].opt_index == OPT_fPIE)
		  {
		    decoded_options[j].opt_index = OPT_fpie;
		    decoded_options[j].canonical_option[0]
		      = pic_option->value ? "-fpie" : "-fno-pie";
		  }
		else if (!pic_option->value)
		  decoded_options[j].canonical_option[0] = "-fno-pie";
		decoded_options[j].value = pic_option->value;
		j++;
	      }
	    else if (pie_option)
	      {
		decoded_options[j] = *pie_option;
		j++;
	      }
	    /* Because we always append pic/PIE options this code path should
	       not happen unless the LTO object was built by old lto1 which
	       did not contain that logic yet.  */
	    else
	      decoded_options.ordered_remove (j);
	  }
	else if (pie_option->opt_index == OPT_fpie
		 && decoded_options[j].opt_index == OPT_fPIE)
	  {
	    decoded_options[j] = *pie_option;
	    j++;
	  }
	else
	  j++;
      }
   else
     j++;

  if (!xassembler_options_error)
    for (i = j = 0; ; i++, j++)
      {
	int existing_opt_index
	  = find_option (decoded_options, OPT_Xassembler);
	int existing_opt2_index
	  = find_option (fdecoded_options, OPT_Xassembler);

	cl_decoded_option *existing_opt = NULL;
	cl_decoded_option *existing_opt2 = NULL;
	if (existing_opt_index != -1)
	  existing_opt = &decoded_options[existing_opt_index];
	if (existing_opt2_index != -1)
	  existing_opt2 = &fdecoded_options[existing_opt2_index];

	if (existing_opt == NULL && existing_opt2 == NULL)
	  break;
	else if (existing_opt != NULL && existing_opt2 == NULL)
	  {
	    warning (0, "Extra option to %<-Xassembler%>: %s,"
		     " dropping all %<-Xassembler%> and %<-Wa%> options.",
		     existing_opt->arg);
	    xassembler_options_error = true;
	    break;
	  }
	else if (existing_opt == NULL && existing_opt2 != NULL)
	  {
	    warning (0, "Extra option to %<-Xassembler%>: %s,"
		     " dropping all %<-Xassembler%> and %<-Wa%> options.",
		     existing_opt2->arg);
	    xassembler_options_error = true;
	    break;
	  }
	else if (strcmp (existing_opt->arg, existing_opt2->arg) != 0)
	  {
	    warning (0, "Options to %<-Xassembler%> do not match: %s, %s,"
		     " dropping all %<-Xassembler%> and %<-Wa%> options.",
		     existing_opt->arg, existing_opt2->arg);
	    xassembler_options_error = true;
	    break;
	  }
      }
}

/* Auxiliary function that frees elements of PTR and PTR itself.
   N is number of elements to be freed.  If PTR is NULL, nothing is freed.
   If an element is NULL, subsequent elements are not freed.  */

static void **
free_array_of_ptrs (void **ptr, unsigned n)
{
  if (!ptr)
    return NULL;
  for (unsigned i = 0; i < n; i++)
    {
      if (!ptr[i])
	break;
      free (ptr[i]);
    }
  free (ptr);
  return NULL;
}

/* Parse STR, saving found tokens into PVALUES and return their number.
   Tokens are assumed to be delimited by ':'.  If APPEND is non-null,
   append it to every token we find.  */

static unsigned
parse_env_var (const char *str, char ***pvalues, const char *append)
{
  const char *curval, *nextval;
  char **values;
  unsigned num = 1, i;

  curval = strchr (str, ':');
  while (curval)
    {
      num++;
      curval = strchr (curval + 1, ':');
    }

  values = (char**) xmalloc (num * sizeof (char*));
  curval = str;
  nextval = strchr (curval, ':');
  if (nextval == NULL)
    nextval = strchr (curval, '\0');

  int append_len = append ? strlen (append) : 0;
  for (i = 0; i < num; i++)
    {
      int l = nextval - curval;
      values[i] = (char*) xmalloc (l + 1 + append_len);
      memcpy (values[i], curval, l);
      values[i][l] = 0;
      if (append)
	strcat (values[i], append);
      curval = nextval + 1;
      nextval = strchr (curval, ':');
      if (nextval == NULL)
	nextval = strchr (curval, '\0');
    }
  *pvalues = values;
  return num;
}

/* Append options OPTS from lto or offload_lto sections to ARGV_OBSTACK.  */

static void
append_compiler_options (obstack *argv_obstack, vec<cl_decoded_option> opts)
{
  /* Append compiler driver arguments as far as they were merged.  */
  for (unsigned int j = 1; j < opts.length (); ++j)
    {
      cl_decoded_option *option = &opts[j];

      /* File options have been properly filtered by lto-opts.c.  */
      switch (option->opt_index)
	{
	/* Drop arguments that we want to take from the link line.  */
	case OPT_flto_:
	case OPT_flto:
	case OPT_flto_partition_:
	  continue;

	default:
	  break;
	}

      /* For now do what the original LTO option code was doing - pass
	 on any CL_TARGET flag and a few selected others.  */
      switch (option->opt_index)
	{
	case OPT_fdiagnostics_show_caret:
	case OPT_fdiagnostics_show_labels:
	case OPT_fdiagnostics_show_line_numbers:
	case OPT_fdiagnostics_show_option:
	case OPT_fdiagnostics_show_location_:
	case OPT_fshow_column:
	case OPT_fPIC:
	case OPT_fpic:
	case OPT_fPIE:
	case OPT_fpie:
	case OPT_fcommon:
	case OPT_fgnu_tm:
	case OPT_fopenmp:
	case OPT_fopenacc:
	case OPT_fopenacc_dim_:
	case OPT_foffload_abi_:
	case OPT_fcf_protection_:
	case OPT_g:
	case OPT_O:
	case OPT_Ofast:
	case OPT_Og:
	case OPT_Os:
	  break;

	case OPT_Xassembler:
	  /* When we detected a mismatch in assembler options between
	     the input TU's fall back to previous behavior of ignoring them.  */
	  if (xassembler_options_error)
	    continue;
	  break;

	default:
	  if (!(cl_options[option->opt_index].flags & CL_TARGET))
	    continue;
	}

      /* Pass the option on.  */
      for (unsigned int i = 0; i < option->canonical_option_num_elements; ++i)
	obstack_ptr_grow (argv_obstack, option->canonical_option[i]);
    }
}

/* Append diag options in OPTS to ARGV_OBSTACK.  */

static void
append_diag_options (obstack *argv_obstack, vec<cl_decoded_option> opts)
{
  /* Append compiler driver arguments as far as they were merged.  */
  for (unsigned int j = 1; j < opts.length (); ++j)
    {
      cl_decoded_option *option = &opts[j];

      switch (option->opt_index)
	{
	case OPT_fdiagnostics_color_:
	case OPT_fdiagnostics_format_:
	case OPT_fdiagnostics_show_caret:
	case OPT_fdiagnostics_show_labels:
	case OPT_fdiagnostics_show_line_numbers:
	case OPT_fdiagnostics_show_option:
	case OPT_fdiagnostics_show_location_:
	case OPT_fshow_column:
	  break;
	default:
	  continue;
	}

      /* Pass the option on.  */
      for (unsigned int i = 0; i < option->canonical_option_num_elements; ++i)
	obstack_ptr_grow (argv_obstack, option->canonical_option[i]);
    }
}


/* Append linker options OPTS to ARGV_OBSTACK.  */

static void
append_linker_options (obstack *argv_obstack, vec<cl_decoded_option> opts)
{
  /* Append linker driver arguments.  Compiler options from the linker
     driver arguments will override / merge with those from the compiler.  */
  for (unsigned int j = 1; j < opts.length (); ++j)
    {
      cl_decoded_option *option = &opts[j];

      /* Do not pass on frontend specific flags not suitable for lto.  */
      if (!(cl_options[option->opt_index].flags
	    & (CL_COMMON|CL_TARGET|CL_DRIVER|CL_LTO)))
	continue;

      switch (option->opt_index)
	{
	case OPT_o:
	case OPT_flto_:
	case OPT_flto:
	  /* We've handled these LTO options, do not pass them on.  */
	  continue;

	case OPT_fopenmp:
	case OPT_fopenacc:
	  /* Ignore -fno-XXX form of these options, as otherwise
	     corresponding builtins will not be enabled.  */
	  if (option->value == 0)
	    continue;
	  break;

	default:
	  break;
	}

      /* Pass the option on.  */
      for (unsigned int i = 0; i < option->canonical_option_num_elements; ++i)
	obstack_ptr_grow (argv_obstack, option->canonical_option[i]);
    }
}

/* Extract options for TARGET offload compiler from OPTIONS and append
   them to ARGV_OBSTACK.  */

static void
append_offload_options (obstack *argv_obstack, const char *target,
			vec<cl_decoded_option> options)
{
  for (unsigned i = 0; i < options.length (); i++)
    {
      const char *cur, *next, *opts;
      char **argv;
      unsigned argc;
      cl_decoded_option *option = &options[i];

      if (option->opt_index != OPT_foffload_options_)
	continue;

      /* If option argument starts with '-' then no target is specified.  That
	 means offload options are specified for all targets, so we need to
	 append them.  */
      if (option->arg[0] == '-')
	opts = option->arg;
      else
	{
	  opts = strchr (option->arg, '=');
	  gcc_assert (opts);
	  cur = option->arg;

	  while (cur < opts)
	    {
	      next = strchr (cur, ',');
	      if (next == NULL)
		next = opts;
	      next = (next > opts) ? opts : next;

	      /* Are we looking for this offload target?  */
	      if (strlen (target) == (size_t) (next - cur)
		  && strncmp (target, cur, next - cur) == 0)
		break;

	      /* Skip the comma or equal sign.  */
	      cur = next + 1;
	    }

	  if (cur >= opts)
	    continue;

	  opts++;
	}

      argv = buildargv (opts);
      for (argc = 0; argv[argc]; argc++)
	obstack_ptr_grow (argv_obstack, argv[argc]);
    }
}

/* Check whether NAME can be accessed in MODE.  This is like access,
   except that it never considers directories to be executable.  */

static int
access_check (const char *name, int mode)
{
  if (mode == X_OK)
    {
      struct stat st;

      if (stat (name, &st) < 0
	  || S_ISDIR (st.st_mode))
	return -1;
    }

  return access (name, mode);
}

/* Prepare a target image for offload TARGET, using mkoffload tool from
   COMPILER_PATH.  Return the name of the resultant object file.  */

static char *
compile_offload_image (const char *target, const char *compiler_path,
		       unsigned in_argc, char *in_argv[],
		       vec<cl_decoded_option> compiler_opts,
		       vec<cl_decoded_option> linker_opts)
{
  char *filename = NULL;
  char *dumpbase;
  char **argv;
  char *suffix
    = XALLOCAVEC (char, sizeof ("/accel//mkoffload") + strlen (target));
  strcpy (suffix, "/accel/");
  strcat (suffix, target);
  strcat (suffix, "/mkoffload");

  char **paths = NULL;
  unsigned n_paths = parse_env_var (compiler_path, &paths, suffix);

  const char *compiler = NULL;
  for (unsigned i = 0; i < n_paths; i++)
    if (access_check (paths[i], X_OK) == 0)
      {
	compiler = paths[i];
	break;
      }
#if OFFLOAD_DEFAULTED
  if (!compiler && getenv (OFFLOAD_TARGET_DEFAULT_ENV))
    {
      free_array_of_ptrs ((void **) paths, n_paths);
      return NULL;
    }
#endif

  if (!compiler)
    fatal_error (input_location,
		 "could not find %s in %s (consider using %<-B%>)",
		 suffix + 1, compiler_path);

  dumpbase = concat (dumppfx, "x", target, NULL);

  /* Generate temporary output file name.  */
  if (save_temps)
    filename = concat (dumpbase, ".o", NULL);
  else
    filename = make_temp_file (".target.o");

  struct obstack argv_obstack;
  obstack_init (&argv_obstack);
  obstack_ptr_grow (&argv_obstack, compiler);
  if (save_temps)
    obstack_ptr_grow (&argv_obstack, "-save-temps");
  if (verbose)
    obstack_ptr_grow (&argv_obstack, "-v");
  obstack_ptr_grow (&argv_obstack, "-o");
  obstack_ptr_grow (&argv_obstack, filename);

  /* Append names of input object files.  */
  for (unsigned i = 0; i < in_argc; i++)
    obstack_ptr_grow (&argv_obstack, in_argv[i]);

  /* Append options from offload_lto sections.  */
  append_compiler_options (&argv_obstack, compiler_opts);
  append_diag_options (&argv_obstack, linker_opts);

  obstack_ptr_grow (&argv_obstack, "-dumpbase");
  obstack_ptr_grow (&argv_obstack, dumpbase);

  /* Append options specified by -foffload last.  In case of conflicting
     options we expect offload compiler to choose the latest.  */
  append_offload_options (&argv_obstack, target, compiler_opts);
  append_offload_options (&argv_obstack, target, linker_opts);

  obstack_ptr_grow (&argv_obstack, NULL);
  argv = XOBFINISH (&argv_obstack, char **);
  fork_execute (argv[0], argv, true, "offload_args");
  obstack_free (&argv_obstack, NULL);

  free_array_of_ptrs ((void **) paths, n_paths);
  return filename;
}


/* The main routine dealing with offloading.
   The routine builds a target image for each offload target.  IN_ARGC and
   IN_ARGV specify options and input object files.  As all of them could contain
   target sections, we pass them all to target compilers.  */

static void
compile_images_for_offload_targets (unsigned in_argc, char *in_argv[],
				    vec<cl_decoded_option> compiler_opts,
				    vec<cl_decoded_option> linker_opts)
{
  char **names = NULL;
  const char *target_names = getenv (OFFLOAD_TARGET_NAMES_ENV);
  if (!target_names)
    return;
  unsigned num_targets = parse_env_var (target_names, &names, NULL);
  int next_name_entry = 0;

  const char *compiler_path = getenv ("COMPILER_PATH");
  if (!compiler_path)
    goto out;

  /* Prepare an image for each target and save the name of the resultant object
     file to the OFFLOAD_NAMES array.  It is terminated by a NULL entry.  */
  offload_names = XCNEWVEC (char *, num_targets + 1);
  for (unsigned i = 0; i < num_targets; i++)
    {
      offload_names[next_name_entry]
	= compile_offload_image (names[i], compiler_path, in_argc, in_argv,
				 compiler_opts, linker_opts);
      if (!offload_names[next_name_entry])
#if OFFLOAD_DEFAULTED
	continue;
#else
	fatal_error (input_location,
		     "problem with building target image for %s", names[i]);
#endif
      next_name_entry++;
    }

#if OFFLOAD_DEFAULTED
  if (next_name_entry == 0)
    {
      free (offload_names);
      offload_names = NULL;
    }
#endif

 out:
  free_array_of_ptrs ((void **) names, num_targets);
}

/* Copy a file from SRC to DEST.  */

static void
copy_file (const char *dest, const char *src)
{
  FILE *d = fopen (dest, "wb");
  FILE *s = fopen (src, "rb");
  char buffer[512];
  while (!feof (s))
    {
      size_t len = fread (buffer, 1, 512, s);
      if (ferror (s) != 0)
	fatal_error (input_location, "reading input file");
      if (len > 0)
	{
	  fwrite (buffer, 1, len, d);
	  if (ferror (d) != 0)
	    fatal_error (input_location, "writing output file");
	}
    }
  fclose (d);
  fclose (s);
}

/* Find the crtoffloadtable.o file in LIBRARY_PATH, make copy and pass name of
   the copy to the linker.  */

static void
find_crtoffloadtable (int save_temps, const char *dumppfx)
{
ofs	hex dump	ascii
0000	ca fe ba be 00 00 00 31 00 62 07 00 02 01 00 21 6a 61 76 61 2f 75 74 69 6c 2f 41 62 73 74 72 61	.......1.b.....!java/util/Abstra
0020	63 74 4d 61 70 24 53 69 6d 70 6c 65 45 6e 74 72 79 07 00 04 01 00 10 6a 61 76 61 2f 6c 61 6e 67	ctMap$SimpleEntry......java/lang
0040	2f 4f 62 6a 65 63 74 07 00 06 01 00 13 6a 61 76 61 2f 75 74 69 6c 2f 4d 61 70 24 45 6e 74 72 79	/Object......java/util/Map$Entry
0060	07 00 08 01 00 14 6a 61 76 61 2f 69 6f 2f 53 65 72 69 61 6c 69 7a 61 62 6c 65 01 00 10 73 65 72	......java/io/Serializable...ser
0080	69 61 6c 56 65 72 73 69 6f 6e 55 49 44 01 00 01 4a 01 00 0d 43 6f 6e 73 74 61 6e 74 56 61 6c 75	ialVersionUID...J...ConstantValu
00a0	65 05 8a 0a ec a5 fc 56 80 1f 01 00 03 6b 65 79 01 00 12 4c 6a 61 76 61 2f 6c 61 6e 67 2f 4f 62	e......V.....key...Ljava/lang/Ob
00c0	6a 65 63 74 3b 01 00 09 53 69 67 6e 61 74 75 72 65 01 00 03 54 4b 3b 01 00 05 76 61 6c 75 65 01	ject;...Signature...TK;...value.
00e0	00 03 54 56 3b 01 00 06 3c 69 6e 69 74 3e 01 00 27 28 4c 6a 61 76 61 2f 6c 61 6e 67 2f 4f 62 6a	..TV;...<init>..'(Ljava/lang/Obj
0100	65 63 74 3b 4c 6a 61 76 61 2f 6c 61 6e 67 2f 4f 62 6a 65 63 74 3b 29 56 01 00 09 28 54 4b 3b 54	ect;Ljava/lang/Object;)V...(TK;T
0120	56 3b 29 56 01 00 04 43 6f 64 65 0a 00 03 00 19 0c 00 14 00 1a 01 00 03 28 29 56 09 00 01 00 1c	V;)V...Code.............()V.....
0140	0c 00 0e 00 0f 09 00 01 00 1e 0c 00 12 00 0f 01 00 0f 4c 69 6e 65 4e 75 6d 62 65 72 54 61 62 6c	..................LineNumberTabl
0160	65 01 00 12 4c 6f 63 61 6c 56 61 72 69 61 62 6c 65 54 61 62 6c 65 01 00 04 74 68 69 73 01 00 23	e...LocalVariableTable...this..#
0180	4c 6a 61 76 61 2f 75 74 69 6c 2f 41 62 73 74 72 61 63 74 4d 61 70 24 53 69 6d 70 6c 65 45 6e 74	Ljava/util/AbstractMap$SimpleEnt
01a0	72 79 3b 01 00 06 6e 65 77 4b 65 79 01 00 08 6e 65 77 56 61 6c 75 65 01 00 16 4c 6f 63 61 6c 56	ry;...newKey...newValue...LocalV
01c0	61 72 69 61 62 6c 65 54 79 70 65 54 61 62 6c 65 01 00 33 4c 6a 61 76 61 2f 75 74 69 6c 2f 41 62	ariableTypeTable..3Ljava/util/Ab
01e0	73 74 72 61 63 74 4d 61 70 3c 54 4b 3b 54 56 3b 3e 2e 53 69 6d 70 6c 65 45 6e 74 72 79 3c 54 4b	stractMap<TK;TV;>.SimpleEntry<TK
0200	3b 54 56 3b 3e 3b 01 00 18 28 4c 6a 61 76 61 2f 75 74 69 6c 2f 4d 61 70 24 45 6e 74 72 79 3b 29	;TV;>;...(Ljava/util/Map$Entry;)
0220	56 01 00 22 28 4c 6a 61 76 61 2f 75 74 69 6c 2f 4d 61 70 24 45 6e 74 72 79 3c 2b 54 4b 3b 2b 54	V.."(Ljava/util/Map$Entry<+TK;+T
0240	56 3b 3e 3b 29 56 0b 00 05 00 2a 0c 00 2b 00 2c 01 00 06 67 65 74 4b 65 79 01 00 14 28 29 4c 6a	V;>;)V....*..+.,...getKey...()Lj
0260	61 76 61 2f 6c 61 6e 67 2f 4f 62 6a 65 63 74 3b 0b 00 05 00 2e 0c 00 2f 00 2c 01 00 08 67 65 74	ava/lang/Object;......./.,...get
0280	56 61 6c 75 65 0a 00 01 00 31 0c 00 14 00 15 01 00 05 65 6e 74 72 79 01 00 15 4c 6a 61 76 61 2f	Value....1........entry...Ljava/
02a0	75 74 69 6c 2f 4d 61 70 24 45 6e 74 72 79 3b 01 00 1f 4c 6a 61 76 61 2f 75 74 69 6c 2f 4d 61 70	util/Map$Entry;...Ljava/util/Map
02c0	24 45 6e 74 72 79 3c 2b 54 4b 3b 2b 54 56 3b 3e 3b 01 00 06 65 71 75 61 6c 73 01 00 15 28 4c 6a	$Entry<+TK;+TV;>;...equals...(Lj
02e0	61 76 61 2f 6c 61 6e 67 2f 4f 62 6a 65 63 74 3b 29 5a 0a 00 38 00 3a 07 00 39 01 00 15 6a 61 76	ava/lang/Object;)Z..8.:..9...jav
0300	61 2f 75 74 69 6c 2f 41 62 73 74 72 61 63 74 4d 61 70 0c 00 35 00 3b 01 00 27 28 4c 6a 61 76 61	a/util/AbstractMap..5.;..'(Ljava
0320	2f 6c 61 6e 67 2f 4f 62 6a 65 63 74 3b 4c 6a 61 76 61 2f 6c 61 6e 67 2f 4f 62 6a 65 63 74 3b 29	/lang/Object;Ljava/lang/Object;)
0340	5a 01 00 01 6f 01 00 01 65 01 00 05 28 29 54 4b 3b 01 00 05 28 29 54 56 3b 01 00 08 68 61 73 68	Z...o...e...()TK;...()TV;...hash
0360	43 6f 64 65 01 00 03 28 29 49 0a 00 38 00 43 0c 00 40 00 44 01 00 15 28 4c 6a 61 76 61 2f 6c 61	Code...()I..8.C..@.D...(Ljava/la
0380	6e 67 2f 4f 62 6a 65 63 74 3b 29 49 01 00 08 73 65 74 56 61 6c 75 65 01 00 26 28 4c 6a 61 76 61	ng/Object;)I...setValue..&(Ljava
03a0	2f 6c 61 6e 67 2f 4f 62 6a 65 63 74 3b 29 4c 6a 61 76 61 2f 6c 61 6e 67 2f 4f 62 6a 65 63 74 3b	/lang/Object;)Ljava/lang/Object;
03c0	01 00 08 28 54 56 3b 29 54 56 3b 01 00 06 6e 65 77 56 61 6c 01 00 01 72 01 00 08 74 6f 53 74 72	...(TV;)TV;...newVal...r...toStr
03e0	69 6e 67 01 00 14 28 29 4c 6a 61 76 61 2f 6c 61 6e 67 2f 53 74 72 69 6e 67 3b 07 00 4d 01 00 17	ing...()Ljava/lang/String;..M...
0400	6a 61 76 61 2f 6c 61 6e 67 2f 53 74 72 69 6e 67 42 75 69 6c 64 65 72 0a 00 4c 00 19 0a 00 4c 00	java/lang/StringBuilder..L....L.
0420	50 0c 00 51 00 52 01 00 06 61 70 70 65 6e 64 01 00 2d 28 4c 6a 61 76 61 2f 6c 61 6e 67 2f 4f 62	P..Q.R...append..-(Ljava/lang/Ob
0440	6a 65 63 74 3b 29 4c 6a 61 76 61 2f 6c 61 6e 67 2f 53 74 72 69 6e 67 42 75 69 6c 64 65 72 3b 08	ject;)Ljava/lang/StringBuilder;.
0460	00 54 01 00 01 3d 0a 00 4c 00 56 0c 00 51 00 57 01 00 2d 28 4c 6a 61 76 61 2f 6c 61 6e 67 2f 53	.T...=..L.V..Q.W..-(Ljava/lang/S
0480	74 72 69 6e 67 3b 29 4c 6a 61 76 61 2f 6c 61 6e 67 2f 53 74 72 69 6e 67 42 75 69 6c 64 65 72 3b	tring;)Ljava/lang/StringBuilder;
04a0	0a 00 4c 00 59 0c 00 4a 00 4b 01 00 0a 53 6f 75 72 63 65 46 69 6c 65 01 00 10 41 62 73 74 72 61	..L.Y..J.K...SourceFile...Abstra
04c0	63 74 4d 61 70 2e 6a 61 76 61 01 00 6f 3c 4b 3a 4c 6a 61 76 61 2f 6c 61 6e 67 2f 4f 62 6a 65 63	ctMap.java..o<K:Ljava/lang/Objec
04e0	74 3b 56 3a 4c 6a 61 76 61 2f 6c 61 6e 67 2f 4f 62 6a 65 63 74 3b 3e 4c 6a 61 76 61 2f 6c 61 6e	t;V:Ljava/lang/Object;>Ljava/lan
0500	67 2f 4f 62 6a 65 63 74 3b 4c 6a 61 76 61 2f 75 74 69 6c 2f 4d 61 70 24 45 6e 74 72 79 3c 54 4b	g/Object;Ljava/util/Map$Entry<TK
0520	3b 54 56 3b 3e 3b 4c 6a 61 76 61 2f 69 6f 2f 53 65 72 69 61 6c 69 7a 61 62 6c 65 3b 01 00 0c 49	;TV;>;Ljava/io/Serializable;...I
0540	6e 6e 65 72 43 6c 61 73 73 65 73 01 00 0b 53 69 6d 70 6c 65 45 6e 74 72 79 07 00 60 01 00 0d 6a	nnerClasses...SimpleEntry..`...j
0560	61 76 61 2f 75 74 69 6c 2f 4d 61 70 01 00 05 45 6e 74 72 79 00 21 00 01 00 03 00 02 00 05 00 07	ava/util/Map...Entry.!..........
0580	00 03 00 1a 00 09 00 0a 00 01 00 0b 00 00 00 02 00 0c 00 00 00 0e 00 0f 00 01 00 10 00 00 00 02	................................
05a0	00 11 00 00 00 12 00 0f 00 01 00 10 00 00 00 02 00 13 00 08 00 01 00 14 00 15 00 02 00 10 00 00	................................
05c0	00 02 00 16 00 17 00 00 00 7f 00 02 00 03 00 00 00 0f 2a b7 00 18 2a 2b b5 00 1b 2a 2c b5 00 1d	.....................+...*,...
05e0	b1 00 00 00 03 00 1f 00 00 00 12 00 04 00 00 02 c5 00 04 02 c7 00 09 02 c8 00 0e 02 c9 00 20 00	................................
0600	00 00 20 00 03 00 00 00 0f 00 21 00 22 00 00 00 00 00 0f 00 23 00 0f 00 01 00 00 00 0f 00 24 00	..........!.".......#.........$.
0620	0f 00 02 00 25 00 00 00 20 00 03 00 00 00 0f 00 21 00 26 00 00 00 00 00 0f 00 23 00 11 00 01 00	....%...........!.&.......#.....
0640	00 00 0f 00 24 00 13 00 02 00 01 00 14 00 27 00 02 00 10 00 00 00 02 00 28 00 17 00 00 00 65 00	....$.........'.........(.....e.
0660	03 00 02 00 00 00 11 2a 2b b9 00 29 01 00 2b b9 00 2d 01 00 b7 00 30 b1 00 00 00 03 00 1f 00 00	.......*+..)..+..-....0.........
0680	00 0a 00 02 00 00 02 cd 00 10 02 ce 00 20 00 00 00 16 00 02 00 00 00 11 00 21 00 22 00 00 00 00	.........................!."....
06a0	00 11 00 32 00 33 00 01 00 25 00 00 00 16 00 02 00 00 00 11 00 21 00 26 00 00 00 00 00 11 00 32	...2.3...%...........!.&.......2
06c0	00 34 00 01 00 01 00 35 00 36 00 01 00 17 00 00 00 e0 00 02 00 03 00 00 00 5e 2b c1 00 05 9a 00	.4.....5.6...............^+.....
06e0	05 03 ac 2b c1 00 01 99 00 28 2b c0 00 01 4d 2a b4 00 1b 2c b4 00 1b b8 00 37 99 00 13 2a b4 00	...+.....(+...M...,.....7.....
0700	1d 2c b4 00 1d b8 00 37 99 00 05 04 ac 03 ac 2b c0 00 05 4d 2a b4 00 1b 2c b9 00 29 01 00 b8 00	.,.....7.......+...M*...,..)....
0720	37 99 00 15 2a b4 00 1d 2c b9 00 2d 01 00 b8 00 37 99 00 05 04 ac 03 ac 00 00 00 03 00 1f 00 00	7...*...,..-....7...............
0740	00 2e 00 0b 00 00 02 df 00 07 02 e0 00 09 02 e2 00 10 02 e4 00 15 02 e5 00 23 02 e6 00 34 02 e5	.........................#...4..
0760	00 35 02 e8 00 3a 02 e9 00 4a 02 ea 00 5d 02 e9 00 20 00 00 00 2a 00 04 00 00 00 5e 00 21 00 22	.5...:...J...].......*.....^.!."
0780	00 00 00 00 00 5e 00 3c 00 0f 00 01 00 15 00 20 00 3d 00 22 00 02 00 3a 00 24 00 3d 00 33 00 02	.....^.<.........=."...:.$.=.3..
07a0	00 25 00 00 00 0c 00 01 00 00 00 5e 00 21 00 26 00 00 00 01 00 2b 00 2c 00 02 00 10 00 00 00 02	.%.........^.!.&.....+.,........
07c0	00 3e 00 17 00 00 00 41 00 01 00 01 00 00 00 05 2a b4 00 1b b0 00 00 00 03 00 1f 00 00 00 06 00	.>.....A........*...............
07e0	01 00 00 02 f4 00 20 00 00 00 0c 00 01 00 00 00 05 00 21 00 22 00 00 00 25 00 00 00 0c 00 01 00	..................!."...%.......
0800	00 00 05 00 21 00 26 00 00 00 01 00 2f 00 2c 00 02 00 10 00 00 00 02 00 3f 00 17 00 00 00 41 00	....!.&...../.,.........?.....A.
0820	01 00 01 00 00 00 05 2a b4 00 1d b0 00 00 00 03 00 1f 00 00 00 06 00 01 00 00 02 ff 00 20 00 00	.......*........................
0840	00 0c 00 01 00 00 00 05 00 21 00 22 00 00 00 25 00 00 00 0c 00 01 00 00 00 05 00 21 00 26 00 00	.........!."...%...........!.&..
0860	00 01 00 40 00 41 00 01 00 17 00 00 00 4c 00 02 00 01 00 00 00 10 2a b4 00 1b b8 00 42 2a b4 00	...@.A.......L.............B..
0880	1d b8 00 42 82 ac 00 00 00 03 00 1f 00 00 00 06 00 01 00 00 03 0d 00 20 00 00 00 0c 00 01 00 00	...B............................
08a0	00 10 00 21 00 22 00 00 00 25 00 00 00 0c 00 01 00 00 00 10 00 21 00 26 00 00 00 01 00 45 00 46	...!."...%...........!.&.....E.F
08c0	00 02 00 10 00 00 00 02 00 47 00 17 00 00 00 78 00 02 00 03 00 00 00 0c 2a b4 00 1d 4d 2a 2b b5	.........G.....x...........M+.
08e0	00 1d 2c b0 00 00 00 03 00 1f 00 00 00 0e 00 03 00 00 03 21 00 05 03 22 00 0a 03 23 00 20 00 00	..,................!..."...#....
0900	00 20 00 03 00 00 00 0c 00 21 00 22 00 00 00 00 00 0c 00 48 00 0f 00 01 00 05 00 07 00 49 00 0f	.........!.".......H.........I..
0920	00 02 00 25 00 00 00 20 00 03 00 00 00 0c 00 21 00 26 00 00 00 00 00 0c 00 48 00 13 00 01 00 05	...%...........!.&.......H......
0940	00 07 00 49 00 13 00 02 00 01 00 4a 00 4b 00 01 00 17 00 00 00 5a 00 02 00 01 00 00 00 1e bb 00	...I.......J.K.......Z..........
0960	4c 59 b7 00 4e 2a b4 00 1b b6 00 4f 12 53 b6 00 55 2a b4 00 1d b6 00 4f b6 00 58 b0 00 00 00 03	LY..N.....O.S..U.....O..X.....
0980	00 1f 00 00 00 06 00 01 00 00 03 2e 00 20 00 00 00 0c 00 01 00 00 00 1e 00 21 00 22 00 00 00 25	.........................!."...%
09a0	00 00 00 0c 00 01 00 00 00 1e 00 21 00 26 00 00 00 03 00 5a 00 00 00 02 00 5b 00 10 00 00 00 02	...........!.&.....Z.....[......
09c0	00 5c 00 5d 00 00 00 12 00 02 00 01 00 38 00 5e 00 09 00 05 00 5f 00 61 06 09	.\.].........8.^....._.a..