blob: 71f3cb9529641c5b85a0fe36199852109bb111dc [file] [log] [blame]
/* Generate insn-target-def.h, an automatically-generated part of targetm.
Copyright (C) 1987-2018 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
<http://www.gnu.org/licenses/>. */
#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 <rtx_def>
{
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 <insn_hasher> *insns;
/* Records the prototype suffix X for each invalid_X stub that has been
generated. */
static hash_table <nofree_string_hash> *stubs;
/* Records which C conditions have been wrapped in functions, as a mapping
from the C condition to the function name. */
static hash_map <nofree_string_hash, const char *> *have_funcs;
/* Return true if the part of the prototype at P is for an argument
name. If so, point *END_OUT to the first character after the name.
If OPNO_OUT is nonnull, set *OPNO_OUT to the number of the associated
operand. If REQUIRED_OUT is nonnull, set *REQUIRED_OUT to whether the
.md pattern is required to match the operand. */
static bool
parse_argument (const char *p, const char **end_out,
unsigned int *opno_out = 0,
bool *required_out = 0)
{
while (ISSPACE (*p))
p++;
if (p[0] == 'x' && ISDIGIT (p[1]))
{
p += 1;
if (required_out)
*required_out = true;
}
else if (p[0] == 'o' && p[1] == 'p' && p[2] == 't' && ISDIGIT (p[3]))
{
p += 3;
if (required_out)
*required_out = false;
}
else
return false;
char *endptr;
unsigned int opno = strtol (p, &endptr, 10);
if (opno_out)
*opno_out = opno;
*end_out = endptr;
return true;
}
/* 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;
unsigned int required_ops = 0;
unsigned int this_opno;
bool required_p;
for (const char *p = prototype; *p; ++p)
if (parse_argument (p, &p, &this_opno, &required_p))
{
if (this_opno != opno || (*p != ',' && *p != ')'))
{
error ("invalid prototype for '%s'", name);
exit (FATAL_EXIT_CODE);
}
if (required_p && required_ops < opno)
{
error ("prototype for '%s' has required operands after"
" optional operands", name);
exit (FATAL_EXIT_CODE);
}
opno += 1;
if (required_p)
required_ops = opno;
/* Skip over ')'s. */
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))
{
pattern_stats stats;
get_pattern_stats (&stats, XVEC (insn, 1));
unsigned int actual_ops = stats.num_generator_args;
if (opno == required_ops && opno != actual_ops)
error_at (get_file_location (insn),
"'%s' must have %d operands (excluding match_dups)",
name, required_ops);
else if (actual_ops < required_ops)
error_at (get_file_location (insn),
"'%s' must have at least %d operands (excluding match_dups)",
name, required_ops);
else if (actual_ops > opno)
error_at (get_file_location (insn),
"'%s' must have no more than %d operands"
" (excluding match_dups)", name, opno);
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 ");
rtx_reader_ptr->print_c_condition (test);
printf (";\n");
printf ("}\n");
}
have_name = entry;
}
printf ("\nstatic rtx_insn *\n");
printf ("target_gen_%s ", name);
/* Print the prototype with the argument names after ACTUAL_OPS
removed. */
const char *p = prototype, *end;
while (*p)
if (parse_argument (p, &end, &this_opno) && this_opno >= actual_ops)
p = end;
else
fputc (*p++, stdout);
printf ("\n{\n");
if (truth < 0)
printf (" gcc_checking_assert (targetm.have_%s ());\n", name);
printf (" return insnify (gen_%s (", name);
for (i = 0; i < actual_ops; ++i)
printf ("%s%s%d", i == 0 ? "" : ", ",
i < required_ops ? "x" : "opt", 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);
/* Print the prototype with the argument names removed. */
const char *p = prototype;
while (*p)
if (!parse_argument (p, &p))
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);
printf ("#undef TARGET_CODE_FOR_%s\n", upper_name);
printf ("#define TARGET_CODE_FOR_%s ", upper_name);
if (truth == 0)
printf ("CODE_FOR_nothing\n");
else
printf ("CODE_FOR_%s\n", name);
}
/* Record the DEFINE_INSN or DEFINE_EXPAND described by INFO. */
static void
add_insn (md_rtx_info *info)
{
rtx def = info->def;
const char *name = XSTR (def, 0);
if (name[0] == 0 || name[0] == '*')
return;
hashval_t hash = htab_hash_string (name);
rtx *slot = insns->find_slot_with_hash (name, hash, INSERT);
if (*slot)
error_at (info->loc, "duplicate definition of '%s'", name);
else
*slot = def;
}
int
main (int argc, const char **argv)
{
progname = "gentarget-def";
if (!init_rtx_reader_args (argc, argv))
return (FATAL_EXIT_CODE);
insns = new hash_table <insn_hasher> (31);
stubs = new hash_table <nofree_string_hash> (31);
have_funcs = new hash_map <nofree_string_hash, const char *>;
md_rtx_info info;
while (read_md_rtx (&info))
switch (GET_CODE (info.def))
{
case DEFINE_INSN:
case DEFINE_EXPAND:
add_insn (&info);
break;
default:
break;
}
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 <rtx_insn *> (x))\n");
printf (" return insn;\n");
printf (" start_sequence ();\n");
printf (" emit (x, false);\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;
}