1 /* Copyright (C) 2007-2018 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 can not 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_32BIT_STATE", TARGET_32BIT);
80
81 cpp_undef (pfile, "__ARM_FEATURE_CMSE");
82 if (arm_arch8 && !arm_arch_notm)
83 {
84 if (arm_arch_cmse && use_cmse)
85 builtin_define_with_int_value ("__ARM_FEATURE_CMSE", 3);
86 else
87 builtin_define ("__ARM_FEATURE_CMSE");
88 }
89
90 cpp_undef (pfile, "__ARM_FEATURE_LDREX");
91 if (TARGET_ARM_FEATURE_LDREX)
92 builtin_define_with_int_value ("__ARM_FEATURE_LDREX",
93 TARGET_ARM_FEATURE_LDREX);
94
95 def_or_undef_macro (pfile, "__ARM_FEATURE_CLZ",
96 ((TARGET_ARM_ARCH >= 5 && !TARGET_THUMB)
97 || TARGET_ARM_ARCH_ISA_THUMB >=2));
98
99 def_or_undef_macro (pfile, "__ARM_FEATURE_NUMERIC_MAXMIN",
100 TARGET_ARM_ARCH >= 8 && TARGET_NEON && TARGET_VFP5);
101
102 def_or_undef_macro (pfile, "__ARM_FEATURE_SIMD32", TARGET_INT_SIMD);
103
104 builtin_define_with_int_value ("__ARM_SIZEOF_MINIMAL_ENUM",
105 flag_short_enums ? 1 : 4);
106 builtin_define_type_sizeof ("__ARM_SIZEOF_WCHAR_T", wchar_type_node);
107
108 cpp_undef (pfile, "__ARM_ARCH_PROFILE");
109 if (TARGET_ARM_ARCH_PROFILE)
110 builtin_define_with_int_value ("__ARM_ARCH_PROFILE",
111 TARGET_ARM_ARCH_PROFILE);
112
113 /* Define __arm__ even when in thumb mode, for
114 consistency with armcc. */
115 builtin_define ("__arm__");
116 if (TARGET_ARM_ARCH)
117 {
118 cpp_undef (pfile, "__ARM_ARCH");
119 builtin_define_with_int_value ("__ARM_ARCH", TARGET_ARM_ARCH);
120 }
121 if (arm_arch_notm)
122 builtin_define ("__ARM_ARCH_ISA_ARM");
123 builtin_define ("__APCS_32__");
124
125 def_or_undef_macro (pfile, "__thumb__", TARGET_THUMB);
126 def_or_undef_macro (pfile, "__thumb2__", TARGET_THUMB2);
127 if (TARGET_BIG_END)
128 def_or_undef_macro (pfile, "__THUMBEB__", TARGET_THUMB);
129 else
130 def_or_undef_macro (pfile, "__THUMBEL__", TARGET_THUMB);
131
132 cpp_undef (pfile, "__ARM_ARCH_ISA_THUMB");
133 if (TARGET_ARM_ARCH_ISA_THUMB)
134 builtin_define_with_int_value ("__ARM_ARCH_ISA_THUMB",
135 TARGET_ARM_ARCH_ISA_THUMB);
136
137 if (TARGET_BIG_END)
138 {
139 builtin_define ("__ARMEB__");
140 builtin_define ("__ARM_BIG_ENDIAN");
141 }
142 else
143 {
144 builtin_define ("__ARMEL__");
145 }
146
147 if (TARGET_SOFT_FLOAT)
148 builtin_define ("__SOFTFP__");
149
150 builtin_define ("__VFP_FP__");
151
152 cpp_undef (pfile, "__ARM_FP");
153 if (TARGET_ARM_FP)
154 builtin_define_with_int_value ("__ARM_FP", TARGET_ARM_FP);
155
156 def_or_undef_macro (pfile, "__ARM_FP16_FORMAT_IEEE",
157 arm_fp16_format == ARM_FP16_FORMAT_IEEE);
158 def_or_undef_macro (pfile, "__ARM_FP16_FORMAT_ALTERNATIVE",
159 arm_fp16_format == ARM_FP16_FORMAT_ALTERNATIVE);
160 def_or_undef_macro (pfile, "__ARM_FP16_ARGS",
161 arm_fp16_format != ARM_FP16_FORMAT_NONE);
162
163 def_or_undef_macro (pfile, "__ARM_FEATURE_FP16_SCALAR_ARITHMETIC",
164 TARGET_VFP_FP16INST);
165 def_or_undef_macro (pfile, "__ARM_FEATURE_FP16_VECTOR_ARITHMETIC",
166 TARGET_NEON_FP16INST);
167 def_or_undef_macro (pfile, "__ARM_FEATURE_FP16_FML", TARGET_FP16FML);
168
169 def_or_undef_macro (pfile, "__ARM_FEATURE_FMA", TARGET_FMA);
170 def_or_undef_macro (pfile, "__ARM_NEON__", TARGET_NEON);
171 def_or_undef_macro (pfile, "__ARM_NEON", TARGET_NEON);
172
173 cpp_undef (pfile, "__ARM_NEON_FP");
174 if (TARGET_NEON_FP)
175 builtin_define_with_int_value ("__ARM_NEON_FP", TARGET_NEON_FP);
176
177 /* Add a define for interworking. Needed when building libgcc.a. */
178 if (arm_cpp_interwork)
179 builtin_define ("__THUMB_INTERWORK__");
180
181 builtin_define (arm_arch_name);
182 if (arm_arch_xscale)
183 builtin_define ("__XSCALE__");
184 if (arm_arch_iwmmxt)
185 {
186 builtin_define ("__IWMMXT__");
187 builtin_define ("__ARM_WMMX");
188 }
189 if (arm_arch_iwmmxt2)
190 builtin_define ("__IWMMXT2__");
191 /* ARMv6KZ was originally identified as the misspelled __ARM_ARCH_6ZK__. To
192 preserve the existing behavior, the misspelled feature macro must still be
193 defined. */
194 if (arm_arch6kz)
195 builtin_define ("__ARM_ARCH_6ZK__");
196 if (TARGET_AAPCS_BASED)
197 {
198 if (arm_pcs_default == ARM_PCS_AAPCS_VFP)
199 builtin_define ("__ARM_PCS_VFP");
200 else if (arm_pcs_default == ARM_PCS_AAPCS)
201 builtin_define ("__ARM_PCS");
202 builtin_define ("__ARM_EABI__");
203 }
204
205 def_or_undef_macro (pfile, "__ARM_ARCH_EXT_IDIV__", TARGET_IDIV);
206 def_or_undef_macro (pfile, "__ARM_FEATURE_IDIV", TARGET_IDIV);
207
208 def_or_undef_macro (pfile, "__ARM_ASM_SYNTAX_UNIFIED__", inline_asm_unified);
209
210 cpp_undef (pfile, "__ARM_FEATURE_COPROC");
211 if (TARGET_32BIT && arm_arch4 && !(arm_arch8 && arm_arch_notm))
212 {
213 int coproc_level = 0x1;
214
215 if (arm_arch5)
216 coproc_level |= 0x2;
217 if (arm_arch5e)
218 coproc_level |= 0x4;
219 if (arm_arch6)
220 coproc_level |= 0x8;
221
222 builtin_define_with_int_value ("__ARM_FEATURE_COPROC", coproc_level);
223 }
224 }
225
226 void
arm_cpu_cpp_builtins(struct cpp_reader * pfile)227 arm_cpu_cpp_builtins (struct cpp_reader * pfile)
228 {
229 builtin_assert ("cpu=arm");
230 builtin_assert ("machine=arm");
231
232 arm_cpu_builtins (pfile);
233 }
234
235 /* Hook to validate the current #pragma GCC target and set the arch custom
236 mode state. If ARGS is NULL, then POP_TARGET is used to reset
237 the options. */
238
239 static bool
arm_pragma_target_parse(tree args,tree pop_target)240 arm_pragma_target_parse (tree args, tree pop_target)
241 {
242 tree prev_tree = target_option_current_node;
243 tree cur_tree;
244 struct cl_target_option *prev_opt;
245 struct cl_target_option *cur_opt;
246
247 if (! args)
248 {
249 cur_tree = ((pop_target) ? pop_target : target_option_default_node);
250 cl_target_option_restore (&global_options,
251 TREE_TARGET_OPTION (cur_tree));
252 }
253 else
254 {
255 cur_tree = arm_valid_target_attribute_tree (args, &global_options,
256 &global_options_set);
257 if (cur_tree == NULL_TREE)
258 {
259 cl_target_option_restore (&global_options,
260 TREE_TARGET_OPTION (prev_tree));
261 return false;
262 }
263
264 /* handle_pragma_pop_options and handle_pragma_reset_options will set
265 target_option_current_node, but not handle_pragma_target. */
266 target_option_current_node = cur_tree;
267 arm_configure_build_target (&arm_active_target,
268 TREE_TARGET_OPTION (cur_tree),
269 &global_options_set, false);
270 }
271
272 /* Update macros if target_node changes. The global state will be restored
273 by arm_set_current_function. */
274 prev_opt = TREE_TARGET_OPTION (prev_tree);
275 cur_opt = TREE_TARGET_OPTION (cur_tree);
276
277 gcc_assert (prev_opt);
278 gcc_assert (cur_opt);
279
280 if (cur_opt != prev_opt)
281 {
282 /* For the definitions, ensure all newly defined macros are considered
283 as used for -Wunused-macros. There is no point warning about the
284 compiler predefined macros. */
285 cpp_options *cpp_opts = cpp_get_options (parse_in);
286 unsigned char saved_warn_unused_macros = cpp_opts->warn_unused_macros;
287
288 cpp_opts->warn_unused_macros = 0;
289
290 /* Update macros. */
291 gcc_assert (cur_opt->x_target_flags == target_flags);
292
293 /* Don't warn for macros that have context sensitive values depending on
294 other attributes.
295 See warn_of_redefinition, reset after cpp_create_definition. */
296 tree acond_macro = get_identifier ("__ARM_NEON_FP");
297 C_CPP_HASHNODE (acond_macro)->flags |= NODE_CONDITIONAL ;
298
299 acond_macro = get_identifier ("__ARM_FP");
300 C_CPP_HASHNODE (acond_macro)->flags |= NODE_CONDITIONAL;
301
302 acond_macro = get_identifier ("__ARM_FEATURE_LDREX");
303 C_CPP_HASHNODE (acond_macro)->flags |= NODE_CONDITIONAL;
304
305 arm_cpu_builtins (parse_in);
306
307 cpp_opts->warn_unused_macros = saved_warn_unused_macros;
308
309 /* Make sure that target_reinit is called for next function, since
310 TREE_TARGET_OPTION might change with the #pragma even if there is
311 no target attribute attached to the function. */
312 arm_reset_previous_fndecl ();
313
314 /* If going to the default mode, we restore the initial states.
315 if cur_tree is a new target, states will be saved/restored on a per
316 function basis in arm_set_current_function. */
317 if (cur_tree == target_option_default_node)
318 save_restore_target_globals (cur_tree);
319 }
320
321 return true;
322 }
323
324 /* Register target pragmas. We need to add the hook for parsing #pragma GCC
325 option here rather than in arm.c since it will pull in various preprocessor
326 functions, and those are not present in languages like fortran without a
327 preprocessor. */
328
329 void
arm_register_target_pragmas(void)330 arm_register_target_pragmas (void)
331 {
332 /* Update pragma hook to allow parsing #pragma GCC target. */
333 targetm.target_option.pragma_parse = arm_pragma_target_parse;
334
335 #ifdef REGISTER_SUBTARGET_PRAGMAS
336 REGISTER_SUBTARGET_PRAGMAS ();
337 #endif
338 }
339