1 /* Copyright (C) 2007-2019 Free Software Foundation, Inc.
2
3 This file is part of GCC.
4
5 GCC is free software; you can redistribute it and/or modify it under
6 the terms of the GNU General Public License as published by the Free
7 Software Foundation; either version 3, or (at your option) any later
8 version.
9
10 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
11 WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with GCC; see the file COPYING3. If not see
17 <http://www.gnu.org/licenses/>. */
18
19 #define IN_TARGET_CODE 1
20
21 #include "config.h"
22 #include "system.h"
23 #include "coretypes.h"
24 #include "target.h"
25 #include "c-family/c-common.h"
26 #include "memmodel.h"
27 #include "tm_p.h"
28 #include "c-family/c-pragma.h"
29 #include "stringpool.h"
30
31 /* Output C specific EABI object attributes. These cannot be done in
32 arm.c because they require information from the C frontend. */
33
34 static void
arm_output_c_attributes(void)35 arm_output_c_attributes (void)
36 {
37 int wchar_size = (int)(TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT);
38 arm_emit_eabi_attribute ("Tag_ABI_PCS_wchar_t", 18, wchar_size);
39 }
40
41
42 /* Setup so that common code calls arm_output_c_attributes. */
43
44 void
arm_lang_object_attributes_init(void)45 arm_lang_object_attributes_init (void)
46 {
47 arm_lang_output_object_attributes_hook = arm_output_c_attributes;
48 }
49
50 #define builtin_define(TXT) cpp_define (pfile, TXT)
51 #define builtin_assert(TXT) cpp_assert (pfile, TXT)
52
53 /* Define or undefine macros based on the current target. If the user does
54 #pragma GCC target, we need to adjust the macros dynamically. */
55
56 static void
def_or_undef_macro(struct cpp_reader * pfile,const char * name,bool def_p)57 def_or_undef_macro(struct cpp_reader* pfile, const char *name, bool def_p)
58 {
59 if (def_p)
60 cpp_define (pfile, name);
61 else
62 cpp_undef (pfile, name);
63 }
64
65 static void
arm_cpu_builtins(struct cpp_reader * pfile)66 arm_cpu_builtins (struct cpp_reader* pfile)
67 {
68 def_or_undef_macro (pfile, "__ARM_FEATURE_DSP", TARGET_DSP_MULTIPLY);
69 def_or_undef_macro (pfile, "__ARM_FEATURE_QBIT", TARGET_ARM_QBIT);
70 def_or_undef_macro (pfile, "__ARM_FEATURE_SAT", TARGET_ARM_SAT);
71 def_or_undef_macro (pfile, "__ARM_FEATURE_CRYPTO", TARGET_CRYPTO);
72
73 def_or_undef_macro (pfile, "__ARM_FEATURE_UNALIGNED", unaligned_access);
74
75 def_or_undef_macro (pfile, "__ARM_FEATURE_QRDMX", TARGET_NEON_RDMA);
76
77 def_or_undef_macro (pfile, "__ARM_FEATURE_CRC32", TARGET_CRC32);
78 def_or_undef_macro (pfile, "__ARM_FEATURE_DOTPROD", TARGET_DOTPROD);
79 def_or_undef_macro (pfile, "__ARM_FEATURE_COMPLEX", TARGET_COMPLEX);
80 def_or_undef_macro (pfile, "__ARM_32BIT_STATE", TARGET_32BIT);
81
82 cpp_undef (pfile, "__ARM_FEATURE_CMSE");
83 if (arm_arch8 && !arm_arch_notm)
84 {
85 if (arm_arch_cmse && use_cmse)
86 builtin_define_with_int_value ("__ARM_FEATURE_CMSE", 3);
87 else
88 builtin_define ("__ARM_FEATURE_CMSE");
89 }
90
91 cpp_undef (pfile, "__ARM_FEATURE_LDREX");
92 if (TARGET_ARM_FEATURE_LDREX)
93 builtin_define_with_int_value ("__ARM_FEATURE_LDREX",
94 TARGET_ARM_FEATURE_LDREX);
95
96 def_or_undef_macro (pfile, "__ARM_FEATURE_CLZ",
97 ((TARGET_ARM_ARCH >= 5 && !TARGET_THUMB)
98 || TARGET_ARM_ARCH_ISA_THUMB >=2));
99
100 def_or_undef_macro (pfile, "__ARM_FEATURE_NUMERIC_MAXMIN",
101 TARGET_ARM_ARCH >= 8 && TARGET_NEON && TARGET_VFP5);
102
103 def_or_undef_macro (pfile, "__ARM_FEATURE_SIMD32", TARGET_INT_SIMD);
104
105 builtin_define_with_int_value ("__ARM_SIZEOF_MINIMAL_ENUM",
106 flag_short_enums ? 1 : 4);
107 builtin_define_type_sizeof ("__ARM_SIZEOF_WCHAR_T", wchar_type_node);
108
109 cpp_undef (pfile, "__ARM_ARCH_PROFILE");
110 if (TARGET_ARM_ARCH_PROFILE)
111 builtin_define_with_int_value ("__ARM_ARCH_PROFILE",
112 TARGET_ARM_ARCH_PROFILE);
113
114 /* Define __arm__ even when in thumb mode, for
115 consistency with armcc. */
116 builtin_define ("__arm__");
117 if (TARGET_ARM_ARCH)
118 {
119 cpp_undef (pfile, "__ARM_ARCH");
120 builtin_define_with_int_value ("__ARM_ARCH", TARGET_ARM_ARCH);
121 }
122 if (arm_arch_notm)
123 builtin_define ("__ARM_ARCH_ISA_ARM");
124 builtin_define ("__APCS_32__");
125
126 def_or_undef_macro (pfile, "__thumb__", TARGET_THUMB);
127 def_or_undef_macro (pfile, "__thumb2__", TARGET_THUMB2);
128 if (TARGET_BIG_END)
129 def_or_undef_macro (pfile, "__THUMBEB__", TARGET_THUMB);
130 else
131 def_or_undef_macro (pfile, "__THUMBEL__", TARGET_THUMB);
132
133 cpp_undef (pfile, "__ARM_ARCH_ISA_THUMB");
134 if (TARGET_ARM_ARCH_ISA_THUMB)
135 builtin_define_with_int_value ("__ARM_ARCH_ISA_THUMB",
136 TARGET_ARM_ARCH_ISA_THUMB);
137
138 if (TARGET_BIG_END)
139 {
140 builtin_define ("__ARMEB__");
141 builtin_define ("__ARM_BIG_ENDIAN");
142 }
143 else
144 {
145 builtin_define ("__ARMEL__");
146 }
147
148 if (TARGET_SOFT_FLOAT)
149 builtin_define ("__SOFTFP__");
150
151 builtin_define ("__VFP_FP__");
152
153 cpp_undef (pfile, "__ARM_FP");
154 if (TARGET_ARM_FP)
155 builtin_define_with_int_value ("__ARM_FP", TARGET_ARM_FP);
156
157 def_or_undef_macro (pfile, "__ARM_FP16_FORMAT_IEEE",
158 arm_fp16_format == ARM_FP16_FORMAT_IEEE);
159 def_or_undef_macro (pfile, "__ARM_FP16_FORMAT_ALTERNATIVE",
160 arm_fp16_format == ARM_FP16_FORMAT_ALTERNATIVE);
161 def_or_undef_macro (pfile, "__ARM_FP16_ARGS",
162 arm_fp16_format != ARM_FP16_FORMAT_NONE);
163
164 def_or_undef_macro (pfile, "__ARM_FEATURE_FP16_SCALAR_ARITHMETIC",
165 TARGET_VFP_FP16INST);
166 def_or_undef_macro (pfile, "__ARM_FEATURE_FP16_VECTOR_ARITHMETIC",
167 TARGET_NEON_FP16INST);
168 def_or_undef_macro (pfile, "__ARM_FEATURE_FP16_FML", TARGET_FP16FML);
169
170 def_or_undef_macro (pfile, "__ARM_FEATURE_FMA", TARGET_FMA);
171 def_or_undef_macro (pfile, "__ARM_NEON__", TARGET_NEON);
172 def_or_undef_macro (pfile, "__ARM_NEON", TARGET_NEON);
173
174 cpp_undef (pfile, "__ARM_NEON_FP");
175 if (TARGET_NEON_FP)
176 builtin_define_with_int_value ("__ARM_NEON_FP", TARGET_NEON_FP);
177
178 /* Add a define for interworking. Needed when building libgcc.a. */
179 if (arm_cpp_interwork)
180 builtin_define ("__THUMB_INTERWORK__");
181
182 builtin_define (arm_arch_name);
183 if (arm_arch_xscale)
184 builtin_define ("__XSCALE__");
185 if (arm_arch_iwmmxt)
186 {
187 builtin_define ("__IWMMXT__");
188 builtin_define ("__ARM_WMMX");
189 }
190 if (arm_arch_iwmmxt2)
191 builtin_define ("__IWMMXT2__");
192 /* ARMv6KZ was originally identified as the misspelled __ARM_ARCH_6ZK__. To
193 preserve the existing behavior, the misspelled feature macro must still be
194 defined. */
195 if (arm_arch6kz)
196 builtin_define ("__ARM_ARCH_6ZK__");
197 if (TARGET_AAPCS_BASED)
198 {
199 if (arm_pcs_default == ARM_PCS_AAPCS_VFP)
200 builtin_define ("__ARM_PCS_VFP");
201 else if (arm_pcs_default == ARM_PCS_AAPCS)
202 builtin_define ("__ARM_PCS");
203 builtin_define ("__ARM_EABI__");
204 }
205
206 def_or_undef_macro (pfile, "__ARM_ARCH_EXT_IDIV__", TARGET_IDIV);
207 def_or_undef_macro (pfile, "__ARM_FEATURE_IDIV", TARGET_IDIV);
208
209 def_or_undef_macro (pfile, "__ARM_ASM_SYNTAX_UNIFIED__", inline_asm_unified);
210
211 cpp_undef (pfile, "__ARM_FEATURE_COPROC");
212 if (TARGET_32BIT && arm_arch4 && !(arm_arch8 && arm_arch_notm))
213 {
214 int coproc_level = 0x1;
215
216 if (arm_arch5t)
217 coproc_level |= 0x2;
218 if (arm_arch5te)
219 coproc_level |= 0x4;
220 if (arm_arch6)
221 coproc_level |= 0x8;
222
223 builtin_define_with_int_value ("__ARM_FEATURE_COPROC", coproc_level);
224 }
225 }
226
227 void
arm_cpu_cpp_builtins(struct cpp_reader * pfile)228 arm_cpu_cpp_builtins (struct cpp_reader * pfile)
229 {
230 builtin_assert ("cpu=arm");
231 builtin_assert ("machine=arm");
232
233 arm_cpu_builtins (pfile);
234 }
235
236 /* Hook to validate the current #pragma GCC target and set the arch custom
237 mode state. If ARGS is NULL, then POP_TARGET is used to reset
238 the options. */
239
240 static bool
arm_pragma_target_parse(tree args,tree pop_target)241 arm_pragma_target_parse (tree args, tree pop_target)
242 {
243 tree prev_tree = target_option_current_node;
244 tree cur_tree;
245 struct cl_target_option *prev_opt;
246 struct cl_target_option *cur_opt;
247
248 if (! args)
249 {
250 cur_tree = ((pop_target) ? pop_target : target_option_default_node);
251 cl_target_option_restore (&global_options,
252 TREE_TARGET_OPTION (cur_tree));
253 }
254 else
255 {
256 cur_tree = arm_valid_target_attribute_tree (args, &global_options,
257 &global_options_set);
258 if (cur_tree == NULL_TREE)
259 {
260 cl_target_option_restore (&global_options,
261 TREE_TARGET_OPTION (prev_tree));
262 return false;
263 }
264
265 /* handle_pragma_pop_options and handle_pragma_reset_options will set
266 target_option_current_node, but not handle_pragma_target. */
267 target_option_current_node = cur_tree;
268 arm_configure_build_target (&arm_active_target,
269 TREE_TARGET_OPTION (cur_tree), false);
270 arm_option_reconfigure_globals ();
271 }
272
273 /* Update macros if target_node changes. The global state will be restored
274 by arm_set_current_function. */
275 prev_opt = TREE_TARGET_OPTION (prev_tree);
276 cur_opt = TREE_TARGET_OPTION (cur_tree);
277
278 gcc_assert (prev_opt);
279 gcc_assert (cur_opt);
280
281 if (cur_opt != prev_opt)
282 {
283 /* For the definitions, ensure all newly defined macros are considered
284 as used for -Wunused-macros. There is no point warning about the
285 compiler predefined macros. */
286 cpp_options *cpp_opts = cpp_get_options (parse_in);
287 unsigned char saved_warn_unused_macros = cpp_opts->warn_unused_macros;
288
289 cpp_opts->warn_unused_macros = 0;
290
291 /* Update macros. */
292 gcc_assert (cur_opt->x_target_flags == target_flags);
293
294 /* Don't warn for macros that have context sensitive values depending on
295 other attributes.
296 See warn_of_redefinition, reset after cpp_create_definition. */
297 tree acond_macro = get_identifier ("__ARM_NEON_FP");
298 C_CPP_HASHNODE (acond_macro)->flags |= NODE_CONDITIONAL ;
299
300 acond_macro = get_identifier ("__ARM_FP");
301 C_CPP_HASHNODE (acond_macro)->flags |= NODE_CONDITIONAL;
302
303 acond_macro = get_identifier ("__ARM_FEATURE_LDREX");
304 C_CPP_HASHNODE (acond_macro)->flags |= NODE_CONDITIONAL;
305
306 arm_cpu_builtins (parse_in);
307
308 cpp_opts->warn_unused_macros = saved_warn_unused_macros;
309
310 /* Make sure that target_reinit is called for next function, since
311 TREE_TARGET_OPTION might change with the #pragma even if there is
312 no target attribute attached to the function. */
313 arm_reset_previous_fndecl ();
314
315 /* If going to the default mode, we restore the initial states.
316 if cur_tree is a new target, states will be saved/restored on a per
317 function basis in arm_set_current_function. */
318 if (cur_tree == target_option_default_node)
319 save_restore_target_globals (cur_tree);
320 }
321
322 return true;
323 }
324
325 /* Register target pragmas. We need to add the hook for parsing #pragma GCC
326 option here rather than in arm.c since it will pull in various preprocessor
327 functions, and those are not present in languages like fortran without a
328 preprocessor. */
329
330 void
arm_register_target_pragmas(void)331 arm_register_target_pragmas (void)
332 {
333 /* Update pragma hook to allow parsing #pragma GCC target. */
334 targetm.target_option.pragma_parse = arm_pragma_target_parse;
335
336 #ifdef REGISTER_SUBTARGET_PRAGMAS
337 REGISTER_SUBTARGET_PRAGMAS ();
338 #endif
339 }
340