[thirdparty/gcc.git] / gcc / config / aarch64 / aarch64-c.c

/* Target-specific code for C family languages.
   Copyright (C) 2015-2019 Free Software Foundation, Inc.

   This file is part of GCC.

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

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

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

#define IN_TARGET_CODE 1

#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "input.h"
#include "memmodel.h"
#include "tm_p.h"
#include "flags.h"
#include "c-family/c-common.h"
#include "cpplib.h"
#include "c-family/c-pragma.h"
#include "langhooks.h"
#include "target.h"


#define builtin_define(TXT) cpp_define (pfile, TXT)
#define builtin_assert(TXT) cpp_assert (pfile, TXT)


static void
aarch64_def_or_undef (bool def_p, const char *macro, cpp_reader *pfile)
{
  if (def_p)
    cpp_define (pfile, macro);
  else
    cpp_undef (pfile, macro);
}

/* Define the macros that we always expect to have on AArch64.  */

static void
aarch64_define_unconditional_macros (cpp_reader *pfile)
{
  builtin_define ("__aarch64__");
  builtin_define ("__ARM_64BIT_STATE");

  builtin_define ("__ARM_ARCH_ISA_A64");
  builtin_define_with_int_value ("__ARM_ALIGN_MAX_PWR", 28);
  builtin_define_with_int_value ("__ARM_ALIGN_MAX_STACK_PWR", 16);

  /* __ARM_ARCH_8A is not mandated by ACLE but we define it unconditionally
     as interoperability with the same arm macro.  */
  builtin_define ("__ARM_ARCH_8A");

  builtin_define_with_int_value ("__ARM_ARCH_PROFILE", 'A');
  builtin_define ("__ARM_FEATURE_CLZ");
  builtin_define ("__ARM_FEATURE_IDIV");
  builtin_define ("__ARM_FEATURE_UNALIGNED");
  builtin_define ("__ARM_PCS_AAPCS64");
  builtin_define_with_int_value ("__ARM_SIZEOF_WCHAR_T", WCHAR_TYPE_SIZE / 8);
}

/* Undefine/redefine macros that depend on the current backend state and may
   need to change when a target pragma modifies the backend state.  */

static void
aarch64_update_cpp_builtins (cpp_reader *pfile)
{
  aarch64_def_or_undef (flag_unsafe_math_optimizations, "__ARM_FP_FAST", pfile);

  builtin_define_with_int_value ("__ARM_ARCH", aarch64_architecture_version);

  builtin_define_with_int_value ("__ARM_SIZEOF_MINIMAL_ENUM",
				 flag_short_enums ? 1 : 4);
  aarch64_def_or_undef (TARGET_BIG_END, "__AARCH64EB__", pfile);
  aarch64_def_or_undef (TARGET_BIG_END, "__ARM_BIG_ENDIAN", pfile);
  aarch64_def_or_undef (!TARGET_BIG_END, "__AARCH64EL__", pfile);

  aarch64_def_or_undef (TARGET_FLOAT, "__ARM_FEATURE_FMA", pfile);

  if (TARGET_FLOAT || TARGET_SIMD)
    {
      builtin_define_with_int_value ("__ARM_FP", 0x0E);
      builtin_define ("__ARM_FP16_FORMAT_IEEE");
      builtin_define ("__ARM_FP16_ARGS");
    }
  else
    cpp_undef (pfile, "__ARM_FP");

  aarch64_def_or_undef (TARGET_FP_F16INST,
			"__ARM_FEATURE_FP16_SCALAR_ARITHMETIC", pfile);
  aarch64_def_or_undef (TARGET_SIMD_F16INST,
			"__ARM_FEATURE_FP16_VECTOR_ARITHMETIC", pfile);

  aarch64_def_or_undef (TARGET_SIMD, "__ARM_FEATURE_NUMERIC_MAXMIN", pfile);
  aarch64_def_or_undef (TARGET_SIMD, "__ARM_NEON", pfile);


  aarch64_def_or_undef (TARGET_CRC32, "__ARM_FEATURE_CRC32", pfile);
  aarch64_def_or_undef (TARGET_DOTPROD, "__ARM_FEATURE_DOTPROD", pfile);
  aarch64_def_or_undef (TARGET_COMPLEX, "__ARM_FEATURE_COMPLEX", pfile);

  cpp_undef (pfile, "__AARCH64_CMODEL_TINY__");
  cpp_undef (pfile, "__AARCH64_CMODEL_SMALL__");
  cpp_undef (pfile, "__AARCH64_CMODEL_LARGE__");

  switch (aarch64_cmodel)
    {
      case AARCH64_CMODEL_TINY:
      case AARCH64_CMODEL_TINY_PIC:
	builtin_define ("__AARCH64_CMODEL_TINY__");
	break;
      case AARCH64_CMODEL_SMALL:
      case AARCH64_CMODEL_SMALL_PIC:
	builtin_define ("__AARCH64_CMODEL_SMALL__");
	break;
      case AARCH64_CMODEL_LARGE:
	builtin_define ("__AARCH64_CMODEL_LARGE__");
	break;
      default:
	break;
    }

  aarch64_def_or_undef (TARGET_ILP32, "_ILP32", pfile);
  aarch64_def_or_undef (TARGET_ILP32, "__ILP32__", pfile);

  aarch64_def_or_undef (TARGET_CRYPTO, "__ARM_FEATURE_CRYPTO", pfile);
  aarch64_def_or_undef (TARGET_SIMD_RDMA, "__ARM_FEATURE_QRDMX", pfile);
  aarch64_def_or_undef (TARGET_SVE, "__ARM_FEATURE_SVE", pfile);
  cpp_undef (pfile, "__ARM_FEATURE_SVE_BITS");
  if (TARGET_SVE)
    {
      int bits;
      if (!BITS_PER_SVE_VECTOR.is_constant (&bits))
	bits = 0;
      builtin_define_with_int_value ("__ARM_FEATURE_SVE_BITS", bits);
    }
  aarch64_def_or_undef (TARGET_SVE2, "__ARM_FEATURE_SVE2", pfile);

  aarch64_def_or_undef (TARGET_LSE, "__ARM_FEATURE_ATOMICS", pfile);
  aarch64_def_or_undef (TARGET_AES, "__ARM_FEATURE_AES", pfile);
  aarch64_def_or_undef (TARGET_SHA2, "__ARM_FEATURE_SHA2", pfile);
  aarch64_def_or_undef (TARGET_SHA3, "__ARM_FEATURE_SHA3", pfile);
  aarch64_def_or_undef (TARGET_SHA3, "__ARM_FEATURE_SHA512", pfile);
  aarch64_def_or_undef (TARGET_SM4, "__ARM_FEATURE_SM3", pfile);
  aarch64_def_or_undef (TARGET_SM4, "__ARM_FEATURE_SM4", pfile);
  aarch64_def_or_undef (TARGET_F16FML, "__ARM_FEATURE_FP16_FML", pfile);

  aarch64_def_or_undef (TARGET_TME, "__ARM_FEATURE_TME", pfile);

  /* Not for ACLE, but required to keep "float.h" correct if we switch
     target between implementations that do or do not support ARMv8.2-A
     16-bit floating-point extensions.  */
  cpp_undef (pfile, "__FLT_EVAL_METHOD__");
  builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
				 c_flt_eval_method (true));
  cpp_undef (pfile, "__FLT_EVAL_METHOD_C99__");
  builtin_define_with_int_value ("__FLT_EVAL_METHOD_C99__",
				 c_flt_eval_method (false));
}

/* Implement TARGET_CPU_CPP_BUILTINS.  */

void
aarch64_cpu_cpp_builtins (cpp_reader *pfile)
{
  aarch64_define_unconditional_macros (pfile);
  aarch64_update_cpp_builtins (pfile);
}

/* Hook to validate the current #pragma GCC target and set the state, and
   update the macros based on what was changed.  If ARGS is NULL, then
   POP_TARGET is used to reset the options.  */

static bool
aarch64_pragma_target_parse (tree args, tree pop_target)
{
  /* If args is not NULL then process it and setup the target-specific
     information that it specifies.  */
  if (args)
    {
      if (!aarch64_process_target_attr (args))
	return false;

      aarch64_override_options_internal (&global_options);
    }

  /* args is NULL, restore to the state described in pop_target.  */
  else
    {
      pop_target = pop_target ? pop_target : target_option_default_node;
      cl_target_option_restore (&global_options,
				TREE_TARGET_OPTION (pop_target));
    }

  target_option_current_node
    = build_target_option_node (&global_options);

  aarch64_reset_previous_fndecl ();
  /* For the definitions, ensure all newly defined macros are considered
     as used for -Wunused-macros.  There is no point warning about the
     compiler predefined macros.  */
  cpp_options *cpp_opts = cpp_get_options (parse_in);
  unsigned char saved_warn_unused_macros = cpp_opts->warn_unused_macros;
  cpp_opts->warn_unused_macros = 0;

  aarch64_update_cpp_builtins (parse_in);

  cpp_opts->warn_unused_macros = saved_warn_unused_macros;

  /* If we're popping or reseting make sure to update the globals so that
     the optab availability predicates get recomputed.  */
  if (pop_target)
    aarch64_save_restore_target_globals (pop_target);

  /* Initialize SIMD builtins if we haven't already.
     Set current_target_pragma to NULL for the duration so that
     the builtin initialization code doesn't try to tag the functions
     being built with the attributes specified by any current pragma, thus
     going into an infinite recursion.  */
  if (TARGET_SIMD)
    {
      tree saved_current_target_pragma = current_target_pragma;
      current_target_pragma = NULL;
      aarch64_init_simd_builtins ();
      current_target_pragma = saved_current_target_pragma;
    }

  return true;
}

/* Implement REGISTER_TARGET_PRAGMAS.  */

void
aarch64_register_pragmas (void)
{
  /* Update pragma hook to allow parsing #pragma GCC target.  */
  targetm.target_option.pragma_parse = aarch64_pragma_target_parse;
}
Commit	Line	Data
e4ea20c8	1	/* Target-specific code for C family languages.
a5544970	2	Copyright (C) 2015-2019 Free Software Foundation, Inc.
e4ea20c8 KT	3
	4	This file is part of GCC.
	5
	6	GCC is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 3, or (at your option)
	9	any later version.
	10
	11	GCC is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with GCC; see the file COPYING3. If not see
	18	<http://www.gnu.org/licenses/>. */
	19
8fcc61f8 RS	20	#define IN_TARGET_CODE 1
8fcc61f8 RS	21
e4ea20c8 KT	22	#include "config.h"
	23	#include "system.h"
	24	#include "coretypes.h"
	25	#include "tm.h"
	26	#include "input.h"
4d0cdd0c	27	#include "memmodel.h"
e4ea20c8 KT	28	#include "tm_p.h"
	29	#include "flags.h"
	30	#include "c-family/c-common.h"
	31	#include "cpplib.h"
	32	#include "c-family/c-pragma.h"
	33	#include "langhooks.h"
	34	#include "target.h"
	35
	36
	37	#define builtin_define(TXT) cpp_define (pfile, TXT)
	38	#define builtin_assert(TXT) cpp_assert (pfile, TXT)
	39
	40
	41	static void
	42	aarch64_def_or_undef (bool def_p, const char macro, cpp_reader pfile)
	43	{
	44	if (def_p)
	45	cpp_define (pfile, macro);
	46	else
	47	cpp_undef (pfile, macro);
	48	}
	49
	50	/* Define the macros that we always expect to have on AArch64. */
	51
	52	static void
	53	aarch64_define_unconditional_macros (cpp_reader *pfile)
	54	{
	55	builtin_define ("__aarch64__");
	56	builtin_define ("__ARM_64BIT_STATE");
	57
	58	builtin_define ("__ARM_ARCH_ISA_A64");
	59	builtin_define_with_int_value ("__ARM_ALIGN_MAX_PWR", 28);
	60	builtin_define_with_int_value ("__ARM_ALIGN_MAX_STACK_PWR", 16);
	61
	62	/* __ARM_ARCH_8A is not mandated by ACLE but we define it unconditionally
	63	as interoperability with the same arm macro. */
	64	builtin_define ("__ARM_ARCH_8A");
	65
	66	builtin_define_with_int_value ("__ARM_ARCH_PROFILE", 'A');
	67	builtin_define ("__ARM_FEATURE_CLZ");
	68	builtin_define ("__ARM_FEATURE_IDIV");
	69	builtin_define ("__ARM_FEATURE_UNALIGNED");
	70	builtin_define ("__ARM_PCS_AAPCS64");
	71	builtin_define_with_int_value ("__ARM_SIZEOF_WCHAR_T", WCHAR_TYPE_SIZE / 8);
	72	}
	73
	74	/* Undefine/redefine macros that depend on the current backend state and may
	75	need to change when a target pragma modifies the backend state. */
	76
	77	static void
	78	aarch64_update_cpp_builtins (cpp_reader *pfile)
	79	{
	80	aarch64_def_or_undef (flag_unsafe_math_optimizations, "__ARM_FP_FAST", pfile);
	81
	82	builtin_define_with_int_value ("__ARM_ARCH", aarch64_architecture_version);
	83
	84	builtin_define_with_int_value ("__ARM_SIZEOF_MINIMAL_ENUM",
	85	flag_short_enums ? 1 : 4);
	86	aarch64_def_or_undef (TARGET_BIG_END, "__AARCH64EB__", pfile);
	87	aarch64_def_or_undef (TARGET_BIG_END, "__ARM_BIG_ENDIAN", pfile);
	88	aarch64_def_or_undef (!TARGET_BIG_END, "__AARCH64EL__", pfile);
	89
	90	aarch64_def_or_undef (TARGET_FLOAT, "__ARM_FEATURE_FMA", pfile);
	91
92	if (TARGET_FLOAT \|\| TARGET_SIMD)
93	{
94	builtin_define_with_int_value ("__ARM_FP", 0x0E);
95	builtin_define ("__ARM_FP16_FORMAT_IEEE");
96	builtin_define ("__ARM_FP16_ARGS");
97	}
98	else
99	cpp_undef (pfile, "__ARM_FP");
100
c61465bd MW	101	aarch64_def_or_undef (TARGET_FP_F16INST,
	102	"__ARM_FEATURE_FP16_SCALAR_ARITHMETIC", pfile);
	103	aarch64_def_or_undef (TARGET_SIMD_F16INST,
	104	"__ARM_FEATURE_FP16_VECTOR_ARITHMETIC", pfile);
	105
e4ea20c8 KT	106	aarch64_def_or_undef (TARGET_SIMD, "__ARM_FEATURE_NUMERIC_MAXMIN", pfile);
	107	aarch64_def_or_undef (TARGET_SIMD, "__ARM_NEON", pfile);
	108
	109
	110	aarch64_def_or_undef (TARGET_CRC32, "__ARM_FEATURE_CRC32", pfile);
1ddc47c0	111	aarch64_def_or_undef (TARGET_DOTPROD, "__ARM_FEATURE_DOTPROD", pfile);
9d63f43b	112	aarch64_def_or_undef (TARGET_COMPLEX, "__ARM_FEATURE_COMPLEX", pfile);
e4ea20c8 KT	113
	114	cpp_undef (pfile, "__AARCH64_CMODEL_TINY__");
	115	cpp_undef (pfile, "__AARCH64_CMODEL_SMALL__");
	116	cpp_undef (pfile, "__AARCH64_CMODEL_LARGE__");
	117
	118	switch (aarch64_cmodel)
	119	{
	120	case AARCH64_CMODEL_TINY:
	121	case AARCH64_CMODEL_TINY_PIC:
	122	builtin_define ("__AARCH64_CMODEL_TINY__");
	123	break;
	124	case AARCH64_CMODEL_SMALL:
	125	case AARCH64_CMODEL_SMALL_PIC:
	126	builtin_define ("__AARCH64_CMODEL_SMALL__");
	127	break;
	128	case AARCH64_CMODEL_LARGE:
	129	builtin_define ("__AARCH64_CMODEL_LARGE__");
	130	break;
	131	default:
	132	break;
	133	}
	134
	135	aarch64_def_or_undef (TARGET_ILP32, "_ILP32", pfile);
	136	aarch64_def_or_undef (TARGET_ILP32, "__ILP32__", pfile);
	137
	138	aarch64_def_or_undef (TARGET_CRYPTO, "__ARM_FEATURE_CRYPTO", pfile);
89c9a60c	139	aarch64_def_or_undef (TARGET_SIMD_RDMA, "__ARM_FEATURE_QRDMX", pfile);
43cacb12 RS	140	aarch64_def_or_undef (TARGET_SVE, "__ARM_FEATURE_SVE", pfile);
	141	cpp_undef (pfile, "__ARM_FEATURE_SVE_BITS");
	142	if (TARGET_SVE)
	143	{
	144	int bits;
	145	if (!BITS_PER_SVE_VECTOR.is_constant (&bits))
	146	bits = 0;
	147	builtin_define_with_int_value ("__ARM_FEATURE_SVE_BITS", bits);
	148	}
0617e23c	149	aarch64_def_or_undef (TARGET_SVE2, "__ARM_FEATURE_SVE2", pfile);
11e554b3	150
abb3c64e	151	aarch64_def_or_undef (TARGET_LSE, "__ARM_FEATURE_ATOMICS", pfile);
27086ea3 MC	152	aarch64_def_or_undef (TARGET_AES, "__ARM_FEATURE_AES", pfile);
	153	aarch64_def_or_undef (TARGET_SHA2, "__ARM_FEATURE_SHA2", pfile);
	154	aarch64_def_or_undef (TARGET_SHA3, "__ARM_FEATURE_SHA3", pfile);
	155	aarch64_def_or_undef (TARGET_SHA3, "__ARM_FEATURE_SHA512", pfile);
	156	aarch64_def_or_undef (TARGET_SM4, "__ARM_FEATURE_SM3", pfile);
	157	aarch64_def_or_undef (TARGET_SM4, "__ARM_FEATURE_SM4", pfile);
	158	aarch64_def_or_undef (TARGET_F16FML, "__ARM_FEATURE_FP16_FML", pfile);
	159
89626179 SD	160	aarch64_def_or_undef (TARGET_TME, "__ARM_FEATURE_TME", pfile);
89626179 SD	161
11e554b3 JG	162	/* Not for ACLE, but required to keep "float.h" correct if we switch
	163	target between implementations that do or do not support ARMv8.2-A
	164	16-bit floating-point extensions. */
	165	cpp_undef (pfile, "__FLT_EVAL_METHOD__");
	166	builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
	167	c_flt_eval_method (true));
	168	cpp_undef (pfile, "__FLT_EVAL_METHOD_C99__");
	169	builtin_define_with_int_value ("__FLT_EVAL_METHOD_C99__",
	170	c_flt_eval_method (false));
e4ea20c8 KT	171	}
	172
	173	/* Implement TARGET_CPU_CPP_BUILTINS. */
	174
	175	void
	176	aarch64_cpu_cpp_builtins (cpp_reader *pfile)
	177	{
	178	aarch64_define_unconditional_macros (pfile);
	179	aarch64_update_cpp_builtins (pfile);
	180	}
	181
	182	/* Hook to validate the current #pragma GCC target and set the state, and
	183	update the macros based on what was changed. If ARGS is NULL, then
	184	POP_TARGET is used to reset the options. */
	185
	186	static bool
	187	aarch64_pragma_target_parse (tree args, tree pop_target)
	188	{
	189	/* If args is not NULL then process it and setup the target-specific
	190	information that it specifies. */
	191	if (args)
	192	{
ab93e9b7	193	if (!aarch64_process_target_attr (args))
e4ea20c8 KT	194	return false;
	195
	196	aarch64_override_options_internal (&global_options);
	197	}
	198
	199	/* args is NULL, restore to the state described in pop_target. */
	200	else
	201	{
	202	pop_target = pop_target ? pop_target : target_option_default_node;
	203	cl_target_option_restore (&global_options,
	204	TREE_TARGET_OPTION (pop_target));
	205	}
	206
	207	target_option_current_node
	208	= build_target_option_node (&global_options);
	209
	210	aarch64_reset_previous_fndecl ();
	211	/* For the definitions, ensure all newly defined macros are considered
	212	as used for -Wunused-macros. There is no point warning about the
	213	compiler predefined macros. */
	214	cpp_options *cpp_opts = cpp_get_options (parse_in);
	215	unsigned char saved_warn_unused_macros = cpp_opts->warn_unused_macros;
	216	cpp_opts->warn_unused_macros = 0;
	217
	218	aarch64_update_cpp_builtins (parse_in);
	219
	220	cpp_opts->warn_unused_macros = saved_warn_unused_macros;
	221
acfc1ac1 KT	222	/* If we're popping or reseting make sure to update the globals so that
	223	the optab availability predicates get recomputed. */
	224	if (pop_target)
	225	aarch64_save_restore_target_globals (pop_target);
	226
e95a988a KT	227	/* Initialize SIMD builtins if we haven't already.
	228	Set current_target_pragma to NULL for the duration so that
	229	the builtin initialization code doesn't try to tag the functions
	230	being built with the attributes specified by any current pragma, thus
	231	going into an infinite recursion. */
	232	if (TARGET_SIMD)
	233	{
	234	tree saved_current_target_pragma = current_target_pragma;
	235	current_target_pragma = NULL;
	236	aarch64_init_simd_builtins ();
	237	current_target_pragma = saved_current_target_pragma;
	238	}
	239
e4ea20c8 KT	240	return true;
	241	}
	242
	243	/* Implement REGISTER_TARGET_PRAGMAS. */
	244
	245	void
	246	aarch64_register_pragmas (void)
	247	{
	248	/* Update pragma hook to allow parsing #pragma GCC target. */
	249	targetm.target_option.pragma_parse = aarch64_pragma_target_parse;
	250	}