From 4bccb39ebaecc3c91ea8aee58dc0c71d5a7e3b95 Mon Sep 17 00:00:00 2001 From: Richard Sandiford Date: Thu, 25 Jun 2015 17:18:12 +0000 Subject: Makefile.in (TARGET_DEF): Add target-insns.def. gcc/ * Makefile.in (TARGET_DEF): Add target-insns.def. (.PRECIOUS, simple_rtl_generated_h): Add insn-target-def.h. (build/gentarget-def.o): New rule. (genprogrtl): Add target-def. * target-insns.def, gentarget-def.c: New files. * target.def: Add targetm.have_* and targetm.gen_* hooks, based on the contents of target-insns.def. * defaults.h (HAVE_simple_return, gen_simple_return): Delete. (HAVE_return, gen_return): Delete. * target-def.h: Include insn-target-def.h. * cfgrtl.c (force_nonfallthru_and_redirect): Use targetm interface instead of direct calls. Rely on them to do the appropriate assertions. * function.c (gen_return_pattern): Likewise. Return an rtx_insn *. (convert_jumps_to_returns): Use targetm interface instead of direct calls. (thread_prologue_and_epilogue_insns): Likewise. * reorg.c (find_end_label, dbr_schedule): Likewise. * shrink-wrap.h (SHRINK_WRAPPING_ENABLED): Likewise. * shrink-wrap.c (convert_to_simple_return): Likewise. (try_shrink_wrapping): Use SHRINK_WRAPPING_ENABLED. From-SVN: r224979 --- gcc/ChangeLog | 23 +++++ gcc/Makefile.in | 12 ++- gcc/cfgrtl.c | 13 +-- gcc/defaults.h | 20 ---- gcc/function.c | 27 +++--- gcc/gentarget-def.c | 265 +++++++++++++++++++++++++++++++++++++++++++++++++++ gcc/reorg.c | 11 ++- gcc/shrink-wrap.c | 6 +- gcc/shrink-wrap.h | 3 +- gcc/target-def.h | 1 + gcc/target-insns.def | 34 +++++++ gcc/target.def | 13 +++ 12 files changed, 372 insertions(+), 56 deletions(-) create mode 100644 gcc/gentarget-def.c create mode 100644 gcc/target-insns.def diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 0fce794..ff6333c 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,5 +1,28 @@ 2015-06-25 Richard Sandiford + * Makefile.in (TARGET_DEF): Add target-insns.def. + (.PRECIOUS, simple_rtl_generated_h): Add insn-target-def.h. + (build/gentarget-def.o): New rule. + (genprogrtl): Add target-def. + * target-insns.def, gentarget-def.c: New files. + * target.def: Add targetm.have_* and targetm.gen_* hooks, + based on the contents of target-insns.def. + * defaults.h (HAVE_simple_return, gen_simple_return): Delete. + (HAVE_return, gen_return): Delete. + * target-def.h: Include insn-target-def.h. + * cfgrtl.c (force_nonfallthru_and_redirect): Use targetm interface + instead of direct calls. Rely on them to do the appropriate assertions. + * function.c (gen_return_pattern): Likewise. Return an rtx_insn *. + (convert_jumps_to_returns): Use targetm interface instead of + direct calls. + (thread_prologue_and_epilogue_insns): Likewise. + * reorg.c (find_end_label, dbr_schedule): Likewise. + * shrink-wrap.h (SHRINK_WRAPPING_ENABLED): Likewise. + * shrink-wrap.c (convert_to_simple_return): Likewise. + (try_shrink_wrapping): Use SHRINK_WRAPPING_ENABLED. + +2015-06-25 Richard Sandiford + * config/aarch64/aarch64.c, config/alpha/alpha.c, config/arm/arm.c, config/avr/avr.c, config/bfin/bfin.c, config/c6x/c6x.c, config/cr16/cr16.c, config/cris/cris.c, config/fr30/fr30.c, diff --git a/gcc/Makefile.in b/gcc/Makefile.in index 5742694..89eda96 100644 --- a/gcc/Makefile.in +++ b/gcc/Makefile.in @@ -866,7 +866,7 @@ DUMPFILE_H = $(srcdir)/../libcpp/include/line-map.h dumpfile.h VEC_H = vec.h statistics.h $(GGC_H) HASH_TABLE_H = $(HASHTAB_H) hash-table.h EXCEPT_H = except.h $(HASHTAB_H) -TARGET_DEF = target.def target-hooks-macros.h +TARGET_DEF = target.def target-hooks-macros.h target-insns.def C_TARGET_DEF = c-family/c-target.def target-hooks-macros.h COMMON_TARGET_DEF = common/common-target.def target-hooks-macros.h TARGET_H = $(TM_H) target.h $(TARGET_DEF) insn-modes.h insn-codes.h @@ -2078,7 +2078,8 @@ $(common_out_object_file): $(common_out_file) .PRECIOUS: insn-config.h insn-flags.h insn-codes.h insn-constants.h \ insn-emit.c insn-recog.c insn-extract.c insn-output.c insn-peep.c \ insn-attr.h insn-attr-common.h insn-attrtab.c insn-dfatab.c \ - insn-latencytab.c insn-preds.c gimple-match.c generic-match.c + insn-latencytab.c insn-preds.c gimple-match.c generic-match.c \ + insn-target-def.h # Dependencies for the md file. The first time through, we just assume # the md file itself and the generated dependency file (in order to get @@ -2099,7 +2100,7 @@ s-mddeps: $(md_file) $(MD_INCLUDES) build/genmddeps$(build_exeext) # the target file. simple_rtl_generated_h = insn-attr.h insn-attr-common.h insn-codes.h \ - insn-config.h insn-flags.h + insn-config.h insn-flags.h insn-target-def.h simple_rtl_generated_c = insn-automata.c insn-emit.c \ insn-extract.c insn-output.c \ @@ -2498,6 +2499,9 @@ build/genextract.o : genextract.c $(RTL_BASE_H) $(BCONFIG_H) \ $(SYSTEM_H) coretypes.h $(GTM_H) errors.h $(READ_MD_H) gensupport.h build/genflags.o : genflags.c $(RTL_BASE_H) $(OBSTACK_H) $(BCONFIG_H) \ $(SYSTEM_H) coretypes.h $(GTM_H) errors.h $(READ_MD_H) gensupport.h +build/gentarget-def.o : gentarget-def.c $(BCONFIG_H) $(SYSTEM_H) \ + coretypes.h $(GTM_H) $(RTL_BASE_H) errors.h $(READ_MD_H) gensupport.h \ + $(HASH_TABLE_H) target-insns.def build/gengenrtl.o : gengenrtl.c $(BCONFIG_H) $(SYSTEM_H) rtl.def # The gengtype generator program is special: Two versions are built. @@ -2562,7 +2566,7 @@ build/genmatch.o : genmatch.c $(BCONFIG_H) $(SYSTEM_H) \ # All these programs use the RTL reader ($(BUILD_RTL)). genprogrtl = attr attr-common attrtab automata codes conditions config emit \ - extract flags opinit output peep preds recog mddump + extract flags mddump opinit output peep preds recog target-def $(genprogrtl:%=build/gen%$(build_exeext)): $(BUILD_RTL) # All these programs use the MD reader ($(BUILD_MD)). diff --git a/gcc/cfgrtl.c b/gcc/cfgrtl.c index 20e3fc7..2e33dda 100644 --- a/gcc/cfgrtl.c +++ b/gcc/cfgrtl.c @@ -1695,19 +1695,12 @@ force_nonfallthru_and_redirect (edge e, basic_block target, rtx jump_label) if (target == EXIT_BLOCK_PTR_FOR_FN (cfun)) { if (jump_label == ret_rtx) - { - if (!HAVE_return) - gcc_unreachable (); - - emit_jump_insn_after_setloc (gen_return (), BB_END (jump_block), loc); - } + emit_jump_insn_after_setloc (targetm.gen_return (), + BB_END (jump_block), loc); else { gcc_assert (jump_label == simple_return_rtx); - if (!HAVE_simple_return) - gcc_unreachable (); - - emit_jump_insn_after_setloc (gen_simple_return (), + emit_jump_insn_after_setloc (targetm.gen_simple_return (), BB_END (jump_block), loc); } set_return_jump_label (BB_END (jump_block)); diff --git a/gcc/defaults.h b/gcc/defaults.h index 057b646..5534e42 100644 --- a/gcc/defaults.h +++ b/gcc/defaults.h @@ -1426,26 +1426,6 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see #define TARGET_VTABLE_USES_DESCRIPTORS 0 #endif -#ifndef HAVE_simple_return -#define HAVE_simple_return 0 -static inline rtx -gen_simple_return () -{ - gcc_unreachable (); - return NULL; -} -#endif - -#ifndef HAVE_return -#define HAVE_return 0 -static inline rtx -gen_return () -{ - gcc_unreachable (); - return NULL; -} -#endif - #ifndef HAVE_epilogue #define HAVE_epilogue 0 static inline rtx diff --git a/gcc/function.c b/gcc/function.c index cb3e9bb..cffe323 100644 --- a/gcc/function.c +++ b/gcc/function.c @@ -5614,13 +5614,12 @@ emit_use_return_register_into_block (basic_block bb) /* Create a return pattern, either simple_return or return, depending on simple_p. */ -static rtx +static rtx_insn * gen_return_pattern (bool simple_p) { - if (!HAVE_simple_return) - gcc_assert (!simple_p); - - return simple_p ? gen_simple_return () : gen_return (); + return (simple_p + ? targetm.gen_simple_return () + : targetm.gen_return ()); } /* Insert an appropriate return pattern at the end of block BB. This @@ -5726,7 +5725,7 @@ convert_jumps_to_returns (basic_block last_bb, bool simple_p, dest = ret_rtx; if (!redirect_jump (as_a (jump), dest, 0)) { - if (HAVE_simple_return && simple_p) + if (targetm.have_simple_return () && simple_p) { if (dump_file) fprintf (dump_file, @@ -5747,7 +5746,7 @@ convert_jumps_to_returns (basic_block last_bb, bool simple_p, } else { - if (HAVE_simple_return && simple_p) + if (targetm.have_simple_return () && simple_p) { if (dump_file) fprintf (dump_file, @@ -5938,12 +5937,12 @@ thread_prologue_and_epilogue_insns (void) exit_fallthru_edge = find_fallthru_edge (EXIT_BLOCK_PTR_FOR_FN (cfun)->preds); - if (HAVE_simple_return && entry_edge != orig_entry_edge) + if (targetm.have_simple_return () && entry_edge != orig_entry_edge) exit_fallthru_edge = get_unconverted_simple_return (exit_fallthru_edge, bb_flags, &unconverted_simple_returns, &returnjump); - if (HAVE_return) + if (targetm.have_return ()) { if (exit_fallthru_edge == NULL) goto epilogue_done; @@ -5964,7 +5963,8 @@ thread_prologue_and_epilogue_insns (void) /* Emitting the return may add a basic block. Fix bb_flags for the added block. */ - if (HAVE_simple_return && last_bb != exit_fallthru_edge->src) + if (targetm.have_simple_return () + && last_bb != exit_fallthru_edge->src) bitmap_set_bit (&bb_flags, last_bb->index); goto epilogue_done; @@ -6080,7 +6080,7 @@ epilogue_done: } } - if (HAVE_simple_return) + if (targetm.have_simple_return ()) convert_to_simple_return (entry_edge, orig_entry_edge, bb_flags, returnjump, unconverted_simple_returns); @@ -6096,8 +6096,9 @@ epilogue_done: if (!CALL_P (insn) || ! SIBLING_CALL_P (insn) - || (HAVE_simple_return && (entry_edge != orig_entry_edge - && !bitmap_bit_p (&bb_flags, bb->index)))) + || (targetm.have_simple_return () + && entry_edge != orig_entry_edge + && !bitmap_bit_p (&bb_flags, bb->index))) { ei_next (&ei); continue; diff --git a/gcc/gentarget-def.c b/gcc/gentarget-def.c new file mode 100644 index 0000000..d4839e8 --- /dev/null +++ b/gcc/gentarget-def.c @@ -0,0 +1,265 @@ +/* Generate insn-target-def.h, an automatically-generated part of targetm. + Copyright (C) 1987-2015 Free Software Foundation, Inc. + +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 +. */ + +#include "bconfig.h" +#include "system.h" +#include "coretypes.h" +#include "tm.h" +#include "rtl.h" +#include "errors.h" +#include "read-md.h" +#include "gensupport.h" +#include "hash-table.h" + +/* This class hashes define_insns and define_expands by name. */ +struct insn_hasher : nofree_ptr_hash +{ + typedef rtx value_type; + typedef const char *compare_type; + + static inline hashval_t hash (rtx); + static inline bool equal (rtx, const char *); +}; + +hashval_t +insn_hasher::hash (rtx x) +{ + return htab_hash_string (XSTR (x, 0)); +} + +bool +insn_hasher::equal (rtx x, const char *y) +{ + return strcmp (XSTR (x, 0), y) == 0; +} + +/* All define_insns and define_expands, hashed by name. */ +static hash_table *insns; + +/* Records the prototype suffix X for each invalid_X stub that has been + generated. */ +static hash_table *stubs; + +/* Records which C conditions have been wrapped in functions, as a mapping + from the C condition to the function name. */ +static hash_map *have_funcs; + +/* Output hook definitions for pattern NAME, which has target-insns.def + prototype PROTOTYPE. */ + +static void +def_target_insn (const char *name, const char *prototype) +{ + /* Get an upper-case form of NAME. */ + unsigned int i; + char *upper_name = XALLOCAVEC (char, strlen (name) + 1); + for (i = 0; name[i]; ++i) + upper_name[i] = TOUPPER (name[i]); + upper_name[i] = 0; + + /* Check that the prototype is valid and concatenate the types + together to get a suffix. */ + char *suffix = XALLOCAVEC (char, strlen (prototype) + 1); + i = 0; + unsigned int opno = 0; + for (const char *p = prototype; *p; ++p) + if (*p == 'x' && ISDIGIT (p[1])) + { + /* This should be a parameter name of the form "x". + That doesn't contribute to the suffix, so skip ahead and + process the following character. */ + char *endptr; + if (strtol (p + 1, &endptr, 10) != opno + || (*endptr != ',' && *endptr != ')')) + { + error ("invalid prototype for '%s'", name); + exit (FATAL_EXIT_CODE); + } + opno += 1; + p = endptr; + if (*p == ',') + suffix[i++] = '_'; + } + else if (*p == ')' || *p == ',') + { + /* We found the end of a parameter without finding a + parameter name. */ + if (strcmp (prototype, "(void)") != 0) + { + error ("argument %d of '%s' did not have the expected name", + opno, name); + exit (FATAL_EXIT_CODE); + } + } + else if (*p != '(' && !ISSPACE (*p)) + suffix[i++] = *p; + suffix[i] = 0; + + /* See whether we have an implementation of this pattern. */ + hashval_t hash = htab_hash_string (name); + int truth = 0; + const char *have_name = name; + if (rtx insn = insns->find_with_hash (name, hash)) + { + const char *test = XSTR (insn, 2); + truth = maybe_eval_c_test (test); + gcc_assert (truth != 0); + if (truth < 0) + { + /* Try to reuse an existing function that performs the same test. */ + bool existed; + const char *&entry = have_funcs->get_or_insert (test, &existed); + if (!existed) + { + entry = name; + printf ("\nstatic bool\n"); + printf ("target_have_%s (void)\n", name); + printf ("{\n"); + printf (" return "); + print_c_condition (test); + printf (";\n"); + printf ("}\n"); + } + have_name = entry; + } + printf ("\nstatic rtx_insn *\n"); + printf ("target_gen_%s %s\n", name, prototype); + printf ("{\n"); + if (truth < 0) + printf (" gcc_checking_assert (targetm.have_%s ());\n", name); + printf (" return insnify (gen_%s (", name); + for (i = 0; i < opno; ++i) + printf ("%sx%d", i == 0 ? "" : ", ", i); + printf ("));\n"); + printf ("}\n"); + } + else + { + const char **slot = stubs->find_slot (suffix, INSERT); + if (!*slot) + { + *slot = xstrdup (suffix); + printf ("\nstatic rtx_insn *\n"); + printf ("invalid_%s ", suffix); + const char *p = prototype; + while (*p) + { + if (p[0] == 'x' && ISDIGIT (p[1])) + { + char *endptr; + strtol (p + 1, &endptr, 10); + p = endptr; + } + else + fputc (*p++, stdout); + } + printf ("\n{\n"); + printf (" gcc_unreachable ();\n"); + printf ("}\n"); + } + } + printf ("\n#undef TARGET_HAVE_%s\n", upper_name); + printf ("#define TARGET_HAVE_%s ", upper_name); + if (truth == 0) + printf ("hook_bool_void_false\n"); + else if (truth == 1) + printf ("hook_bool_void_true\n"); + else + printf ("target_have_%s\n", have_name); + + printf ("#undef TARGET_GEN_%s\n", upper_name); + printf ("#define TARGET_GEN_%s ", upper_name); + if (truth == 0) + printf ("invalid_%s\n", suffix); + else + printf ("target_gen_%s\n", name); +} + +int +main (int argc, char **argv) +{ + int insn_code_number = 0; + + progname = "gentarget-def"; + + if (!init_rtx_reader_args (argc, argv)) + return (FATAL_EXIT_CODE); + + insns = new hash_table (31); + stubs = new hash_table (31); + have_funcs = new hash_map ; + + while (1) + { + int line_no; + rtx desc = read_md_rtx (&line_no, &insn_code_number); + if (desc == NULL) + break; + if (GET_CODE (desc) == DEFINE_INSN || GET_CODE (desc) == DEFINE_EXPAND) + { + const char *name = XSTR (desc, 0); + if (name[0] != 0 && name[0] != '*') + { + hashval_t hash = htab_hash_string (name); + rtx *slot = insns->find_slot_with_hash (name, hash, INSERT); + if (*slot) + { + message_with_line (line_no, "duplicate definition of '%s'", + name); + have_error = 1; + } + else + *slot = desc; + } + } + } + + printf ("/* Generated automatically by the program `gentarget-def'. */\n"); + printf ("#ifndef GCC_INSN_TARGET_DEF_H\n"); + printf ("#define GCC_INSN_TARGET_DEF_H\n"); + + /* Output a routine to convert an rtx to an rtx_insn sequence. + ??? At some point the gen_* functions themselves should return + rtx_insns. */ + printf ("\nstatic inline rtx_insn *\n"); + printf ("insnify (rtx x)\n"); + printf ("{\n"); + printf (" if (!x)\n"); + printf (" return NULL;\n"); + printf (" if (rtx_insn *insn = dyn_cast (x))\n"); + printf (" return insn;\n"); + printf (" start_sequence ();\n"); + printf (" emit (x);\n"); + printf (" rtx_insn *res = get_insns ();\n"); + printf (" end_sequence ();\n"); + printf (" return res;\n"); + printf ("}\n"); + +#define DEF_TARGET_INSN(INSN, ARGS) \ + def_target_insn (#INSN, #ARGS); +#include "target-insns.def" +#undef DEF_TARGET_INSN + + printf ("\n#endif /* GCC_INSN_TARGET_DEF_H */\n"); + + if (have_error || ferror (stdout) || fflush (stdout) || fclose (stdout)) + return FATAL_EXIT_CODE; + + return SUCCESS_EXIT_CODE; +} diff --git a/gcc/reorg.c b/gcc/reorg.c index 15f513c..b24a3f0 100644 --- a/gcc/reorg.c +++ b/gcc/reorg.c @@ -473,7 +473,7 @@ find_end_label (rtx kind) } else { - if (HAVE_epilogue && ! HAVE_return) + if (HAVE_epilogue && ! targetm.have_return ()) /* The RETURN insn has its delay slot filled so we cannot emit the label just before it. Since we already have an epilogue and cannot emit a new RETURN, we cannot @@ -483,10 +483,10 @@ find_end_label (rtx kind) /* Otherwise, make a new label and emit a RETURN and BARRIER, if needed. */ emit_label (label); - if (HAVE_return) + if (targetm.have_return ()) { /* The return we make may have delay slots too. */ - rtx pat = gen_return (); + rtx_insn *pat = targetm.gen_return (); rtx_insn *insn = emit_jump_insn (pat); set_return_jump_label (insn); emit_barrier (); @@ -3815,8 +3815,9 @@ dbr_schedule (rtx_insn *first) delete_related_insns (function_simple_return_label); need_return_insns = false; - need_return_insns |= HAVE_return && function_return_label != 0; - need_return_insns |= HAVE_simple_return && function_simple_return_label != 0; + need_return_insns |= targetm.have_return () && function_return_label != 0; + need_return_insns |= (targetm.have_simple_return () + && function_simple_return_label != 0); if (need_return_insns) make_return_insns (first); diff --git a/gcc/shrink-wrap.c b/gcc/shrink-wrap.c index 7cb68fd..51c0e7b 100644 --- a/gcc/shrink-wrap.c +++ b/gcc/shrink-wrap.c @@ -541,7 +541,7 @@ try_shrink_wrapping (edge *entry_edge, edge orig_entry_edge, break; } - if (flag_shrink_wrap && HAVE_simple_return + if (SHRINK_WRAPPING_ENABLED && (targetm.profile_before_prologue () || !crtl->profile) && nonempty_prologue && !crtl->calls_eh_return) { @@ -1004,8 +1004,8 @@ convert_to_simple_return (edge entry_edge, edge orig_entry_edge, bb = create_basic_block (NULL, NULL, exit_pred); BB_COPY_PARTITION (bb, e->src); - rtx_jump_insn *start = emit_jump_insn_after (gen_simple_return (), - BB_END (bb)); + rtx_insn *ret = targetm.gen_simple_return (); + rtx_jump_insn *start = emit_jump_insn_after (ret, BB_END (bb)); JUMP_LABEL (start) = simple_return_rtx; emit_barrier_after (start); diff --git a/gcc/shrink-wrap.h b/gcc/shrink-wrap.h index 5e7fac9..dda9b92 100644 --- a/gcc/shrink-wrap.h +++ b/gcc/shrink-wrap.h @@ -36,7 +36,8 @@ extern void convert_to_simple_return (edge entry_edge, edge orig_entry_edge, bitmap_head bb_flags, rtx_insn *returnjump, vec unconverted_simple_returns); -#define SHRINK_WRAPPING_ENABLED (flag_shrink_wrap && HAVE_simple_return) +#define SHRINK_WRAPPING_ENABLED \ + (flag_shrink_wrap && targetm.have_simple_return ()) #endif /* GCC_SHRINK_WRAP_H */ diff --git a/gcc/target-def.h b/gcc/target-def.h index 6167791..d24aad4 100644 --- a/gcc/target-def.h +++ b/gcc/target-def.h @@ -107,3 +107,4 @@ #include "hooks.h" #include "targhooks.h" +#include "insn-target-def.h" diff --git a/gcc/target-insns.def b/gcc/target-insns.def new file mode 100644 index 0000000..bf5b367 --- /dev/null +++ b/gcc/target-insns.def @@ -0,0 +1,34 @@ +/* Target instruction definitions. + Copyright (C) 2015 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 + . */ + +/* This file has one entry for each public pattern name that the target + can provide. It is only used if no distinction between operand modes + is necessary. If separate patterns are needed for different modes + (so as to distinguish addition of QImode values from addition of + HImode values, for example) then an optab should be used instead. + + Each entry has the form: + + DEF_TARGET_INSN (name, prototype) + + where NAME is the name of the pattern and PROTOTYPE is its C prototype. + The prototype should use parameter names of the form "x0", "x1", etc. + Patterns that take no operands should have a prototype "(void)". + + Instructions should be documented in md.texi rather than here. */ +DEF_TARGET_INSN (return, (void)) +DEF_TARGET_INSN (simple_return, (void)) diff --git a/gcc/target.def b/gcc/target.def index b606b81..dabb1f2 100644 --- a/gcc/target.def +++ b/gcc/target.def @@ -5864,6 +5864,19 @@ DEFHOOK HOOK_VECTOR_END (mode_switching) +#undef HOOK_PREFIX +#define HOOK_PREFIX "TARGET_" + +#define DEF_TARGET_INSN(NAME, PROTO) \ + DEFHOOK_UNDOC (have_##NAME, "", bool, (void), false) +#include "target-insns.def" +#undef DEF_TARGET_INSN + +#define DEF_TARGET_INSN(NAME, PROTO) \ + DEFHOOK_UNDOC (gen_##NAME, "", rtx_insn *, PROTO, NULL) +#include "target-insns.def" +#undef DEF_TARGET_INSN + /* Close the 'struct gcc_target' definition. */ HOOK_VECTOR_END (C90_EMPTY_HACK) -- cgit v1.1