From a0a3423a0d047dd05d831a61d5974736965f79ef Mon Sep 17 00:00:00 2001 From: rth Date: Fri, 20 Nov 2009 23:51:52 +0000 Subject: [PATCH] * config/i386/i386-builtin-types.awk: New file. * config/i386/i386-builtin-types.def: New file. * config/i386/t-i386: Use them to build i386-builtin-types.inc. * config/i386/i386.c: Include it. (ix86_builtin_type_tab, ix86_get_builtin_type): New. (ix86_builtin_func_type_tab, ix86_get_builtin_func_type): New. (struct builtin_isa): Remove GTY marker. Replace tree type with ix86_builtin_func_type; add set_and_not_built_p. (def_builtin): Change type parameter to tcode; use ix86_get_builtin_func_type; update all callers. Accept zero mask to mean the builtin is unconditionally available. (ix86_add_new_builtins): Use set_and_not_built_p instead of type being set to NULL. (enum ix86_special_builtin_type, enum ix86_builtin_type): Remove. Update some users to rationalized enumeration codes from new include. (enum multi_arg_type): Remove. Replace all enumeration values with defines to new ix86_builtin_func_type. (ix86_init_mmx_sse_builtins): Don't build any types here. Defer all type resolution to def_builtin. (ix86_init_builtin_types): Split out from ... (ix86_init_builtins): ... here. Use ix86_get_builtin_func_type. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@154388 138bc75d-0d04-0410-961f-82ee72b054a4 --- gcc/ChangeLog | 24 + gcc/config/i386/i386-builtin-types.awk | 279 ++++ gcc/config/i386/i386-builtin-types.def | 375 ++++++ gcc/config/i386/i386.c | 2254 +++++--------------------------- gcc/config/i386/t-i386 | 11 +- 5 files changed, 1027 insertions(+), 1916 deletions(-) create mode 100644 gcc/config/i386/i386-builtin-types.awk create mode 100644 gcc/config/i386/i386-builtin-types.def diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 0375dbe..b93f35b 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,27 @@ +2009-11-20 Richard Henderson + + * config/i386/i386-builtin-types.awk: New file. + * config/i386/i386-builtin-types.def: New file. + * config/i386/t-i386: Use them to build i386-builtin-types.inc. + * config/i386/i386.c: Include it. + (ix86_builtin_type_tab, ix86_get_builtin_type): New. + (ix86_builtin_func_type_tab, ix86_get_builtin_func_type): New. + (struct builtin_isa): Remove GTY marker. Replace tree type with + ix86_builtin_func_type; add set_and_not_built_p. + (def_builtin): Change type parameter to tcode; use + ix86_get_builtin_func_type; update all callers. Accept zero mask + to mean the builtin is unconditionally available. + (ix86_add_new_builtins): Use set_and_not_built_p instead of type + being set to NULL. + (enum ix86_special_builtin_type, enum ix86_builtin_type): Remove. + Update some users to rationalized enumeration codes from new include. + (enum multi_arg_type): Remove. Replace all enumeration values + with defines to new ix86_builtin_func_type. + (ix86_init_mmx_sse_builtins): Don't build any types here. Defer + all type resolution to def_builtin. + (ix86_init_builtin_types): Split out from ... + (ix86_init_builtins): ... here. Use ix86_get_builtin_func_type. + 2009-11-20 Michael Meissner PR target/41787 diff --git a/gcc/config/i386/i386-builtin-types.awk b/gcc/config/i386/i386-builtin-types.awk new file mode 100644 index 0000000..0c54458 --- /dev/null +++ b/gcc/config/i386/i386-builtin-types.awk @@ -0,0 +1,279 @@ +# Copyright (C) 2009 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 +# . + +# Generates compressed tables for types for i386 builtin functions. + +function do_error(string) { + print FILENAME ":" FNR ": " string > "/dev/stderr" + errors = 1 +} + +function check_type(string) { + if (!(string in type_hash)) + do_error("undefined type code " string) +} + +# We can significantly reduce the size of the read-only tables +# by forcing the compiler to use a smaller implementation type +# for the enumerations. +function attribute_mode(count) { + # ??? Except that we get strange "comparison always false" warnings + # for comparisons between different elements of the enumeration. + # print "#ifdef __GNUC__" + # if (count < 256) + # print " __attribute__((__mode__(__QI__)))" + # else + # print " __attribute__((__mode__(__HI__)))" + # print "#endif" +} + +BEGIN { + FS = "[() \t,]+" + + prim_defs = 0 + vect_defs = 0 + ptr_defs = 0 + cptr_defs = 0 + func_defs = 0 + func_args = 0 + alias_defs = 0 +} + +# Skip blank lines or comments. +/^[ \t]*(#|$)/ { + next +} + +$1 == "DEF_PRIMITIVE_TYPE" { + if (NF == 4) { + type_hash[$2] = 1 + prim_name[prim_defs] = $2 + prim_base[prim_defs] = $3 + prim_defs++ + } else + do_error("DEF_PRIMITIVE_TYPE expected 2 arguments") + next +} + +$1 == "DEF_VECTOR_TYPE" { + if (NF == 4) { + check_type($3) + type_hash[$2] = 1 + vect_mode[vect_defs] = $2 + vect_base[vect_defs] = $3 + vect_defs++ + } else + do_error("DEF_VECTOR_TYPE expected 2 arguments") + next +} + +$1 == "DEF_POINTER_TYPE" { + if (NF == 4) { + check_type($3) + type_hash[$2] = 1 + ptr_name[ptr_defs] = $2 + ptr_base[ptr_defs] = $3 + ptr_defs++ + } else if (NF == 5) { + check_type($3) + if ($4 == "CONST") { + type_hash[$2] = 1 + cptr_name[cptr_defs] = $2 + cptr_base[cptr_defs] = $3 + cptr_defs++ + } else + do_error("invalid qualifier \"" $4 "\"") + } + else + do_error("DEF_POINTER_TYPE expected 2 or 3 arguments") + next +} + +$1 == "DEF_FUNCTION_TYPE" { + func_start[func_defs] = func_args + for (i = 2; i < NF; ++i) { + check_type($i) + func_types[func_args++] = $i + } + + if (NF < 3) + do_error("DEF_FUNCTION_TYPE expected at least 1 argument") + else if (NF == 3) + name = $2 "_FTYPE_VOID" + else { + name = $2 "_FTYPE" + for (i = 3; i < NF; ++i) + name = name "_" $i + } + func_hash[name] = 1 + func_name[func_defs++] = name + next +} + +$1 == "DEF_FUNCTION_TYPE_ALIAS" { + if (NF == 4) { + if ($2 in func_hash) { + alias_base[alias_defs] = $2 + alias_name[alias_defs] = $2 "_" $3 + alias_defs++ + } else + do_error("undefined function code " $2) + } else + do_error("DEF_FUNCTION_TYPE_ALIAS expected 2 arguments") + next +} + +{ + do_error("unknown directive \"" $1 "\""); +} + +END { + if (errors) + exit 1 + + print "/* This file is auto-generated by i386-builtin-types.awk. */\n" + + # This first enumeration contains all of the non-function types. + print "enum ix86_builtin_type {" + for (i = 0; i < prim_defs; ++i) + print " IX86_BT_" prim_name[i] "," + print " IX86_BT_LAST_PRIM = IX86_BT_" prim_name[i-1] "," + for (i = 0; i < vect_defs; ++i) + print " IX86_BT_" vect_mode[i] "," + print " IX86_BT_LAST_VECT = IX86_BT_" vect_mode[i-1] "," + for (i = 0; i < ptr_defs; ++i) + print " IX86_BT_" ptr_name[i] "," + print " IX86_BT_LAST_PTR = IX86_BT_" ptr_name[i-1] "," + for (i = 0; i < cptr_defs; ++i) + print " IX86_BT_" cptr_name[i] "," + print " IX86_BT_LAST_CPTR = IX86_BT_" cptr_name[i-1] "\n}" + attribute_mode(prim_defs + vect_defs + ptr_defs + cptr_defs) + print ";\n\n" + + # We can't tabularize the initialization of the primitives, since + # at least one of them is created via a local variable. That's ok, + # just create a nice big macro to do all the work. + print "#define DEFINE_BUILTIN_PRIMITIVE_TYPES \\" + for (i = 0; i < prim_defs; ++i) { + printf " ix86_builtin_type_tab[(int)IX86_BT_" prim_name[i] \ + "] = " prim_base[i] + if (i < prim_defs - 1) + print ", \\" + } + print "\n\n" + + # The vector types are defined via two tables defining the real + # machine mode and the builtin primitive type. We use two tables + # rather than a structure to avoid structure padding and save space. + print "static const enum machine_mode ix86_builtin_type_vect_mode[] = {" + for (i = 0; i < vect_defs; ++i) { + if (i == 0) + printf " " + else if (i % 6 == 0) + printf ",\n " + else + printf ", " + printf vect_mode[i] "mode" + } + print "\n};\n\n" + + print "static const enum ix86_builtin_type " \ + "ix86_builtin_type_vect_base[] = {" + for (i = 0; i < vect_defs; ++i) { + if (i == 0) + printf " " + else if (i % 4 == 0) + printf ",\n " + else + printf ", " + printf "IX86_BT_" vect_base[i] + } + print "\n};\n\n" + + # The pointer types are defined via a single table defining the + # builtin primitive type. The const-ness of the pointer is taken + # from the enumeration value > IX86_BT_LAST_PTR. + print "static const enum ix86_builtin_type " \ + "ix86_builtin_type_ptr_base[] = {" + for (i = 0; i < ptr_defs; ++i) { + if (i == 0) + printf " " + else if (i % 4 == 0) + printf "\n " + printf " IX86_BT_" ptr_base[i] "," + } + print "\n /* pointer-to-constant defs start here */" + for (i = 0; i < cptr_defs; ++i) { + if (i == 0) + printf " " + else if (i % 4 == 0) + printf ",\n " + else + printf ", " + printf "IX86_BT_" cptr_base[i] + } + print "\n};\n\n" + + # This second enumeration contains all of the function types. + print "enum ix86_builtin_func_type {" + for (i = 0; i < func_defs; ++i) + print " " func_name[i] "," + print " IX86_BT_LAST_FUNC = " func_name[i-1] "," + for (i = 0; i < alias_defs; ++i) + print " " alias_name[i] "," + print " IX86_BT_LAST_ALIAS = " alias_name[i-1] "\n}" + attribute_mode(func_defs + alias_defs) + print ";\n\n" + + # The function types are defined via two tables. The first contains + # ranges consiting of the function's return type, followed by all of + # the function argument types. The ranges for all of the builtin + # functions are smooshed together in the same array. The second array + # contains, for each builtin, the index of the function's return type + # within the first array. + print "static const enum ix86_builtin_type ix86_builtin_func_args[] = {" + for (i = 0; i < func_args; ++i) { + if (i == 0) + printf " " + else if (i % 4 == 0) + printf ",\n " + else + printf ", " + printf "IX86_BT_" func_types[i] + } + print "\n};\n\n" + + print "static const unsigned short ix86_builtin_func_start[] = {" + for (i = 0; i < func_defs; ++i) { + if (i == 0) + printf " " + else if (i % 10 == 0) + printf "\n " + printf " " func_start[i] "," + } + print " " func_args "\n};\n\n" + + print "static const enum ix86_builtin_func_type " \ + "ix86_builtin_func_alias_base[] = {" + for (i = 0; i < alias_defs; ++i) { + if (i == 0) + printf " " + else + printf ",\n " + printf alias_base[i] + } + print "\n};" +} diff --git a/gcc/config/i386/i386-builtin-types.def b/gcc/config/i386/i386-builtin-types.def new file mode 100644 index 0000000..3f0b20b --- /dev/null +++ b/gcc/config/i386/i386-builtin-types.def @@ -0,0 +1,375 @@ +# This file provides a declarative way of describing the types that +# are used when declaring ix86 builtin functions. It is processed +# with i386-builtin-type.awk to produce C code. +# +# DEF_PRIMITIVE_TYPE (ENUM, TYPE) +# +# The ENUM is an identifier indicating which type is being defined. +# TYPE is a variable that represents the type. +# ??? Note that the awk program expects a single token for TYPE. +# At present, that's all that's required; revisit if it turns out +# that we need more than that. +# +# DEF_VECTOR_TYPE (ENUM, TYPE) +# +# This describes a vector type. ENUM doubles as both the identifier +# to define in the enumeration as well as the mode of the vector; TYPE is +# the enumeral for the inner type which should of course name a type of +# the proper inner mode. +# +# DEF_POINTER_TYPE (ENUM, TYPE [, CONST]) +# +# This describes a pointer type. ENUM is an identifier as above; +# TYPE is the enumeral for the type pointed to. An optional third +# argument is the keyword CONST, which defines this to be a pointer to +# a constant type. +# +# DEF_FUNCTION_TYPE (RETURN, ARGN*) +# +# This describes a function type. The return type and the arguments +# are the enumerals defined above. The enumeration name for the +# function is formed by RETURN ## _FTYPE_ ## ARG1 ## _ ## ARG2 ... +# +# DEF_FUNCTION_TYPE_ALIAS (ENUM, SUFFIX) +# +# This defines an enumeration ENUM ## _ ## SUFFIX and arranges for +# the function type to be copied from ENUM. This is used to control +# how the expanders treat the function. +# + +DEF_PRIMITIVE_TYPE (VOID, void_type_node) +DEF_PRIMITIVE_TYPE (CHAR, char_type_node) +DEF_PRIMITIVE_TYPE (UCHAR, unsigned_char_type_node) +DEF_PRIMITIVE_TYPE (QI, intQI_type_node) +DEF_PRIMITIVE_TYPE (HI, intHI_type_node) +DEF_PRIMITIVE_TYPE (SI, intSI_type_node) +DEF_PRIMITIVE_TYPE (DI, long_long_integer_type_node) +DEF_PRIMITIVE_TYPE (USHORT, short_unsigned_type_node) +DEF_PRIMITIVE_TYPE (INT, integer_type_node) +DEF_PRIMITIVE_TYPE (UINT, unsigned_type_node) +DEF_PRIMITIVE_TYPE (UNSIGNED, unsigned_type_node) +DEF_PRIMITIVE_TYPE (LONGLONG, long_long_integer_type_node) +DEF_PRIMITIVE_TYPE (ULONGLONG, long_long_unsigned_type_node) +DEF_PRIMITIVE_TYPE (UINT8, unsigned_char_type_node) +DEF_PRIMITIVE_TYPE (UINT16, short_unsigned_type_node) +DEF_PRIMITIVE_TYPE (INT64, long_long_integer_type_node) +DEF_PRIMITIVE_TYPE (UINT64, long_long_unsigned_type_node) +DEF_PRIMITIVE_TYPE (FLOAT, float_type_node) +DEF_PRIMITIVE_TYPE (DOUBLE, double_type_node) +DEF_PRIMITIVE_TYPE (FLOAT80, float80_type_node) +DEF_PRIMITIVE_TYPE (FLOAT128, float128_type_node) + +DEF_VECTOR_TYPE (V16HI, HI) +DEF_VECTOR_TYPE (V16QI, CHAR) +DEF_VECTOR_TYPE (V1DI, DI) +DEF_VECTOR_TYPE (V2DF, DOUBLE) +DEF_VECTOR_TYPE (V2DI, DI) +DEF_VECTOR_TYPE (V2SF, FLOAT) +DEF_VECTOR_TYPE (V2SI, SI) +DEF_VECTOR_TYPE (V32QI, CHAR) +DEF_VECTOR_TYPE (V4DF, DOUBLE) +DEF_VECTOR_TYPE (V4DI, DI) +DEF_VECTOR_TYPE (V4HI, HI) +DEF_VECTOR_TYPE (V4SF, FLOAT) +DEF_VECTOR_TYPE (V4SI, SI) +DEF_VECTOR_TYPE (V8HI, HI) +DEF_VECTOR_TYPE (V8QI, CHAR) +DEF_VECTOR_TYPE (V8SF, FLOAT) +DEF_VECTOR_TYPE (V8SI, SI) + +DEF_POINTER_TYPE (PCCHAR, CHAR, CONST) +DEF_POINTER_TYPE (PCDOUBLE, DOUBLE, CONST) +DEF_POINTER_TYPE (PCFLOAT, FLOAT, CONST) +DEF_POINTER_TYPE (PCHAR, CHAR) +DEF_POINTER_TYPE (PCVOID, VOID, CONST) +DEF_POINTER_TYPE (PDOUBLE, DOUBLE) +DEF_POINTER_TYPE (PFLOAT, FLOAT) +DEF_POINTER_TYPE (PINT, INT) +DEF_POINTER_TYPE (PULONGLONG, ULONGLONG) +DEF_POINTER_TYPE (PUNSIGNED, UNSIGNED) + +DEF_POINTER_TYPE (PV2DF, V2DF) +DEF_POINTER_TYPE (PV2DI, V2DI) +DEF_POINTER_TYPE (PV2SF, V2SF) +DEF_POINTER_TYPE (PV4DF, V4DF) +DEF_POINTER_TYPE (PV4DI, V4DI) +DEF_POINTER_TYPE (PV4SF, V4SF) +DEF_POINTER_TYPE (PV8SF, V8SF) + +DEF_POINTER_TYPE (PCV2DF, V2DF, CONST) +DEF_POINTER_TYPE (PCV2SF, V2SF, CONST) +DEF_POINTER_TYPE (PCV4DF, V4DF, CONST) +DEF_POINTER_TYPE (PCV4SF, V4SF, CONST) +DEF_POINTER_TYPE (PCV8SF, V8SF, CONST) + +DEF_FUNCTION_TYPE (FLOAT128) +DEF_FUNCTION_TYPE (UINT64) +DEF_FUNCTION_TYPE (UNSIGNED) +DEF_FUNCTION_TYPE (VOID) + +DEF_FUNCTION_TYPE (FLOAT, FLOAT) +DEF_FUNCTION_TYPE (FLOAT128, FLOAT128) +DEF_FUNCTION_TYPE (INT, INT) +DEF_FUNCTION_TYPE (INT, V16QI) +DEF_FUNCTION_TYPE (INT, V2DF) +DEF_FUNCTION_TYPE (INT, V4DF) +DEF_FUNCTION_TYPE (INT, V4SF) +DEF_FUNCTION_TYPE (INT, V8QI) +DEF_FUNCTION_TYPE (INT, V8SF) +DEF_FUNCTION_TYPE (INT64, INT64) +DEF_FUNCTION_TYPE (INT64, V2DF) +DEF_FUNCTION_TYPE (INT64, V4SF) +DEF_FUNCTION_TYPE (UINT64, INT) +DEF_FUNCTION_TYPE (UINT64, PUNSIGNED) +DEF_FUNCTION_TYPE (V16QI, PCCHAR) +DEF_FUNCTION_TYPE (V16QI, V16QI) +DEF_FUNCTION_TYPE (V2DF, PCDOUBLE) +DEF_FUNCTION_TYPE (V2DF, V2DF) +DEF_FUNCTION_TYPE (V2DF, V2SI) +DEF_FUNCTION_TYPE (V2DF, V4DF) +DEF_FUNCTION_TYPE (V2DF, V4SF) +DEF_FUNCTION_TYPE (V2DF, V4SI) +DEF_FUNCTION_TYPE (V2DI, PV2DI) +DEF_FUNCTION_TYPE (V2DI, V16QI) +DEF_FUNCTION_TYPE (V2DI, V2DI) +DEF_FUNCTION_TYPE (V2DI, V4SI) +DEF_FUNCTION_TYPE (V2DI, V8HI) +DEF_FUNCTION_TYPE (V2SF, V2SF) +DEF_FUNCTION_TYPE (V2SF, V2SI) +DEF_FUNCTION_TYPE (V2SI, V2DF) +DEF_FUNCTION_TYPE (V2SI, V2SF) +DEF_FUNCTION_TYPE (V2SI, V2SI) +DEF_FUNCTION_TYPE (V2SI, V4SF) +DEF_FUNCTION_TYPE (V32QI, PCCHAR) +DEF_FUNCTION_TYPE (V4DF, PCDOUBLE) +DEF_FUNCTION_TYPE (V4DF, PCV2DF) +DEF_FUNCTION_TYPE (V4DF, V2DF) +DEF_FUNCTION_TYPE (V4DF, V4DF) +DEF_FUNCTION_TYPE (V4DF, V4SF) +DEF_FUNCTION_TYPE (V4DF, V4SI) +DEF_FUNCTION_TYPE (V4HI, V4HI) +DEF_FUNCTION_TYPE (V4SF, PCFLOAT) +DEF_FUNCTION_TYPE (V4SF, V2DF) +DEF_FUNCTION_TYPE (V4SF, V4DF) +DEF_FUNCTION_TYPE (V4SF, V4SF) +DEF_FUNCTION_TYPE (V4SF, V4SI) +DEF_FUNCTION_TYPE (V4SF, V8SF) +DEF_FUNCTION_TYPE (V4SI, V16QI) +DEF_FUNCTION_TYPE (V4SI, V2DF) +DEF_FUNCTION_TYPE (V4SI, V4DF) +DEF_FUNCTION_TYPE (V4SI, V4SF) +DEF_FUNCTION_TYPE (V4SI, V4SI) +DEF_FUNCTION_TYPE (V4SI, V8HI) +DEF_FUNCTION_TYPE (V4SI, V8SI) +DEF_FUNCTION_TYPE (V8HI, V16QI) +DEF_FUNCTION_TYPE (V8HI, V8HI) +DEF_FUNCTION_TYPE (V8QI, V8QI) +DEF_FUNCTION_TYPE (V8SF, PCFLOAT) +DEF_FUNCTION_TYPE (V8SF, PCV4SF) +DEF_FUNCTION_TYPE (V8SF, V4SF) +DEF_FUNCTION_TYPE (V8SF, V8SF) +DEF_FUNCTION_TYPE (V8SF, V8SI) +DEF_FUNCTION_TYPE (V8SI, V4SI) +DEF_FUNCTION_TYPE (V8SI, V8SF) +DEF_FUNCTION_TYPE (VOID, PCVOID) +DEF_FUNCTION_TYPE (VOID, UNSIGNED) + +DEF_FUNCTION_TYPE (DI, V2DI, INT) +DEF_FUNCTION_TYPE (DOUBLE, V2DF, INT) +DEF_FUNCTION_TYPE (FLOAT, V4SF, INT) +DEF_FUNCTION_TYPE (FLOAT128, FLOAT128, FLOAT128) +DEF_FUNCTION_TYPE (HI, V4HI, INT) +DEF_FUNCTION_TYPE (HI, V8HI, INT) +DEF_FUNCTION_TYPE (INT, V2DF, V2DF) +DEF_FUNCTION_TYPE (INT, V2DI, V2DI) +DEF_FUNCTION_TYPE (INT, V4DF, V4DF) +DEF_FUNCTION_TYPE (INT, V4DI, V4DI) +DEF_FUNCTION_TYPE (INT, V4SF, V4SF) +DEF_FUNCTION_TYPE (INT, V8SF, V8SF) +DEF_FUNCTION_TYPE (QI, V16QI, INT) +DEF_FUNCTION_TYPE (QI, V8QI, INT) +DEF_FUNCTION_TYPE (SI, V2SI, INT) +DEF_FUNCTION_TYPE (SI, V4SI, INT) +DEF_FUNCTION_TYPE (UINT, UINT, UCHAR) +DEF_FUNCTION_TYPE (UINT, UINT, UINT) +DEF_FUNCTION_TYPE (UINT, UINT, USHORT) +DEF_FUNCTION_TYPE (UINT16, UINT16, INT) +DEF_FUNCTION_TYPE (UINT64, UINT64, UINT64) +DEF_FUNCTION_TYPE (UINT8, UINT8, INT) +DEF_FUNCTION_TYPE (V16QI, V16QI, SI) +DEF_FUNCTION_TYPE (V16QI, V16QI, V16QI) +DEF_FUNCTION_TYPE (V16QI, V8HI, V8HI) +DEF_FUNCTION_TYPE (V1DI, V1DI, SI) +DEF_FUNCTION_TYPE (V1DI, V1DI, V1DI) +DEF_FUNCTION_TYPE (V1DI, V2SI, V2SI) +DEF_FUNCTION_TYPE (V1DI, V8QI, V8QI) +DEF_FUNCTION_TYPE (V2DF, PCV2DF, V2DF) +DEF_FUNCTION_TYPE (V2DF, V2DF, DI) +DEF_FUNCTION_TYPE (V2DF, V2DF, INT) +DEF_FUNCTION_TYPE (V2DF, V2DF, PCDOUBLE) +DEF_FUNCTION_TYPE (V2DF, V2DF, SI) +DEF_FUNCTION_TYPE (V2DF, V2DF, V2DF) +DEF_FUNCTION_TYPE (V2DF, V2DF, V2DI) +DEF_FUNCTION_TYPE (V2DF, V2DF, V4SF) +DEF_FUNCTION_TYPE (V2DF, V4DF, INT) +DEF_FUNCTION_TYPE (V2DI, V16QI, V16QI) +DEF_FUNCTION_TYPE (V2DI, V2DF, V2DF) +DEF_FUNCTION_TYPE (V2DI, V2DI, INT) +DEF_FUNCTION_TYPE (V2DI, V2DI, SI) +DEF_FUNCTION_TYPE (V2DI, V2DI, V16QI) +DEF_FUNCTION_TYPE (V2DI, V2DI, V2DI) +DEF_FUNCTION_TYPE (V2DI, V4SI, V4SI) +DEF_FUNCTION_TYPE (V2SF, V2SF, V2SF) +DEF_FUNCTION_TYPE (V2SI, INT, INT) +DEF_FUNCTION_TYPE (V2SI, V2SF, V2SF) +DEF_FUNCTION_TYPE (V2SI, V2SI, SI) +DEF_FUNCTION_TYPE (V2SI, V2SI, V2SI) +DEF_FUNCTION_TYPE (V2SI, V4HI, V4HI) +DEF_FUNCTION_TYPE (V4DF, PCV4DF, V4DF) +DEF_FUNCTION_TYPE (V4DF, V4DF, INT) +DEF_FUNCTION_TYPE (V4DF, V4DF, V4DF) +DEF_FUNCTION_TYPE (V4DF, V4DF, V4DI) +DEF_FUNCTION_TYPE (V4HI, V2SI, V2SI) +DEF_FUNCTION_TYPE (V4HI, V4HI, INT) +DEF_FUNCTION_TYPE (V4HI, V4HI, SI) +DEF_FUNCTION_TYPE (V4HI, V4HI, V4HI) +DEF_FUNCTION_TYPE (V4HI, V8QI, V8QI) +DEF_FUNCTION_TYPE (V4SF, PCV4SF, V4SF) +DEF_FUNCTION_TYPE (V4SF, V4SF, DI) +DEF_FUNCTION_TYPE (V4SF, V4SF, INT) +DEF_FUNCTION_TYPE (V4SF, V4SF, PCV2SF) +DEF_FUNCTION_TYPE (V4SF, V4SF, SI) +DEF_FUNCTION_TYPE (V4SF, V4SF, V2DF) +DEF_FUNCTION_TYPE (V4SF, V4SF, V2SI) +DEF_FUNCTION_TYPE (V4SF, V4SF, V4SF) +DEF_FUNCTION_TYPE (V4SF, V4SF, V4SI) +DEF_FUNCTION_TYPE (V4SF, V8SF, INT) +DEF_FUNCTION_TYPE (V4SI, V2DF, V2DF) +DEF_FUNCTION_TYPE (V4SI, V4SF, V4SF) +DEF_FUNCTION_TYPE (V4SI, V4SI, INT) +DEF_FUNCTION_TYPE (V4SI, V4SI, SI) +DEF_FUNCTION_TYPE (V4SI, V4SI, V4SI) +DEF_FUNCTION_TYPE (V4SI, V8HI, V8HI) +DEF_FUNCTION_TYPE (V4SI, V8SI, INT) +DEF_FUNCTION_TYPE (V8HI, V16QI, V16QI) +DEF_FUNCTION_TYPE (V8HI, V4SI, V4SI) +DEF_FUNCTION_TYPE (V8HI, V8HI, INT) +DEF_FUNCTION_TYPE (V8HI, V8HI, SI) +DEF_FUNCTION_TYPE (V8HI, V8HI, V8HI) +DEF_FUNCTION_TYPE (V8QI, V4HI, V4HI) +DEF_FUNCTION_TYPE (V8QI, V8QI, V8QI) +DEF_FUNCTION_TYPE (V8SF, PCV8SF, V8SF) +DEF_FUNCTION_TYPE (V8SF, V8SF, INT) +DEF_FUNCTION_TYPE (V8SF, V8SF, V8SF) +DEF_FUNCTION_TYPE (V8SF, V8SF, V8SI) +DEF_FUNCTION_TYPE (VOID, PCHAR, V16QI) +DEF_FUNCTION_TYPE (VOID, PCHAR, V32QI) +DEF_FUNCTION_TYPE (VOID, PDOUBLE, V2DF) +DEF_FUNCTION_TYPE (VOID, PDOUBLE, V4DF) +DEF_FUNCTION_TYPE (VOID, PFLOAT, V4SF) +DEF_FUNCTION_TYPE (VOID, PFLOAT, V8SF) +DEF_FUNCTION_TYPE (VOID, PINT, INT) +DEF_FUNCTION_TYPE (VOID, PULONGLONG, ULONGLONG) +DEF_FUNCTION_TYPE (VOID, PV2DI, V2DI) +DEF_FUNCTION_TYPE (VOID, PV2SF, V4SF) +DEF_FUNCTION_TYPE (VOID, PV4DI, V4DI) +DEF_FUNCTION_TYPE (VOID, UNSIGNED, UNSIGNED) + +DEF_FUNCTION_TYPE (INT, V16QI, V16QI, INT) +DEF_FUNCTION_TYPE (UCHAR, UINT, UINT, UINT) +DEF_FUNCTION_TYPE (UCHAR, UINT64, UINT, UINT) +DEF_FUNCTION_TYPE (UCHAR, USHORT, UINT, USHORT) +DEF_FUNCTION_TYPE (V16HI, V16HI, V16HI, V16HI) +DEF_FUNCTION_TYPE (V16QI, V16QI, QI, INT) +DEF_FUNCTION_TYPE (V16QI, V16QI, V16QI, INT) +DEF_FUNCTION_TYPE (V16QI, V16QI, V16QI, V16QI) +DEF_FUNCTION_TYPE (V1DI, V1DI, V1DI, INT) +DEF_FUNCTION_TYPE (V2DF, V2DF, V2DF, INT) +DEF_FUNCTION_TYPE (V2DF, V2DF, V2DF, V2DF) +DEF_FUNCTION_TYPE (V2DI, V2DI, DI, INT) +DEF_FUNCTION_TYPE (V2DI, V2DI, UINT, UINT) +DEF_FUNCTION_TYPE (V2DI, V2DI, V2DI, INT) +DEF_FUNCTION_TYPE (V2DI, V2DI, V2DI, V2DI) +DEF_FUNCTION_TYPE (V32QI, V32QI, V32QI, V32QI) +DEF_FUNCTION_TYPE (V4DF, V4DF, V2DF, INT) +DEF_FUNCTION_TYPE (V4DF, V4DF, V4DF, INT) +DEF_FUNCTION_TYPE (V4DF, V4DF, V4DF, V4DF) +DEF_FUNCTION_TYPE (V4DI, V4DI, V4DI, V4DI) +DEF_FUNCTION_TYPE (V4HI, V4HI, HI, INT) +DEF_FUNCTION_TYPE (V4SF, V4SF, FLOAT, INT) +DEF_FUNCTION_TYPE (V4SF, V4SF, V4SF, INT) +DEF_FUNCTION_TYPE (V4SF, V4SF, V4SF, V4SF) +DEF_FUNCTION_TYPE (V4SI, V4SI, SI, INT) +DEF_FUNCTION_TYPE (V4SI, V4SI, V4SI, INT) +DEF_FUNCTION_TYPE (V4SI, V4SI, V4SI, V2DI) +DEF_FUNCTION_TYPE (V4SI, V4SI, V4SI, V4SI) +DEF_FUNCTION_TYPE (V8HI, V8HI, HI, INT) +DEF_FUNCTION_TYPE (V8HI, V8HI, V8HI, INT) +DEF_FUNCTION_TYPE (V8HI, V8HI, V8HI, V4SI) +DEF_FUNCTION_TYPE (V8HI, V8HI, V8HI, V8HI) +DEF_FUNCTION_TYPE (V8SF, V8SF, V4SF, INT) +DEF_FUNCTION_TYPE (V8SF, V8SF, V8SF, INT) +DEF_FUNCTION_TYPE (V8SF, V8SF, V8SF, V8SF) +DEF_FUNCTION_TYPE (V8SI, V8SI, V4SI, INT) +DEF_FUNCTION_TYPE (V8SI, V8SI, V8SI, INT) +DEF_FUNCTION_TYPE (V8SI, V8SI, V8SI, V8SI) +DEF_FUNCTION_TYPE (VOID, PCVOID, UNSIGNED, UNSIGNED) +DEF_FUNCTION_TYPE (VOID, PV2DF, V2DF, V2DF) +DEF_FUNCTION_TYPE (VOID, PV4DF, V4DF, V4DF) +DEF_FUNCTION_TYPE (VOID, PV4SF, V4SF, V4SF) +DEF_FUNCTION_TYPE (VOID, PV8SF, V8SF, V8SF) +DEF_FUNCTION_TYPE (VOID, UINT, UINT, UINT) +DEF_FUNCTION_TYPE (VOID, UINT64, UINT, UINT) +DEF_FUNCTION_TYPE (VOID, USHORT, UINT, USHORT) +DEF_FUNCTION_TYPE (VOID, V16QI, V16QI, PCHAR) +DEF_FUNCTION_TYPE (VOID, V8QI, V8QI, PCHAR) + +DEF_FUNCTION_TYPE (V2DI, V2DI, V2DI, UINT, UINT) +DEF_FUNCTION_TYPE (V4HI, HI, HI, HI, HI) + +DEF_FUNCTION_TYPE (INT, V16QI, INT, V16QI, INT, INT) +DEF_FUNCTION_TYPE (V16QI, V16QI, INT, V16QI, INT, INT) + +DEF_FUNCTION_TYPE (V8QI, QI, QI, QI, QI, QI, QI, QI, QI) + +DEF_FUNCTION_TYPE_ALIAS (INT_FTYPE_V2DF_V2DF, PTEST) +DEF_FUNCTION_TYPE_ALIAS (INT_FTYPE_V2DI_V2DI, PTEST) +DEF_FUNCTION_TYPE_ALIAS (INT_FTYPE_V4DF_V4DF, PTEST) +DEF_FUNCTION_TYPE_ALIAS (INT_FTYPE_V4DI_V4DI, PTEST) +DEF_FUNCTION_TYPE_ALIAS (INT_FTYPE_V4SF_V4SF, PTEST) +DEF_FUNCTION_TYPE_ALIAS (INT_FTYPE_V8SF_V8SF, PTEST) + +DEF_FUNCTION_TYPE_ALIAS (V2DF_FTYPE_V2DF, VEC_MERGE) +DEF_FUNCTION_TYPE_ALIAS (V4SF_FTYPE_V4SF, VEC_MERGE) + +DEF_FUNCTION_TYPE_ALIAS (V1DI_FTYPE_V1DI_SI, COUNT) +DEF_FUNCTION_TYPE_ALIAS (V2DI_FTYPE_V2DI_SI, COUNT) +DEF_FUNCTION_TYPE_ALIAS (V2SI_FTYPE_V2SI_SI, COUNT) +DEF_FUNCTION_TYPE_ALIAS (V4HI_FTYPE_V4HI_SI, COUNT) +DEF_FUNCTION_TYPE_ALIAS (V4SI_FTYPE_V4SI_SI, COUNT) +DEF_FUNCTION_TYPE_ALIAS (V8HI_FTYPE_V8HI_SI, COUNT) +DEF_FUNCTION_TYPE_ALIAS (V1DI_FTYPE_V1DI_V1DI, COUNT) +DEF_FUNCTION_TYPE_ALIAS (V2DI_FTYPE_V2DI_V2DI, COUNT) +DEF_FUNCTION_TYPE_ALIAS (V2SI_FTYPE_V2SI_V2SI, COUNT) +DEF_FUNCTION_TYPE_ALIAS (V4HI_FTYPE_V4HI_V4HI, COUNT) +DEF_FUNCTION_TYPE_ALIAS (V4SI_FTYPE_V4SI_V4SI, COUNT) +DEF_FUNCTION_TYPE_ALIAS (V8HI_FTYPE_V8HI_V8HI, COUNT) + +DEF_FUNCTION_TYPE_ALIAS (V2DF_FTYPE_V2DF_V2DF, SWAP) +DEF_FUNCTION_TYPE_ALIAS (V4SF_FTYPE_V4SF_V4SF, SWAP) + +DEF_FUNCTION_TYPE_ALIAS (V2DI_FTYPE_V2DI_INT, CONVERT) +DEF_FUNCTION_TYPE_ALIAS (V2DI_FTYPE_V2DI_V2DI_INT, CONVERT) +DEF_FUNCTION_TYPE_ALIAS (V1DI_FTYPE_V1DI_V1DI_INT, CONVERT) + +DEF_FUNCTION_TYPE_ALIAS (V16QI_FTYPE_V16QI_V16QI, CMP) +DEF_FUNCTION_TYPE_ALIAS (V2DI_FTYPE_V2DI_V2DI, CMP) +DEF_FUNCTION_TYPE_ALIAS (V4SI_FTYPE_V4SI_V4SI, CMP) +DEF_FUNCTION_TYPE_ALIAS (V8HI_FTYPE_V8HI_V8HI, CMP) + +DEF_FUNCTION_TYPE_ALIAS (V16QI_FTYPE_V16QI_V16QI, TF) +DEF_FUNCTION_TYPE_ALIAS (V2DF_FTYPE_V2DF_V2DF, TF) +DEF_FUNCTION_TYPE_ALIAS (V2DI_FTYPE_V2DI_V2DI, TF) +DEF_FUNCTION_TYPE_ALIAS (V4SF_FTYPE_V4SF_V4SF, TF) +DEF_FUNCTION_TYPE_ALIAS (V4SI_FTYPE_V4SI_V4SI, TF) +DEF_FUNCTION_TYPE_ALIAS (V8HI_FTYPE_V8HI_V8HI, TF) diff --git a/gcc/config/i386/i386.c b/gcc/config/i386/i386.c index 69e4e61..b85ef63 100644 --- a/gcc/config/i386/i386.c +++ b/gcc/config/i386/i386.c @@ -20194,6 +20194,108 @@ ix86_trampoline_init (rtx m_tramp, tree fndecl, rtx chain_value) #endif } +/* The following file contains several enumerations and data structures + built from the definitions in i386-builtin-types.def. */ + +#include "i386-builtin-types.inc" + +/* Table for the ix86 builtin non-function types. */ +static GTY(()) tree ix86_builtin_type_tab[(int) IX86_BT_LAST_CPTR + 1]; + +/* Retrieve an element from the above table, building some of + the types lazily. */ + +static tree +ix86_get_builtin_type (enum ix86_builtin_type tcode) +{ + unsigned int index; + tree type, itype; + + gcc_assert ((unsigned)tcode < ARRAY_SIZE(ix86_builtin_type_tab)); + + type = ix86_builtin_type_tab[(int) tcode]; + if (type != NULL) + return type; + + gcc_assert (tcode > IX86_BT_LAST_PRIM); + if (tcode <= IX86_BT_LAST_VECT) + { + enum machine_mode mode; + + index = tcode - IX86_BT_LAST_PRIM - 1; + itype = ix86_get_builtin_type (ix86_builtin_type_vect_base[index]); + mode = ix86_builtin_type_vect_mode[index]; + + type = build_vector_type_for_mode (itype, mode); + } + else + { + int quals; + + index = tcode - IX86_BT_LAST_VECT - 1; + if (tcode <= IX86_BT_LAST_PTR) + quals = TYPE_UNQUALIFIED; + else + quals = TYPE_QUAL_CONST; + + itype = ix86_get_builtin_type (ix86_builtin_type_ptr_base[index]); + if (quals != TYPE_UNQUALIFIED) + itype = build_qualified_type (itype, quals); + + type = build_pointer_type (itype); + } + + ix86_builtin_type_tab[(int) tcode] = type; + return type; +} + +/* Table for the ix86 builtin function types. */ +static GTY(()) tree ix86_builtin_func_type_tab[(int) IX86_BT_LAST_ALIAS + 1]; + +/* Retrieve an element from the above table, building some of + the types lazily. */ + +static tree +ix86_get_builtin_func_type (enum ix86_builtin_func_type tcode) +{ + tree type; + + gcc_assert ((unsigned)tcode < ARRAY_SIZE (ix86_builtin_func_type_tab)); + + type = ix86_builtin_func_type_tab[(int) tcode]; + if (type != NULL) + return type; + + if (tcode <= IX86_BT_LAST_FUNC) + { + unsigned start = ix86_builtin_func_start[(int) tcode]; + unsigned after = ix86_builtin_func_start[(int) tcode + 1]; + tree rtype, atype, args = void_list_node; + unsigned i; + + rtype = ix86_get_builtin_type (ix86_builtin_func_args[start]); + for (i = after - 1; i > start; --i) + { + atype = ix86_get_builtin_type (ix86_builtin_func_args[i]); + args = tree_cons (NULL, atype, args); + } + + type = build_function_type (rtype, args); + } + else + { + unsigned index = tcode - IX86_BT_LAST_FUNC - 1; + enum ix86_builtin_func_type icode; + + icode = ix86_builtin_func_alias_base[index]; + type = ix86_get_builtin_func_type (icode); + } + + ix86_builtin_func_type_tab[(int) tcode] = type; + return type; +} + + /* Codes for all the SSE/MMX builtins. */ enum ix86_builtins { @@ -21124,34 +21226,36 @@ static GTY(()) tree ix86_builtins[(int) IX86_BUILTIN_MAX]; /* Table of all of the builtin functions that are possible with different ISA's but are waiting to be built until a function is declared to use that ISA. */ -struct GTY(()) builtin_isa { - tree type; /* builtin type to use in the declaration */ +struct builtin_isa { const char *name; /* function name */ + enum ix86_builtin_func_type tcode; /* type to use in the declaration */ int isa; /* isa_flags this builtin is defined for */ bool const_p; /* true if the declaration is constant */ + bool set_and_not_built_p; }; -static GTY(()) struct builtin_isa ix86_builtins_isa[(int) IX86_BUILTIN_MAX]; +static struct builtin_isa ix86_builtins_isa[(int) IX86_BUILTIN_MAX]; /* Add an ix86 target builtin function with CODE, NAME and TYPE. Save the MASK - * of which isa_flags to use in the ix86_builtins_isa array. Stores the - * function decl in the ix86_builtins array. Returns the function decl or - * NULL_TREE, if the builtin was not added. - * - * If the front end has a special hook for builtin functions, delay adding - * builtin functions that aren't in the current ISA until the ISA is changed - * with function specific optimization. Doing so, can save about 300K for the - * default compiler. When the builtin is expanded, check at that time whether - * it is valid. - * - * If the front end doesn't have a special hook, record all builtins, even if - * it isn't an instruction set in the current ISA in case the user uses - * function specific options for a different ISA, so that we don't get scope - * errors if a builtin is added in the middle of a function scope. */ + of which isa_flags to use in the ix86_builtins_isa array. Stores the + function decl in the ix86_builtins array. Returns the function decl or + NULL_TREE, if the builtin was not added. + + If the front end has a special hook for builtin functions, delay adding + builtin functions that aren't in the current ISA until the ISA is changed + with function specific optimization. Doing so, can save about 300K for the + default compiler. When the builtin is expanded, check at that time whether + it is valid. + + If the front end doesn't have a special hook, record all builtins, even if + it isn't an instruction set in the current ISA in case the user uses + function specific options for a different ISA, so that we don't get scope + errors if a builtin is added in the middle of a function scope. */ static inline tree -def_builtin (int mask, const char *name, tree type, enum ix86_builtins code) +def_builtin (int mask, const char *name, enum ix86_builtin_func_type tcode, + enum ix86_builtins code) { tree decl = NULL_TREE; @@ -21159,22 +21263,25 @@ def_builtin (int mask, const char *name, tree type, enum ix86_builtins code) { ix86_builtins_isa[(int) code].isa = mask; - if ((mask & ix86_isa_flags) != 0 + if (mask == 0 + || (mask & ix86_isa_flags) != 0 || (lang_hooks.builtin_function == lang_hooks.builtin_function_ext_scope)) { - decl = add_builtin_function (name, type, code, BUILT_IN_MD, NULL, - NULL_TREE); + tree type = ix86_get_builtin_func_type (tcode); + decl = add_builtin_function (name, type, code, BUILT_IN_MD, + NULL, NULL_TREE); ix86_builtins[(int) code] = decl; - ix86_builtins_isa[(int) code].type = NULL_TREE; + ix86_builtins_isa[(int) code].set_and_not_built_p = false; } else { ix86_builtins[(int) code] = NULL_TREE; - ix86_builtins_isa[(int) code].const_p = false; - ix86_builtins_isa[(int) code].type = type; + ix86_builtins_isa[(int) code].tcode = tcode; ix86_builtins_isa[(int) code].name = name; + ix86_builtins_isa[(int) code].const_p = false; + ix86_builtins_isa[(int) code].set_and_not_built_p = true; } } @@ -21184,10 +21291,10 @@ def_builtin (int mask, const char *name, tree type, enum ix86_builtins code) /* Like def_builtin, but also marks the function decl "const". */ static inline tree -def_builtin_const (int mask, const char *name, tree type, - enum ix86_builtins code) +def_builtin_const (int mask, const char *name, + enum ix86_builtin_func_type tcode, enum ix86_builtins code) { - tree decl = def_builtin (mask, name, type, code); + tree decl = def_builtin (mask, name, tcode, code); if (decl) TREE_READONLY (decl) = 1; else @@ -21204,20 +21311,23 @@ static void ix86_add_new_builtins (int isa) { int i; - tree decl; for (i = 0; i < (int)IX86_BUILTIN_MAX; i++) { if ((ix86_builtins_isa[i].isa & isa) != 0 - && ix86_builtins_isa[i].type != NULL_TREE) + && ix86_builtins_isa[i].set_and_not_built_p) { + tree decl, type; + + /* Don't define the builtin again. */ + ix86_builtins_isa[i].set_and_not_built_p = false; + + type = ix86_get_builtin_func_type (ix86_builtins_isa[i].tcode); decl = add_builtin_function_ext_scope (ix86_builtins_isa[i].name, - ix86_builtins_isa[i].type, - i, BUILT_IN_MD, NULL, + type, i, BUILT_IN_MD, NULL, NULL_TREE); ix86_builtins[i] = decl; - ix86_builtins_isa[i].type = NULL_TREE; if (ix86_builtins_isa[i].const_p) TREE_READONLY (decl) = 1; } @@ -21292,214 +21402,6 @@ static const struct builtin_description bdesc_pcmpistr[] = { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpistr, "__builtin_ia32_pcmpistriz128", IX86_BUILTIN_PCMPISTRZ128, UNKNOWN, (int) CCZmode }, }; -/* Special builtin types */ -enum ix86_special_builtin_type -{ - SPECIAL_FTYPE_UNKNOWN, - VOID_FTYPE_VOID, - UINT64_FTYPE_VOID, - UINT64_FTYPE_PUNSIGNED, - V32QI_FTYPE_PCCHAR, - V16QI_FTYPE_PCCHAR, - V8SF_FTYPE_PCV4SF, - V8SF_FTYPE_PCFLOAT, - V4DF_FTYPE_PCV2DF, - V4DF_FTYPE_PCDOUBLE, - V4SF_FTYPE_PCFLOAT, - V2DF_FTYPE_PCDOUBLE, - V8SF_FTYPE_PCV8SF_V8SF, - V4DF_FTYPE_PCV4DF_V4DF, - V4SF_FTYPE_V4SF_PCV2SF, - V4SF_FTYPE_PCV4SF_V4SF, - V2DF_FTYPE_V2DF_PCDOUBLE, - V2DF_FTYPE_PCV2DF_V2DF, - V2DI_FTYPE_PV2DI, - VOID_FTYPE_PV2SF_V4SF, - VOID_FTYPE_PV4DI_V4DI, - VOID_FTYPE_PV2DI_V2DI, - VOID_FTYPE_PCHAR_V32QI, - VOID_FTYPE_PCHAR_V16QI, - VOID_FTYPE_PFLOAT_V8SF, - VOID_FTYPE_PFLOAT_V4SF, - VOID_FTYPE_PDOUBLE_V4DF, - VOID_FTYPE_PDOUBLE_V2DF, - VOID_FTYPE_PDI_DI, - VOID_FTYPE_PINT_INT, - VOID_FTYPE_PV8SF_V8SF_V8SF, - VOID_FTYPE_PV4DF_V4DF_V4DF, - VOID_FTYPE_PV4SF_V4SF_V4SF, - VOID_FTYPE_PV2DF_V2DF_V2DF, - VOID_FTYPE_USHORT_UINT_USHORT, - VOID_FTYPE_UINT_UINT_UINT, - VOID_FTYPE_UINT64_UINT_UINT, - UCHAR_FTYPE_USHORT_UINT_USHORT, - UCHAR_FTYPE_UINT_UINT_UINT, - UCHAR_FTYPE_UINT64_UINT_UINT -}; - -/* Builtin types */ -enum ix86_builtin_type -{ - FTYPE_UNKNOWN, - FLOAT128_FTYPE_FLOAT128, - FLOAT_FTYPE_FLOAT, - FLOAT128_FTYPE_FLOAT128_FLOAT128, - INT_FTYPE_V8SF_V8SF_PTEST, - INT_FTYPE_V4DI_V4DI_PTEST, - INT_FTYPE_V4DF_V4DF_PTEST, - INT_FTYPE_V4SF_V4SF_PTEST, - INT_FTYPE_V2DI_V2DI_PTEST, - INT_FTYPE_V2DF_V2DF_PTEST, - INT_FTYPE_INT, - UINT64_FTYPE_INT, - INT64_FTYPE_INT64, - INT64_FTYPE_V4SF, - INT64_FTYPE_V2DF, - INT_FTYPE_V16QI, - INT_FTYPE_V8QI, - INT_FTYPE_V8SF, - INT_FTYPE_V4DF, - INT_FTYPE_V4SF, - INT_FTYPE_V2DF, - V16QI_FTYPE_V16QI, - V8SI_FTYPE_V8SF, - V8SI_FTYPE_V4SI, - V8HI_FTYPE_V8HI, - V8HI_FTYPE_V16QI, - V8QI_FTYPE_V8QI, - V8SF_FTYPE_V8SF, - V8SF_FTYPE_V8SI, - V8SF_FTYPE_V4SF, - V4SI_FTYPE_V4SI, - V4SI_FTYPE_V16QI, - V4SI_FTYPE_V8SI, - V4SI_FTYPE_V8HI, - V4SI_FTYPE_V4DF, - V4SI_FTYPE_V4SF, - V4SI_FTYPE_V2DF, - V4HI_FTYPE_V4HI, - V4DF_FTYPE_V4DF, - V4DF_FTYPE_V4SI, - V4DF_FTYPE_V4SF, - V4DF_FTYPE_V2DF, - V4SF_FTYPE_V4DF, - V4SF_FTYPE_V4SF, - V4SF_FTYPE_V4SF_VEC_MERGE, - V4SF_FTYPE_V8SF, - V4SF_FTYPE_V4SI, - V4SF_FTYPE_V2DF, - V2DI_FTYPE_V2DI, - V2DI_FTYPE_V16QI, - V2DI_FTYPE_V8HI, - V2DI_FTYPE_V4SI, - V2DF_FTYPE_V2DF, - V2DF_FTYPE_V2DF_VEC_MERGE, - V2DF_FTYPE_V4SI, - V2DF_FTYPE_V4DF, - V2DF_FTYPE_V4SF, - V2DF_FTYPE_V2SI, - V2SI_FTYPE_V2SI, - V2SI_FTYPE_V4SF, - V2SI_FTYPE_V2SF, - V2SI_FTYPE_V2DF, - V2SF_FTYPE_V2SF, - V2SF_FTYPE_V2SI, - V16QI_FTYPE_V16QI_V16QI, - V16QI_FTYPE_V8HI_V8HI, - V8QI_FTYPE_V8QI_V8QI, - V8QI_FTYPE_V4HI_V4HI, - V8HI_FTYPE_V8HI_V8HI, - V8HI_FTYPE_V8HI_V8HI_COUNT, - V8HI_FTYPE_V16QI_V16QI, - V8HI_FTYPE_V4SI_V4SI, - V8HI_FTYPE_V8HI_SI_COUNT, - V8SF_FTYPE_V8SF_V8SF, - V8SF_FTYPE_V8SF_V8SI, - V4SI_FTYPE_V4SI_V4SI, - V4SI_FTYPE_V4SI_V4SI_COUNT, - V4SI_FTYPE_V8HI_V8HI, - V4SI_FTYPE_V4SF_V4SF, - V4SI_FTYPE_V2DF_V2DF, - V4SI_FTYPE_V4SI_SI_COUNT, - V4HI_FTYPE_V4HI_V4HI, - V4HI_FTYPE_V4HI_V4HI_COUNT, - V4HI_FTYPE_V8QI_V8QI, - V4HI_FTYPE_V2SI_V2SI, - V4HI_FTYPE_V4HI_SI_COUNT, - V4DF_FTYPE_V4DF_V4DF, - V4DF_FTYPE_V4DF_V4DI, - V4SF_FTYPE_V4SF_V4SF, - V4SF_FTYPE_V4SF_V4SF_SWAP, - V4SF_FTYPE_V4SF_V4SI, - V4SF_FTYPE_V4SF_V2SI, - V4SF_FTYPE_V4SF_V2DF, - V4SF_FTYPE_V4SF_DI, - V4SF_FTYPE_V4SF_SI, - V2DI_FTYPE_V2DI_V2DI, - V2DI_FTYPE_V2DI_V2DI_COUNT, - V2DI_FTYPE_V16QI_V16QI, - V2DI_FTYPE_V4SI_V4SI, - V2DI_FTYPE_V2DI_V16QI, - V2DI_FTYPE_V2DF_V2DF, - V2DI_FTYPE_V2DI_SI_COUNT, - V2SI_FTYPE_V2SI_V2SI, - V2SI_FTYPE_V2SI_V2SI_COUNT, - V2SI_FTYPE_V4HI_V4HI, - V2SI_FTYPE_V2SF_V2SF, - V2SI_FTYPE_V2SI_SI_COUNT, - V2DF_FTYPE_V2DF_V2DF, - V2DF_FTYPE_V2DF_V2DF_SWAP, - V2DF_FTYPE_V2DF_V4SF, - V2DF_FTYPE_V2DF_V2DI, - V2DF_FTYPE_V2DF_DI, - V2DF_FTYPE_V2DF_SI, - V2SF_FTYPE_V2SF_V2SF, - V1DI_FTYPE_V1DI_V1DI, - V1DI_FTYPE_V1DI_V1DI_COUNT, - V1DI_FTYPE_V8QI_V8QI, - V1DI_FTYPE_V2SI_V2SI, - V1DI_FTYPE_V1DI_SI_COUNT, - UINT64_FTYPE_UINT64_UINT64, - UINT_FTYPE_UINT_UINT, - UINT_FTYPE_UINT_USHORT, - UINT_FTYPE_UINT_UCHAR, - UINT16_FTYPE_UINT16_INT, - UINT8_FTYPE_UINT8_INT, - V8HI_FTYPE_V8HI_INT, - V4SI_FTYPE_V4SI_INT, - V4HI_FTYPE_V4HI_INT, - V8SF_FTYPE_V8SF_INT, - V4SI_FTYPE_V8SI_INT, - V4SF_FTYPE_V8SF_INT, - V2DF_FTYPE_V4DF_INT, - V4DF_FTYPE_V4DF_INT, - V4SF_FTYPE_V4SF_INT, - V2DI_FTYPE_V2DI_INT, - V2DI2TI_FTYPE_V2DI_INT, - V2DF_FTYPE_V2DF_INT, - V16QI_FTYPE_V16QI_V16QI_V16QI, - V8SF_FTYPE_V8SF_V8SF_V8SF, - V4DF_FTYPE_V4DF_V4DF_V4DF, - V4SF_FTYPE_V4SF_V4SF_V4SF, - V2DF_FTYPE_V2DF_V2DF_V2DF, - V16QI_FTYPE_V16QI_V16QI_INT, - V8SI_FTYPE_V8SI_V8SI_INT, - V8SI_FTYPE_V8SI_V4SI_INT, - V8HI_FTYPE_V8HI_V8HI_INT, - V8SF_FTYPE_V8SF_V8SF_INT, - V8SF_FTYPE_V8SF_V4SF_INT, - V4SI_FTYPE_V4SI_V4SI_INT, - V4DF_FTYPE_V4DF_V4DF_INT, - V4DF_FTYPE_V4DF_V2DF_INT, - V4SF_FTYPE_V4SF_V4SF_INT, - V2DI_FTYPE_V2DI_V2DI_INT, - V2DI2TI_FTYPE_V2DI_V2DI_INT, - V1DI2DI_FTYPE_V1DI_V1DI_INT, - V2DF_FTYPE_V2DF_V2DF_INT, - V2DI_FTYPE_V2DI_UINT_UINT, - V2DI_FTYPE_V2DI_V2DI_UINT_UINT -}; - /* Special builtins with variable number of arguments. */ static const struct builtin_description bdesc_special_args[] = { @@ -21524,7 +21426,7 @@ static const struct builtin_description bdesc_special_args[] = /* SSE or 3DNow!A */ { OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A, CODE_FOR_sse_sfence, "__builtin_ia32_sfence", IX86_BUILTIN_SFENCE, UNKNOWN, (int) VOID_FTYPE_VOID }, - { OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A, CODE_FOR_sse_movntdi, "__builtin_ia32_movntq", IX86_BUILTIN_MOVNTQ, UNKNOWN, (int) VOID_FTYPE_PDI_DI }, + { OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A, CODE_FOR_sse_movntdi, "__builtin_ia32_movntq", IX86_BUILTIN_MOVNTQ, UNKNOWN, (int) VOID_FTYPE_PULONGLONG_ULONGLONG }, /* SSE2 */ { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_lfence, "__builtin_ia32_lfence", IX86_BUILTIN_LFENCE, UNKNOWN, (int) VOID_FTYPE_VOID }, @@ -21937,7 +21839,7 @@ static const struct builtin_description bdesc_args[] = { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtsd2ss, "__builtin_ia32_cvtsd2ss", IX86_BUILTIN_CVTSD2SS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V2DF }, { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtss2sd, "__builtin_ia32_cvtss2sd", IX86_BUILTIN_CVTSS2SD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V4SF }, - { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ashlti3, "__builtin_ia32_pslldqi128", IX86_BUILTIN_PSLLDQI128, UNKNOWN, (int) V2DI2TI_FTYPE_V2DI_INT }, + { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ashlti3, "__builtin_ia32_pslldqi128", IX86_BUILTIN_PSLLDQI128, UNKNOWN, (int) V2DI_FTYPE_V2DI_INT_CONVERT }, { OPTION_MASK_ISA_SSE2, CODE_FOR_ashlv8hi3, "__builtin_ia32_psllwi128", IX86_BUILTIN_PSLLWI128, UNKNOWN, (int) V8HI_FTYPE_V8HI_SI_COUNT }, { OPTION_MASK_ISA_SSE2, CODE_FOR_ashlv4si3, "__builtin_ia32_pslldi128", IX86_BUILTIN_PSLLDI128, UNKNOWN, (int) V4SI_FTYPE_V4SI_SI_COUNT }, { OPTION_MASK_ISA_SSE2, CODE_FOR_ashlv2di3, "__builtin_ia32_psllqi128", IX86_BUILTIN_PSLLQI128, UNKNOWN, (int) V2DI_FTYPE_V2DI_SI_COUNT }, @@ -21945,7 +21847,7 @@ static const struct builtin_description bdesc_args[] = { OPTION_MASK_ISA_SSE2, CODE_FOR_ashlv4si3, "__builtin_ia32_pslld128", IX86_BUILTIN_PSLLD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI_COUNT }, { OPTION_MASK_ISA_SSE2, CODE_FOR_ashlv2di3, "__builtin_ia32_psllq128", IX86_BUILTIN_PSLLQ128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI_COUNT }, - { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_lshrti3, "__builtin_ia32_psrldqi128", IX86_BUILTIN_PSRLDQI128, UNKNOWN, (int) V2DI2TI_FTYPE_V2DI_INT }, + { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_lshrti3, "__builtin_ia32_psrldqi128", IX86_BUILTIN_PSRLDQI128, UNKNOWN, (int) V2DI_FTYPE_V2DI_INT_CONVERT }, { OPTION_MASK_ISA_SSE2, CODE_FOR_lshrv8hi3, "__builtin_ia32_psrlwi128", IX86_BUILTIN_PSRLWI128, UNKNOWN, (int) V8HI_FTYPE_V8HI_SI_COUNT }, { OPTION_MASK_ISA_SSE2, CODE_FOR_lshrv4si3, "__builtin_ia32_psrldi128", IX86_BUILTIN_PSRLDI128, UNKNOWN, (int) V4SI_FTYPE_V4SI_SI_COUNT }, { OPTION_MASK_ISA_SSE2, CODE_FOR_lshrv2di3, "__builtin_ia32_psrlqi128", IX86_BUILTIN_PSRLQI128, UNKNOWN, (int) V2DI_FTYPE_V2DI_SI_COUNT }, @@ -22018,8 +21920,8 @@ static const struct builtin_description bdesc_args[] = { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_psignv2si3, "__builtin_ia32_psignd", IX86_BUILTIN_PSIGND, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI }, /* SSSE3. */ - { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_palignrti, "__builtin_ia32_palignr128", IX86_BUILTIN_PALIGNR128, UNKNOWN, (int) V2DI2TI_FTYPE_V2DI_V2DI_INT }, - { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_palignrdi, "__builtin_ia32_palignr", IX86_BUILTIN_PALIGNR, UNKNOWN, (int) V1DI2DI_FTYPE_V1DI_V1DI_INT }, + { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_palignrti, "__builtin_ia32_palignr128", IX86_BUILTIN_PALIGNR128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI_INT_CONVERT }, + { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_palignrdi, "__builtin_ia32_palignr", IX86_BUILTIN_PALIGNR, UNKNOWN, (int) V1DI_FTYPE_V1DI_V1DI_INT_CONVERT }, /* SSE4.1 */ { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_blendpd, "__builtin_ia32_blendpd", IX86_BUILTIN_BLENDPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF_INT }, @@ -22211,58 +22113,54 @@ static const struct builtin_description bdesc_args[] = }; /* FMA4 and XOP. */ -enum multi_arg_type { - MULTI_ARG_UNKNOWN, - MULTI_ARG_3_SF, - MULTI_ARG_3_DF, - MULTI_ARG_3_SF2, - MULTI_ARG_3_DF2, - MULTI_ARG_3_DI, - MULTI_ARG_3_SI, - MULTI_ARG_3_SI_DI, - MULTI_ARG_3_HI, - MULTI_ARG_3_HI_SI, - MULTI_ARG_3_QI, - MULTI_ARG_3_DI2, - MULTI_ARG_3_SI2, - MULTI_ARG_3_HI2, - MULTI_ARG_3_QI2, - MULTI_ARG_2_SF, - MULTI_ARG_2_DF, - MULTI_ARG_2_DI, - MULTI_ARG_2_SI, - MULTI_ARG_2_HI, - MULTI_ARG_2_QI, - MULTI_ARG_2_DI_IMM, - MULTI_ARG_2_SI_IMM, - MULTI_ARG_2_HI_IMM, - MULTI_ARG_2_QI_IMM, - MULTI_ARG_2_DI_CMP, - MULTI_ARG_2_SI_CMP, - MULTI_ARG_2_HI_CMP, - MULTI_ARG_2_QI_CMP, - MULTI_ARG_2_DI_TF, - MULTI_ARG_2_SI_TF, - MULTI_ARG_2_HI_TF, - MULTI_ARG_2_QI_TF, - MULTI_ARG_2_SF_TF, - MULTI_ARG_2_DF_TF, - MULTI_ARG_1_SF, - MULTI_ARG_1_DF, - MULTI_ARG_1_SF2, - MULTI_ARG_1_DF2, - MULTI_ARG_1_DI, - MULTI_ARG_1_SI, - MULTI_ARG_1_HI, - MULTI_ARG_1_QI, - MULTI_ARG_1_SI_DI, - MULTI_ARG_1_HI_DI, - MULTI_ARG_1_HI_SI, - MULTI_ARG_1_QI_DI, - MULTI_ARG_1_QI_SI, - MULTI_ARG_1_QI_HI - -}; +#define MULTI_ARG_3_SF V4SF_FTYPE_V4SF_V4SF_V4SF +#define MULTI_ARG_3_DF V2DF_FTYPE_V2DF_V2DF_V2DF +#define MULTI_ARG_3_SF2 V8SF_FTYPE_V8SF_V8SF_V8SF +#define MULTI_ARG_3_DF2 V4DF_FTYPE_V4DF_V4DF_V4DF +#define MULTI_ARG_3_DI V2DI_FTYPE_V2DI_V2DI_V2DI +#define MULTI_ARG_3_SI V4SI_FTYPE_V4SI_V4SI_V4SI +#define MULTI_ARG_3_SI_DI V4SI_FTYPE_V4SI_V4SI_V2DI +#define MULTI_ARG_3_HI V8HI_FTYPE_V8HI_V8HI_V8HI +#define MULTI_ARG_3_HI_SI V8HI_FTYPE_V8HI_V8HI_V4SI +#define MULTI_ARG_3_QI V16QI_FTYPE_V16QI_V16QI_V16QI +#define MULTI_ARG_3_DI2 V4DI_FTYPE_V4DI_V4DI_V4DI +#define MULTI_ARG_3_SI2 V8SI_FTYPE_V8SI_V8SI_V8SI +#define MULTI_ARG_3_HI2 V16HI_FTYPE_V16HI_V16HI_V16HI +#define MULTI_ARG_3_QI2 V32QI_FTYPE_V32QI_V32QI_V32QI +#define MULTI_ARG_2_SF V4SF_FTYPE_V4SF_V4SF +#define MULTI_ARG_2_DF V2DF_FTYPE_V2DF_V2DF +#define MULTI_ARG_2_DI V2DI_FTYPE_V2DI_V2DI +#define MULTI_ARG_2_SI V4SI_FTYPE_V4SI_V4SI +#define MULTI_ARG_2_HI V8HI_FTYPE_V8HI_V8HI +#define MULTI_ARG_2_QI V16QI_FTYPE_V16QI_V16QI +#define MULTI_ARG_2_DI_IMM V2DI_FTYPE_V2DI_SI +#define MULTI_ARG_2_SI_IMM V4SI_FTYPE_V4SI_SI +#define MULTI_ARG_2_HI_IMM V8HI_FTYPE_V8HI_SI +#define MULTI_ARG_2_QI_IMM V16QI_FTYPE_V16QI_SI +#define MULTI_ARG_2_DI_CMP V2DI_FTYPE_V2DI_V2DI_CMP +#define MULTI_ARG_2_SI_CMP V4SI_FTYPE_V4SI_V4SI_CMP +#define MULTI_ARG_2_HI_CMP V8HI_FTYPE_V8HI_V8HI_CMP +#define MULTI_ARG_2_QI_CMP V16QI_FTYPE_V16QI_V16QI_CMP +#define MULTI_ARG_2_SF_TF V4SF_FTYPE_V4SF_V4SF_TF +#define MULTI_ARG_2_DF_TF V2DF_FTYPE_V2DF_V2DF_TF +#define MULTI_ARG_2_DI_TF V2DI_FTYPE_V2DI_V2DI_TF +#define MULTI_ARG_2_SI_TF V4SI_FTYPE_V4SI_V4SI_TF +#define MULTI_ARG_2_HI_TF V8HI_FTYPE_V8HI_V8HI_TF +#define MULTI_ARG_2_QI_TF V16QI_FTYPE_V16QI_V16QI_TF +#define MULTI_ARG_1_SF V4SF_FTYPE_V4SF +#define MULTI_ARG_1_DF V2DF_FTYPE_V2DF +#define MULTI_ARG_1_SF2 V8SF_FTYPE_V8SF +#define MULTI_ARG_1_DF2 V4DF_FTYPE_V4DF +#define MULTI_ARG_1_DI V2DI_FTYPE_V2DI +#define MULTI_ARG_1_SI V4SI_FTYPE_V4SI +#define MULTI_ARG_1_HI V8HI_FTYPE_V8HI +#define MULTI_ARG_1_QI V16QI_FTYPE_V16QI +#define MULTI_ARG_1_SI_DI V2DI_FTYPE_V4SI +#define MULTI_ARG_1_HI_DI V2DI_FTYPE_V8HI +#define MULTI_ARG_1_HI_SI V4SI_FTYPE_V8HI +#define MULTI_ARG_1_QI_DI V2DI_FTYPE_V16QI +#define MULTI_ARG_1_QI_SI V4SI_FTYPE_V16QI +#define MULTI_ARG_1_QI_HI V8HI_FTYPE_V16QI static const struct builtin_description bdesc_multi_arg[] = { @@ -22467,975 +22365,19 @@ static void ix86_init_mmx_sse_builtins (void) { const struct builtin_description * d; + enum ix86_builtin_func_type ftype; size_t i; - tree V16QI_type_node = build_vector_type_for_mode (char_type_node, V16QImode); - tree V2SI_type_node = build_vector_type_for_mode (intSI_type_node, V2SImode); - tree V1DI_type_node - = build_vector_type_for_mode (long_long_integer_type_node, V1DImode); - tree V2SF_type_node = build_vector_type_for_mode (float_type_node, V2SFmode); - tree V2DI_type_node - = build_vector_type_for_mode (long_long_integer_type_node, V2DImode); - tree V2DF_type_node = build_vector_type_for_mode (double_type_node, V2DFmode); - tree V4SF_type_node = build_vector_type_for_mode (float_type_node, V4SFmode); - tree V4SI_type_node = build_vector_type_for_mode (intSI_type_node, V4SImode); - tree V4HI_type_node = build_vector_type_for_mode (intHI_type_node, V4HImode); - tree V8QI_type_node = build_vector_type_for_mode (char_type_node, V8QImode); - tree V8HI_type_node = build_vector_type_for_mode (intHI_type_node, V8HImode); - - tree pchar_type_node = build_pointer_type (char_type_node); - tree pcchar_type_node - = build_pointer_type (build_type_variant (char_type_node, 1, 0)); - tree pfloat_type_node = build_pointer_type (float_type_node); - tree pcfloat_type_node - = build_pointer_type (build_type_variant (float_type_node, 1, 0)); - tree pv2sf_type_node = build_pointer_type (V2SF_type_node); - tree pcv2sf_type_node - = build_pointer_type (build_type_variant (V2SF_type_node, 1, 0)); - tree pv2di_type_node = build_pointer_type (V2DI_type_node); - tree pdi_type_node = build_pointer_type (long_long_unsigned_type_node); - - /* Comparisons. */ - tree int_ftype_v4sf_v4sf - = build_function_type_list (integer_type_node, - V4SF_type_node, V4SF_type_node, NULL_TREE); - tree v4si_ftype_v4sf_v4sf - = build_function_type_list (V4SI_type_node, - V4SF_type_node, V4SF_type_node, NULL_TREE); - /* MMX/SSE/integer conversions. */ - tree int_ftype_v4sf - = build_function_type_list (integer_type_node, - V4SF_type_node, NULL_TREE); - tree int64_ftype_v4sf - = build_function_type_list (long_long_integer_type_node, - V4SF_type_node, NULL_TREE); - tree int_ftype_v8qi - = build_function_type_list (integer_type_node, V8QI_type_node, NULL_TREE); - tree v4sf_ftype_v4sf_int - = build_function_type_list (V4SF_type_node, - V4SF_type_node, integer_type_node, NULL_TREE); - tree v4sf_ftype_v4sf_int64 - = build_function_type_list (V4SF_type_node, - V4SF_type_node, long_long_integer_type_node, - NULL_TREE); - tree v4sf_ftype_v4sf_v2si - = build_function_type_list (V4SF_type_node, - V4SF_type_node, V2SI_type_node, NULL_TREE); - - /* Miscellaneous. */ - tree v8qi_ftype_v4hi_v4hi - = build_function_type_list (V8QI_type_node, - V4HI_type_node, V4HI_type_node, NULL_TREE); - tree v4hi_ftype_v2si_v2si - = build_function_type_list (V4HI_type_node, - V2SI_type_node, V2SI_type_node, NULL_TREE); - tree v4sf_ftype_v4sf_v4sf_int - = build_function_type_list (V4SF_type_node, - V4SF_type_node, V4SF_type_node, - integer_type_node, NULL_TREE); - tree v2si_ftype_v4hi_v4hi - = build_function_type_list (V2SI_type_node, - V4HI_type_node, V4HI_type_node, NULL_TREE); - tree v4hi_ftype_v4hi_int - = build_function_type_list (V4HI_type_node, - V4HI_type_node, integer_type_node, NULL_TREE); - tree v2si_ftype_v2si_int - = build_function_type_list (V2SI_type_node, - V2SI_type_node, integer_type_node, NULL_TREE); - tree v1di_ftype_v1di_int - = build_function_type_list (V1DI_type_node, - V1DI_type_node, integer_type_node, NULL_TREE); - - tree void_ftype_void - = build_function_type (void_type_node, void_list_node); - tree void_ftype_unsigned - = build_function_type_list (void_type_node, unsigned_type_node, NULL_TREE); - tree void_ftype_unsigned_unsigned - = build_function_type_list (void_type_node, unsigned_type_node, - unsigned_type_node, NULL_TREE); - tree void_ftype_pcvoid_unsigned_unsigned - = build_function_type_list (void_type_node, const_ptr_type_node, - unsigned_type_node, unsigned_type_node, - NULL_TREE); - tree unsigned_ftype_void - = build_function_type (unsigned_type_node, void_list_node); - tree v2si_ftype_v4sf - = build_function_type_list (V2SI_type_node, V4SF_type_node, NULL_TREE); - /* Loads/stores. */ - tree void_ftype_v8qi_v8qi_pchar - = build_function_type_list (void_type_node, - V8QI_type_node, V8QI_type_node, - pchar_type_node, NULL_TREE); - tree v4sf_ftype_pcfloat - = build_function_type_list (V4SF_type_node, pcfloat_type_node, NULL_TREE); - tree v4sf_ftype_v4sf_pcv2sf - = build_function_type_list (V4SF_type_node, - V4SF_type_node, pcv2sf_type_node, NULL_TREE); - tree void_ftype_pv2sf_v4sf - = build_function_type_list (void_type_node, - pv2sf_type_node, V4SF_type_node, NULL_TREE); - tree void_ftype_pfloat_v4sf - = build_function_type_list (void_type_node, - pfloat_type_node, V4SF_type_node, NULL_TREE); - tree void_ftype_pdi_di - = build_function_type_list (void_type_node, - pdi_type_node, long_long_unsigned_type_node, - NULL_TREE); - tree void_ftype_pv2di_v2di - = build_function_type_list (void_type_node, - pv2di_type_node, V2DI_type_node, NULL_TREE); - /* Normal vector unops. */ - tree v4sf_ftype_v4sf - = build_function_type_list (V4SF_type_node, V4SF_type_node, NULL_TREE); - tree v16qi_ftype_v16qi - = build_function_type_list (V16QI_type_node, V16QI_type_node, NULL_TREE); - tree v8hi_ftype_v8hi - = build_function_type_list (V8HI_type_node, V8HI_type_node, NULL_TREE); - tree v4si_ftype_v4si - = build_function_type_list (V4SI_type_node, V4SI_type_node, NULL_TREE); - tree v8qi_ftype_v8qi - = build_function_type_list (V8QI_type_node, V8QI_type_node, NULL_TREE); - tree v4hi_ftype_v4hi - = build_function_type_list (V4HI_type_node, V4HI_type_node, NULL_TREE); - - /* Normal vector binops. */ - tree v4sf_ftype_v4sf_v4sf - = build_function_type_list (V4SF_type_node, - V4SF_type_node, V4SF_type_node, NULL_TREE); - tree v8qi_ftype_v8qi_v8qi - = build_function_type_list (V8QI_type_node, - V8QI_type_node, V8QI_type_node, NULL_TREE); - tree v4hi_ftype_v4hi_v4hi - = build_function_type_list (V4HI_type_node, - V4HI_type_node, V4HI_type_node, NULL_TREE); - tree v2si_ftype_v2si_v2si - = build_function_type_list (V2SI_type_node, - V2SI_type_node, V2SI_type_node, NULL_TREE); - tree v1di_ftype_v1di_v1di - = build_function_type_list (V1DI_type_node, - V1DI_type_node, V1DI_type_node, NULL_TREE); - tree v1di_ftype_v1di_v1di_int - = build_function_type_list (V1DI_type_node, - V1DI_type_node, V1DI_type_node, - integer_type_node, NULL_TREE); - tree v2si_ftype_v2sf - = build_function_type_list (V2SI_type_node, V2SF_type_node, NULL_TREE); - tree v2sf_ftype_v2si - = build_function_type_list (V2SF_type_node, V2SI_type_node, NULL_TREE); - tree v2si_ftype_v2si - = build_function_type_list (V2SI_type_node, V2SI_type_node, NULL_TREE); - tree v2sf_ftype_v2sf - = build_function_type_list (V2SF_type_node, V2SF_type_node, NULL_TREE); - tree v2sf_ftype_v2sf_v2sf - = build_function_type_list (V2SF_type_node, - V2SF_type_node, V2SF_type_node, NULL_TREE); - tree v2si_ftype_v2sf_v2sf - = build_function_type_list (V2SI_type_node, - V2SF_type_node, V2SF_type_node, NULL_TREE); - tree pint_type_node = build_pointer_type (integer_type_node); - tree pdouble_type_node = build_pointer_type (double_type_node); - tree pcdouble_type_node = build_pointer_type ( - build_type_variant (double_type_node, 1, 0)); - tree int_ftype_v2df_v2df - = build_function_type_list (integer_type_node, - V2DF_type_node, V2DF_type_node, NULL_TREE); - - tree void_ftype_pcvoid - = build_function_type_list (void_type_node, const_ptr_type_node, NULL_TREE); - tree v4sf_ftype_v4si - = build_function_type_list (V4SF_type_node, V4SI_type_node, NULL_TREE); - tree v4si_ftype_v4sf - = build_function_type_list (V4SI_type_node, V4SF_type_node, NULL_TREE); - tree v2df_ftype_v4si - = build_function_type_list (V2DF_type_node, V4SI_type_node, NULL_TREE); - tree v4si_ftype_v2df - = build_function_type_list (V4SI_type_node, V2DF_type_node, NULL_TREE); - tree v4si_ftype_v2df_v2df - = build_function_type_list (V4SI_type_node, - V2DF_type_node, V2DF_type_node, NULL_TREE); - tree v2si_ftype_v2df - = build_function_type_list (V2SI_type_node, V2DF_type_node, NULL_TREE); - tree v4sf_ftype_v2df - = build_function_type_list (V4SF_type_node, V2DF_type_node, NULL_TREE); - tree v2df_ftype_v2si - = build_function_type_list (V2DF_type_node, V2SI_type_node, NULL_TREE); - tree v2df_ftype_v4sf - = build_function_type_list (V2DF_type_node, V4SF_type_node, NULL_TREE); - tree int_ftype_v2df - = build_function_type_list (integer_type_node, V2DF_type_node, NULL_TREE); - tree int64_ftype_v2df - = build_function_type_list (long_long_integer_type_node, - V2DF_type_node, NULL_TREE); - tree v2df_ftype_v2df_int - = build_function_type_list (V2DF_type_node, - V2DF_type_node, integer_type_node, NULL_TREE); - tree v2df_ftype_v2df_int64 - = build_function_type_list (V2DF_type_node, - V2DF_type_node, long_long_integer_type_node, - NULL_TREE); - tree v4sf_ftype_v4sf_v2df - = build_function_type_list (V4SF_type_node, - V4SF_type_node, V2DF_type_node, NULL_TREE); - tree v2df_ftype_v2df_v4sf - = build_function_type_list (V2DF_type_node, - V2DF_type_node, V4SF_type_node, NULL_TREE); - tree v2df_ftype_v2df_v2df_int - = build_function_type_list (V2DF_type_node, - V2DF_type_node, V2DF_type_node, - integer_type_node, - NULL_TREE); - tree v2df_ftype_v2df_pcdouble - = build_function_type_list (V2DF_type_node, - V2DF_type_node, pcdouble_type_node, NULL_TREE); - tree void_ftype_pdouble_v2df - = build_function_type_list (void_type_node, - pdouble_type_node, V2DF_type_node, NULL_TREE); - tree void_ftype_pint_int - = build_function_type_list (void_type_node, - pint_type_node, integer_type_node, NULL_TREE); - tree void_ftype_v16qi_v16qi_pchar - = build_function_type_list (void_type_node, - V16QI_type_node, V16QI_type_node, - pchar_type_node, NULL_TREE); - tree v2df_ftype_pcdouble - = build_function_type_list (V2DF_type_node, pcdouble_type_node, NULL_TREE); - tree v2df_ftype_v2df_v2df - = build_function_type_list (V2DF_type_node, - V2DF_type_node, V2DF_type_node, NULL_TREE); - tree v16qi_ftype_v16qi_v16qi - = build_function_type_list (V16QI_type_node, - V16QI_type_node, V16QI_type_node, NULL_TREE); - tree v8hi_ftype_v8hi_v8hi - = build_function_type_list (V8HI_type_node, - V8HI_type_node, V8HI_type_node, NULL_TREE); - tree v4si_ftype_v4si_v4si - = build_function_type_list (V4SI_type_node, - V4SI_type_node, V4SI_type_node, NULL_TREE); - tree v2di_ftype_v2di_v2di - = build_function_type_list (V2DI_type_node, - V2DI_type_node, V2DI_type_node, NULL_TREE); - tree v2di_ftype_v2df_v2df - = build_function_type_list (V2DI_type_node, - V2DF_type_node, V2DF_type_node, NULL_TREE); - tree v2df_ftype_v2df - = build_function_type_list (V2DF_type_node, V2DF_type_node, NULL_TREE); - tree v2di_ftype_v2di_int - = build_function_type_list (V2DI_type_node, - V2DI_type_node, integer_type_node, NULL_TREE); - tree v2di_ftype_v2di_v2di_int - = build_function_type_list (V2DI_type_node, V2DI_type_node, - V2DI_type_node, integer_type_node, NULL_TREE); - tree v4si_ftype_v4si_int - = build_function_type_list (V4SI_type_node, - V4SI_type_node, integer_type_node, NULL_TREE); - tree v8hi_ftype_v8hi_int - = build_function_type_list (V8HI_type_node, - V8HI_type_node, integer_type_node, NULL_TREE); - tree v4si_ftype_v8hi_v8hi - = build_function_type_list (V4SI_type_node, - V8HI_type_node, V8HI_type_node, NULL_TREE); - tree v1di_ftype_v8qi_v8qi - = build_function_type_list (V1DI_type_node, - V8QI_type_node, V8QI_type_node, NULL_TREE); - tree v1di_ftype_v2si_v2si - = build_function_type_list (V1DI_type_node, - V2SI_type_node, V2SI_type_node, NULL_TREE); - tree v2di_ftype_v16qi_v16qi - = build_function_type_list (V2DI_type_node, - V16QI_type_node, V16QI_type_node, NULL_TREE); - tree v2di_ftype_v4si_v4si - = build_function_type_list (V2DI_type_node, - V4SI_type_node, V4SI_type_node, NULL_TREE); - tree int_ftype_v16qi - = build_function_type_list (integer_type_node, V16QI_type_node, NULL_TREE); - tree v16qi_ftype_pcchar - = build_function_type_list (V16QI_type_node, pcchar_type_node, NULL_TREE); - tree void_ftype_pchar_v16qi - = build_function_type_list (void_type_node, - pchar_type_node, V16QI_type_node, NULL_TREE); - - tree v2di_ftype_v2di_unsigned_unsigned - = build_function_type_list (V2DI_type_node, V2DI_type_node, - unsigned_type_node, unsigned_type_node, - NULL_TREE); - tree v2di_ftype_v2di_v2di_unsigned_unsigned - = build_function_type_list (V2DI_type_node, V2DI_type_node, V2DI_type_node, - unsigned_type_node, unsigned_type_node, - NULL_TREE); - tree v2di_ftype_v2di_v16qi - = build_function_type_list (V2DI_type_node, V2DI_type_node, V16QI_type_node, - NULL_TREE); - tree v2df_ftype_v2df_v2df_v2df - = build_function_type_list (V2DF_type_node, - V2DF_type_node, V2DF_type_node, - V2DF_type_node, NULL_TREE); - tree v4sf_ftype_v4sf_v4sf_v4sf - = build_function_type_list (V4SF_type_node, - V4SF_type_node, V4SF_type_node, - V4SF_type_node, NULL_TREE); - tree v8hi_ftype_v16qi - = build_function_type_list (V8HI_type_node, V16QI_type_node, - NULL_TREE); - tree v4si_ftype_v16qi - = build_function_type_list (V4SI_type_node, V16QI_type_node, - NULL_TREE); - tree v2di_ftype_v16qi - = build_function_type_list (V2DI_type_node, V16QI_type_node, - NULL_TREE); - tree v4si_ftype_v8hi - = build_function_type_list (V4SI_type_node, V8HI_type_node, - NULL_TREE); - tree v2di_ftype_v8hi - = build_function_type_list (V2DI_type_node, V8HI_type_node, - NULL_TREE); - tree v2di_ftype_v4si - = build_function_type_list (V2DI_type_node, V4SI_type_node, - NULL_TREE); - tree v2di_ftype_pv2di - = build_function_type_list (V2DI_type_node, pv2di_type_node, - NULL_TREE); - tree v16qi_ftype_v16qi_v16qi_int - = build_function_type_list (V16QI_type_node, V16QI_type_node, - V16QI_type_node, integer_type_node, - NULL_TREE); - tree v16qi_ftype_v16qi_v16qi_v16qi - = build_function_type_list (V16QI_type_node, V16QI_type_node, - V16QI_type_node, V16QI_type_node, - NULL_TREE); - tree v8hi_ftype_v8hi_v8hi_int - = build_function_type_list (V8HI_type_node, V8HI_type_node, - V8HI_type_node, integer_type_node, - NULL_TREE); - tree v4si_ftype_v4si_v4si_int - = build_function_type_list (V4SI_type_node, V4SI_type_node, - V4SI_type_node, integer_type_node, - NULL_TREE); - tree int_ftype_v2di_v2di - = build_function_type_list (integer_type_node, - V2DI_type_node, V2DI_type_node, - NULL_TREE); - tree int_ftype_v16qi_int_v16qi_int_int - = build_function_type_list (integer_type_node, - V16QI_type_node, - integer_type_node, - V16QI_type_node, - integer_type_node, - integer_type_node, - NULL_TREE); - tree v16qi_ftype_v16qi_int_v16qi_int_int - = build_function_type_list (V16QI_type_node, - V16QI_type_node, - integer_type_node, - V16QI_type_node, - integer_type_node, - integer_type_node, - NULL_TREE); - tree int_ftype_v16qi_v16qi_int - = build_function_type_list (integer_type_node, - V16QI_type_node, - V16QI_type_node, - integer_type_node, - NULL_TREE); - - /* AVX builtins */ - tree V32QI_type_node = build_vector_type_for_mode (char_type_node, - V32QImode); - tree V8SI_type_node = build_vector_type_for_mode (intSI_type_node, - V8SImode); - tree V8SF_type_node = build_vector_type_for_mode (float_type_node, - V8SFmode); - tree V4DI_type_node = build_vector_type_for_mode (long_long_integer_type_node, - V4DImode); - tree V4DF_type_node = build_vector_type_for_mode (double_type_node, - V4DFmode); - tree V16HI_type_node = build_vector_type_for_mode (intHI_type_node, - V16HImode); - tree v8sf_ftype_v8sf - = build_function_type_list (V8SF_type_node, - V8SF_type_node, - NULL_TREE); - tree v8si_ftype_v8sf - = build_function_type_list (V8SI_type_node, - V8SF_type_node, - NULL_TREE); - tree v8sf_ftype_v8si - = build_function_type_list (V8SF_type_node, - V8SI_type_node, - NULL_TREE); - tree v4si_ftype_v4df - = build_function_type_list (V4SI_type_node, - V4DF_type_node, - NULL_TREE); - tree v4df_ftype_v4df - = build_function_type_list (V4DF_type_node, - V4DF_type_node, - NULL_TREE); - tree v4df_ftype_v4si - = build_function_type_list (V4DF_type_node, - V4SI_type_node, - NULL_TREE); - tree v4df_ftype_v4sf - = build_function_type_list (V4DF_type_node, - V4SF_type_node, - NULL_TREE); - tree v4sf_ftype_v4df - = build_function_type_list (V4SF_type_node, - V4DF_type_node, - NULL_TREE); - tree v8sf_ftype_v8sf_v8sf - = build_function_type_list (V8SF_type_node, - V8SF_type_node, V8SF_type_node, - NULL_TREE); - tree v4df_ftype_v4df_v4df - = build_function_type_list (V4DF_type_node, - V4DF_type_node, V4DF_type_node, - NULL_TREE); - tree v8sf_ftype_v8sf_int - = build_function_type_list (V8SF_type_node, - V8SF_type_node, integer_type_node, - NULL_TREE); - tree v4si_ftype_v8si_int - = build_function_type_list (V4SI_type_node, - V8SI_type_node, integer_type_node, - NULL_TREE); - tree v4df_ftype_v4df_int - = build_function_type_list (V4DF_type_node, - V4DF_type_node, integer_type_node, - NULL_TREE); - tree v4sf_ftype_v8sf_int - = build_function_type_list (V4SF_type_node, - V8SF_type_node, integer_type_node, - NULL_TREE); - tree v2df_ftype_v4df_int - = build_function_type_list (V2DF_type_node, - V4DF_type_node, integer_type_node, - NULL_TREE); - tree v8sf_ftype_v8sf_v8sf_int - = build_function_type_list (V8SF_type_node, - V8SF_type_node, V8SF_type_node, - integer_type_node, - NULL_TREE); - tree v8sf_ftype_v8sf_v8sf_v8sf - = build_function_type_list (V8SF_type_node, - V8SF_type_node, V8SF_type_node, - V8SF_type_node, - NULL_TREE); - tree v4df_ftype_v4df_v4df_v4df - = build_function_type_list (V4DF_type_node, - V4DF_type_node, V4DF_type_node, - V4DF_type_node, - NULL_TREE); - tree v8si_ftype_v8si_v8si_int - = build_function_type_list (V8SI_type_node, - V8SI_type_node, V8SI_type_node, - integer_type_node, - NULL_TREE); - tree v4df_ftype_v4df_v4df_int - = build_function_type_list (V4DF_type_node, - V4DF_type_node, V4DF_type_node, - integer_type_node, - NULL_TREE); - tree v8sf_ftype_pcfloat - = build_function_type_list (V8SF_type_node, - pcfloat_type_node, - NULL_TREE); - tree v4df_ftype_pcdouble - = build_function_type_list (V4DF_type_node, - pcdouble_type_node, - NULL_TREE); - tree pcv4sf_type_node - = build_pointer_type (build_type_variant (V4SF_type_node, 1, 0)); - tree pcv2df_type_node - = build_pointer_type (build_type_variant (V2DF_type_node, 1, 0)); - tree v8sf_ftype_pcv4sf - = build_function_type_list (V8SF_type_node, - pcv4sf_type_node, - NULL_TREE); - tree v4df_ftype_pcv2df - = build_function_type_list (V4DF_type_node, - pcv2df_type_node, - NULL_TREE); - tree v32qi_ftype_pcchar - = build_function_type_list (V32QI_type_node, - pcchar_type_node, - NULL_TREE); - tree void_ftype_pchar_v32qi - = build_function_type_list (void_type_node, - pchar_type_node, V32QI_type_node, - NULL_TREE); - tree v8si_ftype_v8si_v4si_int - = build_function_type_list (V8SI_type_node, - V8SI_type_node, V4SI_type_node, - integer_type_node, - NULL_TREE); - tree pv4di_type_node = build_pointer_type (V4DI_type_node); - tree void_ftype_pv4di_v4di - = build_function_type_list (void_type_node, - pv4di_type_node, V4DI_type_node, - NULL_TREE); - tree v8sf_ftype_v8sf_v4sf_int - = build_function_type_list (V8SF_type_node, - V8SF_type_node, V4SF_type_node, - integer_type_node, - NULL_TREE); - tree v4df_ftype_v4df_v2df_int - = build_function_type_list (V4DF_type_node, - V4DF_type_node, V2DF_type_node, - integer_type_node, - NULL_TREE); - tree void_ftype_pfloat_v8sf - = build_function_type_list (void_type_node, - pfloat_type_node, V8SF_type_node, - NULL_TREE); - tree void_ftype_pdouble_v4df - = build_function_type_list (void_type_node, - pdouble_type_node, V4DF_type_node, - NULL_TREE); - tree pv8sf_type_node = build_pointer_type (V8SF_type_node); - tree pv4sf_type_node = build_pointer_type (V4SF_type_node); - tree pv4df_type_node = build_pointer_type (V4DF_type_node); - tree pv2df_type_node = build_pointer_type (V2DF_type_node); - tree pcv8sf_type_node - = build_pointer_type (build_type_variant (V8SF_type_node, 1, 0)); - tree pcv4df_type_node - = build_pointer_type (build_type_variant (V4DF_type_node, 1, 0)); - tree v8sf_ftype_pcv8sf_v8sf - = build_function_type_list (V8SF_type_node, - pcv8sf_type_node, V8SF_type_node, - NULL_TREE); - tree v4df_ftype_pcv4df_v4df - = build_function_type_list (V4DF_type_node, - pcv4df_type_node, V4DF_type_node, - NULL_TREE); - tree v4sf_ftype_pcv4sf_v4sf - = build_function_type_list (V4SF_type_node, - pcv4sf_type_node, V4SF_type_node, - NULL_TREE); - tree v2df_ftype_pcv2df_v2df - = build_function_type_list (V2DF_type_node, - pcv2df_type_node, V2DF_type_node, - NULL_TREE); - tree void_ftype_pv8sf_v8sf_v8sf - = build_function_type_list (void_type_node, - pv8sf_type_node, V8SF_type_node, - V8SF_type_node, - NULL_TREE); - tree void_ftype_pv4df_v4df_v4df - = build_function_type_list (void_type_node, - pv4df_type_node, V4DF_type_node, - V4DF_type_node, - NULL_TREE); - tree void_ftype_pv4sf_v4sf_v4sf - = build_function_type_list (void_type_node, - pv4sf_type_node, V4SF_type_node, - V4SF_type_node, - NULL_TREE); - tree void_ftype_pv2df_v2df_v2df - = build_function_type_list (void_type_node, - pv2df_type_node, V2DF_type_node, - V2DF_type_node, - NULL_TREE); - tree v4df_ftype_v2df - = build_function_type_list (V4DF_type_node, - V2DF_type_node, - NULL_TREE); - tree v8sf_ftype_v4sf - = build_function_type_list (V8SF_type_node, - V4SF_type_node, - NULL_TREE); - tree v8si_ftype_v4si - = build_function_type_list (V8SI_type_node, - V4SI_type_node, - NULL_TREE); - tree v2df_ftype_v4df - = build_function_type_list (V2DF_type_node, - V4DF_type_node, - NULL_TREE); - tree v4sf_ftype_v8sf - = build_function_type_list (V4SF_type_node, - V8SF_type_node, - NULL_TREE); - tree v4si_ftype_v8si - = build_function_type_list (V4SI_type_node, - V8SI_type_node, - NULL_TREE); - tree int_ftype_v4df - = build_function_type_list (integer_type_node, - V4DF_type_node, - NULL_TREE); - tree int_ftype_v8sf - = build_function_type_list (integer_type_node, - V8SF_type_node, - NULL_TREE); - tree int_ftype_v8sf_v8sf - = build_function_type_list (integer_type_node, - V8SF_type_node, V8SF_type_node, - NULL_TREE); - tree int_ftype_v4di_v4di - = build_function_type_list (integer_type_node, - V4DI_type_node, V4DI_type_node, - NULL_TREE); - tree int_ftype_v4df_v4df - = build_function_type_list (integer_type_node, - V4DF_type_node, V4DF_type_node, - NULL_TREE); - tree v8sf_ftype_v8sf_v8si - = build_function_type_list (V8SF_type_node, - V8SF_type_node, V8SI_type_node, - NULL_TREE); - tree v4df_ftype_v4df_v4di - = build_function_type_list (V4DF_type_node, - V4DF_type_node, V4DI_type_node, - NULL_TREE); - tree v4sf_ftype_v4sf_v4si - = build_function_type_list (V4SF_type_node, - V4SF_type_node, V4SI_type_node, NULL_TREE); - tree v2df_ftype_v2df_v2di - = build_function_type_list (V2DF_type_node, - V2DF_type_node, V2DI_type_node, NULL_TREE); - - /* XOP instructions */ - tree v2di_ftype_v2di_v2di_v2di - = build_function_type_list (V2DI_type_node, - V2DI_type_node, - V2DI_type_node, - V2DI_type_node, - NULL_TREE); - - tree v4di_ftype_v4di_v4di_v4di - = build_function_type_list (V4DI_type_node, - V4DI_type_node, - V4DI_type_node, - V4DI_type_node, - NULL_TREE); - - tree v4si_ftype_v4si_v4si_v4si - = build_function_type_list (V4SI_type_node, - V4SI_type_node, - V4SI_type_node, - V4SI_type_node, - NULL_TREE); - - tree v8si_ftype_v8si_v8si_v8si - = build_function_type_list (V8SI_type_node, - V8SI_type_node, - V8SI_type_node, - V8SI_type_node, - NULL_TREE); - - tree v32qi_ftype_v32qi_v32qi_v32qi - = build_function_type_list (V32QI_type_node, - V32QI_type_node, - V32QI_type_node, - V32QI_type_node, - NULL_TREE); - - tree v4si_ftype_v4si_v4si_v2di - = build_function_type_list (V4SI_type_node, - V4SI_type_node, - V4SI_type_node, - V2DI_type_node, - NULL_TREE); - - tree v8hi_ftype_v8hi_v8hi_v8hi - = build_function_type_list (V8HI_type_node, - V8HI_type_node, - V8HI_type_node, - V8HI_type_node, - NULL_TREE); - - tree v16hi_ftype_v16hi_v16hi_v16hi - = build_function_type_list (V16HI_type_node, - V16HI_type_node, - V16HI_type_node, - V16HI_type_node, - NULL_TREE); - - tree v8hi_ftype_v8hi_v8hi_v4si - = build_function_type_list (V8HI_type_node, - V8HI_type_node, - V8HI_type_node, - V4SI_type_node, - NULL_TREE); - - tree v2di_ftype_v2di_si - = build_function_type_list (V2DI_type_node, - V2DI_type_node, - integer_type_node, - NULL_TREE); - - tree v4si_ftype_v4si_si - = build_function_type_list (V4SI_type_node, - V4SI_type_node, - integer_type_node, - NULL_TREE); - - tree v8hi_ftype_v8hi_si - = build_function_type_list (V8HI_type_node, - V8HI_type_node, - integer_type_node, - NULL_TREE); - - tree v16qi_ftype_v16qi_si - = build_function_type_list (V16QI_type_node, - V16QI_type_node, - integer_type_node, - NULL_TREE); - - tree v2di_ftype_v2di - = build_function_type_list (V2DI_type_node, V2DI_type_node, NULL_TREE); - - tree v16qi_ftype_v8hi_v8hi - = build_function_type_list (V16QI_type_node, - V8HI_type_node, V8HI_type_node, - NULL_TREE); - tree v8hi_ftype_v4si_v4si - = build_function_type_list (V8HI_type_node, - V4SI_type_node, V4SI_type_node, - NULL_TREE); - tree v8hi_ftype_v16qi_v16qi - = build_function_type_list (V8HI_type_node, - V16QI_type_node, V16QI_type_node, - NULL_TREE); - tree v4hi_ftype_v8qi_v8qi - = build_function_type_list (V4HI_type_node, - V8QI_type_node, V8QI_type_node, - NULL_TREE); - tree unsigned_ftype_unsigned_uchar - = build_function_type_list (unsigned_type_node, - unsigned_type_node, - unsigned_char_type_node, - NULL_TREE); - tree unsigned_ftype_unsigned_ushort - = build_function_type_list (unsigned_type_node, - unsigned_type_node, - short_unsigned_type_node, - NULL_TREE); - tree unsigned_ftype_unsigned_unsigned - = build_function_type_list (unsigned_type_node, - unsigned_type_node, - unsigned_type_node, - NULL_TREE); - tree uint64_ftype_uint64_uint64 - = build_function_type_list (long_long_unsigned_type_node, - long_long_unsigned_type_node, - long_long_unsigned_type_node, - NULL_TREE); - tree float_ftype_float - = build_function_type_list (float_type_node, - float_type_node, - NULL_TREE); - - /* Integer intrinsics. */ - tree uint64_ftype_void - = build_function_type (long_long_unsigned_type_node, - void_list_node); - tree int_ftype_int - = build_function_type_list (integer_type_node, - integer_type_node, NULL_TREE); - tree int64_ftype_int64 - = build_function_type_list (long_long_integer_type_node, - long_long_integer_type_node, - NULL_TREE); - tree uint64_ftype_int - = build_function_type_list (long_long_unsigned_type_node, - integer_type_node, NULL_TREE); - tree punsigned_type_node = build_pointer_type (unsigned_type_node); - tree uint64_ftype_punsigned - = build_function_type_list (long_long_unsigned_type_node, - punsigned_type_node, NULL_TREE); - tree ushort_ftype_ushort_int - = build_function_type_list (short_unsigned_type_node, - short_unsigned_type_node, - integer_type_node, - NULL_TREE); - tree uchar_ftype_uchar_int - = build_function_type_list (unsigned_char_type_node, - unsigned_char_type_node, - integer_type_node, - NULL_TREE); - - /* LWP instructions. */ - - tree void_ftype_ushort_unsigned_ushort - = build_function_type_list (void_type_node, - short_unsigned_type_node, - unsigned_type_node, - short_unsigned_type_node, - NULL_TREE); - - tree void_ftype_unsigned_unsigned_unsigned - = build_function_type_list (void_type_node, - unsigned_type_node, - unsigned_type_node, - unsigned_type_node, - NULL_TREE); - - tree void_ftype_uint64_unsigned_unsigned - = build_function_type_list (void_type_node, - long_long_unsigned_type_node, - unsigned_type_node, - unsigned_type_node, - NULL_TREE); - - tree uchar_ftype_ushort_unsigned_ushort - = build_function_type_list (unsigned_char_type_node, - short_unsigned_type_node, - unsigned_type_node, - short_unsigned_type_node, - NULL_TREE); - - tree uchar_ftype_unsigned_unsigned_unsigned - = build_function_type_list (unsigned_char_type_node, - unsigned_type_node, - unsigned_type_node, - unsigned_type_node, - NULL_TREE); - - tree uchar_ftype_uint64_unsigned_unsigned - = build_function_type_list (unsigned_char_type_node, - long_long_unsigned_type_node, - unsigned_type_node, - unsigned_type_node, - NULL_TREE); - - tree ftype; - /* Add all special builtins with variable number of operands. */ for (i = 0, d = bdesc_special_args; i < ARRAY_SIZE (bdesc_special_args); i++, d++) { - tree type; - if (d->name == 0) continue; - switch ((enum ix86_special_builtin_type) d->flag) - { - case VOID_FTYPE_VOID: - type = void_ftype_void; - break; - case UINT64_FTYPE_VOID: - type = uint64_ftype_void; - break; - case UINT64_FTYPE_PUNSIGNED: - type = uint64_ftype_punsigned; - break; - case V32QI_FTYPE_PCCHAR: - type = v32qi_ftype_pcchar; - break; - case V16QI_FTYPE_PCCHAR: - type = v16qi_ftype_pcchar; - break; - case V8SF_FTYPE_PCV4SF: - type = v8sf_ftype_pcv4sf; - break; - case V8SF_FTYPE_PCFLOAT: - type = v8sf_ftype_pcfloat; - break; - case V4DF_FTYPE_PCV2DF: - type = v4df_ftype_pcv2df; - break; - case V4DF_FTYPE_PCDOUBLE: - type = v4df_ftype_pcdouble; - break; - case V4SF_FTYPE_PCFLOAT: - type = v4sf_ftype_pcfloat; - break; - case V2DI_FTYPE_PV2DI: - type = v2di_ftype_pv2di; - break; - case V2DF_FTYPE_PCDOUBLE: - type = v2df_ftype_pcdouble; - break; - case V8SF_FTYPE_PCV8SF_V8SF: - type = v8sf_ftype_pcv8sf_v8sf; - break; - case V4DF_FTYPE_PCV4DF_V4DF: - type = v4df_ftype_pcv4df_v4df; - break; - case V4SF_FTYPE_V4SF_PCV2SF: - type = v4sf_ftype_v4sf_pcv2sf; - break; - case V4SF_FTYPE_PCV4SF_V4SF: - type = v4sf_ftype_pcv4sf_v4sf; - break; - case V2DF_FTYPE_V2DF_PCDOUBLE: - type = v2df_ftype_v2df_pcdouble; - break; - case V2DF_FTYPE_PCV2DF_V2DF: - type = v2df_ftype_pcv2df_v2df; - break; - case VOID_FTYPE_PV2SF_V4SF: - type = void_ftype_pv2sf_v4sf; - break; - case VOID_FTYPE_PV4DI_V4DI: - type = void_ftype_pv4di_v4di; - break; - case VOID_FTYPE_PV2DI_V2DI: - type = void_ftype_pv2di_v2di; - break; - case VOID_FTYPE_PCHAR_V32QI: - type = void_ftype_pchar_v32qi; - break; - case VOID_FTYPE_PCHAR_V16QI: - type = void_ftype_pchar_v16qi; - break; - case VOID_FTYPE_PFLOAT_V8SF: - type = void_ftype_pfloat_v8sf; - break; - case VOID_FTYPE_PFLOAT_V4SF: - type = void_ftype_pfloat_v4sf; - break; - case VOID_FTYPE_PDOUBLE_V4DF: - type = void_ftype_pdouble_v4df; - break; - case VOID_FTYPE_PDOUBLE_V2DF: - type = void_ftype_pdouble_v2df; - break; - case VOID_FTYPE_PDI_DI: - type = void_ftype_pdi_di; - break; - case VOID_FTYPE_PINT_INT: - type = void_ftype_pint_int; - break; - case VOID_FTYPE_PV8SF_V8SF_V8SF: - type = void_ftype_pv8sf_v8sf_v8sf; - break; - case VOID_FTYPE_PV4DF_V4DF_V4DF: - type = void_ftype_pv4df_v4df_v4df; - break; - case VOID_FTYPE_PV4SF_V4SF_V4SF: - type = void_ftype_pv4sf_v4sf_v4sf; - break; - case VOID_FTYPE_PV2DF_V2DF_V2DF: - type = void_ftype_pv2df_v2df_v2df; - break; - case VOID_FTYPE_USHORT_UINT_USHORT: - type = void_ftype_ushort_unsigned_ushort; - break; - case VOID_FTYPE_UINT_UINT_UINT: - type = void_ftype_unsigned_unsigned_unsigned; - break; - case VOID_FTYPE_UINT64_UINT_UINT: - type = void_ftype_uint64_unsigned_unsigned; - break; - case UCHAR_FTYPE_USHORT_UINT_USHORT: - type = uchar_ftype_ushort_unsigned_ushort; - break; - case UCHAR_FTYPE_UINT_UINT_UINT: - type = uchar_ftype_unsigned_unsigned_unsigned; - break; - case UCHAR_FTYPE_UINT64_UINT_UINT: - type = uchar_ftype_uint64_unsigned_unsigned; - break; - - default: - gcc_unreachable (); - } - - def_builtin (d->mask, d->name, type, d->code); + ftype = (enum ix86_builtin_func_type) d->flag; + def_builtin (d->mask, d->name, ftype, d->code); } /* Add all builtins with variable number of operands. */ @@ -23443,459 +22385,11 @@ ix86_init_mmx_sse_builtins (void) i < ARRAY_SIZE (bdesc_args); i++, d++) { - tree type; - if (d->name == 0) continue; - switch ((enum ix86_builtin_type) d->flag) - { - case FLOAT_FTYPE_FLOAT: - type = float_ftype_float; - break; - case INT_FTYPE_V8SF_V8SF_PTEST: - type = int_ftype_v8sf_v8sf; - break; - case INT_FTYPE_V4DI_V4DI_PTEST: - type = int_ftype_v4di_v4di; - break; - case INT_FTYPE_V4DF_V4DF_PTEST: - type = int_ftype_v4df_v4df; - break; - case INT_FTYPE_V4SF_V4SF_PTEST: - type = int_ftype_v4sf_v4sf; - break; - case INT_FTYPE_V2DI_V2DI_PTEST: - type = int_ftype_v2di_v2di; - break; - case INT_FTYPE_V2DF_V2DF_PTEST: - type = int_ftype_v2df_v2df; - break; - case INT_FTYPE_INT: - type = int_ftype_int; - break; - case UINT64_FTYPE_INT: - type = uint64_ftype_int; - break; - case INT64_FTYPE_INT64: - type = int64_ftype_int64; - break; - case INT64_FTYPE_V4SF: - type = int64_ftype_v4sf; - break; - case INT64_FTYPE_V2DF: - type = int64_ftype_v2df; - break; - case INT_FTYPE_V16QI: - type = int_ftype_v16qi; - break; - case INT_FTYPE_V8QI: - type = int_ftype_v8qi; - break; - case INT_FTYPE_V8SF: - type = int_ftype_v8sf; - break; - case INT_FTYPE_V4DF: - type = int_ftype_v4df; - break; - case INT_FTYPE_V4SF: - type = int_ftype_v4sf; - break; - case INT_FTYPE_V2DF: - type = int_ftype_v2df; - break; - case V16QI_FTYPE_V16QI: - type = v16qi_ftype_v16qi; - break; - case V8SI_FTYPE_V8SF: - type = v8si_ftype_v8sf; - break; - case V8SI_FTYPE_V4SI: - type = v8si_ftype_v4si; - break; - case V8HI_FTYPE_V8HI: - type = v8hi_ftype_v8hi; - break; - case V8HI_FTYPE_V16QI: - type = v8hi_ftype_v16qi; - break; - case V8QI_FTYPE_V8QI: - type = v8qi_ftype_v8qi; - break; - case V8SF_FTYPE_V8SF: - type = v8sf_ftype_v8sf; - break; - case V8SF_FTYPE_V8SI: - type = v8sf_ftype_v8si; - break; - case V8SF_FTYPE_V4SF: - type = v8sf_ftype_v4sf; - break; - case V4SI_FTYPE_V4DF: - type = v4si_ftype_v4df; - break; - case V4SI_FTYPE_V4SI: - type = v4si_ftype_v4si; - break; - case V4SI_FTYPE_V16QI: - type = v4si_ftype_v16qi; - break; - case V4SI_FTYPE_V8SI: - type = v4si_ftype_v8si; - break; - case V4SI_FTYPE_V8HI: - type = v4si_ftype_v8hi; - break; - case V4SI_FTYPE_V4SF: - type = v4si_ftype_v4sf; - break; - case V4SI_FTYPE_V2DF: - type = v4si_ftype_v2df; - break; - case V4HI_FTYPE_V4HI: - type = v4hi_ftype_v4hi; - break; - case V4DF_FTYPE_V4DF: - type = v4df_ftype_v4df; - break; - case V4DF_FTYPE_V4SI: - type = v4df_ftype_v4si; - break; - case V4DF_FTYPE_V4SF: - type = v4df_ftype_v4sf; - break; - case V4DF_FTYPE_V2DF: - type = v4df_ftype_v2df; - break; - case V4SF_FTYPE_V4SF: - case V4SF_FTYPE_V4SF_VEC_MERGE: - type = v4sf_ftype_v4sf; - break; - case V4SF_FTYPE_V8SF: - type = v4sf_ftype_v8sf; - break; - case V4SF_FTYPE_V4SI: - type = v4sf_ftype_v4si; - break; - case V4SF_FTYPE_V4DF: - type = v4sf_ftype_v4df; - break; - case V4SF_FTYPE_V2DF: - type = v4sf_ftype_v2df; - break; - case V2DI_FTYPE_V2DI: - type = v2di_ftype_v2di; - break; - case V2DI_FTYPE_V16QI: - type = v2di_ftype_v16qi; - break; - case V2DI_FTYPE_V8HI: - type = v2di_ftype_v8hi; - break; - case V2DI_FTYPE_V4SI: - type = v2di_ftype_v4si; - break; - case V2SI_FTYPE_V2SI: - type = v2si_ftype_v2si; - break; - case V2SI_FTYPE_V4SF: - type = v2si_ftype_v4sf; - break; - case V2SI_FTYPE_V2DF: - type = v2si_ftype_v2df; - break; - case V2SI_FTYPE_V2SF: - type = v2si_ftype_v2sf; - break; - case V2DF_FTYPE_V4DF: - type = v2df_ftype_v4df; - break; - case V2DF_FTYPE_V4SF: - type = v2df_ftype_v4sf; - break; - case V2DF_FTYPE_V2DF: - case V2DF_FTYPE_V2DF_VEC_MERGE: - type = v2df_ftype_v2df; - break; - case V2DF_FTYPE_V2SI: - type = v2df_ftype_v2si; - break; - case V2DF_FTYPE_V4SI: - type = v2df_ftype_v4si; - break; - case V2SF_FTYPE_V2SF: - type = v2sf_ftype_v2sf; - break; - case V2SF_FTYPE_V2SI: - type = v2sf_ftype_v2si; - break; - case V16QI_FTYPE_V16QI_V16QI: - type = v16qi_ftype_v16qi_v16qi; - break; - case V16QI_FTYPE_V8HI_V8HI: - type = v16qi_ftype_v8hi_v8hi; - break; - case V8QI_FTYPE_V8QI_V8QI: - type = v8qi_ftype_v8qi_v8qi; - break; - case V8QI_FTYPE_V4HI_V4HI: - type = v8qi_ftype_v4hi_v4hi; - break; - case V8HI_FTYPE_V8HI_V8HI: - case V8HI_FTYPE_V8HI_V8HI_COUNT: - type = v8hi_ftype_v8hi_v8hi; - break; - case V8HI_FTYPE_V16QI_V16QI: - type = v8hi_ftype_v16qi_v16qi; - break; - case V8HI_FTYPE_V4SI_V4SI: - type = v8hi_ftype_v4si_v4si; - break; - case V8HI_FTYPE_V8HI_SI_COUNT: - type = v8hi_ftype_v8hi_int; - break; - case V8SF_FTYPE_V8SF_V8SF: - type = v8sf_ftype_v8sf_v8sf; - break; - case V8SF_FTYPE_V8SF_V8SI: - type = v8sf_ftype_v8sf_v8si; - break; - case V4SI_FTYPE_V4SI_V4SI: - case V4SI_FTYPE_V4SI_V4SI_COUNT: - type = v4si_ftype_v4si_v4si; - break; - case V4SI_FTYPE_V8HI_V8HI: - type = v4si_ftype_v8hi_v8hi; - break; - case V4SI_FTYPE_V4SF_V4SF: - type = v4si_ftype_v4sf_v4sf; - break; - case V4SI_FTYPE_V2DF_V2DF: - type = v4si_ftype_v2df_v2df; - break; - case V4SI_FTYPE_V4SI_SI_COUNT: - type = v4si_ftype_v4si_int; - break; - case V4HI_FTYPE_V4HI_V4HI: - case V4HI_FTYPE_V4HI_V4HI_COUNT: - type = v4hi_ftype_v4hi_v4hi; - break; - case V4HI_FTYPE_V8QI_V8QI: - type = v4hi_ftype_v8qi_v8qi; - break; - case V4HI_FTYPE_V2SI_V2SI: - type = v4hi_ftype_v2si_v2si; - break; - case V4HI_FTYPE_V4HI_SI_COUNT: - type = v4hi_ftype_v4hi_int; - break; - case V4DF_FTYPE_V4DF_V4DF: - type = v4df_ftype_v4df_v4df; - break; - case V4DF_FTYPE_V4DF_V4DI: - type = v4df_ftype_v4df_v4di; - break; - case V4SF_FTYPE_V4SF_V4SF: - case V4SF_FTYPE_V4SF_V4SF_SWAP: - type = v4sf_ftype_v4sf_v4sf; - break; - case V4SF_FTYPE_V4SF_V4SI: - type = v4sf_ftype_v4sf_v4si; - break; - case V4SF_FTYPE_V4SF_V2SI: - type = v4sf_ftype_v4sf_v2si; - break; - case V4SF_FTYPE_V4SF_V2DF: - type = v4sf_ftype_v4sf_v2df; - break; - case V4SF_FTYPE_V4SF_DI: - type = v4sf_ftype_v4sf_int64; - break; - case V4SF_FTYPE_V4SF_SI: - type = v4sf_ftype_v4sf_int; - break; - case V2DI_FTYPE_V2DI_V2DI: - case V2DI_FTYPE_V2DI_V2DI_COUNT: - type = v2di_ftype_v2di_v2di; - break; - case V2DI_FTYPE_V16QI_V16QI: - type = v2di_ftype_v16qi_v16qi; - break; - case V2DI_FTYPE_V4SI_V4SI: - type = v2di_ftype_v4si_v4si; - break; - case V2DI_FTYPE_V2DI_V16QI: - type = v2di_ftype_v2di_v16qi; - break; - case V2DI_FTYPE_V2DF_V2DF: - type = v2di_ftype_v2df_v2df; - break; - case V2DI_FTYPE_V2DI_SI_COUNT: - type = v2di_ftype_v2di_int; - break; - case V2SI_FTYPE_V2SI_V2SI: - case V2SI_FTYPE_V2SI_V2SI_COUNT: - type = v2si_ftype_v2si_v2si; - break; - case V2SI_FTYPE_V4HI_V4HI: - type = v2si_ftype_v4hi_v4hi; - break; - case V2SI_FTYPE_V2SF_V2SF: - type = v2si_ftype_v2sf_v2sf; - break; - case V2SI_FTYPE_V2SI_SI_COUNT: - type = v2si_ftype_v2si_int; - break; - case V2DF_FTYPE_V2DF_V2DF: - case V2DF_FTYPE_V2DF_V2DF_SWAP: - type = v2df_ftype_v2df_v2df; - break; - case V2DF_FTYPE_V2DF_V4SF: - type = v2df_ftype_v2df_v4sf; - break; - case V2DF_FTYPE_V2DF_V2DI: - type = v2df_ftype_v2df_v2di; - break; - case V2DF_FTYPE_V2DF_DI: - type = v2df_ftype_v2df_int64; - break; - case V2DF_FTYPE_V2DF_SI: - type = v2df_ftype_v2df_int; - break; - case V2SF_FTYPE_V2SF_V2SF: - type = v2sf_ftype_v2sf_v2sf; - break; - case V1DI_FTYPE_V1DI_V1DI: - case V1DI_FTYPE_V1DI_V1DI_COUNT: - type = v1di_ftype_v1di_v1di; - break; - case V1DI_FTYPE_V8QI_V8QI: - type = v1di_ftype_v8qi_v8qi; - break; - case V1DI_FTYPE_V2SI_V2SI: - type = v1di_ftype_v2si_v2si; - break; - case V1DI_FTYPE_V1DI_SI_COUNT: - type = v1di_ftype_v1di_int; - break; - case UINT64_FTYPE_UINT64_UINT64: - type = uint64_ftype_uint64_uint64; - break; - case UINT_FTYPE_UINT_UINT: - type = unsigned_ftype_unsigned_unsigned; - break; - case UINT_FTYPE_UINT_USHORT: - type = unsigned_ftype_unsigned_ushort; - break; - case UINT_FTYPE_UINT_UCHAR: - type = unsigned_ftype_unsigned_uchar; - break; - case UINT16_FTYPE_UINT16_INT: - type = ushort_ftype_ushort_int; - break; - case UINT8_FTYPE_UINT8_INT: - type = uchar_ftype_uchar_int; - break; - case V8HI_FTYPE_V8HI_INT: - type = v8hi_ftype_v8hi_int; - break; - case V8SF_FTYPE_V8SF_INT: - type = v8sf_ftype_v8sf_int; - break; - case V4SI_FTYPE_V4SI_INT: - type = v4si_ftype_v4si_int; - break; - case V4SI_FTYPE_V8SI_INT: - type = v4si_ftype_v8si_int; - break; - case V4HI_FTYPE_V4HI_INT: - type = v4hi_ftype_v4hi_int; - break; - case V4DF_FTYPE_V4DF_INT: - type = v4df_ftype_v4df_int; - break; - case V4SF_FTYPE_V4SF_INT: - type = v4sf_ftype_v4sf_int; - break; - case V4SF_FTYPE_V8SF_INT: - type = v4sf_ftype_v8sf_int; - break; - case V2DI_FTYPE_V2DI_INT: - case V2DI2TI_FTYPE_V2DI_INT: - type = v2di_ftype_v2di_int; - break; - case V2DF_FTYPE_V2DF_INT: - type = v2df_ftype_v2df_int; - break; - case V2DF_FTYPE_V4DF_INT: - type = v2df_ftype_v4df_int; - break; - case V16QI_FTYPE_V16QI_V16QI_V16QI: - type = v16qi_ftype_v16qi_v16qi_v16qi; - break; - case V8SF_FTYPE_V8SF_V8SF_V8SF: - type = v8sf_ftype_v8sf_v8sf_v8sf; - break; - case V4DF_FTYPE_V4DF_V4DF_V4DF: - type = v4df_ftype_v4df_v4df_v4df; - break; - case V4SF_FTYPE_V4SF_V4SF_V4SF: - type = v4sf_ftype_v4sf_v4sf_v4sf; - break; - case V2DF_FTYPE_V2DF_V2DF_V2DF: - type = v2df_ftype_v2df_v2df_v2df; - break; - case V16QI_FTYPE_V16QI_V16QI_INT: - type = v16qi_ftype_v16qi_v16qi_int; - break; - case V8SI_FTYPE_V8SI_V8SI_INT: - type = v8si_ftype_v8si_v8si_int; - break; - case V8SI_FTYPE_V8SI_V4SI_INT: - type = v8si_ftype_v8si_v4si_int; - break; - case V8HI_FTYPE_V8HI_V8HI_INT: - type = v8hi_ftype_v8hi_v8hi_int; - break; - case V8SF_FTYPE_V8SF_V8SF_INT: - type = v8sf_ftype_v8sf_v8sf_int; - break; - case V8SF_FTYPE_V8SF_V4SF_INT: - type = v8sf_ftype_v8sf_v4sf_int; - break; - case V4SI_FTYPE_V4SI_V4SI_INT: - type = v4si_ftype_v4si_v4si_int; - break; - case V4DF_FTYPE_V4DF_V4DF_INT: - type = v4df_ftype_v4df_v4df_int; - break; - case V4DF_FTYPE_V4DF_V2DF_INT: - type = v4df_ftype_v4df_v2df_int; - break; - case V4SF_FTYPE_V4SF_V4SF_INT: - type = v4sf_ftype_v4sf_v4sf_int; - break; - case V2DI_FTYPE_V2DI_V2DI_INT: - case V2DI2TI_FTYPE_V2DI_V2DI_INT: - type = v2di_ftype_v2di_v2di_int; - break; - case V2DF_FTYPE_V2DF_V2DF_INT: - type = v2df_ftype_v2df_v2df_int; - break; - case V2DI_FTYPE_V2DI_UINT_UINT: - type = v2di_ftype_v2di_unsigned_unsigned; - break; - case V2DI_FTYPE_V2DI_V2DI_UINT_UINT: - type = v2di_ftype_v2di_v2di_unsigned_unsigned; - break; - case V1DI2DI_FTYPE_V1DI_V1DI_INT: - type = v1di_ftype_v1di_v1di_int; - break; - default: - gcc_unreachable (); - } - - def_builtin_const (d->mask, d->name, type, d->code); + ftype = (enum ix86_builtin_func_type) d->flag; + def_builtin_const (d->mask, d->name, ftype, d->code); } /* pcmpestr[im] insns. */ @@ -23904,9 +22398,9 @@ ix86_init_mmx_sse_builtins (void) i++, d++) { if (d->code == IX86_BUILTIN_PCMPESTRM128) - ftype = v16qi_ftype_v16qi_int_v16qi_int_int; + ftype = V16QI_FTYPE_V16QI_INT_V16QI_INT_INT; else - ftype = int_ftype_v16qi_int_v16qi_int_int; + ftype = INT_FTYPE_V16QI_INT_V16QI_INT_INT; def_builtin_const (d->mask, d->name, ftype, d->code); } @@ -23916,199 +22410,135 @@ ix86_init_mmx_sse_builtins (void) i++, d++) { if (d->code == IX86_BUILTIN_PCMPISTRM128) - ftype = v16qi_ftype_v16qi_v16qi_int; + ftype = V16QI_FTYPE_V16QI_V16QI_INT; else - ftype = int_ftype_v16qi_v16qi_int; + ftype = INT_FTYPE_V16QI_V16QI_INT; def_builtin_const (d->mask, d->name, ftype, d->code); } /* comi/ucomi insns. */ for (i = 0, d = bdesc_comi; i < ARRAY_SIZE (bdesc_comi); i++, d++) - if (d->mask == OPTION_MASK_ISA_SSE2) - def_builtin_const (d->mask, d->name, int_ftype_v2df_v2df, d->code); - else - def_builtin_const (d->mask, d->name, int_ftype_v4sf_v4sf, d->code); + { + if (d->mask == OPTION_MASK_ISA_SSE2) + ftype = INT_FTYPE_V2DF_V2DF; + else + ftype = INT_FTYPE_V4SF_V4SF; + def_builtin_const (d->mask, d->name, ftype, d->code); + } /* SSE */ - def_builtin (OPTION_MASK_ISA_SSE, "__builtin_ia32_ldmxcsr", void_ftype_unsigned, IX86_BUILTIN_LDMXCSR); - def_builtin (OPTION_MASK_ISA_SSE, "__builtin_ia32_stmxcsr", unsigned_ftype_void, IX86_BUILTIN_STMXCSR); + def_builtin (OPTION_MASK_ISA_SSE, "__builtin_ia32_ldmxcsr", + VOID_FTYPE_UNSIGNED, IX86_BUILTIN_LDMXCSR); + def_builtin (OPTION_MASK_ISA_SSE, "__builtin_ia32_stmxcsr", + UNSIGNED_FTYPE_VOID, IX86_BUILTIN_STMXCSR); /* SSE or 3DNow!A */ - def_builtin (OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A, "__builtin_ia32_maskmovq", void_ftype_v8qi_v8qi_pchar, IX86_BUILTIN_MASKMOVQ); + def_builtin (OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A, + "__builtin_ia32_maskmovq", VOID_FTYPE_V8QI_V8QI_PCHAR, + IX86_BUILTIN_MASKMOVQ); /* SSE2 */ - def_builtin (OPTION_MASK_ISA_SSE2, "__builtin_ia32_maskmovdqu", void_ftype_v16qi_v16qi_pchar, IX86_BUILTIN_MASKMOVDQU); + def_builtin (OPTION_MASK_ISA_SSE2, "__builtin_ia32_maskmovdqu", + VOID_FTYPE_V16QI_V16QI_PCHAR, IX86_BUILTIN_MASKMOVDQU); - def_builtin (OPTION_MASK_ISA_SSE2, "__builtin_ia32_clflush", void_ftype_pcvoid, IX86_BUILTIN_CLFLUSH); - x86_mfence = def_builtin (OPTION_MASK_ISA_SSE2, "__builtin_ia32_mfence", void_ftype_void, IX86_BUILTIN_MFENCE); + def_builtin (OPTION_MASK_ISA_SSE2, "__builtin_ia32_clflush", + VOID_FTYPE_PCVOID, IX86_BUILTIN_CLFLUSH); + x86_mfence = def_builtin (OPTION_MASK_ISA_SSE2, "__builtin_ia32_mfence", + VOID_FTYPE_VOID, IX86_BUILTIN_MFENCE); /* SSE3. */ - def_builtin (OPTION_MASK_ISA_SSE3, "__builtin_ia32_monitor", void_ftype_pcvoid_unsigned_unsigned, IX86_BUILTIN_MONITOR); - def_builtin (OPTION_MASK_ISA_SSE3, "__builtin_ia32_mwait", void_ftype_unsigned_unsigned, IX86_BUILTIN_MWAIT); + def_builtin (OPTION_MASK_ISA_SSE3, "__builtin_ia32_monitor", + VOID_FTYPE_PCVOID_UNSIGNED_UNSIGNED, IX86_BUILTIN_MONITOR); + def_builtin (OPTION_MASK_ISA_SSE3, "__builtin_ia32_mwait", + VOID_FTYPE_UNSIGNED_UNSIGNED, IX86_BUILTIN_MWAIT); /* AES */ - def_builtin_const (OPTION_MASK_ISA_AES, "__builtin_ia32_aesenc128", v2di_ftype_v2di_v2di, IX86_BUILTIN_AESENC128); - def_builtin_const (OPTION_MASK_ISA_AES, "__builtin_ia32_aesenclast128", v2di_ftype_v2di_v2di, IX86_BUILTIN_AESENCLAST128); - def_builtin_const (OPTION_MASK_ISA_AES, "__builtin_ia32_aesdec128", v2di_ftype_v2di_v2di, IX86_BUILTIN_AESDEC128); - def_builtin_const (OPTION_MASK_ISA_AES, "__builtin_ia32_aesdeclast128", v2di_ftype_v2di_v2di, IX86_BUILTIN_AESDECLAST128); - def_builtin_const (OPTION_MASK_ISA_AES, "__builtin_ia32_aesimc128", v2di_ftype_v2di, IX86_BUILTIN_AESIMC128); - def_builtin_const (OPTION_MASK_ISA_AES, "__builtin_ia32_aeskeygenassist128", v2di_ftype_v2di_int, IX86_BUILTIN_AESKEYGENASSIST128); + def_builtin_const (OPTION_MASK_ISA_AES, "__builtin_ia32_aesenc128", + V2DI_FTYPE_V2DI_V2DI, IX86_BUILTIN_AESENC128); + def_builtin_const (OPTION_MASK_ISA_AES, "__builtin_ia32_aesenclast128", + V2DI_FTYPE_V2DI_V2DI, IX86_BUILTIN_AESENCLAST128); + def_builtin_const (OPTION_MASK_ISA_AES, "__builtin_ia32_aesdec128", + V2DI_FTYPE_V2DI_V2DI, IX86_BUILTIN_AESDEC128); + def_builtin_const (OPTION_MASK_ISA_AES, "__builtin_ia32_aesdeclast128", + V2DI_FTYPE_V2DI_V2DI, IX86_BUILTIN_AESDECLAST128); + def_builtin_const (OPTION_MASK_ISA_AES, "__builtin_ia32_aesimc128", + V2DI_FTYPE_V2DI, IX86_BUILTIN_AESIMC128); + def_builtin_const (OPTION_MASK_ISA_AES, "__builtin_ia32_aeskeygenassist128", + V2DI_FTYPE_V2DI_INT, IX86_BUILTIN_AESKEYGENASSIST128); /* PCLMUL */ - def_builtin_const (OPTION_MASK_ISA_PCLMUL, "__builtin_ia32_pclmulqdq128", v2di_ftype_v2di_v2di_int, IX86_BUILTIN_PCLMULQDQ128); + def_builtin_const (OPTION_MASK_ISA_PCLMUL, "__builtin_ia32_pclmulqdq128", + V2DI_FTYPE_V2DI_V2DI_INT, IX86_BUILTIN_PCLMULQDQ128); /* AVX */ - def_builtin (OPTION_MASK_ISA_AVX, "__builtin_ia32_vzeroupper", void_ftype_void, - TARGET_64BIT ? IX86_BUILTIN_VZEROUPPER_REX64 : IX86_BUILTIN_VZEROUPPER); - - /* Access to the vec_init patterns. */ - ftype = build_function_type_list (V2SI_type_node, integer_type_node, - integer_type_node, NULL_TREE); - def_builtin_const (OPTION_MASK_ISA_MMX, "__builtin_ia32_vec_init_v2si", ftype, IX86_BUILTIN_VEC_INIT_V2SI); - - ftype = build_function_type_list (V4HI_type_node, short_integer_type_node, - short_integer_type_node, - short_integer_type_node, - short_integer_type_node, NULL_TREE); - def_builtin_const (OPTION_MASK_ISA_MMX, "__builtin_ia32_vec_init_v4hi", ftype, IX86_BUILTIN_VEC_INIT_V4HI); - - ftype = build_function_type_list (V8QI_type_node, char_type_node, - char_type_node, char_type_node, - char_type_node, char_type_node, - char_type_node, char_type_node, - char_type_node, NULL_TREE); - def_builtin_const (OPTION_MASK_ISA_MMX, "__builtin_ia32_vec_init_v8qi", ftype, IX86_BUILTIN_VEC_INIT_V8QI); + def_builtin (OPTION_MASK_ISA_AVX, "__builtin_ia32_vzeroupper", + VOID_FTYPE_VOID, + (TARGET_64BIT ? IX86_BUILTIN_VZEROUPPER_REX64 + : IX86_BUILTIN_VZEROUPPER)); - /* Access to the vec_extract patterns. */ - ftype = build_function_type_list (double_type_node, V2DF_type_node, - integer_type_node, NULL_TREE); - def_builtin_const (OPTION_MASK_ISA_SSE2, "__builtin_ia32_vec_ext_v2df", ftype, IX86_BUILTIN_VEC_EXT_V2DF); + /* MMX access to the vec_init patterns. */ + def_builtin_const (OPTION_MASK_ISA_MMX, "__builtin_ia32_vec_init_v2si", + V2SI_FTYPE_INT_INT, IX86_BUILTIN_VEC_INIT_V2SI); - ftype = build_function_type_list (long_long_integer_type_node, - V2DI_type_node, integer_type_node, - NULL_TREE); - def_builtin_const (OPTION_MASK_ISA_SSE2, "__builtin_ia32_vec_ext_v2di", ftype, IX86_BUILTIN_VEC_EXT_V2DI); + def_builtin_const (OPTION_MASK_ISA_MMX, "__builtin_ia32_vec_init_v4hi", + V4HI_FTYPE_HI_HI_HI_HI, + IX86_BUILTIN_VEC_INIT_V4HI); - ftype = build_function_type_list (float_type_node, V4SF_type_node, - integer_type_node, NULL_TREE); - def_builtin_const (OPTION_MASK_ISA_SSE, "__builtin_ia32_vec_ext_v4sf", ftype, IX86_BUILTIN_VEC_EXT_V4SF); + def_builtin_const (OPTION_MASK_ISA_MMX, "__builtin_ia32_vec_init_v8qi", + V8QI_FTYPE_QI_QI_QI_QI_QI_QI_QI_QI, + IX86_BUILTIN_VEC_INIT_V8QI); - ftype = build_function_type_list (intSI_type_node, V4SI_type_node, - integer_type_node, NULL_TREE); - def_builtin_const (OPTION_MASK_ISA_SSE2, "__builtin_ia32_vec_ext_v4si", ftype, IX86_BUILTIN_VEC_EXT_V4SI); + /* Access to the vec_extract patterns. */ + def_builtin_const (OPTION_MASK_ISA_SSE2, "__builtin_ia32_vec_ext_v2df", + DOUBLE_FTYPE_V2DF_INT, IX86_BUILTIN_VEC_EXT_V2DF); + def_builtin_const (OPTION_MASK_ISA_SSE2, "__builtin_ia32_vec_ext_v2di", + DI_FTYPE_V2DI_INT, IX86_BUILTIN_VEC_EXT_V2DI); + def_builtin_const (OPTION_MASK_ISA_SSE, "__builtin_ia32_vec_ext_v4sf", + FLOAT_FTYPE_V4SF_INT, IX86_BUILTIN_VEC_EXT_V4SF); + def_builtin_const (OPTION_MASK_ISA_SSE2, "__builtin_ia32_vec_ext_v4si", + SI_FTYPE_V4SI_INT, IX86_BUILTIN_VEC_EXT_V4SI); + def_builtin_const (OPTION_MASK_ISA_SSE2, "__builtin_ia32_vec_ext_v8hi", + HI_FTYPE_V8HI_INT, IX86_BUILTIN_VEC_EXT_V8HI); + + def_builtin_const (OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A, + "__builtin_ia32_vec_ext_v4hi", + HI_FTYPE_V4HI_INT, IX86_BUILTIN_VEC_EXT_V4HI); + + def_builtin_const (OPTION_MASK_ISA_MMX, "__builtin_ia32_vec_ext_v2si", + SI_FTYPE_V2SI_INT, IX86_BUILTIN_VEC_EXT_V2SI); + + def_builtin_const (OPTION_MASK_ISA_SSE2, "__builtin_ia32_vec_ext_v16qi", + QI_FTYPE_V16QI_INT, IX86_BUILTIN_VEC_EXT_V16QI); - ftype = build_function_type_list (intHI_type_node, V8HI_type_node, - integer_type_node, NULL_TREE); - def_builtin_const (OPTION_MASK_ISA_SSE2, "__builtin_ia32_vec_ext_v8hi", ftype, IX86_BUILTIN_VEC_EXT_V8HI); + /* Access to the vec_set patterns. */ + def_builtin_const (OPTION_MASK_ISA_SSE4_1 | OPTION_MASK_ISA_64BIT, + "__builtin_ia32_vec_set_v2di", + V2DI_FTYPE_V2DI_DI_INT, IX86_BUILTIN_VEC_SET_V2DI); - ftype = build_function_type_list (intHI_type_node, V4HI_type_node, - integer_type_node, NULL_TREE); - def_builtin_const (OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A, "__builtin_ia32_vec_ext_v4hi", ftype, IX86_BUILTIN_VEC_EXT_V4HI); + def_builtin_const (OPTION_MASK_ISA_SSE4_1, "__builtin_ia32_vec_set_v4sf", + V4SF_FTYPE_V4SF_FLOAT_INT, IX86_BUILTIN_VEC_SET_V4SF); - ftype = build_function_type_list (intSI_type_node, V2SI_type_node, - integer_type_node, NULL_TREE); - def_builtin_const (OPTION_MASK_ISA_MMX, "__builtin_ia32_vec_ext_v2si", ftype, IX86_BUILTIN_VEC_EXT_V2SI); + def_builtin_const (OPTION_MASK_ISA_SSE4_1, "__builtin_ia32_vec_set_v4si", + V4SI_FTYPE_V4SI_SI_INT, IX86_BUILTIN_VEC_SET_V4SI); - ftype = build_function_type_list (intQI_type_node, V16QI_type_node, - integer_type_node, NULL_TREE); - def_builtin_const (OPTION_MASK_ISA_SSE2, "__builtin_ia32_vec_ext_v16qi", ftype, IX86_BUILTIN_VEC_EXT_V16QI); + def_builtin_const (OPTION_MASK_ISA_SSE2, "__builtin_ia32_vec_set_v8hi", + V8HI_FTYPE_V8HI_HI_INT, IX86_BUILTIN_VEC_SET_V8HI); + + def_builtin_const (OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A, + "__builtin_ia32_vec_set_v4hi", + V4HI_FTYPE_V4HI_HI_INT, IX86_BUILTIN_VEC_SET_V4HI); + + def_builtin_const (OPTION_MASK_ISA_SSE4_1, "__builtin_ia32_vec_set_v16qi", + V16QI_FTYPE_V16QI_QI_INT, IX86_BUILTIN_VEC_SET_V16QI); - /* Access to the vec_set patterns. */ - ftype = build_function_type_list (V2DI_type_node, V2DI_type_node, - intDI_type_node, - integer_type_node, NULL_TREE); - def_builtin_const (OPTION_MASK_ISA_SSE4_1 | OPTION_MASK_ISA_64BIT, "__builtin_ia32_vec_set_v2di", ftype, IX86_BUILTIN_VEC_SET_V2DI); - - ftype = build_function_type_list (V4SF_type_node, V4SF_type_node, - float_type_node, - integer_type_node, NULL_TREE); - def_builtin_const (OPTION_MASK_ISA_SSE4_1, "__builtin_ia32_vec_set_v4sf", ftype, IX86_BUILTIN_VEC_SET_V4SF); - - ftype = build_function_type_list (V4SI_type_node, V4SI_type_node, - intSI_type_node, - integer_type_node, NULL_TREE); - def_builtin_const (OPTION_MASK_ISA_SSE4_1, "__builtin_ia32_vec_set_v4si", ftype, IX86_BUILTIN_VEC_SET_V4SI); - - ftype = build_function_type_list (V8HI_type_node, V8HI_type_node, - intHI_type_node, - integer_type_node, NULL_TREE); - def_builtin_const (OPTION_MASK_ISA_SSE2, "__builtin_ia32_vec_set_v8hi", ftype, IX86_BUILTIN_VEC_SET_V8HI); - - ftype = build_function_type_list (V4HI_type_node, V4HI_type_node, - intHI_type_node, - integer_type_node, NULL_TREE); - def_builtin_const (OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A, "__builtin_ia32_vec_set_v4hi", ftype, IX86_BUILTIN_VEC_SET_V4HI); - - ftype = build_function_type_list (V16QI_type_node, V16QI_type_node, - intQI_type_node, - integer_type_node, NULL_TREE); - def_builtin_const (OPTION_MASK_ISA_SSE4_1, "__builtin_ia32_vec_set_v16qi", ftype, IX86_BUILTIN_VEC_SET_V16QI); /* Add FMA4 multi-arg argument instructions */ for (i = 0, d = bdesc_multi_arg; i < ARRAY_SIZE (bdesc_multi_arg); i++, d++) { - tree mtype = NULL_TREE; - if (d->name == 0) continue; - switch ((enum multi_arg_type)d->flag) - { - case MULTI_ARG_3_SF: mtype = v4sf_ftype_v4sf_v4sf_v4sf; break; - case MULTI_ARG_3_DF: mtype = v2df_ftype_v2df_v2df_v2df; break; - case MULTI_ARG_3_SF2: mtype = v8sf_ftype_v8sf_v8sf_v8sf; break; - case MULTI_ARG_3_DF2: mtype = v4df_ftype_v4df_v4df_v4df; break; - case MULTI_ARG_3_DI: mtype = v2di_ftype_v2di_v2di_v2di; break; - case MULTI_ARG_3_SI: mtype = v4si_ftype_v4si_v4si_v4si; break; - case MULTI_ARG_3_SI_DI: mtype = v4si_ftype_v4si_v4si_v2di; break; - case MULTI_ARG_3_HI: mtype = v8hi_ftype_v8hi_v8hi_v8hi; break; - case MULTI_ARG_3_HI_SI: mtype = v8hi_ftype_v8hi_v8hi_v4si; break; - case MULTI_ARG_3_QI: mtype = v16qi_ftype_v16qi_v16qi_v16qi; break; - case MULTI_ARG_3_DI2: mtype = v4di_ftype_v4di_v4di_v4di; break; - case MULTI_ARG_3_SI2: mtype = v8si_ftype_v8si_v8si_v8si; break; - case MULTI_ARG_3_HI2: mtype = v16hi_ftype_v16hi_v16hi_v16hi; break; - case MULTI_ARG_3_QI2: mtype = v32qi_ftype_v32qi_v32qi_v32qi; break; - case MULTI_ARG_2_SF: mtype = v4sf_ftype_v4sf_v4sf; break; - case MULTI_ARG_2_DF: mtype = v2df_ftype_v2df_v2df; break; - case MULTI_ARG_2_DI: mtype = v2di_ftype_v2di_v2di; break; - case MULTI_ARG_2_SI: mtype = v4si_ftype_v4si_v4si; break; - case MULTI_ARG_2_HI: mtype = v8hi_ftype_v8hi_v8hi; break; - case MULTI_ARG_2_QI: mtype = v16qi_ftype_v16qi_v16qi; break; - case MULTI_ARG_2_DI_IMM: mtype = v2di_ftype_v2di_si; break; - case MULTI_ARG_2_SI_IMM: mtype = v4si_ftype_v4si_si; break; - case MULTI_ARG_2_HI_IMM: mtype = v8hi_ftype_v8hi_si; break; - case MULTI_ARG_2_QI_IMM: mtype = v16qi_ftype_v16qi_si; break; - case MULTI_ARG_2_DI_CMP: mtype = v2di_ftype_v2di_v2di; break; - case MULTI_ARG_2_SI_CMP: mtype = v4si_ftype_v4si_v4si; break; - case MULTI_ARG_2_HI_CMP: mtype = v8hi_ftype_v8hi_v8hi; break; - case MULTI_ARG_2_QI_CMP: mtype = v16qi_ftype_v16qi_v16qi; break; - case MULTI_ARG_2_SF_TF: mtype = v4sf_ftype_v4sf_v4sf; break; - case MULTI_ARG_2_DF_TF: mtype = v2df_ftype_v2df_v2df; break; - case MULTI_ARG_2_DI_TF: mtype = v2di_ftype_v2di_v2di; break; - case MULTI_ARG_2_SI_TF: mtype = v4si_ftype_v4si_v4si; break; - case MULTI_ARG_2_HI_TF: mtype = v8hi_ftype_v8hi_v8hi; break; - case MULTI_ARG_2_QI_TF: mtype = v16qi_ftype_v16qi_v16qi; break; - case MULTI_ARG_1_SF: mtype = v4sf_ftype_v4sf; break; - case MULTI_ARG_1_DF: mtype = v2df_ftype_v2df; break; - case MULTI_ARG_1_SF2: mtype = v8sf_ftype_v8sf; break; - case MULTI_ARG_1_DF2: mtype = v4df_ftype_v4df; break; - case MULTI_ARG_1_DI: mtype = v2di_ftype_v2di; break; - case MULTI_ARG_1_SI: mtype = v4si_ftype_v4si; break; - case MULTI_ARG_1_HI: mtype = v8hi_ftype_v8hi; break; - case MULTI_ARG_1_QI: mtype = v16qi_ftype_v16qi; break; - case MULTI_ARG_1_SI_DI: mtype = v2di_ftype_v4si; break; - case MULTI_ARG_1_HI_DI: mtype = v2di_ftype_v8hi; break; - case MULTI_ARG_1_HI_SI: mtype = v4si_ftype_v8hi; break; - case MULTI_ARG_1_QI_DI: mtype = v2di_ftype_v16qi; break; - case MULTI_ARG_1_QI_SI: mtype = v4si_ftype_v16qi; break; - case MULTI_ARG_1_QI_HI: mtype = v8hi_ftype_v16qi; break; - - case MULTI_ARG_UNKNOWN: - default: - gcc_unreachable (); - } - - if (mtype) - def_builtin_const (d->mask, d->name, mtype, d->code); + ftype = (enum ix86_builtin_func_type) d->flag; + def_builtin_const (d->mask, d->name, ftype, d->code); } } @@ -24162,66 +22592,61 @@ ix86_init_builtins_va_builtins_abi (void) } static void -ix86_init_builtins (void) +ix86_init_builtin_types (void) { - tree float128_type_node = make_node (REAL_TYPE); - tree ftype, decl; + tree float128_type_node, float80_type_node; /* The __float80 type. */ - if (TYPE_MODE (long_double_type_node) == XFmode) - (*lang_hooks.types.register_builtin_type) (long_double_type_node, - "__float80"); - else + float80_type_node = long_double_type_node; + if (TYPE_MODE (float80_type_node) != XFmode) { /* The __float80 type. */ - tree float80_type_node = make_node (REAL_TYPE); + float80_type_node = make_node (REAL_TYPE); TYPE_PRECISION (float80_type_node) = 80; layout_type (float80_type_node); - (*lang_hooks.types.register_builtin_type) (float80_type_node, - "__float80"); } + (*lang_hooks.types.register_builtin_type) (float80_type_node, "__float80"); /* The __float128 type. */ + float128_type_node = make_node (REAL_TYPE); TYPE_PRECISION (float128_type_node) = 128; layout_type (float128_type_node); - (*lang_hooks.types.register_builtin_type) (float128_type_node, - "__float128"); + (*lang_hooks.types.register_builtin_type) (float128_type_node, "__float128"); - /* TFmode support builtins. */ - ftype = build_function_type (float128_type_node, void_list_node); - decl = add_builtin_function ("__builtin_infq", ftype, - IX86_BUILTIN_INFQ, BUILT_IN_MD, - NULL, NULL_TREE); - ix86_builtins[(int) IX86_BUILTIN_INFQ] = decl; + /* This macro is built by i386-builtin-types.awk. */ + DEFINE_BUILTIN_PRIMITIVE_TYPES; +} + +static void +ix86_init_builtins (void) +{ + tree t; + + ix86_init_builtin_types (); - decl = add_builtin_function ("__builtin_huge_valq", ftype, - IX86_BUILTIN_HUGE_VALQ, BUILT_IN_MD, - NULL, NULL_TREE); - ix86_builtins[(int) IX86_BUILTIN_HUGE_VALQ] = decl; + /* TFmode support builtins. */ + def_builtin_const (0, "__builtin_infq", + FLOAT128_FTYPE_VOID, IX86_BUILTIN_INFQ); + def_builtin_const (0, "__builtin_huge_valq", + FLOAT128_FTYPE_VOID, IX86_BUILTIN_HUGE_VALQ); /* We will expand them to normal call if SSE2 isn't available since they are used by libgcc. */ - ftype = build_function_type_list (float128_type_node, - float128_type_node, - NULL_TREE); - decl = add_builtin_function ("__builtin_fabsq", ftype, - IX86_BUILTIN_FABSQ, BUILT_IN_MD, - "__fabstf2", NULL_TREE); - ix86_builtins[(int) IX86_BUILTIN_FABSQ] = decl; - TREE_READONLY (decl) = 1; - - ftype = build_function_type_list (float128_type_node, - float128_type_node, - float128_type_node, - NULL_TREE); - decl = add_builtin_function ("__builtin_copysignq", ftype, - IX86_BUILTIN_COPYSIGNQ, BUILT_IN_MD, - "__copysigntf3", NULL_TREE); - ix86_builtins[(int) IX86_BUILTIN_COPYSIGNQ] = decl; - TREE_READONLY (decl) = 1; + t = ix86_get_builtin_func_type (FLOAT128_FTYPE_FLOAT128); + t = add_builtin_function ("__builtin_fabsq", t, IX86_BUILTIN_FABSQ, + BUILT_IN_MD, "__fabstf2", NULL_TREE); + TREE_READONLY (t) = 1; + ix86_builtins[(int) IX86_BUILTIN_FABSQ] = t; + + t = ix86_get_builtin_func_type (FLOAT128_FTYPE_FLOAT128_FLOAT128); + t = add_builtin_function ("__builtin_copysignq", t, IX86_BUILTIN_COPYSIGNQ, + BUILT_IN_MD, "__copysigntf3", NULL_TREE); + TREE_READONLY (t) = 1; + ix86_builtins[(int) IX86_BUILTIN_COPYSIGNQ] = t; ix86_init_mmx_sse_builtins (); + if (TARGET_64BIT) ix86_init_builtins_va_builtins_abi (); } @@ -24297,7 +22722,7 @@ ix86_expand_binop_builtin (enum insn_code icode, tree exp, rtx target) static rtx ix86_expand_multi_arg_builtin (enum insn_code icode, tree exp, rtx target, - enum multi_arg_type m_type, + enum ix86_builtin_func_type m_type, enum rtx_code sub_code) { rtx pat; @@ -24385,7 +22810,6 @@ ix86_expand_multi_arg_builtin (enum insn_code icode, tree exp, rtx target, tf_p = true; break; - case MULTI_ARG_UNKNOWN: default: gcc_unreachable (); } @@ -24879,7 +23303,7 @@ ix86_expand_args_builtin (const struct builtin_description *d, bool swap = false; enum rtx_code comparison = d->comparison; - switch ((enum ix86_builtin_type) d->flag) + switch ((enum ix86_builtin_func_type) d->flag) { case INT_FTYPE_V8SF_V8SF_PTEST: case INT_FTYPE_V4DI_V4DI_PTEST: @@ -25022,7 +23446,7 @@ ix86_expand_args_builtin (const struct builtin_description *d, case UINT8_FTYPE_UINT8_INT: nargs = 2; break; - case V2DI2TI_FTYPE_V2DI_INT: + case V2DI_FTYPE_V2DI_INT_CONVERT: nargs = 2; rmode = V2DImode; nargs_constant = 1; @@ -25063,12 +23487,12 @@ ix86_expand_args_builtin (const struct builtin_description *d, nargs = 3; nargs_constant = 1; break; - case V2DI2TI_FTYPE_V2DI_V2DI_INT: + case V2DI_FTYPE_V2DI_V2DI_INT_CONVERT: nargs = 3; rmode = V2DImode; nargs_constant = 1; break; - case V1DI2DI_FTYPE_V1DI_V1DI_INT: + case V1DI_FTYPE_V1DI_V1DI_INT_CONVERT: nargs = 3; rmode = DImode; nargs_constant = 1; @@ -25259,7 +23683,7 @@ ix86_expand_special_args_builtin (const struct builtin_description *d, enum machine_mode tmode = insn_p->operand[0].mode; enum { load, store } klass; - switch ((enum ix86_special_builtin_type) d->flag) + switch ((enum ix86_builtin_func_type) d->flag) { case VOID_FTYPE_VOID: emit_insn (GEN_FCN (icode) (target)); @@ -25292,7 +23716,7 @@ ix86_expand_special_args_builtin (const struct builtin_description *d, case VOID_FTYPE_PFLOAT_V4SF: case VOID_FTYPE_PDOUBLE_V4DF: case VOID_FTYPE_PDOUBLE_V2DF: - case VOID_FTYPE_PDI_DI: + case VOID_FTYPE_PULONGLONG_ULONGLONG: case VOID_FTYPE_PINT_INT: nargs = 1; klass = store; @@ -25753,8 +24177,8 @@ ix86_expand_builtin (tree exp, rtx target, rtx subtarget ATTRIBUTE_UNUSED, for (i = 0, d = bdesc_multi_arg; i < ARRAY_SIZE (bdesc_multi_arg); i++, d++) if (d->code == fcode) return ix86_expand_multi_arg_builtin (d->icode, exp, target, - (enum multi_arg_type)d->flag, - d->comparison); + (enum ix86_builtin_func_type) + d->flag, d->comparison); gcc_unreachable (); } diff --git a/gcc/config/i386/t-i386 b/gcc/config/i386/t-i386 index 087c474..87a25fb 100644 --- a/gcc/config/i386/t-i386 +++ b/gcc/config/i386/t-i386 @@ -22,7 +22,8 @@ i386.o: $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \ $(INSN_ATTR_H) $(FLAGS_H) $(C_COMMON_H) except.h $(FUNCTION_H) \ $(RECOG_H) $(EXPR_H) $(OPTABS_H) toplev.h $(BASIC_BLOCK_H) \ $(GGC_H) $(TARGET_H) $(TARGET_DEF_H) langhooks.h $(CGRAPH_H) \ - $(TREE_GIMPLE_H) $(DWARF2_H) $(DF_H) tm-constrs.h $(PARAMS_H) + $(TREE_GIMPLE_H) $(DWARF2_H) $(DF_H) tm-constrs.h $(PARAMS_H) \ + i386-builtin-types.inc i386-c.o: $(srcdir)/config/i386/i386-c.c \ $(srcdir)/config/i386/i386-protos.h $(CONFIG_H) $(SYSTEM_H) coretypes.h \ @@ -30,3 +31,11 @@ i386-c.o: $(srcdir)/config/i386/i386-c.c \ $(TARGET_H) $(TARGET_DEF_H) $(CPPLIB_H) $(C_PRAGMA_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ $(srcdir)/config/i386/i386-c.c + + +i386-builtin-types.inc: s-i386-bt ; @true +s-i386-bt: $(srcdir)/config/i386/i386-builtin-types.awk \ + $(srcdir)/config/i386/i386-builtin-types.def + $(AWK) -f $^ > tmp-bt.inc + $(SHELL) $(srcdir)/../move-if-change tmp-bt.inc i386-builtin-types.inc + $(STAMP) $@ -- 2.7.4