1 files changed, 321 insertions, 0 deletions
diff --git a/lib/gcc/arm-none-eabi/13.2.1/plugin/include/target.h b/lib/gcc/arm-none-eabi/13.2.1/plugin/include/target.h
new file mode 100644
index 0000000..cd448e4
--- /dev/null
+++ b/lib/gcc/arm-none-eabi/13.2.1/plugin/include/target.h
@@ -0,0 +1,321 @@
+/* Data structure definitions for a generic GCC target.
+   Copyright (C) 2001-2023 Free Software Foundation, Inc.
+
+   This program 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.
+
+   This program 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 this program; see the file COPYING3.  If not see
+   <http://www.gnu.org/licenses/>.
+
+   In other words, you are welcome to use, share and improve this program.
+   You are forbidden to forbid anyone else to use, share and improve
+   what you give them.   Help stamp out software-hoarding!  */
+
+
+/* This file contains a data structure that describes a GCC target.
+   At present it is incomplete, but in future it should grow to
+   contain most or all target machine and target O/S specific
+   information.
+
+   This structure has its initializer declared in target-def.h in the
+   form of large macro TARGET_INITIALIZER that expands to many smaller
+   macros.
+
+   The smaller macros each initialize one component of the structure,
+   and each has a default.  Each target should have a file that
+   includes target.h and target-def.h, and overrides any inappropriate
+   defaults by undefining the relevant macro and defining a suitable
+   replacement.  That file should then contain the definition of
+   "targetm" like so:
+
+   struct gcc_target targetm = TARGET_INITIALIZER;
+
+   Doing things this way allows us to bring together everything that
+   defines a GCC target.  By supplying a default that is appropriate
+   to most targets, we can easily add new items without needing to
+   edit dozens of target configuration files.  It should also allow us
+   to gradually reduce the amount of conditional compilation that is
+   scattered throughout GCC.  */
+
+#ifndef GCC_TARGET_H
+#define GCC_TARGET_H
+
+#include "insn-codes.h"
+#include "tm.h"
+#include "hard-reg-set.h"
+
+#if CHECKING_P
+
+struct cumulative_args_t { void *magic; void *p; };
+
+#else /* !CHECKING_P */
+
+/* When using a GCC build compiler, we could use
+   __attribute__((transparent_union)) to get cumulative_args_t function
+   arguments passed like scalars where the ABI would mandate a less
+   efficient way of argument passing otherwise.  However, that would come
+   at the cost of less type-safe !CHECKING_P compilation.  */
+
+union cumulative_args_t { void *p; };
+
+#endif /* !CHECKING_P */
+
+/* Types of memory operation understood by the "by_pieces" infrastructure.
+   Used by the TARGET_USE_BY_PIECES_INFRASTRUCTURE_P target hook and
+   internally by the functions in expr.cc.  */
+
+enum by_pieces_operation
+{
+  CLEAR_BY_PIECES,
+  MOVE_BY_PIECES,
+  SET_BY_PIECES,
+  STORE_BY_PIECES,
+  COMPARE_BY_PIECES
+};
+
+extern unsigned HOST_WIDE_INT by_pieces_ninsns (unsigned HOST_WIDE_INT,
+						unsigned int,
+						unsigned int,
+						by_pieces_operation);
+
+/* An example implementation for ELF targets.  Defined in varasm.cc  */
+extern void elf_record_gcc_switches (const char *);
+
+/* Some places still assume that all pointer or address modes are the
+   standard Pmode and ptr_mode.  These optimizations become invalid if
+   the target actually supports multiple different modes.  For now,
+   we disable such optimizations on such targets, using this function.  */
+extern bool target_default_pointer_address_modes_p (void);
+
+/* For hooks which use the MOVE_RATIO macro, this gives the legacy default
+   behavior.  */
+extern unsigned int get_move_ratio (bool);
+
+struct stdarg_info;
+struct spec_info_def;
+struct hard_reg_set_container;
+struct cgraph_node;
+struct cgraph_simd_clone;
+
+/* The struct used by the secondary_reload target hook.  */
+struct secondary_reload_info
+{
+  /* icode is actually an enum insn_code, but we don't want to force every
+     file that includes target.h to include optabs.h .  */
+  int icode;
+  int extra_cost; /* Cost for using (a) scratch register(s) to be taken
+		     into account by copy_cost.  */
+  /* The next two members are for the use of the backward
+     compatibility hook.  */
+  struct secondary_reload_info *prev_sri;
+  int t_icode; /* Actually an enum insn_code - see above.  */
+};
+
+/* This is defined in sched-int.h .  */
+struct _dep;
+
+/* This is defined in ddg.h .  */
+struct ddg;
+
+/* This is defined in cfgloop.h .  */
+class loop;
+
+/* This is defined in ifcvt.h.  */
+struct noce_if_info;
+
+/* This is defined in tree-ssa-alias.h.  */
+class ao_ref;
+
+/* This is defined in tree-vectorizer.h.  */
+class _stmt_vec_info;
+
+/* This is defined in calls.h.  */
+class function_arg_info;
+
+/* This is defined in function-abi.h.  */
+class predefined_function_abi;
+
+/* These are defined in tree-vect-stmts.cc.  */
+extern tree stmt_vectype (class _stmt_vec_info *);
+extern bool stmt_in_inner_loop_p (class vec_info *, class _stmt_vec_info *);
+
+/* Assembler instructions for creating various kinds of integer object.  */
+
+struct asm_int_op
+{
+  const char *hi;
+  const char *psi;
+  const char *si;
+  const char *pdi;
+  const char *di;
+  const char *pti;
+  const char *ti;
+};
+
+/* Types of costs for vectorizer cost model.  */
+enum vect_cost_for_stmt
+{
+  scalar_stmt,
+  scalar_load,
+  scalar_store,
+  vector_stmt,
+  vector_load,
+  vector_gather_load,
+  unaligned_load,
+  unaligned_store,
+  vector_store,
+  vector_scatter_store,
+  vec_to_scalar,
+  scalar_to_vec,
+  cond_branch_not_taken,
+  cond_branch_taken,
+  vec_perm,
+  vec_promote_demote,
+  vec_construct
+};
+
+/* Separate locations for which the vectorizer cost model should
+   track costs.  */
+enum vect_cost_model_location {
+  vect_prologue = 0,
+  vect_body = 1,
+  vect_epilogue = 2
+};
+
+class vec_perm_indices;
+
+/* The type to use for lists of vector sizes.  */
+typedef vec<machine_mode> vector_modes;
+
+/* Same, but can be used to construct local lists that are
+   automatically freed.  */
+typedef auto_vec<machine_mode, 8> auto_vector_modes;
+
+/* First argument of targetm.omp.device_kind_arch_isa.  */
+enum omp_device_kind_arch_isa {
+  omp_device_kind,
+  omp_device_arch,
+  omp_device_isa
+};
+
+/* Flags returned by TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_MODES:
+
+   VECT_COMPARE_COSTS
+       Tells the loop vectorizer to try all the provided modes and
+       pick the one with the lowest cost.  By default the vectorizer
+       will choose the first mode that works.  */
+const unsigned int VECT_COMPARE_COSTS = 1U << 0;
+
+/* The contexts in which the use of a type T can be checked by
+   TARGET_VERIFY_TYPE_CONTEXT.  */
+enum type_context_kind {
+  /* Directly measuring the size of T.  */
+  TCTX_SIZEOF,
+
+  /* Directly measuring the alignment of T.  */
+  TCTX_ALIGNOF,
+
+  /* Creating objects of type T with static storage duration.  */
+  TCTX_STATIC_STORAGE,
+
+  /* Creating objects of type T with thread-local storage duration.  */
+  TCTX_THREAD_STORAGE,
+
+  /* Creating a field of type T.  */
+  TCTX_FIELD,
+
+  /* Creating an array with elements of type T.  */
+  TCTX_ARRAY_ELEMENT,
+
+  /* Adding to or subtracting from a pointer to T, or computing the
+     difference between two pointers when one of them is a pointer to T.  */
+  TCTX_POINTER_ARITH,
+
+  /* Dynamically allocating objects of type T.  */
+  TCTX_ALLOCATION,
+
+  /* Dynamically deallocating objects of type T.  */
+  TCTX_DEALLOCATION,
+
+  /* Throwing or catching an object of type T.  */
+  TCTX_EXCEPTIONS,
+
+  /* Capturing objects of type T by value in a closure.  */
+  TCTX_CAPTURE_BY_COPY
+};
+
+enum poly_value_estimate_kind
+{
+  POLY_VALUE_MIN,
+  POLY_VALUE_MAX,
+  POLY_VALUE_LIKELY
+};
+
+typedef void (*emit_support_tinfos_callback) (tree);
+
+extern bool verify_type_context (location_t, type_context_kind, const_tree,
+				 bool = false);
+
+/* The target structure.  This holds all the backend hooks.  */
+#define DEFHOOKPOD(NAME, DOC, TYPE, INIT) TYPE NAME;
+#define DEFHOOK(NAME, DOC, TYPE, PARAMS, INIT) TYPE (* NAME) PARAMS;
+#define DEFHOOK_UNDOC DEFHOOK
+#define HOOKSTRUCT(FRAGMENT) FRAGMENT
+
+#include "target.def"
+
+extern struct gcc_target targetm;
+
+/* Return an estimate of the runtime value of X, for use in things
+   like cost calculations or profiling frequencies.  Note that this
+   function should never be used in situations where the actual
+   runtime value is needed for correctness, since the function only
+   provides a rough guess.  */
+
+inline HOST_WIDE_INT
+estimated_poly_value (poly_int64 x,
+		      poly_value_estimate_kind kind = POLY_VALUE_LIKELY)
+{
+  if (NUM_POLY_INT_COEFFS == 1)
+    return x.coeffs[0];
+  else
+    return targetm.estimated_poly_value (x, kind);
+}
+
+#ifdef GCC_TM_H
+
+#ifndef CUMULATIVE_ARGS_MAGIC
+#define CUMULATIVE_ARGS_MAGIC ((void *) &targetm.calls)
+#endif
+
+inline CUMULATIVE_ARGS *
+get_cumulative_args (cumulative_args_t arg)
+{
+#if CHECKING_P
+  gcc_assert (arg.magic == CUMULATIVE_ARGS_MAGIC);
+#endif /* CHECKING_P */
+  return (CUMULATIVE_ARGS *) arg.p;
+}
+
+inline cumulative_args_t
+pack_cumulative_args (CUMULATIVE_ARGS *arg)
+{
+  cumulative_args_t ret;
+
+#if CHECKING_P
+  ret.magic = CUMULATIVE_ARGS_MAGIC;
+#endif /* CHECKING_P */
+  ret.p = (void *) arg;
+  return ret;
+}
+#endif /* GCC_TM_H */
+
+#endif /* GCC_TARGET_H */