Bug Summary

File:build/gcc/stor-layout.c
Warning:line 1240, column 19
Division by zero

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name stor-layout.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model static -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/11.0.0 -D IN_GCC -D HAVE_CONFIG_H -I . -I . -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/. -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../include -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcpp/include -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcody -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber/bid -I ../libdecnumber -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libbacktrace -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/10/../../../../include/c++/10 -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/10/../../../../include/c++/10/x86_64-suse-linux -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/10/../../../../include/c++/10/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/11.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-narrowing -Wwrite-strings -Wno-error=format-diag -Wno-long-long -Wno-variadic-macros -Wno-overlength-strings -fdeprecated-macro -fdebug-compilation-dir /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/gcc -ferror-limit 19 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=plist-html -analyzer-config silence-checkers=core.NullDereference -faddrsig -o /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/clang-static-analyzer/2021-01-16-135054-17580-1/report-VOw7iY.plist -x c++ /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c

/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c

1/* C-compiler utilities for types and variables storage layout
2 Copyright (C) 1987-2021 Free Software Foundation, Inc.
3
4This file is part of GCC.
5
6GCC is free software; you can redistribute it and/or modify it under
7the terms of the GNU General Public License as published by the Free
8Software Foundation; either version 3, or (at your option) any later
9version.
10
11GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12WARRANTY; without even the implied warranty of MERCHANTABILITY or
13FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14for more details.
15
16You should have received a copy of the GNU General Public License
17along with GCC; see the file COPYING3. If not see
18<http://www.gnu.org/licenses/>. */
19
20
21#include "config.h"
22#include "system.h"
23#include "coretypes.h"
24#include "target.h"
25#include "function.h"
26#include "rtl.h"
27#include "tree.h"
28#include "memmodel.h"
29#include "tm_p.h"
30#include "stringpool.h"
31#include "regs.h"
32#include "emit-rtl.h"
33#include "cgraph.h"
34#include "diagnostic-core.h"
35#include "fold-const.h"
36#include "stor-layout.h"
37#include "varasm.h"
38#include "print-tree.h"
39#include "langhooks.h"
40#include "tree-inline.h"
41#include "dumpfile.h"
42#include "gimplify.h"
43#include "attribs.h"
44#include "debug.h"
45#include "calls.h"
46
47/* Data type for the expressions representing sizes of data types.
48 It is the first integer type laid out. */
49tree sizetype_tab[(int) stk_type_kind_last];
50
51/* If nonzero, this is an upper limit on alignment of structure fields.
52 The value is measured in bits. */
53unsigned int maximum_field_alignment = TARGET_DEFAULT_PACK_STRUCT0 * BITS_PER_UNIT(8);
54
55static tree self_referential_size (tree);
56static void finalize_record_size (record_layout_info);
57static void finalize_type_size (tree);
58static void place_union_field (record_layout_info, tree);
59static int excess_unit_span (HOST_WIDE_INTlong, HOST_WIDE_INTlong, HOST_WIDE_INTlong,
60 HOST_WIDE_INTlong, tree);
61extern void debug_rli (record_layout_info);
62
63/* Given a size SIZE that may not be a constant, return a SAVE_EXPR
64 to serve as the actual size-expression for a type or decl. */
65
66tree
67variable_size (tree size)
68{
69 /* Obviously. */
70 if (TREE_CONSTANT (size)((non_type_check ((size), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 70, __FUNCTION__))->base.constant_flag)
)
71 return size;
72
73 /* If the size is self-referential, we can't make a SAVE_EXPR (see
74 save_expr for the rationale). But we can do something else. */
75 if (CONTAINS_PLACEHOLDER_P (size)((size) != 0 && ! ((non_type_check ((size), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 75, __FUNCTION__))->base.constant_flag) && contains_placeholder_p
(size))
)
76 return self_referential_size (size);
77
78 /* If we are in the global binding level, we can't make a SAVE_EXPR
79 since it may end up being shared across functions, so it is up
80 to the front-end to deal with this case. */
81 if (lang_hooks.decls.global_bindings_p ())
82 return size;
83
84 return save_expr (size);
85}
86
87/* An array of functions used for self-referential size computation. */
88static GTY(()) vec<tree, va_gc> *size_functions;
89
90/* Return true if T is a self-referential component reference. */
91
92static bool
93self_referential_component_ref_p (tree t)
94{
95 if (TREE_CODE (t)((enum tree_code) (t)->base.code) != COMPONENT_REF)
96 return false;
97
98 while (REFERENCE_CLASS_P (t)(tree_code_type[(int) (((enum tree_code) (t)->base.code))]
== tcc_reference)
)
99 t = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 99, __FUNCTION__)))))
;
100
101 return (TREE_CODE (t)((enum tree_code) (t)->base.code) == PLACEHOLDER_EXPR);
102}
103
104/* Similar to copy_tree_r but do not copy component references involving
105 PLACEHOLDER_EXPRs. These nodes are spotted in find_placeholder_in_expr
106 and substituted in substitute_in_expr. */
107
108static tree
109copy_self_referential_tree_r (tree *tp, int *walk_subtrees, void *data)
110{
111 enum tree_code code = TREE_CODE (*tp)((enum tree_code) (*tp)->base.code);
112
113 /* Stop at types, decls, constants like copy_tree_r. */
114 if (TREE_CODE_CLASS (code)tree_code_type[(int) (code)] == tcc_type
115 || TREE_CODE_CLASS (code)tree_code_type[(int) (code)] == tcc_declaration
116 || TREE_CODE_CLASS (code)tree_code_type[(int) (code)] == tcc_constant)
117 {
118 *walk_subtrees = 0;
119 return NULL_TREE(tree) nullptr;
120 }
121
122 /* This is the pattern built in ada/make_aligning_type. */
123 else if (code == ADDR_EXPR
124 && TREE_CODE (TREE_OPERAND (*tp, 0))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
((*tp), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 124, __FUNCTION__))))))->base.code)
== PLACEHOLDER_EXPR)
125 {
126 *walk_subtrees = 0;
127 return NULL_TREE(tree) nullptr;
128 }
129
130 /* Default case: the component reference. */
131 else if (self_referential_component_ref_p (*tp))
132 {
133 *walk_subtrees = 0;
134 return NULL_TREE(tree) nullptr;
135 }
136
137 /* We're not supposed to have them in self-referential size trees
138 because we wouldn't properly control when they are evaluated.
139 However, not creating superfluous SAVE_EXPRs requires accurate
140 tracking of readonly-ness all the way down to here, which we
141 cannot always guarantee in practice. So punt in this case. */
142 else if (code == SAVE_EXPR)
143 return error_mark_nodeglobal_trees[TI_ERROR_MARK];
144
145 else if (code == STATEMENT_LIST)
146 gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 146, __FUNCTION__))
;
147
148 return copy_tree_r (tp, walk_subtrees, data);
149}
150
151/* Given a SIZE expression that is self-referential, return an equivalent
152 expression to serve as the actual size expression for a type. */
153
154static tree
155self_referential_size (tree size)
156{
157 static unsigned HOST_WIDE_INTlong fnno = 0;
158 vec<tree> self_refs = vNULL;
159 tree param_type_list = NULLnullptr, param_decl_list = NULLnullptr;
160 tree t, ref, return_type, fntype, fnname, fndecl;
161 unsigned int i;
162 char buf[128];
163 vec<tree, va_gc> *args = NULLnullptr;
164
165 /* Do not factor out simple operations. */
166 t = skip_simple_constant_arithmetic (size);
167 if (TREE_CODE (t)((enum tree_code) (t)->base.code) == CALL_EXPR || self_referential_component_ref_p (t))
168 return size;
169
170 /* Collect the list of self-references in the expression. */
171 find_placeholder_in_expr (size, &self_refs);
172 gcc_assert (self_refs.length () > 0)((void)(!(self_refs.length () > 0) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 172, __FUNCTION__), 0 : 0))
;
173
174 /* Obtain a private copy of the expression. */
175 t = size;
176 if (walk_tree (&t, copy_self_referential_tree_r, NULL, NULL)walk_tree_1 (&t, copy_self_referential_tree_r, nullptr, nullptr
, nullptr)
!= NULL_TREE(tree) nullptr)
177 return size;
178 size = t;
179
180 /* Build the parameter and argument lists in parallel; also
181 substitute the former for the latter in the expression. */
182 vec_alloc (args, self_refs.length ());
183 FOR_EACH_VEC_ELT (self_refs, i, ref)for (i = 0; (self_refs).iterate ((i), &(ref)); ++(i))
184 {
185 tree subst, param_name, param_type, param_decl;
186
187 if (DECL_P (ref)(tree_code_type[(int) (((enum tree_code) (ref)->base.code)
)] == tcc_declaration)
)
188 {
189 /* We shouldn't have true variables here. */
190 gcc_assert (TREE_READONLY (ref))((void)(!(((non_type_check ((ref), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 190, __FUNCTION__))->base.readonly_flag)) ? fancy_abort (
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 190, __FUNCTION__), 0 : 0))
;
191 subst = ref;
192 }
193 /* This is the pattern built in ada/make_aligning_type. */
194 else if (TREE_CODE (ref)((enum tree_code) (ref)->base.code) == ADDR_EXPR)
195 subst = ref;
196 /* Default case: the component reference. */
197 else
198 subst = TREE_OPERAND (ref, 1)(*((const_cast<tree*> (tree_operand_check ((ref), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 198, __FUNCTION__)))))
;
199
200 sprintf (buf, "p%d", i);
201 param_name = get_identifier (buf)(__builtin_constant_p (buf) ? get_identifier_with_length ((buf
), strlen (buf)) : get_identifier (buf))
;
202 param_type = TREE_TYPE (ref)((contains_struct_check ((ref), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 202, __FUNCTION__))->typed.type)
;
203 param_decl
204 = build_decl (input_location, PARM_DECL, param_name, param_type);
205 DECL_ARG_TYPE (param_decl)((tree_check ((param_decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 205, __FUNCTION__, (PARM_DECL)))->decl_common.initial)
= param_type;
206 DECL_ARTIFICIAL (param_decl)((contains_struct_check ((param_decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 206, __FUNCTION__))->decl_common.artificial_flag)
= 1;
207 TREE_READONLY (param_decl)((non_type_check ((param_decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 207, __FUNCTION__))->base.readonly_flag)
= 1;
208
209 size = substitute_in_expr (size, subst, param_decl);
210
211 param_type_list = tree_cons (NULL_TREE(tree) nullptr, param_type, param_type_list);
212 param_decl_list = chainon (param_decl, param_decl_list);
213 args->quick_push (ref);
214 }
215
216 self_refs.release ();
217
218 /* Append 'void' to indicate that the number of parameters is fixed. */
219 param_type_list = tree_cons (NULL_TREE(tree) nullptr, void_type_nodeglobal_trees[TI_VOID_TYPE], param_type_list);
220
221 /* The 3 lists have been created in reverse order. */
222 param_type_list = nreverse (param_type_list);
223 param_decl_list = nreverse (param_decl_list);
224
225 /* Build the function type. */
226 return_type = TREE_TYPE (size)((contains_struct_check ((size), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 226, __FUNCTION__))->typed.type)
;
227 fntype = build_function_type (return_type, param_type_list);
228
229 /* Build the function declaration. */
230 sprintf (buf, "SZ" HOST_WIDE_INT_PRINT_UNSIGNED"%" "l" "u", fnno++);
231 fnname = get_file_function_name (buf);
232 fndecl = build_decl (input_location, FUNCTION_DECL, fnname, fntype);
233 for (t = param_decl_list; t; t = DECL_CHAIN (t)(((contains_struct_check (((contains_struct_check ((t), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 233, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 233, __FUNCTION__))->common.chain))
)
234 DECL_CONTEXT (t)((contains_struct_check ((t), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 234, __FUNCTION__))->decl_minimal.context)
= fndecl;
235 DECL_ARGUMENTS (fndecl)((tree_check ((fndecl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 235, __FUNCTION__, (FUNCTION_DECL)))->function_decl.arguments
)
= param_decl_list;
236 DECL_RESULT (fndecl)((tree_check ((fndecl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 236, __FUNCTION__, (FUNCTION_DECL)))->decl_non_common.result
)
237 = build_decl (input_location, RESULT_DECL, 0, return_type);
238 DECL_CONTEXT (DECL_RESULT (fndecl))((contains_struct_check ((((tree_check ((fndecl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 238, __FUNCTION__, (FUNCTION_DECL)))->decl_non_common.result
)), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 238, __FUNCTION__))->decl_minimal.context)
= fndecl;
239
240 /* The function has been created by the compiler and we don't
241 want to emit debug info for it. */
242 DECL_ARTIFICIAL (fndecl)((contains_struct_check ((fndecl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 242, __FUNCTION__))->decl_common.artificial_flag)
= 1;
243 DECL_IGNORED_P (fndecl)((contains_struct_check ((fndecl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 243, __FUNCTION__))->decl_common.ignored_flag)
= 1;
244
245 /* It is supposed to be "const" and never throw. */
246 TREE_READONLY (fndecl)((non_type_check ((fndecl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 246, __FUNCTION__))->base.readonly_flag)
= 1;
247 TREE_NOTHROW (fndecl)((fndecl)->base.nothrow_flag) = 1;
248
249 /* We want it to be inlined when this is deemed profitable, as
250 well as discarded if every call has been integrated. */
251 DECL_DECLARED_INLINE_P (fndecl)((tree_check ((fndecl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 251, __FUNCTION__, (FUNCTION_DECL)))->function_decl.declared_inline_flag
)
= 1;
252
253 /* It is made up of a unique return statement. */
254 DECL_INITIAL (fndecl)((contains_struct_check ((fndecl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 254, __FUNCTION__))->decl_common.initial)
= make_node (BLOCK);
255 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl))((tree_check ((((contains_struct_check ((fndecl), (TS_DECL_COMMON
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 255, __FUNCTION__))->decl_common.initial)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 255, __FUNCTION__, (BLOCK)))->block.supercontext)
= fndecl;
256 t = build2 (MODIFY_EXPR, return_type, DECL_RESULT (fndecl)((tree_check ((fndecl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 256, __FUNCTION__, (FUNCTION_DECL)))->decl_non_common.result
)
, size);
257 DECL_SAVED_TREE (fndecl)((tree_check ((fndecl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 257, __FUNCTION__, (FUNCTION_DECL)))->function_decl.saved_tree
)
= build1 (RETURN_EXPR, void_type_nodeglobal_trees[TI_VOID_TYPE], t);
258 TREE_STATIC (fndecl)((fndecl)->base.static_flag) = 1;
259
260 /* Put it onto the list of size functions. */
261 vec_safe_push (size_functions, fndecl);
262
263 /* Replace the original expression with a call to the size function. */
264 return build_call_expr_loc_vec (UNKNOWN_LOCATION((location_t) 0), fndecl, args);
265}
266
267/* Take, queue and compile all the size functions. It is essential that
268 the size functions be gimplified at the very end of the compilation
269 in order to guarantee transparent handling of self-referential sizes.
270 Otherwise the GENERIC inliner would not be able to inline them back
271 at each of their call sites, thus creating artificial non-constant
272 size expressions which would trigger nasty problems later on. */
273
274void
275finalize_size_functions (void)
276{
277 unsigned int i;
278 tree fndecl;
279
280 for (i = 0; size_functions && size_functions->iterate (i, &fndecl); i++)
281 {
282 allocate_struct_function (fndecl, false);
283 set_cfun (NULLnullptr);
284 dump_function (TDI_original, fndecl);
285
286 /* As these functions are used to describe the layout of variable-length
287 structures, debug info generation needs their implementation. */
288 debug_hooks->size_function (fndecl);
289 gimplify_function_tree (fndecl);
290 cgraph_node::finalize_function (fndecl, false);
291 }
292
293 vec_free (size_functions);
294}
295
296/* Return a machine mode of class MCLASS with SIZE bits of precision,
297 if one exists. The mode may have padding bits as well the SIZE
298 value bits. If LIMIT is nonzero, disregard modes wider than
299 MAX_FIXED_MODE_SIZE. */
300
301opt_machine_mode
302mode_for_size (poly_uint64 size, enum mode_class mclass, int limit)
303{
304 machine_mode mode;
305 int i;
306
307 if (limit && maybe_gt (size, (unsigned int) MAX_FIXED_MODE_SIZE)maybe_lt ((unsigned int) GET_MODE_BITSIZE (((global_options.x_ix86_isa_flags
& (1UL << 1)) != 0) ? (scalar_int_mode ((scalar_int_mode
::from_int) E_TImode)) : (scalar_int_mode ((scalar_int_mode::
from_int) E_DImode))), size)
)
308 return opt_machine_mode ();
309
310 /* Get the first mode which has this size, in the specified class. */
311 FOR_EACH_MODE_IN_CLASS (mode, mclass)for (mode_iterator::start (&(mode), mclass); mode_iterator
::iterate_p (&(mode)); mode_iterator::get_wider (&(mode
)))
312 if (known_eq (GET_MODE_PRECISION (mode), size)(!maybe_ne (GET_MODE_PRECISION (mode), size)))
313 return mode;
314
315 if (mclass == MODE_INT || mclass == MODE_PARTIAL_INT)
316 for (i = 0; i < NUM_INT_N_ENTS1; i ++)
317 if (known_eq (int_n_data[i].bitsize, size)(!maybe_ne (int_n_data[i].bitsize, size))
318 && int_n_enabled_p[i])
319 return int_n_data[i].m;
320
321 return opt_machine_mode ();
322}
323
324/* Similar, except passed a tree node. */
325
326opt_machine_mode
327mode_for_size_tree (const_tree size, enum mode_class mclass, int limit)
328{
329 unsigned HOST_WIDE_INTlong uhwi;
330 unsigned int ui;
331
332 if (!tree_fits_uhwi_p (size))
333 return opt_machine_mode ();
334 uhwi = tree_to_uhwi (size);
335 ui = uhwi;
336 if (uhwi != ui)
337 return opt_machine_mode ();
338 return mode_for_size (ui, mclass, limit);
339}
340
341/* Return the narrowest mode of class MCLASS that contains at least
342 SIZE bits. Abort if no such mode exists. */
343
344machine_mode
345smallest_mode_for_size (poly_uint64 size, enum mode_class mclass)
346{
347 machine_mode mode = VOIDmode((void) 0, E_VOIDmode);
348 int i;
349
350 /* Get the first mode which has at least this size, in the
351 specified class. */
352 FOR_EACH_MODE_IN_CLASS (mode, mclass)for (mode_iterator::start (&(mode), mclass); mode_iterator
::iterate_p (&(mode)); mode_iterator::get_wider (&(mode
)))
353 if (known_ge (GET_MODE_PRECISION (mode), size)(!maybe_lt (GET_MODE_PRECISION (mode), size)))
354 break;
355
356 gcc_assert (mode != VOIDmode)((void)(!(mode != ((void) 0, E_VOIDmode)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 356, __FUNCTION__), 0 : 0))
;
357
358 if (mclass == MODE_INT || mclass == MODE_PARTIAL_INT)
359 for (i = 0; i < NUM_INT_N_ENTS1; i ++)
360 if (known_ge (int_n_data[i].bitsize, size)(!maybe_lt (int_n_data[i].bitsize, size))
361 && known_lt (int_n_data[i].bitsize, GET_MODE_PRECISION (mode))(!maybe_le (GET_MODE_PRECISION (mode), int_n_data[i].bitsize)
)
362 && int_n_enabled_p[i])
363 mode = int_n_data[i].m;
364
365 return mode;
366}
367
368/* Return an integer mode of exactly the same size as MODE, if one exists. */
369
370opt_scalar_int_mode
371int_mode_for_mode (machine_mode mode)
372{
373 switch (GET_MODE_CLASS (mode)((enum mode_class) mode_class[mode]))
374 {
375 case MODE_INT:
376 case MODE_PARTIAL_INT:
377 return as_a <scalar_int_mode> (mode);
378
379 case MODE_COMPLEX_INT:
380 case MODE_COMPLEX_FLOAT:
381 case MODE_FLOAT:
382 case MODE_DECIMAL_FLOAT:
383 case MODE_FRACT:
384 case MODE_ACCUM:
385 case MODE_UFRACT:
386 case MODE_UACCUM:
387 case MODE_VECTOR_BOOL:
388 case MODE_VECTOR_INT:
389 case MODE_VECTOR_FLOAT:
390 case MODE_VECTOR_FRACT:
391 case MODE_VECTOR_ACCUM:
392 case MODE_VECTOR_UFRACT:
393 case MODE_VECTOR_UACCUM:
394 return int_mode_for_size (GET_MODE_BITSIZE (mode), 0);
395
396 case MODE_OPAQUE:
397 return opt_scalar_int_mode ();
398
399 case MODE_RANDOM:
400 if (mode == BLKmode((void) 0, E_BLKmode))
401 return opt_scalar_int_mode ();
402
403 /* fall through */
404
405 case MODE_CC:
406 default:
407 gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 407, __FUNCTION__))
;
408 }
409}
410
411/* Find a mode that can be used for efficient bitwise operations on MODE,
412 if one exists. */
413
414opt_machine_mode
415bitwise_mode_for_mode (machine_mode mode)
416{
417 /* Quick exit if we already have a suitable mode. */
418 scalar_int_mode int_mode;
419 if (is_a <scalar_int_mode> (mode, &int_mode)
420 && GET_MODE_BITSIZE (int_mode) <= MAX_FIXED_MODE_SIZEGET_MODE_BITSIZE (((global_options.x_ix86_isa_flags & (1UL
<< 1)) != 0) ? (scalar_int_mode ((scalar_int_mode::from_int
) E_TImode)) : (scalar_int_mode ((scalar_int_mode::from_int) E_DImode
)))
)
421 return int_mode;
422
423 /* Reuse the sanity checks from int_mode_for_mode. */
424 gcc_checking_assert ((int_mode_for_mode (mode), true))((void)(!((int_mode_for_mode (mode), true)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 424, __FUNCTION__), 0 : 0))
;
425
426 poly_int64 bitsize = GET_MODE_BITSIZE (mode);
427
428 /* Try to replace complex modes with complex modes. In general we
429 expect both components to be processed independently, so we only
430 care whether there is a register for the inner mode. */
431 if (COMPLEX_MODE_P (mode)(((enum mode_class) mode_class[mode]) == MODE_COMPLEX_INT || (
(enum mode_class) mode_class[mode]) == MODE_COMPLEX_FLOAT)
)
432 {
433 machine_mode trial = mode;
434 if ((GET_MODE_CLASS (trial)((enum mode_class) mode_class[trial]) == MODE_COMPLEX_INT
435 || mode_for_size (bitsize, MODE_COMPLEX_INT, false).exists (&trial))
436 && have_regs_of_mode(this_target_regs->x_have_regs_of_mode)[GET_MODE_INNER (trial)(mode_to_inner (trial))])
437 return trial;
438 }
439
440 /* Try to replace vector modes with vector modes. Also try using vector
441 modes if an integer mode would be too big. */
442 if (VECTOR_MODE_P (mode)(((enum mode_class) mode_class[mode]) == MODE_VECTOR_BOOL || (
(enum mode_class) mode_class[mode]) == MODE_VECTOR_INT || ((enum
mode_class) mode_class[mode]) == MODE_VECTOR_FLOAT || ((enum
mode_class) mode_class[mode]) == MODE_VECTOR_FRACT || ((enum
mode_class) mode_class[mode]) == MODE_VECTOR_UFRACT || ((enum
mode_class) mode_class[mode]) == MODE_VECTOR_ACCUM || ((enum
mode_class) mode_class[mode]) == MODE_VECTOR_UACCUM)
443 || maybe_gt (bitsize, MAX_FIXED_MODE_SIZE)maybe_lt (GET_MODE_BITSIZE (((global_options.x_ix86_isa_flags
& (1UL << 1)) != 0) ? (scalar_int_mode ((scalar_int_mode
::from_int) E_TImode)) : (scalar_int_mode ((scalar_int_mode::
from_int) E_DImode))), bitsize)
)
444 {
445 machine_mode trial = mode;
446 if ((GET_MODE_CLASS (trial)((enum mode_class) mode_class[trial]) == MODE_VECTOR_INT
447 || mode_for_size (bitsize, MODE_VECTOR_INT, 0).exists (&trial))
448 && have_regs_of_mode(this_target_regs->x_have_regs_of_mode)[trial]
449 && targetm.vector_mode_supported_p (trial))
450 return trial;
451 }
452
453 /* Otherwise fall back on integers while honoring MAX_FIXED_MODE_SIZE. */
454 return mode_for_size (bitsize, MODE_INT, true);
455}
456
457/* Find a type that can be used for efficient bitwise operations on MODE.
458 Return null if no such mode exists. */
459
460tree
461bitwise_type_for_mode (machine_mode mode)
462{
463 if (!bitwise_mode_for_mode (mode).exists (&mode))
464 return NULL_TREE(tree) nullptr;
465
466 unsigned int inner_size = GET_MODE_UNIT_BITSIZE (mode)((unsigned short) (mode_to_unit_size (mode) * (8)));
467 tree inner_type = build_nonstandard_integer_type (inner_size, true);
468
469 if (VECTOR_MODE_P (mode)(((enum mode_class) mode_class[mode]) == MODE_VECTOR_BOOL || (
(enum mode_class) mode_class[mode]) == MODE_VECTOR_INT || ((enum
mode_class) mode_class[mode]) == MODE_VECTOR_FLOAT || ((enum
mode_class) mode_class[mode]) == MODE_VECTOR_FRACT || ((enum
mode_class) mode_class[mode]) == MODE_VECTOR_UFRACT || ((enum
mode_class) mode_class[mode]) == MODE_VECTOR_ACCUM || ((enum
mode_class) mode_class[mode]) == MODE_VECTOR_UACCUM)
)
470 return build_vector_type_for_mode (inner_type, mode);
471
472 if (COMPLEX_MODE_P (mode)(((enum mode_class) mode_class[mode]) == MODE_COMPLEX_INT || (
(enum mode_class) mode_class[mode]) == MODE_COMPLEX_FLOAT)
)
473 return build_complex_type (inner_type);
474
475 gcc_checking_assert (GET_MODE_INNER (mode) == mode)((void)(!((mode_to_inner (mode)) == mode) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 475, __FUNCTION__), 0 : 0))
;
476 return inner_type;
477}
478
479/* Find a mode that is suitable for representing a vector with NUNITS
480 elements of mode INNERMODE, if one exists. The returned mode can be
481 either an integer mode or a vector mode. */
482
483opt_machine_mode
484mode_for_vector (scalar_mode innermode, poly_uint64 nunits)
485{
486 machine_mode mode;
487
488 /* First, look for a supported vector type. */
489 if (SCALAR_FLOAT_MODE_P (innermode)(((enum mode_class) mode_class[innermode]) == MODE_FLOAT || (
(enum mode_class) mode_class[innermode]) == MODE_DECIMAL_FLOAT
)
)
490 mode = MIN_MODE_VECTOR_FLOAT;
491 else if (SCALAR_FRACT_MODE_P (innermode)(((enum mode_class) mode_class[innermode]) == MODE_FRACT))
492 mode = MIN_MODE_VECTOR_FRACT;
493 else if (SCALAR_UFRACT_MODE_P (innermode)(((enum mode_class) mode_class[innermode]) == MODE_UFRACT))
494 mode = MIN_MODE_VECTOR_UFRACT;
495 else if (SCALAR_ACCUM_MODE_P (innermode)(((enum mode_class) mode_class[innermode]) == MODE_ACCUM))
496 mode = MIN_MODE_VECTOR_ACCUM;
497 else if (SCALAR_UACCUM_MODE_P (innermode)(((enum mode_class) mode_class[innermode]) == MODE_UACCUM))
498 mode = MIN_MODE_VECTOR_UACCUM;
499 else
500 mode = MIN_MODE_VECTOR_INT;
501
502 /* Do not check vector_mode_supported_p here. We'll do that
503 later in vector_type_mode. */
504 FOR_EACH_MODE_FROM (mode, mode)for ((mode) = (mode); mode_iterator::iterate_p (&(mode));
mode_iterator::get_wider (&(mode)))
505 if (known_eq (GET_MODE_NUNITS (mode), nunits)(!maybe_ne (GET_MODE_NUNITS (mode), nunits))
506 && GET_MODE_INNER (mode)(mode_to_inner (mode)) == innermode)
507 return mode;
508
509 /* For integers, try mapping it to a same-sized scalar mode. */
510 if (GET_MODE_CLASS (innermode)((enum mode_class) mode_class[innermode]) == MODE_INT)
511 {
512 poly_uint64 nbits = nunits * GET_MODE_BITSIZE (innermode);
513 if (int_mode_for_size (nbits, 0).exists (&mode)
514 && have_regs_of_mode(this_target_regs->x_have_regs_of_mode)[mode])
515 return mode;
516 }
517
518 return opt_machine_mode ();
519}
520
521/* If a piece of code is using vector mode VECTOR_MODE and also wants
522 to operate on elements of mode ELEMENT_MODE, return the vector mode
523 it should use for those elements. If NUNITS is nonzero, ensure that
524 the mode has exactly NUNITS elements, otherwise pick whichever vector
525 size pairs the most naturally with VECTOR_MODE; this may mean choosing
526 a mode with a different size and/or number of elements, depending on
527 what the target prefers. Return an empty opt_machine_mode if there
528 is no supported vector mode with the required properties.
529
530 Unlike mode_for_vector. any returned mode is guaranteed to satisfy
531 both VECTOR_MODE_P and targetm.vector_mode_supported_p. */
532
533opt_machine_mode
534related_vector_mode (machine_mode vector_mode, scalar_mode element_mode,
535 poly_uint64 nunits)
536{
537 gcc_assert (VECTOR_MODE_P (vector_mode))((void)(!((((enum mode_class) mode_class[vector_mode]) == MODE_VECTOR_BOOL
|| ((enum mode_class) mode_class[vector_mode]) == MODE_VECTOR_INT
|| ((enum mode_class) mode_class[vector_mode]) == MODE_VECTOR_FLOAT
|| ((enum mode_class) mode_class[vector_mode]) == MODE_VECTOR_FRACT
|| ((enum mode_class) mode_class[vector_mode]) == MODE_VECTOR_UFRACT
|| ((enum mode_class) mode_class[vector_mode]) == MODE_VECTOR_ACCUM
|| ((enum mode_class) mode_class[vector_mode]) == MODE_VECTOR_UACCUM
)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 537, __FUNCTION__), 0 : 0))
;
538 return targetm.vectorize.related_mode (vector_mode, element_mode, nunits);
539}
540
541/* If a piece of code is using vector mode VECTOR_MODE and also wants
542 to operate on integer vectors with the same element size and number
543 of elements, return the vector mode it should use. Return an empty
544 opt_machine_mode if there is no supported vector mode with the
545 required properties.
546
547 Unlike mode_for_vector. any returned mode is guaranteed to satisfy
548 both VECTOR_MODE_P and targetm.vector_mode_supported_p. */
549
550opt_machine_mode
551related_int_vector_mode (machine_mode vector_mode)
552{
553 gcc_assert (VECTOR_MODE_P (vector_mode))((void)(!((((enum mode_class) mode_class[vector_mode]) == MODE_VECTOR_BOOL
|| ((enum mode_class) mode_class[vector_mode]) == MODE_VECTOR_INT
|| ((enum mode_class) mode_class[vector_mode]) == MODE_VECTOR_FLOAT
|| ((enum mode_class) mode_class[vector_mode]) == MODE_VECTOR_FRACT
|| ((enum mode_class) mode_class[vector_mode]) == MODE_VECTOR_UFRACT
|| ((enum mode_class) mode_class[vector_mode]) == MODE_VECTOR_ACCUM
|| ((enum mode_class) mode_class[vector_mode]) == MODE_VECTOR_UACCUM
)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 553, __FUNCTION__), 0 : 0))
;
554 scalar_int_mode int_mode;
555 if (int_mode_for_mode (GET_MODE_INNER (vector_mode)(mode_to_inner (vector_mode))).exists (&int_mode))
556 return related_vector_mode (vector_mode, int_mode,
557 GET_MODE_NUNITS (vector_mode));
558 return opt_machine_mode ();
559}
560
561/* Return the alignment of MODE. This will be bounded by 1 and
562 BIGGEST_ALIGNMENT. */
563
564unsigned int
565get_mode_alignment (machine_mode mode)
566{
567 return MIN (BIGGEST_ALIGNMENT, MAX (1, mode_base_align[mode]*BITS_PER_UNIT))(((((global_options.x_target_flags & (1U << 12)) !=
0) ? 32 : (((global_options.x_ix86_isa_flags & (1UL <<
15)) != 0) ? 512 : (((global_options.x_ix86_isa_flags & (
1UL << 8)) != 0) ? 256 : 128)))) < (((1) > (mode_base_align
[mode]*(8)) ? (1) : (mode_base_align[mode]*(8)))) ? ((((global_options
.x_target_flags & (1U << 12)) != 0) ? 32 : (((global_options
.x_ix86_isa_flags & (1UL << 15)) != 0) ? 512 : (((global_options
.x_ix86_isa_flags & (1UL << 8)) != 0) ? 256 : 128))
)) : (((1) > (mode_base_align[mode]*(8)) ? (1) : (mode_base_align
[mode]*(8)))))
;
568}
569
570/* Return the natural mode of an array, given that it is SIZE bytes in
571 total and has elements of type ELEM_TYPE. */
572
573static machine_mode
574mode_for_array (tree elem_type, tree size)
575{
576 tree elem_size;
577 poly_uint64 int_size, int_elem_size;
578 unsigned HOST_WIDE_INTlong num_elems;
579 bool limit_p;
580
581 /* One-element arrays get the component type's mode. */
582 elem_size = TYPE_SIZE (elem_type)((tree_class_check ((elem_type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 582, __FUNCTION__))->type_common.size)
;
583 if (simple_cst_equal (size, elem_size))
584 return TYPE_MODE (elem_type)((((enum tree_code) ((tree_class_check ((elem_type), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 584, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(elem_type) : (elem_type)->type_common.mode)
;
585
586 limit_p = true;
587 if (poly_int_tree_p (size, &int_size)
588 && poly_int_tree_p (elem_size, &int_elem_size)
589 && maybe_ne (int_elem_size, 0U)
590 && constant_multiple_p (int_size, int_elem_size, &num_elems))
591 {
592 machine_mode elem_mode = TYPE_MODE (elem_type)((((enum tree_code) ((tree_class_check ((elem_type), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 592, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(elem_type) : (elem_type)->type_common.mode)
;
593 machine_mode mode;
594 if (targetm.array_mode (elem_mode, num_elems).exists (&mode))
595 return mode;
596 if (targetm.array_mode_supported_p (elem_mode, num_elems))
597 limit_p = false;
598 }
599 return mode_for_size_tree (size, MODE_INT, limit_p).else_blk ();
600}
601
602/* Subroutine of layout_decl: Force alignment required for the data type.
603 But if the decl itself wants greater alignment, don't override that. */
604
605static inline void
606do_type_align (tree type, tree decl)
607{
608 if (TYPE_ALIGN (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 608, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((type)->type_common.align - 1) : 0)
> DECL_ALIGN (decl)(((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 608, __FUNCTION__))->decl_common.align) ? ((unsigned)1) <<
(((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 608, __FUNCTION__))->decl_common.align) - 1) : 0)
)
609 {
610 SET_DECL_ALIGN (decl, TYPE_ALIGN (type))(((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 610, __FUNCTION__))->decl_common.align) = ffs_hwi (((tree_class_check
((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 610, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((type)->type_common.align - 1) : 0)))
;
611 if (TREE_CODE (decl)((enum tree_code) (decl)->base.code) == FIELD_DECL)
612 DECL_USER_ALIGN (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 612, __FUNCTION__))->base.u.bits.user_align)
= TYPE_USER_ALIGN (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 612, __FUNCTION__))->base.u.bits.user_align)
;
613 }
614 if (TYPE_WARN_IF_NOT_ALIGN (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 614, __FUNCTION__))->type_common.warn_if_not_align ? ((unsigned
)1) << ((type)->type_common.warn_if_not_align - 1) :
0)
> DECL_WARN_IF_NOT_ALIGN (decl)(((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 614, __FUNCTION__))->decl_common.warn_if_not_align) ? ((
unsigned)1) << (((contains_struct_check ((decl), (TS_DECL_COMMON
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 614, __FUNCTION__))->decl_common.warn_if_not_align) - 1)
: 0)
)
615 SET_DECL_WARN_IF_NOT_ALIGN (decl, TYPE_WARN_IF_NOT_ALIGN (type))(((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 615, __FUNCTION__))->decl_common.warn_if_not_align) = ffs_hwi
(((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 615, __FUNCTION__))->type_common.warn_if_not_align ? ((unsigned
)1) << ((type)->type_common.warn_if_not_align - 1) :
0)))
;
616}
617
618/* Set the size, mode and alignment of a ..._DECL node.
619 TYPE_DECL does need this for C++.
620 Note that LABEL_DECL and CONST_DECL nodes do not need this,
621 and FUNCTION_DECL nodes have them set up in a special (and simple) way.
622 Don't call layout_decl for them.
623
624 KNOWN_ALIGN is the amount of alignment we can assume this
625 decl has with no special effort. It is relevant only for FIELD_DECLs
626 and depends on the previous fields.
627 All that matters about KNOWN_ALIGN is which powers of 2 divide it.
628 If KNOWN_ALIGN is 0, it means, "as much alignment as you like":
629 the record will be aligned to suit. */
630
631void
632layout_decl (tree decl, unsigned int known_align)
633{
634 tree type = TREE_TYPE (decl)((contains_struct_check ((decl), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 634, __FUNCTION__))->typed.type)
;
635 enum tree_code code = TREE_CODE (decl)((enum tree_code) (decl)->base.code);
636 rtx rtl = NULL_RTX(rtx) 0;
637 location_t loc = DECL_SOURCE_LOCATION (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 637, __FUNCTION__))->decl_minimal.locus)
;
638
639 if (code == CONST_DECL)
640 return;
641
642 gcc_assert (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL((void)(!(code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL
|| code == TYPE_DECL || code == FIELD_DECL) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 643, __FUNCTION__), 0 : 0))
643 || code == TYPE_DECL || code == FIELD_DECL)((void)(!(code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL
|| code == TYPE_DECL || code == FIELD_DECL) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 643, __FUNCTION__), 0 : 0))
;
644
645 rtl = DECL_RTL_IF_SET (decl)((((tree_contains_struct[(((enum tree_code) (decl)->base.code
))][(TS_DECL_WRTL)])) && (contains_struct_check ((decl
), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 645, __FUNCTION__))->decl_with_rtl.rtl != nullptr) ? ((contains_struct_check
((decl), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 645, __FUNCTION__))->decl_with_rtl.rtl ? (decl)->decl_with_rtl
.rtl : (make_decl_rtl (decl), (decl)->decl_with_rtl.rtl)) :
nullptr)
;
646
647 if (type == error_mark_nodeglobal_trees[TI_ERROR_MARK])
648 type = void_type_nodeglobal_trees[TI_VOID_TYPE];
649
650 /* Usually the size and mode come from the data type without change,
651 however, the front-end may set the explicit width of the field, so its
652 size may not be the same as the size of its type. This happens with
653 bitfields, of course (an `int' bitfield may be only 2 bits, say), but it
654 also happens with other fields. For example, the C++ front-end creates
655 zero-sized fields corresponding to empty base classes, and depends on
656 layout_type setting DECL_FIELD_BITPOS correctly for the field. Set the
657 size in bytes from the size in bits. If we have already set the mode,
658 don't set it again since we can be called twice for FIELD_DECLs. */
659
660 DECL_UNSIGNED (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 660, __FUNCTION__))->base.u.bits.unsigned_flag)
= TYPE_UNSIGNED (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 660, __FUNCTION__))->base.u.bits.unsigned_flag)
;
661 if (DECL_MODE (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 661, __FUNCTION__))->decl_common.mode)
== VOIDmode((void) 0, E_VOIDmode))
662 SET_DECL_MODE (decl, TYPE_MODE (type))((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 662, __FUNCTION__))->decl_common.mode = (((((enum tree_code
) ((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 662, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(type) : (type)->type_common.mode)))
;
663
664 if (DECL_SIZE (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 664, __FUNCTION__))->decl_common.size)
== 0)
665 {
666 DECL_SIZE (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 666, __FUNCTION__))->decl_common.size)
= TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 666, __FUNCTION__))->type_common.size)
;
667 DECL_SIZE_UNIT (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 667, __FUNCTION__))->decl_common.size_unit)
= TYPE_SIZE_UNIT (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 667, __FUNCTION__))->type_common.size_unit)
;
668 }
669 else if (DECL_SIZE_UNIT (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 669, __FUNCTION__))->decl_common.size_unit)
== 0)
670 DECL_SIZE_UNIT (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 670, __FUNCTION__))->decl_common.size_unit)
671 = fold_convert_loc (loc, sizetypesizetype_tab[(int) stk_sizetype],
672 size_binop_loc (loc, CEIL_DIV_EXPR, DECL_SIZE (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 672, __FUNCTION__))->decl_common.size)
,
673 bitsize_unit_nodeglobal_trees[TI_BITSIZE_UNIT]));
674
675 if (code != FIELD_DECL)
676 /* For non-fields, update the alignment from the type. */
677 do_type_align (type, decl);
678 else
679 /* For fields, it's a bit more complicated... */
680 {
681 bool old_user_align = DECL_USER_ALIGN (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 681, __FUNCTION__))->base.u.bits.user_align)
;
682 bool zero_bitfield = false;
683 bool packed_p = DECL_PACKED (decl)((tree_check ((decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 683, __FUNCTION__, (FIELD_DECL)))->base.u.bits.packed_flag
)
;
684 unsigned int mfa;
685
686 if (DECL_BIT_FIELD (decl)((tree_check ((decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 686, __FUNCTION__, (FIELD_DECL)))->decl_common.decl_flag_1
)
)
687 {
688 DECL_BIT_FIELD_TYPE (decl)((tree_check ((decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 688, __FUNCTION__, (FIELD_DECL)))->field_decl.bit_field_type
)
= type;
689
690 /* A zero-length bit-field affects the alignment of the next
691 field. In essence such bit-fields are not influenced by
692 any packing due to #pragma pack or attribute packed. */
693 if (integer_zerop (DECL_SIZE (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 693, __FUNCTION__))->decl_common.size)
)
694 && ! targetm.ms_bitfield_layout_p (DECL_FIELD_CONTEXT (decl)((tree_check ((decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 694, __FUNCTION__, (FIELD_DECL)))->decl_minimal.context)
))
695 {
696 zero_bitfield = true;
697 packed_p = false;
698 if (PCC_BITFIELD_TYPE_MATTERS1)
699 do_type_align (type, decl);
700 else
701 {
702#ifdef EMPTY_FIELD_BOUNDARY
703 if (EMPTY_FIELD_BOUNDARY > DECL_ALIGN (decl)(((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 703, __FUNCTION__))->decl_common.align) ? ((unsigned)1) <<
(((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 703, __FUNCTION__))->decl_common.align) - 1) : 0)
)
704 {
705 SET_DECL_ALIGN (decl, EMPTY_FIELD_BOUNDARY)(((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 705, __FUNCTION__))->decl_common.align) = ffs_hwi (EMPTY_FIELD_BOUNDARY
))
;
706 DECL_USER_ALIGN (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 706, __FUNCTION__))->base.u.bits.user_align)
= 0;
707 }
708#endif
709 }
710 }
711
712 /* See if we can use an ordinary integer mode for a bit-field.
713 Conditions are: a fixed size that is correct for another mode,
714 occupying a complete byte or bytes on proper boundary. */
715 if (TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 715, __FUNCTION__))->type_common.size)
!= 0
716 && TREE_CODE (TYPE_SIZE (type))((enum tree_code) (((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 716, __FUNCTION__))->type_common.size))->base.code)
== INTEGER_CST
717 && GET_MODE_CLASS (TYPE_MODE (type))((enum mode_class) mode_class[((((enum tree_code) ((tree_class_check
((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 717, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(type) : (type)->type_common.mode)])
== MODE_INT)
718 {
719 machine_mode xmode;
720 if (mode_for_size_tree (DECL_SIZE (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 720, __FUNCTION__))->decl_common.size)
,
721 MODE_INT, 1).exists (&xmode))
722 {
723 unsigned int xalign = GET_MODE_ALIGNMENT (xmode)get_mode_alignment (xmode);
724 if (!(xalign > BITS_PER_UNIT(8) && DECL_PACKED (decl)((tree_check ((decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 724, __FUNCTION__, (FIELD_DECL)))->base.u.bits.packed_flag
)
)
725 && (known_align == 0 || known_align >= xalign))
726 {
727 SET_DECL_ALIGN (decl, MAX (xalign, DECL_ALIGN (decl)))(((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 727, __FUNCTION__))->decl_common.align) = ffs_hwi (((xalign
) > ((((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 727, __FUNCTION__))->decl_common.align) ? ((unsigned)1) <<
(((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 727, __FUNCTION__))->decl_common.align) - 1) : 0)) ? (xalign
) : ((((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 727, __FUNCTION__))->decl_common.align) ? ((unsigned)1) <<
(((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 727, __FUNCTION__))->decl_common.align) - 1) : 0)))))
;
728 SET_DECL_MODE (decl, xmode)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 728, __FUNCTION__))->decl_common.mode = (xmode))
;
729 DECL_BIT_FIELD (decl)((tree_check ((decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 729, __FUNCTION__, (FIELD_DECL)))->decl_common.decl_flag_1
)
= 0;
730 }
731 }
732 }
733
734 /* Turn off DECL_BIT_FIELD if we won't need it set. */
735 if (TYPE_MODE (type)((((enum tree_code) ((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 735, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(type) : (type)->type_common.mode)
== BLKmode((void) 0, E_BLKmode) && DECL_MODE (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 735, __FUNCTION__))->decl_common.mode)
== BLKmode((void) 0, E_BLKmode)
736 && known_align >= TYPE_ALIGN (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 736, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((type)->type_common.align - 1) : 0)
737 && DECL_ALIGN (decl)(((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 737, __FUNCTION__))->decl_common.align) ? ((unsigned)1) <<
(((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 737, __FUNCTION__))->decl_common.align) - 1) : 0)
>= TYPE_ALIGN (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 737, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((type)->type_common.align - 1) : 0)
)
738 DECL_BIT_FIELD (decl)((tree_check ((decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 738, __FUNCTION__, (FIELD_DECL)))->decl_common.decl_flag_1
)
= 0;
739 }
740 else if (packed_p && DECL_USER_ALIGN (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 740, __FUNCTION__))->base.u.bits.user_align)
)
741 /* Don't touch DECL_ALIGN. For other packed fields, go ahead and
742 round up; we'll reduce it again below. We want packing to
743 supersede USER_ALIGN inherited from the type, but defer to
744 alignment explicitly specified on the field decl. */;
745 else
746 do_type_align (type, decl);
747
748 /* If the field is packed and not explicitly aligned, give it the
749 minimum alignment. Note that do_type_align may set
750 DECL_USER_ALIGN, so we need to check old_user_align instead. */
751 if (packed_p
752 && !old_user_align)
753 SET_DECL_ALIGN (decl, MIN (DECL_ALIGN (decl), BITS_PER_UNIT))(((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 753, __FUNCTION__))->decl_common.align) = ffs_hwi ((((((
contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 753, __FUNCTION__))->decl_common.align) ? ((unsigned)1) <<
(((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 753, __FUNCTION__))->decl_common.align) - 1) : 0)) < (
(8)) ? ((((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 753, __FUNCTION__))->decl_common.align) ? ((unsigned)1) <<
(((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 753, __FUNCTION__))->decl_common.align) - 1) : 0)) : ((8
)))))
;
754
755 if (! packed_p && ! DECL_USER_ALIGN (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 755, __FUNCTION__))->base.u.bits.user_align)
)
756 {
757 /* Some targets (i.e. i386, VMS) limit struct field alignment
758 to a lower boundary than alignment of variables unless
759 it was overridden by attribute aligned. */
760#ifdef BIGGEST_FIELD_ALIGNMENT
761 SET_DECL_ALIGN (decl, MIN (DECL_ALIGN (decl),(((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 762, __FUNCTION__))->decl_common.align) = ffs_hwi ((((((
contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 761, __FUNCTION__))->decl_common.align) ? ((unsigned)1) <<
(((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 761, __FUNCTION__))->decl_common.align) - 1) : 0)) < (
(unsigned) BIGGEST_FIELD_ALIGNMENT) ? ((((contains_struct_check
((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 761, __FUNCTION__))->decl_common.align) ? ((unsigned)1) <<
(((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 761, __FUNCTION__))->decl_common.align) - 1) : 0)) : ((unsigned
) BIGGEST_FIELD_ALIGNMENT))))
762 (unsigned) BIGGEST_FIELD_ALIGNMENT))(((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 762, __FUNCTION__))->decl_common.align) = ffs_hwi ((((((
contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 761, __FUNCTION__))->decl_common.align) ? ((unsigned)1) <<
(((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 761, __FUNCTION__))->decl_common.align) - 1) : 0)) < (
(unsigned) BIGGEST_FIELD_ALIGNMENT) ? ((((contains_struct_check
((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 761, __FUNCTION__))->decl_common.align) ? ((unsigned)1) <<
(((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 761, __FUNCTION__))->decl_common.align) - 1) : 0)) : ((unsigned
) BIGGEST_FIELD_ALIGNMENT))))
;
763#endif
764#ifdef ADJUST_FIELD_ALIGN
765 SET_DECL_ALIGN (decl, ADJUST_FIELD_ALIGN (decl, TREE_TYPE (decl),(((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 766, __FUNCTION__))->decl_common.align) = ffs_hwi (x86_field_alignment
((((contains_struct_check ((decl), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 765, __FUNCTION__))->typed.type)), ((((contains_struct_check
((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 766, __FUNCTION__))->decl_common.align) ? ((unsigned)1) <<
(((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 766, __FUNCTION__))->decl_common.align) - 1) : 0)))))
766 DECL_ALIGN (decl)))(((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 766, __FUNCTION__))->decl_common.align) = ffs_hwi (x86_field_alignment
((((contains_struct_check ((decl), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 765, __FUNCTION__))->typed.type)), ((((contains_struct_check
((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 766, __FUNCTION__))->decl_common.align) ? ((unsigned)1) <<
(((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 766, __FUNCTION__))->decl_common.align) - 1) : 0)))))
;
767#endif
768 }
769
770 if (zero_bitfield)
771 mfa = initial_max_fld_alignglobal_options.x_initial_max_fld_align * BITS_PER_UNIT(8);
772 else
773 mfa = maximum_field_alignment;
774 /* Should this be controlled by DECL_USER_ALIGN, too? */
775 if (mfa != 0)
776 SET_DECL_ALIGN (decl, MIN (DECL_ALIGN (decl), mfa))(((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 776, __FUNCTION__))->decl_common.align) = ffs_hwi ((((((
contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 776, __FUNCTION__))->decl_common.align) ? ((unsigned)1) <<
(((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 776, __FUNCTION__))->decl_common.align) - 1) : 0)) < (
mfa) ? ((((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 776, __FUNCTION__))->decl_common.align) ? ((unsigned)1) <<
(((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 776, __FUNCTION__))->decl_common.align) - 1) : 0)) : (mfa
))))
;
777 }
778
779 /* Evaluate nonconstant size only once, either now or as soon as safe. */
780 if (DECL_SIZE (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 780, __FUNCTION__))->decl_common.size)
!= 0 && TREE_CODE (DECL_SIZE (decl))((enum tree_code) (((contains_struct_check ((decl), (TS_DECL_COMMON
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 780, __FUNCTION__))->decl_common.size))->base.code)
!= INTEGER_CST)
781 DECL_SIZE (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 781, __FUNCTION__))->decl_common.size)
= variable_size (DECL_SIZE (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 781, __FUNCTION__))->decl_common.size)
);
782 if (DECL_SIZE_UNIT (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 782, __FUNCTION__))->decl_common.size_unit)
!= 0
783 && TREE_CODE (DECL_SIZE_UNIT (decl))((enum tree_code) (((contains_struct_check ((decl), (TS_DECL_COMMON
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 783, __FUNCTION__))->decl_common.size_unit))->base.code
)
!= INTEGER_CST)
784 DECL_SIZE_UNIT (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 784, __FUNCTION__))->decl_common.size_unit)
= variable_size (DECL_SIZE_UNIT (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 784, __FUNCTION__))->decl_common.size_unit)
);
785
786 /* If requested, warn about definitions of large data objects. */
787 if ((code == PARM_DECL || (code == VAR_DECL && !DECL_NONLOCAL_FRAME (decl)((tree_check ((decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 787, __FUNCTION__, (VAR_DECL)))->base.default_def_flag)
))
788 && !DECL_EXTERNAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 788, __FUNCTION__))->decl_common.decl_flag_1)
)
789 {
790 tree size = DECL_SIZE_UNIT (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 790, __FUNCTION__))->decl_common.size_unit)
;
791
792 if (size != 0 && TREE_CODE (size)((enum tree_code) (size)->base.code) == INTEGER_CST)
793 {
794 /* -Wlarger-than= argument of HOST_WIDE_INT_MAX is treated
795 as if PTRDIFF_MAX had been specified, with the value
796 being that on the target rather than the host. */
797 unsigned HOST_WIDE_INTlong max_size = warn_larger_than_sizeglobal_options.x_warn_larger_than_size;
798 if (max_size == HOST_WIDE_INT_MAX(~((long) (1UL << (64 - 1)))))
799 max_size = tree_to_shwi (TYPE_MAX_VALUE (ptrdiff_type_node)((tree_check5 ((global_trees[TI_PTRDIFF_TYPE]), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 799, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.maxval
)
);
800
801 if (compare_tree_int (size, max_size) > 0)
802 warning (OPT_Wlarger_than_, "size of %q+D %E bytes exceeds "
803 "maximum object size %wu",
804 decl, size, max_size);
805 }
806 }
807
808 /* If the RTL was already set, update its mode and mem attributes. */
809 if (rtl)
810 {
811 PUT_MODE (rtl, DECL_MODE (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 811, __FUNCTION__))->decl_common.mode)
);
812 SET_DECL_RTL (decl, 0)set_decl_rtl (decl, 0);
813 if (MEM_P (rtl)(((enum rtx_code) (rtl)->code) == MEM))
814 set_mem_attributes (rtl, decl, 1);
815 SET_DECL_RTL (decl, rtl)set_decl_rtl (decl, rtl);
816 }
817}
818
819/* Given a VAR_DECL, PARM_DECL, RESULT_DECL, or FIELD_DECL, clears the
820 results of a previous call to layout_decl and calls it again. */
821
822void
823relayout_decl (tree decl)
824{
825 DECL_SIZE (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 825, __FUNCTION__))->decl_common.size)
= DECL_SIZE_UNIT (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 825, __FUNCTION__))->decl_common.size_unit)
= 0;
826 SET_DECL_MODE (decl, VOIDmode)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 826, __FUNCTION__))->decl_common.mode = (((void) 0, E_VOIDmode
)))
;
827 if (!DECL_USER_ALIGN (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 827, __FUNCTION__))->base.u.bits.user_align)
)
828 SET_DECL_ALIGN (decl, 0)(((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 828, __FUNCTION__))->decl_common.align) = ffs_hwi (0))
;
829 if (DECL_RTL_SET_P (decl)(((tree_contains_struct[(((enum tree_code) (decl)->base.code
))][(TS_DECL_WRTL)])) && (contains_struct_check ((decl
), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 829, __FUNCTION__))->decl_with_rtl.rtl != nullptr)
)
830 SET_DECL_RTL (decl, 0)set_decl_rtl (decl, 0);
831
832 layout_decl (decl, 0);
833}
834
835/* Begin laying out type T, which may be a RECORD_TYPE, UNION_TYPE, or
836 QUAL_UNION_TYPE. Return a pointer to a struct record_layout_info which
837 is to be passed to all other layout functions for this record. It is the
838 responsibility of the caller to call `free' for the storage returned.
839 Note that garbage collection is not permitted until we finish laying
840 out the record. */
841
842record_layout_info
843start_record_layout (tree t)
844{
845 record_layout_info rli = XNEW (struct record_layout_info_s)((struct record_layout_info_s *) xmalloc (sizeof (struct record_layout_info_s
)))
;
846
847 rli->t = t;
848
849 /* If the type has a minimum specified alignment (via an attribute
850 declaration, for example) use it -- otherwise, start with a
851 one-byte alignment. */
852 rli->record_align = MAX (BITS_PER_UNIT, TYPE_ALIGN (t))(((8)) > (((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 852, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((t)->type_common.align - 1) : 0)) ? ((8)) : (((tree_class_check
((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 852, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((t)->type_common.align - 1) : 0)))
;
853 rli->unpacked_align = rli->record_align;
854 rli->offset_align = MAX (rli->record_align, BIGGEST_ALIGNMENT)((rli->record_align) > ((((global_options.x_target_flags
& (1U << 12)) != 0) ? 32 : (((global_options.x_ix86_isa_flags
& (1UL << 15)) != 0) ? 512 : (((global_options.x_ix86_isa_flags
& (1UL << 8)) != 0) ? 256 : 128)))) ? (rli->record_align
) : ((((global_options.x_target_flags & (1U << 12))
!= 0) ? 32 : (((global_options.x_ix86_isa_flags & (1UL <<
15)) != 0) ? 512 : (((global_options.x_ix86_isa_flags & (
1UL << 8)) != 0) ? 256 : 128)))))
;
855
856#ifdef STRUCTURE_SIZE_BOUNDARY
857 /* Packed structures don't need to have minimum size. */
858 if (! TYPE_PACKED (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 858, __FUNCTION__))->base.u.bits.packed_flag)
)
859 {
860 unsigned tmp;
861
862 /* #pragma pack overrides STRUCTURE_SIZE_BOUNDARY. */
863 tmp = (unsigned) STRUCTURE_SIZE_BOUNDARY;
864 if (maximum_field_alignment != 0)
865 tmp = MIN (tmp, maximum_field_alignment)((tmp) < (maximum_field_alignment) ? (tmp) : (maximum_field_alignment
))
;
866 rli->record_align = MAX (rli->record_align, tmp)((rli->record_align) > (tmp) ? (rli->record_align) :
(tmp))
;
867 }
868#endif
869
870 rli->offset = size_zero_nodeglobal_trees[TI_SIZE_ZERO];
871 rli->bitpos = bitsize_zero_nodeglobal_trees[TI_BITSIZE_ZERO];
872 rli->prev_field = 0;
873 rli->pending_statics = 0;
874 rli->packed_maybe_necessary = 0;
875 rli->remaining_in_alignment = 0;
876
877 return rli;
878}
879
880/* Fold sizetype value X to bitsizetype, given that X represents a type
881 size or offset. */
882
883static tree
884bits_from_bytes (tree x)
885{
886 if (POLY_INT_CST_P (x)(1 > 1 && ((enum tree_code) (x)->base.code) == POLY_INT_CST
)
)
887 /* The runtime calculation isn't allowed to overflow sizetype;
888 increasing the runtime values must always increase the size
889 or offset of the object. This means that the object imposes
890 a maximum value on the runtime parameters, but we don't record
891 what that is. */
892 return build_poly_int_cst
893 (bitsizetypesizetype_tab[(int) stk_bitsizetype],
894 poly_wide_int::from (poly_int_cst_value (x),
895 TYPE_PRECISION (bitsizetype)((tree_class_check ((sizetype_tab[(int) stk_bitsizetype]), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 895, __FUNCTION__))->type_common.precision)
,
896 TYPE_SIGN (TREE_TYPE (x))((signop) ((tree_class_check ((((contains_struct_check ((x), (
TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 896, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 896, __FUNCTION__))->base.u.bits.unsigned_flag))
));
897 x = fold_convert (bitsizetype, x)fold_convert_loc (((location_t) 0), sizetype_tab[(int) stk_bitsizetype
], x)
;
898 gcc_checking_assert (x)((void)(!(x) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 898, __FUNCTION__), 0 : 0))
;
899 return x;
900}
901
902/* Return the combined bit position for the byte offset OFFSET and the
903 bit position BITPOS.
904
905 These functions operate on byte and bit positions present in FIELD_DECLs
906 and assume that these expressions result in no (intermediate) overflow.
907 This assumption is necessary to fold the expressions as much as possible,
908 so as to avoid creating artificially variable-sized types in languages
909 supporting variable-sized types like Ada. */
910
911tree
912bit_from_pos (tree offset, tree bitpos)
913{
914 return size_binop (PLUS_EXPR, bitpos,size_binop_loc (((location_t) 0), PLUS_EXPR, bitpos, size_binop_loc
(((location_t) 0), MULT_EXPR, bits_from_bytes (offset), global_trees
[TI_BITSIZE_UNIT]))
915 size_binop (MULT_EXPR, bits_from_bytes (offset),size_binop_loc (((location_t) 0), PLUS_EXPR, bitpos, size_binop_loc
(((location_t) 0), MULT_EXPR, bits_from_bytes (offset), global_trees
[TI_BITSIZE_UNIT]))
916 bitsize_unit_node))size_binop_loc (((location_t) 0), PLUS_EXPR, bitpos, size_binop_loc
(((location_t) 0), MULT_EXPR, bits_from_bytes (offset), global_trees
[TI_BITSIZE_UNIT]))
;
917}
918
919/* Return the combined truncated byte position for the byte offset OFFSET and
920 the bit position BITPOS. */
921
922tree
923byte_from_pos (tree offset, tree bitpos)
924{
925 tree bytepos;
926 if (TREE_CODE (bitpos)((enum tree_code) (bitpos)->base.code) == MULT_EXPR
927 && tree_int_cst_equal (TREE_OPERAND (bitpos, 1)(*((const_cast<tree*> (tree_operand_check ((bitpos), (1
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 927, __FUNCTION__)))))
, bitsize_unit_nodeglobal_trees[TI_BITSIZE_UNIT]))
928 bytepos = TREE_OPERAND (bitpos, 0)(*((const_cast<tree*> (tree_operand_check ((bitpos), (0
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 928, __FUNCTION__)))))
;
929 else
930 bytepos = size_binop (TRUNC_DIV_EXPR, bitpos, bitsize_unit_node)size_binop_loc (((location_t) 0), TRUNC_DIV_EXPR, bitpos, global_trees
[TI_BITSIZE_UNIT])
;
931 return size_binop (PLUS_EXPR, offset, fold_convert (sizetype, bytepos))size_binop_loc (((location_t) 0), PLUS_EXPR, offset, fold_convert_loc
(((location_t) 0), sizetype_tab[(int) stk_sizetype], bytepos
))
;
932}
933
934/* Split the bit position POS into a byte offset *POFFSET and a bit
935 position *PBITPOS with the byte offset aligned to OFF_ALIGN bits. */
936
937void
938pos_from_bit (tree *poffset, tree *pbitpos, unsigned int off_align,
939 tree pos)
940{
941 tree toff_align = bitsize_int (off_align)size_int_kind (off_align, stk_bitsizetype);
942 if (TREE_CODE (pos)((enum tree_code) (pos)->base.code) == MULT_EXPR
943 && tree_int_cst_equal (TREE_OPERAND (pos, 1)(*((const_cast<tree*> (tree_operand_check ((pos), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 943, __FUNCTION__)))))
, toff_align))
944 {
945 *poffset = size_binop (MULT_EXPR,size_binop_loc (((location_t) 0), MULT_EXPR, fold_convert_loc
(((location_t) 0), sizetype_tab[(int) stk_sizetype], (*((const_cast
<tree*> (tree_operand_check ((pos), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 946, __FUNCTION__)))))), size_int_kind (off_align / (8), stk_sizetype
))
946 fold_convert (sizetype, TREE_OPERAND (pos, 0)),size_binop_loc (((location_t) 0), MULT_EXPR, fold_convert_loc
(((location_t) 0), sizetype_tab[(int) stk_sizetype], (*((const_cast
<tree*> (tree_operand_check ((pos), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 946, __FUNCTION__)))))), size_int_kind (off_align / (8), stk_sizetype
))
947 size_int (off_align / BITS_PER_UNIT))size_binop_loc (((location_t) 0), MULT_EXPR, fold_convert_loc
(((location_t) 0), sizetype_tab[(int) stk_sizetype], (*((const_cast
<tree*> (tree_operand_check ((pos), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 946, __FUNCTION__)))))), size_int_kind (off_align / (8), stk_sizetype
))
;
948 *pbitpos = bitsize_zero_nodeglobal_trees[TI_BITSIZE_ZERO];
949 }
950 else
951 {
952 *poffset = size_binop (MULT_EXPR,size_binop_loc (((location_t) 0), MULT_EXPR, fold_convert_loc
(((location_t) 0), sizetype_tab[(int) stk_sizetype], size_binop_loc
(((location_t) 0), FLOOR_DIV_EXPR, pos, toff_align)), size_int_kind
(off_align / (8), stk_sizetype))
953 fold_convert (sizetype,size_binop_loc (((location_t) 0), MULT_EXPR, fold_convert_loc
(((location_t) 0), sizetype_tab[(int) stk_sizetype], size_binop_loc
(((location_t) 0), FLOOR_DIV_EXPR, pos, toff_align)), size_int_kind
(off_align / (8), stk_sizetype))
954 size_binop (FLOOR_DIV_EXPR, pos,size_binop_loc (((location_t) 0), MULT_EXPR, fold_convert_loc
(((location_t) 0), sizetype_tab[(int) stk_sizetype], size_binop_loc
(((location_t) 0), FLOOR_DIV_EXPR, pos, toff_align)), size_int_kind
(off_align / (8), stk_sizetype))
955 toff_align)),size_binop_loc (((location_t) 0), MULT_EXPR, fold_convert_loc
(((location_t) 0), sizetype_tab[(int) stk_sizetype], size_binop_loc
(((location_t) 0), FLOOR_DIV_EXPR, pos, toff_align)), size_int_kind
(off_align / (8), stk_sizetype))
956 size_int (off_align / BITS_PER_UNIT))size_binop_loc (((location_t) 0), MULT_EXPR, fold_convert_loc
(((location_t) 0), sizetype_tab[(int) stk_sizetype], size_binop_loc
(((location_t) 0), FLOOR_DIV_EXPR, pos, toff_align)), size_int_kind
(off_align / (8), stk_sizetype))
;
957 *pbitpos = size_binop (FLOOR_MOD_EXPR, pos, toff_align)size_binop_loc (((location_t) 0), FLOOR_MOD_EXPR, pos, toff_align
)
;
958 }
959}
960
961/* Given a pointer to bit and byte offsets and an offset alignment,
962 normalize the offsets so they are within the alignment. */
963
964void
965normalize_offset (tree *poffset, tree *pbitpos, unsigned int off_align)
966{
967 /* If the bit position is now larger than it should be, adjust it
968 downwards. */
969 if (compare_tree_int (*pbitpos, off_align) >= 0)
970 {
971 tree offset, bitpos;
972 pos_from_bit (&offset, &bitpos, off_align, *pbitpos);
973 *poffset = size_binop (PLUS_EXPR, *poffset, offset)size_binop_loc (((location_t) 0), PLUS_EXPR, *poffset, offset
)
;
974 *pbitpos = bitpos;
975 }
976}
977
978/* Print debugging information about the information in RLI. */
979
980DEBUG_FUNCTION__attribute__ ((__used__)) void
981debug_rli (record_layout_info rli)
982{
983 print_node_brief (stderrstderr, "type", rli->t, 0);
984 print_node_brief (stderrstderr, "\noffset", rli->offset, 0);
985 print_node_brief (stderrstderr, " bitpos", rli->bitpos, 0);
986
987 fprintf (stderrstderr, "\naligns: rec = %u, unpack = %u, off = %u\n",
988 rli->record_align, rli->unpacked_align,
989 rli->offset_align);
990
991 /* The ms_struct code is the only that uses this. */
992 if (targetm.ms_bitfield_layout_p (rli->t))
993 fprintf (stderrstderr, "remaining in alignment = %u\n", rli->remaining_in_alignment);
994
995 if (rli->packed_maybe_necessary)
996 fprintf (stderrstderr, "packed may be necessary\n");
997
998 if (!vec_safe_is_empty (rli->pending_statics))
999 {
1000 fprintf (stderrstderr, "pending statics:\n");
1001 debug (rli->pending_statics);
1002 }
1003}
1004
1005/* Given an RLI with a possibly-incremented BITPOS, adjust OFFSET and
1006 BITPOS if necessary to keep BITPOS below OFFSET_ALIGN. */
1007
1008void
1009normalize_rli (record_layout_info rli)
1010{
1011 normalize_offset (&rli->offset, &rli->bitpos, rli->offset_align);
1012}
1013
1014/* Returns the size in bytes allocated so far. */
1015
1016tree
1017rli_size_unit_so_far (record_layout_info rli)
1018{
1019 return byte_from_pos (rli->offset, rli->bitpos);
1020}
1021
1022/* Returns the size in bits allocated so far. */
1023
1024tree
1025rli_size_so_far (record_layout_info rli)
1026{
1027 return bit_from_pos (rli->offset, rli->bitpos);
1028}
1029
1030/* FIELD is about to be added to RLI->T. The alignment (in bits) of
1031 the next available location within the record is given by KNOWN_ALIGN.
1032 Update the variable alignment fields in RLI, and return the alignment
1033 to give the FIELD. */
1034
1035unsigned int
1036update_alignment_for_field (record_layout_info rli, tree field,
1037 unsigned int known_align)
1038{
1039 /* The alignment required for FIELD. */
1040 unsigned int desired_align;
1041 /* The type of this field. */
1042 tree type = TREE_TYPE (field)((contains_struct_check ((field), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1042, __FUNCTION__))->typed.type)
;
1043 /* True if the field was explicitly aligned by the user. */
1044 bool user_align;
1045 bool is_bitfield;
1046
1047 /* Do not attempt to align an ERROR_MARK node */
1048 if (TREE_CODE (type)((enum tree_code) (type)->base.code) == ERROR_MARK)
1049 return 0;
1050
1051 /* Lay out the field so we know what alignment it needs. */
1052 layout_decl (field, known_align);
1053 desired_align = DECL_ALIGN (field)(((contains_struct_check ((field), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1053, __FUNCTION__))->decl_common.align) ? ((unsigned)1)
<< (((contains_struct_check ((field), (TS_DECL_COMMON)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1053, __FUNCTION__))->decl_common.align) - 1) : 0)
;
1054 user_align = DECL_USER_ALIGN (field)((contains_struct_check ((field), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1054, __FUNCTION__))->base.u.bits.user_align)
;
1055
1056 is_bitfield = (type != error_mark_nodeglobal_trees[TI_ERROR_MARK]
1057 && DECL_BIT_FIELD_TYPE (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1057, __FUNCTION__, (FIELD_DECL)))->field_decl.bit_field_type
)
1058 && ! integer_zerop (TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1058, __FUNCTION__))->type_common.size)
));
1059
1060 /* Record must have at least as much alignment as any field.
1061 Otherwise, the alignment of the field within the record is
1062 meaningless. */
1063 if (targetm.ms_bitfield_layout_p (rli->t))
1064 {
1065 /* Here, the alignment of the underlying type of a bitfield can
1066 affect the alignment of a record; even a zero-sized field
1067 can do this. The alignment should be to the alignment of
1068 the type, except that for zero-size bitfields this only
1069 applies if there was an immediately prior, nonzero-size
1070 bitfield. (That's the way it is, experimentally.) */
1071 if (!is_bitfield
1072 || ((DECL_SIZE (field)((contains_struct_check ((field), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1072, __FUNCTION__))->decl_common.size)
== NULL_TREE(tree) nullptr
1073 || !integer_zerop (DECL_SIZE (field)((contains_struct_check ((field), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1073, __FUNCTION__))->decl_common.size)
))
1074 ? !DECL_PACKED (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1074, __FUNCTION__, (FIELD_DECL)))->base.u.bits.packed_flag
)
1075 : (rli->prev_field
1076 && DECL_BIT_FIELD_TYPE (rli->prev_field)((tree_check ((rli->prev_field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1076, __FUNCTION__, (FIELD_DECL)))->field_decl.bit_field_type
)
1077 && ! integer_zerop (DECL_SIZE (rli->prev_field)((contains_struct_check ((rli->prev_field), (TS_DECL_COMMON
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1077, __FUNCTION__))->decl_common.size)
))))
1078 {
1079 unsigned int type_align = TYPE_ALIGN (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1079, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((type)->type_common.align - 1) : 0)
;
1080 if (!is_bitfield && DECL_PACKED (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1080, __FUNCTION__, (FIELD_DECL)))->base.u.bits.packed_flag
)
)
1081 type_align = desired_align;
1082 else
1083 type_align = MAX (type_align, desired_align)((type_align) > (desired_align) ? (type_align) : (desired_align
))
;
1084 if (maximum_field_alignment != 0)
1085 type_align = MIN (type_align, maximum_field_alignment)((type_align) < (maximum_field_alignment) ? (type_align) :
(maximum_field_alignment))
;
1086 rli->record_align = MAX (rli->record_align, type_align)((rli->record_align) > (type_align) ? (rli->record_align
) : (type_align))
;
1087 rli->unpacked_align = MAX (rli->unpacked_align, TYPE_ALIGN (type))((rli->unpacked_align) > (((tree_class_check ((type), (
tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1087, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((type)->type_common.align - 1) : 0)) ? (rli->unpacked_align
) : (((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1087, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((type)->type_common.align - 1) : 0)))
;
1088 }
1089 }
1090 else if (is_bitfield && PCC_BITFIELD_TYPE_MATTERS1)
1091 {
1092 /* Named bit-fields cause the entire structure to have the
1093 alignment implied by their type. Some targets also apply the same
1094 rules to unnamed bitfields. */
1095 if (DECL_NAME (field)((contains_struct_check ((field), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1095, __FUNCTION__))->decl_minimal.name)
!= 0
1096 || targetm.align_anon_bitfield ())
1097 {
1098 unsigned int type_align = TYPE_ALIGN (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1098, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((type)->type_common.align - 1) : 0)
;
1099
1100#ifdef ADJUST_FIELD_ALIGN
1101 if (! TYPE_USER_ALIGN (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1101, __FUNCTION__))->base.u.bits.user_align)
)
1102 type_align = ADJUST_FIELD_ALIGN (field, type, type_align)x86_field_alignment ((type), (type_align));
1103#endif
1104
1105 /* Targets might chose to handle unnamed and hence possibly
1106 zero-width bitfield. Those are not influenced by #pragmas
1107 or packed attributes. */
1108 if (integer_zerop (DECL_SIZE (field)((contains_struct_check ((field), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1108, __FUNCTION__))->decl_common.size)
))
1109 {
1110 if (initial_max_fld_alignglobal_options.x_initial_max_fld_align)
1111 type_align = MIN (type_align,((type_align) < (global_options.x_initial_max_fld_align * (
8)) ? (type_align) : (global_options.x_initial_max_fld_align *
(8)))
1112 initial_max_fld_align * BITS_PER_UNIT)((type_align) < (global_options.x_initial_max_fld_align * (
8)) ? (type_align) : (global_options.x_initial_max_fld_align *
(8)))
;
1113 }
1114 else if (maximum_field_alignment != 0)
1115 type_align = MIN (type_align, maximum_field_alignment)((type_align) < (maximum_field_alignment) ? (type_align) :
(maximum_field_alignment))
;
1116 else if (DECL_PACKED (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1116, __FUNCTION__, (FIELD_DECL)))->base.u.bits.packed_flag
)
)
1117 type_align = MIN (type_align, BITS_PER_UNIT)((type_align) < ((8)) ? (type_align) : ((8)));
1118
1119 /* The alignment of the record is increased to the maximum
1120 of the current alignment, the alignment indicated on the
1121 field (i.e., the alignment specified by an __aligned__
1122 attribute), and the alignment indicated by the type of
1123 the field. */
1124 rli->record_align = MAX (rli->record_align, desired_align)((rli->record_align) > (desired_align) ? (rli->record_align
) : (desired_align))
;
1125 rli->record_align = MAX (rli->record_align, type_align)((rli->record_align) > (type_align) ? (rli->record_align
) : (type_align))
;
1126
1127 if (warn_packedglobal_options.x_warn_packed)
1128 rli->unpacked_align = MAX (rli->unpacked_align, TYPE_ALIGN (type))((rli->unpacked_align) > (((tree_class_check ((type), (
tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1128, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((type)->type_common.align - 1) : 0)) ? (rli->unpacked_align
) : (((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1128, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((type)->type_common.align - 1) : 0)))
;
1129 user_align |= TYPE_USER_ALIGN (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1129, __FUNCTION__))->base.u.bits.user_align)
;
1130 }
1131 }
1132 else
1133 {
1134 rli->record_align = MAX (rli->record_align, desired_align)((rli->record_align) > (desired_align) ? (rli->record_align
) : (desired_align))
;
1135 rli->unpacked_align = MAX (rli->unpacked_align, TYPE_ALIGN (type))((rli->unpacked_align) > (((tree_class_check ((type), (
tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1135, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((type)->type_common.align - 1) : 0)) ? (rli->unpacked_align
) : (((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1135, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((type)->type_common.align - 1) : 0)))
;
1136 }
1137
1138 TYPE_USER_ALIGN (rli->t)((tree_class_check ((rli->t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1138, __FUNCTION__))->base.u.bits.user_align)
|= user_align;
1139
1140 return desired_align;
1141}
1142
1143/* Issue a warning if the record alignment, RECORD_ALIGN, is less than
1144 the field alignment of FIELD or FIELD isn't aligned. */
1145
1146static void
1147handle_warn_if_not_align (tree field, unsigned int record_align)
1148{
1149 tree type = TREE_TYPE (field)((contains_struct_check ((field), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1149, __FUNCTION__))->typed.type)
;
1150
1151 if (type == error_mark_nodeglobal_trees[TI_ERROR_MARK])
1152 return;
1153
1154 unsigned int warn_if_not_align = 0;
1155
1156 int opt_w = 0;
1157
1158 if (warn_if_not_alignedglobal_options.x_warn_if_not_aligned)
1159 {
1160 warn_if_not_align = DECL_WARN_IF_NOT_ALIGN (field)(((contains_struct_check ((field), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1160, __FUNCTION__))->decl_common.warn_if_not_align) ? (
(unsigned)1) << (((contains_struct_check ((field), (TS_DECL_COMMON
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1160, __FUNCTION__))->decl_common.warn_if_not_align) - 1
) : 0)
;
1161 if (!warn_if_not_align)
1162 warn_if_not_align = TYPE_WARN_IF_NOT_ALIGN (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1162, __FUNCTION__))->type_common.warn_if_not_align ? ((
unsigned)1) << ((type)->type_common.warn_if_not_align
- 1) : 0)
;
1163 if (warn_if_not_align)
1164 opt_w = OPT_Wif_not_aligned;
1165 }
1166
1167 if (!warn_if_not_align
1168 && warn_packed_not_alignedglobal_options.x_warn_packed_not_aligned
1169 && lookup_attribute ("aligned", TYPE_ATTRIBUTES (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1169, __FUNCTION__))->type_common.attributes)
))
1170 {
1171 warn_if_not_align = TYPE_ALIGN (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1171, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((type)->type_common.align - 1) : 0)
;
1172 opt_w = OPT_Wpacked_not_aligned;
1173 }
1174
1175 if (!warn_if_not_align)
1176 return;
1177
1178 tree context = DECL_CONTEXT (field)((contains_struct_check ((field), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1178, __FUNCTION__))->decl_minimal.context)
;
1179
1180 warn_if_not_align /= BITS_PER_UNIT(8);
1181 record_align /= BITS_PER_UNIT(8);
1182 if ((record_align % warn_if_not_align) != 0)
1183 warning (opt_w, "alignment %u of %qT is less than %u",
1184 record_align, context, warn_if_not_align);
1185
1186 tree off = byte_position (field);
1187 if (!multiple_of_p (TREE_TYPE (off)((contains_struct_check ((off), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1187, __FUNCTION__))->typed.type)
, off, size_int (warn_if_not_align)size_int_kind (warn_if_not_align, stk_sizetype)))
1188 {
1189 if (TREE_CODE (off)((enum tree_code) (off)->base.code) == INTEGER_CST)
1190 warning (opt_w, "%q+D offset %E in %qT isn%'t aligned to %u",
1191 field, off, context, warn_if_not_align);
1192 else
1193 warning (opt_w, "%q+D offset %E in %qT may not be aligned to %u",
1194 field, off, context, warn_if_not_align);
1195 }
1196}
1197
1198/* Called from place_field to handle unions. */
1199
1200static void
1201place_union_field (record_layout_info rli, tree field)
1202{
1203 update_alignment_for_field (rli, field, /*known_align=*/0);
1204
1205 DECL_FIELD_OFFSET (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1205, __FUNCTION__, (FIELD_DECL)))->field_decl.offset)
= size_zero_nodeglobal_trees[TI_SIZE_ZERO];
1206 DECL_FIELD_BIT_OFFSET (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1206, __FUNCTION__, (FIELD_DECL)))->field_decl.bit_offset
)
= bitsize_zero_nodeglobal_trees[TI_BITSIZE_ZERO];
1207 SET_DECL_OFFSET_ALIGN (field, BIGGEST_ALIGNMENT)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1207, __FUNCTION__, (FIELD_DECL)))->decl_common.off_align
= ffs_hwi ((((global_options.x_target_flags & (1U <<
12)) != 0) ? 32 : (((global_options.x_ix86_isa_flags & (
1UL << 15)) != 0) ? 512 : (((global_options.x_ix86_isa_flags
& (1UL << 8)) != 0) ? 256 : 128)))) - 1)
;
1208 handle_warn_if_not_align (field, rli->record_align);
1209
1210 /* If this is an ERROR_MARK return *after* having set the
1211 field at the start of the union. This helps when parsing
1212 invalid fields. */
1213 if (TREE_CODE (TREE_TYPE (field))((enum tree_code) (((contains_struct_check ((field), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1213, __FUNCTION__))->typed.type))->base.code)
== ERROR_MARK)
1214 return;
1215
1216 if (AGGREGATE_TYPE_P (TREE_TYPE (field))(((enum tree_code) (((contains_struct_check ((field), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1216, __FUNCTION__))->typed.type))->base.code) == ARRAY_TYPE
|| (((enum tree_code) (((contains_struct_check ((field), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1216, __FUNCTION__))->typed.type))->base.code) == RECORD_TYPE
|| ((enum tree_code) (((contains_struct_check ((field), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1216, __FUNCTION__))->typed.type))->base.code) == UNION_TYPE
|| ((enum tree_code) (((contains_struct_check ((field), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1216, __FUNCTION__))->typed.type))->base.code) == QUAL_UNION_TYPE
))
1217 && TYPE_TYPELESS_STORAGE (TREE_TYPE (field))((tree_check4 ((((contains_struct_check ((field), (TS_TYPED),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1217, __FUNCTION__))->typed.type)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1217, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))->type_common.typeless_storage)
)
1218 TYPE_TYPELESS_STORAGE (rli->t)((tree_check4 ((rli->t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1218, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))->type_common.typeless_storage)
= 1;
1219
1220 /* We assume the union's size will be a multiple of a byte so we don't
1221 bother with BITPOS. */
1222 if (TREE_CODE (rli->t)((enum tree_code) (rli->t)->base.code) == UNION_TYPE)
1223 rli->offset = size_binop (MAX_EXPR, rli->offset, DECL_SIZE_UNIT (field))size_binop_loc (((location_t) 0), MAX_EXPR, rli->offset, (
(contains_struct_check ((field), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1223, __FUNCTION__))->decl_common.size_unit))
;
1224 else if (TREE_CODE (rli->t)((enum tree_code) (rli->t)->base.code) == QUAL_UNION_TYPE)
1225 rli->offset = fold_build3 (COND_EXPR, sizetype, DECL_QUALIFIER (field),fold_build3_loc (((location_t) 0), COND_EXPR, sizetype_tab[(int
) stk_sizetype], ((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1225, __FUNCTION__, (FIELD_DECL)))->field_decl.qualifier
), ((contains_struct_check ((field), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1226, __FUNCTION__))->decl_common.size_unit), rli->offset
)
1226 DECL_SIZE_UNIT (field), rli->offset)fold_build3_loc (((location_t) 0), COND_EXPR, sizetype_tab[(int
) stk_sizetype], ((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1225, __FUNCTION__, (FIELD_DECL)))->field_decl.qualifier
), ((contains_struct_check ((field), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1226, __FUNCTION__))->decl_common.size_unit), rli->offset
)
;
1227}
1228
1229/* A bitfield of SIZE with a required access alignment of ALIGN is allocated
1230 at BYTE_OFFSET / BIT_OFFSET. Return nonzero if the field would span more
1231 units of alignment than the underlying TYPE. */
1232static int
1233excess_unit_span (HOST_WIDE_INTlong byte_offset, HOST_WIDE_INTlong bit_offset,
1234 HOST_WIDE_INTlong size, HOST_WIDE_INTlong align, tree type)
1235{
1236 /* Note that the calculation of OFFSET might overflow; we calculate it so
1237 that we still get the right result as long as ALIGN is a power of two. */
1238 unsigned HOST_WIDE_INTlong offset = byte_offset * BITS_PER_UNIT(8) + bit_offset;
1239
1240 offset = offset % align;
58
Division by zero
1241 return ((offset + size + align - 1) / align
1242 > tree_to_uhwi (TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1242, __FUNCTION__))->type_common.size)
) / align);
1243}
1244
1245/* RLI contains information about the layout of a RECORD_TYPE. FIELD
1246 is a FIELD_DECL to be added after those fields already present in
1247 T. (FIELD is not actually added to the TYPE_FIELDS list here;
1248 callers that desire that behavior must manually perform that step.) */
1249
1250void
1251place_field (record_layout_info rli, tree field)
1252{
1253 /* The alignment required for FIELD. */
1254 unsigned int desired_align;
1255 /* The alignment FIELD would have if we just dropped it into the
1256 record as it presently stands. */
1257 unsigned int known_align;
1258 unsigned int actual_align;
1259 /* The type of this field. */
1260 tree type = TREE_TYPE (field)((contains_struct_check ((field), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1260, __FUNCTION__))->typed.type)
;
1
Calling 'contains_struct_check'
6
Returning from 'contains_struct_check'
1261
1262 gcc_assert (TREE_CODE (field) != ERROR_MARK)((void)(!(((enum tree_code) (field)->base.code) != ERROR_MARK
) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1262, __FUNCTION__), 0 : 0))
;
7
Assuming field 'code' is not equal to ERROR_MARK
8
'?' condition is false
1263
1264 /* If FIELD is static, then treat it like a separate variable, not
1265 really like a structure field. If it is a FUNCTION_DECL, it's a
1266 method. In both cases, all we do is lay out the decl, and we do
1267 it *after* the record is laid out. */
1268 if (VAR_P (field)(((enum tree_code) (field)->base.code) == VAR_DECL))
9
Assuming field 'code' is not equal to VAR_DECL
10
Taking false branch
1269 {
1270 vec_safe_push (rli->pending_statics, field);
1271 return;
1272 }
1273
1274 /* Enumerators and enum types which are local to this class need not
1275 be laid out. Likewise for initialized constant fields. */
1276 else if (TREE_CODE (field)((enum tree_code) (field)->base.code) != FIELD_DECL)
11
Assuming field 'code' is equal to FIELD_DECL
12
Taking false branch
1277 return;
1278
1279 /* Unions are laid out very differently than records, so split
1280 that code off to another function. */
1281 else if (TREE_CODE (rli->t)((enum tree_code) (rli->t)->base.code) != RECORD_TYPE)
13
Assuming field 'code' is equal to RECORD_TYPE
14
Taking false branch
1282 {
1283 place_union_field (rli, field);
1284 return;
1285 }
1286
1287 else if (TREE_CODE (type)((enum tree_code) (type)->base.code) == ERROR_MARK)
15
Assuming field 'code' is not equal to ERROR_MARK
16
Taking false branch
1288 {
1289 /* Place this field at the current allocation position, so we
1290 maintain monotonicity. */
1291 DECL_FIELD_OFFSET (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1291, __FUNCTION__, (FIELD_DECL)))->field_decl.offset)
= rli->offset;
1292 DECL_FIELD_BIT_OFFSET (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1292, __FUNCTION__, (FIELD_DECL)))->field_decl.bit_offset
)
= rli->bitpos;
1293 SET_DECL_OFFSET_ALIGN (field, rli->offset_align)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1293, __FUNCTION__, (FIELD_DECL)))->decl_common.off_align
= ffs_hwi (rli->offset_align) - 1)
;
1294 handle_warn_if_not_align (field, rli->record_align);
1295 return;
1296 }
1297
1298 if (AGGREGATE_TYPE_P (type)(((enum tree_code) (type)->base.code) == ARRAY_TYPE || (((
enum tree_code) (type)->base.code) == RECORD_TYPE || ((enum
tree_code) (type)->base.code) == UNION_TYPE || ((enum tree_code
) (type)->base.code) == QUAL_UNION_TYPE))
17
Assuming field 'code' is not equal to ARRAY_TYPE
18
Assuming field 'code' is not equal to RECORD_TYPE
19
Assuming field 'code' is not equal to UNION_TYPE
20
Assuming field 'code' is not equal to QUAL_UNION_TYPE
1299 && TYPE_TYPELESS_STORAGE (type)((tree_check4 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1299, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))->type_common.typeless_storage)
)
1300 TYPE_TYPELESS_STORAGE (rli->t)((tree_check4 ((rli->t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1300, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))->type_common.typeless_storage)
= 1;
1301
1302 /* Work out the known alignment so far. Note that A & (-A) is the
1303 value of the least-significant bit in A that is one. */
1304 if (! integer_zerop (rli->bitpos))
21
Assuming the condition is false
22
Taking false branch
1305 known_align = least_bit_hwi (tree_to_uhwi (rli->bitpos));
1306 else if (integer_zerop (rli->offset))
23
Assuming the condition is false
24
Taking false branch
1307 known_align = 0;
1308 else if (tree_fits_uhwi_p (rli->offset))
25
Assuming the condition is false
26
Taking false branch
1309 known_align = (BITS_PER_UNIT(8)
1310 * least_bit_hwi (tree_to_uhwi (rli->offset)));
1311 else
1312 known_align = rli->offset_align;
1313
1314 desired_align = update_alignment_for_field (rli, field, known_align);
1315 if (known_align == 0)
27
Assuming 'known_align' is not equal to 0
28
Taking false branch
1316 known_align = MAX (BIGGEST_ALIGNMENT, rli->record_align)(((((global_options.x_target_flags & (1U << 12)) !=
0) ? 32 : (((global_options.x_ix86_isa_flags & (1UL <<
15)) != 0) ? 512 : (((global_options.x_ix86_isa_flags & (
1UL << 8)) != 0) ? 256 : 128)))) > (rli->record_align
) ? ((((global_options.x_target_flags & (1U << 12))
!= 0) ? 32 : (((global_options.x_ix86_isa_flags & (1UL <<
15)) != 0) ? 512 : (((global_options.x_ix86_isa_flags & (
1UL << 8)) != 0) ? 256 : 128)))) : (rli->record_align
))
;
1317
1318 if (warn_packedglobal_options.x_warn_packed && DECL_PACKED (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1318, __FUNCTION__, (FIELD_DECL)))->base.u.bits.packed_flag
)
)
29
Assuming field 'x_warn_packed' is 0
1319 {
1320 if (known_align >= TYPE_ALIGN (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1320, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((type)->type_common.align - 1) : 0)
)
1321 {
1322 if (TYPE_ALIGN (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1322, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((type)->type_common.align - 1) : 0)
> desired_align)
1323 {
1324 if (STRICT_ALIGNMENT0)
1325 warning (OPT_Wattributes, "packed attribute causes "
1326 "inefficient alignment for %q+D", field);
1327 /* Don't warn if DECL_PACKED was set by the type. */
1328 else if (!TYPE_PACKED (rli->t)((tree_class_check ((rli->t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1328, __FUNCTION__))->base.u.bits.packed_flag)
)
1329 warning (OPT_Wattributes, "packed attribute is "
1330 "unnecessary for %q+D", field);
1331 }
1332 }
1333 else
1334 rli->packed_maybe_necessary = 1;
1335 }
1336
1337 /* Does this field automatically have alignment it needs by virtue
1338 of the fields that precede it and the record's own alignment? */
1339 if (known_align < desired_align
30
Assuming 'known_align' is >= 'desired_align'
1340 && (! targetm.ms_bitfield_layout_p (rli->t)
1341 || rli->prev_field == NULLnullptr))
1342 {
1343 /* No, we need to skip space before this field.
1344 Bump the cumulative size to multiple of field alignment. */
1345
1346 if (!targetm.ms_bitfield_layout_p (rli->t)
1347 && DECL_SOURCE_LOCATION (field)((contains_struct_check ((field), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1347, __FUNCTION__))->decl_minimal.locus)
!= BUILTINS_LOCATION((location_t) 1)
1348 && !TYPE_ARTIFICIAL (rli->t)((tree_class_check ((rli->t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1348, __FUNCTION__))->base.nowarning_flag)
)
1349 warning (OPT_Wpadded, "padding struct to align %q+D", field);
1350
1351 /* If the alignment is still within offset_align, just align
1352 the bit position. */
1353 if (desired_align < rli->offset_align)
1354 rli->bitpos = round_up (rli->bitpos, desired_align)round_up_loc (((location_t) 0), rli->bitpos, desired_align
)
;
1355 else
1356 {
1357 /* First adjust OFFSET by the partial bits, then align. */
1358 rli->offset
1359 = size_binop (PLUS_EXPR, rli->offset,size_binop_loc (((location_t) 0), PLUS_EXPR, rli->offset, fold_convert_loc
(((location_t) 0), sizetype_tab[(int) stk_sizetype], size_binop_loc
(((location_t) 0), CEIL_DIV_EXPR, rli->bitpos, global_trees
[TI_BITSIZE_UNIT])))
1360 fold_convert (sizetype,size_binop_loc (((location_t) 0), PLUS_EXPR, rli->offset, fold_convert_loc
(((location_t) 0), sizetype_tab[(int) stk_sizetype], size_binop_loc
(((location_t) 0), CEIL_DIV_EXPR, rli->bitpos, global_trees
[TI_BITSIZE_UNIT])))
1361 size_binop (CEIL_DIV_EXPR, rli->bitpos,size_binop_loc (((location_t) 0), PLUS_EXPR, rli->offset, fold_convert_loc
(((location_t) 0), sizetype_tab[(int) stk_sizetype], size_binop_loc
(((location_t) 0), CEIL_DIV_EXPR, rli->bitpos, global_trees
[TI_BITSIZE_UNIT])))
1362 bitsize_unit_node)))size_binop_loc (((location_t) 0), PLUS_EXPR, rli->offset, fold_convert_loc
(((location_t) 0), sizetype_tab[(int) stk_sizetype], size_binop_loc
(((location_t) 0), CEIL_DIV_EXPR, rli->bitpos, global_trees
[TI_BITSIZE_UNIT])))
;
1363 rli->bitpos = bitsize_zero_nodeglobal_trees[TI_BITSIZE_ZERO];
1364
1365 rli->offset = round_up (rli->offset, desired_align / BITS_PER_UNIT)round_up_loc (((location_t) 0), rli->offset, desired_align
/ (8))
;
1366 }
1367
1368 if (! TREE_CONSTANT (rli->offset)((non_type_check ((rli->offset), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1368, __FUNCTION__))->base.constant_flag)
)
1369 rli->offset_align = desired_align;
1370 }
1371
1372 /* Handle compatibility with PCC. Note that if the record has any
1373 variable-sized fields, we need not worry about compatibility. */
1374 if (PCC_BITFIELD_TYPE_MATTERS1
50
Taking true branch
1375 && ! targetm.ms_bitfield_layout_p (rli->t)
31
Assuming the condition is true
1376 && TREE_CODE (field)((enum tree_code) (field)->base.code) == FIELD_DECL
32
Assuming field 'code' is equal to FIELD_DECL
1377 && type != error_mark_nodeglobal_trees[TI_ERROR_MARK]
33
Assuming the condition is true
1378 && DECL_BIT_FIELD (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1378, __FUNCTION__, (FIELD_DECL)))->decl_common.decl_flag_1
)
34
Calling 'tree_check'
38
Returning from 'tree_check'
39
Assuming field 'decl_flag_1' is not equal to 0
1379 && (! DECL_PACKED (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1379, __FUNCTION__, (FIELD_DECL)))->base.u.bits.packed_flag
)
40
Calling 'tree_check'
43
Returning from 'tree_check'
44
Assuming field 'packed_flag' is 0
1380 /* Enter for these packed fields only to issue a warning. */
1381 || TYPE_ALIGN (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1381, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((type)->type_common.align - 1) : 0)
<= BITS_PER_UNIT(8))
1382 && maximum_field_alignment == 0
45
Assuming 'maximum_field_alignment' is equal to 0
1383 && ! integer_zerop (DECL_SIZE (field)((contains_struct_check ((field), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1383, __FUNCTION__))->decl_common.size)
)
46
Assuming the condition is true
1384 && tree_fits_uhwi_p (DECL_SIZE (field)((contains_struct_check ((field), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1384, __FUNCTION__))->decl_common.size)
)
47
Assuming the condition is true
1385 && tree_fits_uhwi_p (rli->offset)
48
Assuming the condition is true
1386 && tree_fits_uhwi_p (TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1386, __FUNCTION__))->type_common.size)
)
)
49
Assuming the condition is true
1387 {
1388 unsigned int type_align = TYPE_ALIGN (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1388, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((type)->type_common.align - 1) : 0)
;
51
Assuming field 'align' is 0
52
'?' condition is false
53
'type_align' initialized to 0
1389 tree dsize = DECL_SIZE (field)((contains_struct_check ((field), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1389, __FUNCTION__))->decl_common.size)
;
1390 HOST_WIDE_INTlong field_size = tree_to_uhwi (dsize);
1391 HOST_WIDE_INTlong offset = tree_to_uhwi (rli->offset);
1392 HOST_WIDE_INTlong bit_offset = tree_to_shwi (rli->bitpos);
1393
1394#ifdef ADJUST_FIELD_ALIGN
1395 if (! TYPE_USER_ALIGN (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1395, __FUNCTION__))->base.u.bits.user_align)
)
54
Assuming field 'user_align' is not equal to 0
55
Taking false branch
1396 type_align = ADJUST_FIELD_ALIGN (field, type, type_align)x86_field_alignment ((type), (type_align));
1397#endif
1398
1399 /* A bit field may not span more units of alignment of its type
1400 than its type itself. Advance to next boundary if necessary. */
1401 if (excess_unit_span (offset, bit_offset, field_size, type_align, type))
56
Passing the value 0 via 4th parameter 'align'
57
Calling 'excess_unit_span'
1402 {
1403 if (DECL_PACKED (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1403, __FUNCTION__, (FIELD_DECL)))->base.u.bits.packed_flag
)
)
1404 {
1405 if (warn_packed_bitfield_compatglobal_options.x_warn_packed_bitfield_compat == 1)
1406 inform
1407 (input_location,
1408 "offset of packed bit-field %qD has changed in GCC 4.4",
1409 field);
1410 }
1411 else
1412 rli->bitpos = round_up (rli->bitpos, type_align)round_up_loc (((location_t) 0), rli->bitpos, type_align);
1413 }
1414
1415 if (! DECL_PACKED (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1415, __FUNCTION__, (FIELD_DECL)))->base.u.bits.packed_flag
)
)
1416 TYPE_USER_ALIGN (rli->t)((tree_class_check ((rli->t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1416, __FUNCTION__))->base.u.bits.user_align)
|= TYPE_USER_ALIGN (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1416, __FUNCTION__))->base.u.bits.user_align)
;
1417
1418 SET_TYPE_WARN_IF_NOT_ALIGN (rli->t,((tree_class_check ((rli->t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1419, __FUNCTION__))->type_common.warn_if_not_align = ffs_hwi
(((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1419, __FUNCTION__))->type_common.warn_if_not_align ? ((
unsigned)1) << ((type)->type_common.warn_if_not_align
- 1) : 0)))
1419 TYPE_WARN_IF_NOT_ALIGN (type))((tree_class_check ((rli->t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1419, __FUNCTION__))->type_common.warn_if_not_align = ffs_hwi
(((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1419, __FUNCTION__))->type_common.warn_if_not_align ? ((
unsigned)1) << ((type)->type_common.warn_if_not_align
- 1) : 0)))
;
1420 }
1421
1422#ifdef BITFIELD_NBYTES_LIMITED
1423 if (BITFIELD_NBYTES_LIMITED
1424 && ! targetm.ms_bitfield_layout_p (rli->t)
1425 && TREE_CODE (field)((enum tree_code) (field)->base.code) == FIELD_DECL
1426 && type != error_mark_nodeglobal_trees[TI_ERROR_MARK]
1427 && DECL_BIT_FIELD_TYPE (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1427, __FUNCTION__, (FIELD_DECL)))->field_decl.bit_field_type
)
1428 && ! DECL_PACKED (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1428, __FUNCTION__, (FIELD_DECL)))->base.u.bits.packed_flag
)
1429 && ! integer_zerop (DECL_SIZE (field)((contains_struct_check ((field), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1429, __FUNCTION__))->decl_common.size)
)
1430 && tree_fits_uhwi_p (DECL_SIZE (field)((contains_struct_check ((field), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1430, __FUNCTION__))->decl_common.size)
)
1431 && tree_fits_uhwi_p (rli->offset)
1432 && tree_fits_uhwi_p (TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1432, __FUNCTION__))->type_common.size)
))
1433 {
1434 unsigned int type_align = TYPE_ALIGN (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1434, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((type)->type_common.align - 1) : 0)
;
1435 tree dsize = DECL_SIZE (field)((contains_struct_check ((field), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1435, __FUNCTION__))->decl_common.size)
;
1436 HOST_WIDE_INTlong field_size = tree_to_uhwi (dsize);
1437 HOST_WIDE_INTlong offset = tree_to_uhwi (rli->offset);
1438 HOST_WIDE_INTlong bit_offset = tree_to_shwi (rli->bitpos);
1439
1440#ifdef ADJUST_FIELD_ALIGN
1441 if (! TYPE_USER_ALIGN (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1441, __FUNCTION__))->base.u.bits.user_align)
)
1442 type_align = ADJUST_FIELD_ALIGN (field, type, type_align)x86_field_alignment ((type), (type_align));
1443#endif
1444
1445 if (maximum_field_alignment != 0)
1446 type_align = MIN (type_align, maximum_field_alignment)((type_align) < (maximum_field_alignment) ? (type_align) :
(maximum_field_alignment))
;
1447 /* ??? This test is opposite the test in the containing if
1448 statement, so this code is unreachable currently. */
1449 else if (DECL_PACKED (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1449, __FUNCTION__, (FIELD_DECL)))->base.u.bits.packed_flag
)
)
1450 type_align = MIN (type_align, BITS_PER_UNIT)((type_align) < ((8)) ? (type_align) : ((8)));
1451
1452 /* A bit field may not span the unit of alignment of its type.
1453 Advance to next boundary if necessary. */
1454 if (excess_unit_span (offset, bit_offset, field_size, type_align, type))
1455 rli->bitpos = round_up (rli->bitpos, type_align)round_up_loc (((location_t) 0), rli->bitpos, type_align);
1456
1457 TYPE_USER_ALIGN (rli->t)((tree_class_check ((rli->t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1457, __FUNCTION__))->base.u.bits.user_align)
|= TYPE_USER_ALIGN (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1457, __FUNCTION__))->base.u.bits.user_align)
;
1458 SET_TYPE_WARN_IF_NOT_ALIGN (rli->t,((tree_class_check ((rli->t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1459, __FUNCTION__))->type_common.warn_if_not_align = ffs_hwi
(((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1459, __FUNCTION__))->type_common.warn_if_not_align ? ((
unsigned)1) << ((type)->type_common.warn_if_not_align
- 1) : 0)))
1459 TYPE_WARN_IF_NOT_ALIGN (type))((tree_class_check ((rli->t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1459, __FUNCTION__))->type_common.warn_if_not_align = ffs_hwi
(((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1459, __FUNCTION__))->type_common.warn_if_not_align ? ((
unsigned)1) << ((type)->type_common.warn_if_not_align
- 1) : 0)))
;
1460 }
1461#endif
1462
1463 /* See the docs for TARGET_MS_BITFIELD_LAYOUT_P for details.
1464 A subtlety:
1465 When a bit field is inserted into a packed record, the whole
1466 size of the underlying type is used by one or more same-size
1467 adjacent bitfields. (That is, if its long:3, 32 bits is
1468 used in the record, and any additional adjacent long bitfields are
1469 packed into the same chunk of 32 bits. However, if the size
1470 changes, a new field of that size is allocated.) In an unpacked
1471 record, this is the same as using alignment, but not equivalent
1472 when packing.
1473
1474 Note: for compatibility, we use the type size, not the type alignment
1475 to determine alignment, since that matches the documentation */
1476
1477 if (targetm.ms_bitfield_layout_p (rli->t))
1478 {
1479 tree prev_saved = rli->prev_field;
1480 tree prev_type = prev_saved ? DECL_BIT_FIELD_TYPE (prev_saved)((tree_check ((prev_saved), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1480, __FUNCTION__, (FIELD_DECL)))->field_decl.bit_field_type
)
: NULLnullptr;
1481
1482 /* This is a bitfield if it exists. */
1483 if (rli->prev_field)
1484 {
1485 bool realign_p = known_align < desired_align;
1486
1487 /* If both are bitfields, nonzero, and the same size, this is
1488 the middle of a run. Zero declared size fields are special
1489 and handled as "end of run". (Note: it's nonzero declared
1490 size, but equal type sizes!) (Since we know that both
1491 the current and previous fields are bitfields by the
1492 time we check it, DECL_SIZE must be present for both.) */
1493 if (DECL_BIT_FIELD_TYPE (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1493, __FUNCTION__, (FIELD_DECL)))->field_decl.bit_field_type
)
1494 && !integer_zerop (DECL_SIZE (field)((contains_struct_check ((field), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1494, __FUNCTION__))->decl_common.size)
)
1495 && !integer_zerop (DECL_SIZE (rli->prev_field)((contains_struct_check ((rli->prev_field), (TS_DECL_COMMON
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1495, __FUNCTION__))->decl_common.size)
)
1496 && tree_fits_shwi_p (DECL_SIZE (rli->prev_field)((contains_struct_check ((rli->prev_field), (TS_DECL_COMMON
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1496, __FUNCTION__))->decl_common.size)
)
1497 && tree_fits_uhwi_p (TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1497, __FUNCTION__))->type_common.size)
)
1498 && simple_cst_equal (TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1498, __FUNCTION__))->type_common.size)
, TYPE_SIZE (prev_type)((tree_class_check ((prev_type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1498, __FUNCTION__))->type_common.size)
))
1499 {
1500 /* We're in the middle of a run of equal type size fields; make
1501 sure we realign if we run out of bits. (Not decl size,
1502 type size!) */
1503 HOST_WIDE_INTlong bitsize = tree_to_uhwi (DECL_SIZE (field)((contains_struct_check ((field), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1503, __FUNCTION__))->decl_common.size)
);
1504
1505 if (rli->remaining_in_alignment < bitsize)
1506 {
1507 HOST_WIDE_INTlong typesize = tree_to_uhwi (TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1507, __FUNCTION__))->type_common.size)
);
1508
1509 /* out of bits; bump up to next 'word'. */
1510 rli->bitpos
1511 = size_binop (PLUS_EXPR, rli->bitpos,size_binop_loc (((location_t) 0), PLUS_EXPR, rli->bitpos, size_int_kind
(rli->remaining_in_alignment, stk_bitsizetype))
1512 bitsize_int (rli->remaining_in_alignment))size_binop_loc (((location_t) 0), PLUS_EXPR, rli->bitpos, size_int_kind
(rli->remaining_in_alignment, stk_bitsizetype))
;
1513 rli->prev_field = field;
1514 if (typesize < bitsize)
1515 rli->remaining_in_alignment = 0;
1516 else
1517 rli->remaining_in_alignment = typesize - bitsize;
1518 }
1519 else
1520 {
1521 rli->remaining_in_alignment -= bitsize;
1522 realign_p = false;
1523 }
1524 }
1525 else
1526 {
1527 /* End of a run: if leaving a run of bitfields of the same type
1528 size, we have to "use up" the rest of the bits of the type
1529 size.
1530
1531 Compute the new position as the sum of the size for the prior
1532 type and where we first started working on that type.
1533 Note: since the beginning of the field was aligned then
1534 of course the end will be too. No round needed. */
1535
1536 if (!integer_zerop (DECL_SIZE (rli->prev_field)((contains_struct_check ((rli->prev_field), (TS_DECL_COMMON
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1536, __FUNCTION__))->decl_common.size)
))
1537 {
1538 rli->bitpos
1539 = size_binop (PLUS_EXPR, rli->bitpos,size_binop_loc (((location_t) 0), PLUS_EXPR, rli->bitpos, size_int_kind
(rli->remaining_in_alignment, stk_bitsizetype))
1540 bitsize_int (rli->remaining_in_alignment))size_binop_loc (((location_t) 0), PLUS_EXPR, rli->bitpos, size_int_kind
(rli->remaining_in_alignment, stk_bitsizetype))
;
1541 }
1542 else
1543 /* We "use up" size zero fields; the code below should behave
1544 as if the prior field was not a bitfield. */
1545 prev_saved = NULLnullptr;
1546
1547 /* Cause a new bitfield to be captured, either this time (if
1548 currently a bitfield) or next time we see one. */
1549 if (!DECL_BIT_FIELD_TYPE (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1549, __FUNCTION__, (FIELD_DECL)))->field_decl.bit_field_type
)
1550 || integer_zerop (DECL_SIZE (field)((contains_struct_check ((field), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1550, __FUNCTION__))->decl_common.size)
))
1551 rli->prev_field = NULLnullptr;
1552 }
1553
1554 /* Does this field automatically have alignment it needs by virtue
1555 of the fields that precede it and the record's own alignment? */
1556 if (realign_p)
1557 {
1558 /* If the alignment is still within offset_align, just align
1559 the bit position. */
1560 if (desired_align < rli->offset_align)
1561 rli->bitpos = round_up (rli->bitpos, desired_align)round_up_loc (((location_t) 0), rli->bitpos, desired_align
)
;
1562 else
1563 {
1564 /* First adjust OFFSET by the partial bits, then align. */
1565 tree d = size_binop (CEIL_DIV_EXPR, rli->bitpos,size_binop_loc (((location_t) 0), CEIL_DIV_EXPR, rli->bitpos
, global_trees[TI_BITSIZE_UNIT])
1566 bitsize_unit_node)size_binop_loc (((location_t) 0), CEIL_DIV_EXPR, rli->bitpos
, global_trees[TI_BITSIZE_UNIT])
;
1567 rli->offset = size_binop (PLUS_EXPR, rli->offset,size_binop_loc (((location_t) 0), PLUS_EXPR, rli->offset, fold_convert_loc
(((location_t) 0), sizetype_tab[(int) stk_sizetype], d))
1568 fold_convert (sizetype, d))size_binop_loc (((location_t) 0), PLUS_EXPR, rli->offset, fold_convert_loc
(((location_t) 0), sizetype_tab[(int) stk_sizetype], d))
;
1569 rli->bitpos = bitsize_zero_nodeglobal_trees[TI_BITSIZE_ZERO];
1570
1571 rli->offset = round_up (rli->offset,round_up_loc (((location_t) 0), rli->offset, desired_align
/ (8))
1572 desired_align / BITS_PER_UNIT)round_up_loc (((location_t) 0), rli->offset, desired_align
/ (8))
;
1573 }
1574
1575 if (! TREE_CONSTANT (rli->offset)((non_type_check ((rli->offset), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1575, __FUNCTION__))->base.constant_flag)
)
1576 rli->offset_align = desired_align;
1577 }
1578
1579 normalize_rli (rli);
1580 }
1581
1582 /* If we're starting a new run of same type size bitfields
1583 (or a run of non-bitfields), set up the "first of the run"
1584 fields.
1585
1586 That is, if the current field is not a bitfield, or if there
1587 was a prior bitfield the type sizes differ, or if there wasn't
1588 a prior bitfield the size of the current field is nonzero.
1589
1590 Note: we must be sure to test ONLY the type size if there was
1591 a prior bitfield and ONLY for the current field being zero if
1592 there wasn't. */
1593
1594 if (!DECL_BIT_FIELD_TYPE (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1594, __FUNCTION__, (FIELD_DECL)))->field_decl.bit_field_type
)
1595 || (prev_saved != NULLnullptr
1596 ? !simple_cst_equal (TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1596, __FUNCTION__))->type_common.size)
, TYPE_SIZE (prev_type)((tree_class_check ((prev_type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1596, __FUNCTION__))->type_common.size)
)
1597 : !integer_zerop (DECL_SIZE (field)((contains_struct_check ((field), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1597, __FUNCTION__))->decl_common.size)
)))
1598 {
1599 /* Never smaller than a byte for compatibility. */
1600 unsigned int type_align = BITS_PER_UNIT(8);
1601
1602 /* (When not a bitfield), we could be seeing a flex array (with
1603 no DECL_SIZE). Since we won't be using remaining_in_alignment
1604 until we see a bitfield (and come by here again) we just skip
1605 calculating it. */
1606 if (DECL_SIZE (field)((contains_struct_check ((field), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1606, __FUNCTION__))->decl_common.size)
!= NULLnullptr
1607 && tree_fits_uhwi_p (TYPE_SIZE (TREE_TYPE (field))((tree_class_check ((((contains_struct_check ((field), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1607, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1607, __FUNCTION__))->type_common.size)
)
1608 && tree_fits_uhwi_p (DECL_SIZE (field)((contains_struct_check ((field), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1608, __FUNCTION__))->decl_common.size)
))
1609 {
1610 unsigned HOST_WIDE_INTlong bitsize
1611 = tree_to_uhwi (DECL_SIZE (field)((contains_struct_check ((field), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1611, __FUNCTION__))->decl_common.size)
);
1612 unsigned HOST_WIDE_INTlong typesize
1613 = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (field))((tree_class_check ((((contains_struct_check ((field), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1613, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1613, __FUNCTION__))->type_common.size)
);
1614
1615 if (typesize < bitsize)
1616 rli->remaining_in_alignment = 0;
1617 else
1618 rli->remaining_in_alignment = typesize - bitsize;
1619 }
1620
1621 /* Now align (conventionally) for the new type. */
1622 if (! DECL_PACKED (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1622, __FUNCTION__, (FIELD_DECL)))->base.u.bits.packed_flag
)
)
1623 type_align = TYPE_ALIGN (TREE_TYPE (field))((tree_class_check ((((contains_struct_check ((field), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1623, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1623, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((((contains_struct_check ((field), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1623, __FUNCTION__))->typed.type))->type_common.align
- 1) : 0)
;
1624
1625 if (maximum_field_alignment != 0)
1626 type_align = MIN (type_align, maximum_field_alignment)((type_align) < (maximum_field_alignment) ? (type_align) :
(maximum_field_alignment))
;
1627
1628 rli->bitpos = round_up (rli->bitpos, type_align)round_up_loc (((location_t) 0), rli->bitpos, type_align);
1629
1630 /* If we really aligned, don't allow subsequent bitfields
1631 to undo that. */
1632 rli->prev_field = NULLnullptr;
1633 }
1634 }
1635
1636 /* Offset so far becomes the position of this field after normalizing. */
1637 normalize_rli (rli);
1638 DECL_FIELD_OFFSET (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1638, __FUNCTION__, (FIELD_DECL)))->field_decl.offset)
= rli->offset;
1639 DECL_FIELD_BIT_OFFSET (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1639, __FUNCTION__, (FIELD_DECL)))->field_decl.bit_offset
)
= rli->bitpos;
1640 SET_DECL_OFFSET_ALIGN (field, rli->offset_align)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1640, __FUNCTION__, (FIELD_DECL)))->decl_common.off_align
= ffs_hwi (rli->offset_align) - 1)
;
1641 handle_warn_if_not_align (field, rli->record_align);
1642
1643 /* Evaluate nonconstant offsets only once, either now or as soon as safe. */
1644 if (TREE_CODE (DECL_FIELD_OFFSET (field))((enum tree_code) (((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1644, __FUNCTION__, (FIELD_DECL)))->field_decl.offset))->
base.code)
!= INTEGER_CST)
1645 DECL_FIELD_OFFSET (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1645, __FUNCTION__, (FIELD_DECL)))->field_decl.offset)
= variable_size (DECL_FIELD_OFFSET (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1645, __FUNCTION__, (FIELD_DECL)))->field_decl.offset)
);
1646
1647 /* If this field ended up more aligned than we thought it would be (we
1648 approximate this by seeing if its position changed), lay out the field
1649 again; perhaps we can use an integral mode for it now. */
1650 if (! integer_zerop (DECL_FIELD_BIT_OFFSET (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1650, __FUNCTION__, (FIELD_DECL)))->field_decl.bit_offset
)
))
1651 actual_align = least_bit_hwi (tree_to_uhwi (DECL_FIELD_BIT_OFFSET (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1651, __FUNCTION__, (FIELD_DECL)))->field_decl.bit_offset
)
));
1652 else if (integer_zerop (DECL_FIELD_OFFSET (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1652, __FUNCTION__, (FIELD_DECL)))->field_decl.offset)
))
1653 actual_align = MAX (BIGGEST_ALIGNMENT, rli->record_align)(((((global_options.x_target_flags & (1U << 12)) !=
0) ? 32 : (((global_options.x_ix86_isa_flags & (1UL <<
15)) != 0) ? 512 : (((global_options.x_ix86_isa_flags & (
1UL << 8)) != 0) ? 256 : 128)))) > (rli->record_align
) ? ((((global_options.x_target_flags & (1U << 12))
!= 0) ? 32 : (((global_options.x_ix86_isa_flags & (1UL <<
15)) != 0) ? 512 : (((global_options.x_ix86_isa_flags & (
1UL << 8)) != 0) ? 256 : 128)))) : (rli->record_align
))
;
1654 else if (tree_fits_uhwi_p (DECL_FIELD_OFFSET (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1654, __FUNCTION__, (FIELD_DECL)))->field_decl.offset)
))
1655 actual_align = (BITS_PER_UNIT(8)
1656 * least_bit_hwi (tree_to_uhwi (DECL_FIELD_OFFSET (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1656, __FUNCTION__, (FIELD_DECL)))->field_decl.offset)
)));
1657 else
1658 actual_align = DECL_OFFSET_ALIGN (field)(((unsigned long)1) << (tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1658, __FUNCTION__, (FIELD_DECL)))->decl_common.off_align
)
;
1659 /* ACTUAL_ALIGN is still the actual alignment *within the record* .
1660 store / extract bit field operations will check the alignment of the
1661 record against the mode of bit fields. */
1662
1663 if (known_align != actual_align)
1664 layout_decl (field, actual_align);
1665
1666 if (rli->prev_field == NULLnullptr && DECL_BIT_FIELD_TYPE (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1666, __FUNCTION__, (FIELD_DECL)))->field_decl.bit_field_type
)
)
1667 rli->prev_field = field;
1668
1669 /* Now add size of this field to the size of the record. If the size is
1670 not constant, treat the field as being a multiple of bytes and just
1671 adjust the offset, resetting the bit position. Otherwise, apportion the
1672 size amongst the bit position and offset. First handle the case of an
1673 unspecified size, which can happen when we have an invalid nested struct
1674 definition, such as struct j { struct j { int i; } }. The error message
1675 is printed in finish_struct. */
1676 if (DECL_SIZE (field)((contains_struct_check ((field), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1676, __FUNCTION__))->decl_common.size)
== 0)
1677 /* Do nothing. */;
1678 else if (TREE_CODE (DECL_SIZE (field))((enum tree_code) (((contains_struct_check ((field), (TS_DECL_COMMON
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1678, __FUNCTION__))->decl_common.size))->base.code)
!= INTEGER_CST
1679 || TREE_OVERFLOW (DECL_SIZE (field))((tree_class_check ((((contains_struct_check ((field), (TS_DECL_COMMON
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1679, __FUNCTION__))->decl_common.size)), (tcc_constant)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1679, __FUNCTION__))->base.public_flag)
)
1680 {
1681 rli->offset
1682 = size_binop (PLUS_EXPR, rli->offset,size_binop_loc (((location_t) 0), PLUS_EXPR, rli->offset, fold_convert_loc
(((location_t) 0), sizetype_tab[(int) stk_sizetype], size_binop_loc
(((location_t) 0), CEIL_DIV_EXPR, rli->bitpos, global_trees
[TI_BITSIZE_UNIT])))
1683 fold_convert (sizetype,size_binop_loc (((location_t) 0), PLUS_EXPR, rli->offset, fold_convert_loc
(((location_t) 0), sizetype_tab[(int) stk_sizetype], size_binop_loc
(((location_t) 0), CEIL_DIV_EXPR, rli->bitpos, global_trees
[TI_BITSIZE_UNIT])))
1684 size_binop (CEIL_DIV_EXPR, rli->bitpos,size_binop_loc (((location_t) 0), PLUS_EXPR, rli->offset, fold_convert_loc
(((location_t) 0), sizetype_tab[(int) stk_sizetype], size_binop_loc
(((location_t) 0), CEIL_DIV_EXPR, rli->bitpos, global_trees
[TI_BITSIZE_UNIT])))
1685 bitsize_unit_node)))size_binop_loc (((location_t) 0), PLUS_EXPR, rli->offset, fold_convert_loc
(((location_t) 0), sizetype_tab[(int) stk_sizetype], size_binop_loc
(((location_t) 0), CEIL_DIV_EXPR, rli->bitpos, global_trees
[TI_BITSIZE_UNIT])))
;
1686 rli->offset
1687 = size_binop (PLUS_EXPR, rli->offset, DECL_SIZE_UNIT (field))size_binop_loc (((location_t) 0), PLUS_EXPR, rli->offset, (
(contains_struct_check ((field), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1687, __FUNCTION__))->decl_common.size_unit))
;
1688 rli->bitpos = bitsize_zero_nodeglobal_trees[TI_BITSIZE_ZERO];
1689 rli->offset_align = MIN (rli->offset_align, desired_align)((rli->offset_align) < (desired_align) ? (rli->offset_align
) : (desired_align))
;
1690
1691 if (!multiple_of_p (bitsizetypesizetype_tab[(int) stk_bitsizetype], DECL_SIZE (field)((contains_struct_check ((field), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1691, __FUNCTION__))->decl_common.size)
,
1692 bitsize_int (rli->offset_align)size_int_kind (rli->offset_align, stk_bitsizetype)))
1693 {
1694 tree type = strip_array_types (TREE_TYPE (field)((contains_struct_check ((field), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1694, __FUNCTION__))->typed.type)
);
1695 /* The above adjusts offset_align just based on the start of the
1696 field. The field might not have a size that is a multiple of
1697 that offset_align though. If the field is an array of fixed
1698 sized elements, assume there can be any multiple of those
1699 sizes. If it is a variable length aggregate or array of
1700 variable length aggregates, assume worst that the end is
1701 just BITS_PER_UNIT aligned. */
1702 if (TREE_CODE (TYPE_SIZE (type))((enum tree_code) (((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1702, __FUNCTION__))->type_common.size))->base.code)
== INTEGER_CST)
1703 {
1704 if (TREE_INT_CST_LOW (TYPE_SIZE (type))((unsigned long) (*tree_int_cst_elt_check ((((tree_class_check
((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1704, __FUNCTION__))->type_common.size)), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1704, __FUNCTION__)))
)
1705 {
1706 unsigned HOST_WIDE_INTlong sz
1707 = least_bit_hwi (TREE_INT_CST_LOW (TYPE_SIZE (type))((unsigned long) (*tree_int_cst_elt_check ((((tree_class_check
((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1707, __FUNCTION__))->type_common.size)), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1707, __FUNCTION__)))
);
1708 rli->offset_align = MIN (rli->offset_align, sz)((rli->offset_align) < (sz) ? (rli->offset_align) : (
sz))
;
1709 }
1710 }
1711 else
1712 rli->offset_align = MIN (rli->offset_align, BITS_PER_UNIT)((rli->offset_align) < ((8)) ? (rli->offset_align) :
((8)))
;
1713 }
1714 }
1715 else if (targetm.ms_bitfield_layout_p (rli->t))
1716 {
1717 rli->bitpos = size_binop (PLUS_EXPR, rli->bitpos, DECL_SIZE (field))size_binop_loc (((location_t) 0), PLUS_EXPR, rli->bitpos, (
(contains_struct_check ((field), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1717, __FUNCTION__))->decl_common.size))
;
1718
1719 /* If FIELD is the last field and doesn't end at the full length
1720 of the type then pad the struct out to the full length of the
1721 last type. */
1722 if (DECL_BIT_FIELD_TYPE (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1722, __FUNCTION__, (FIELD_DECL)))->field_decl.bit_field_type
)
1723 && !integer_zerop (DECL_SIZE (field)((contains_struct_check ((field), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1723, __FUNCTION__))->decl_common.size)
))
1724 {
1725 /* We have to scan, because non-field DECLS are also here. */
1726 tree probe = field;
1727 while ((probe = DECL_CHAIN (probe)(((contains_struct_check (((contains_struct_check ((probe), (
TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1727, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1727, __FUNCTION__))->common.chain))
))
1728 if (TREE_CODE (probe)((enum tree_code) (probe)->base.code) == FIELD_DECL)
1729 break;
1730 if (!probe)
1731 rli->bitpos = size_binop (PLUS_EXPR, rli->bitpos,size_binop_loc (((location_t) 0), PLUS_EXPR, rli->bitpos, size_int_kind
(rli->remaining_in_alignment, stk_bitsizetype))
1732 bitsize_int (rli->remaining_in_alignment))size_binop_loc (((location_t) 0), PLUS_EXPR, rli->bitpos, size_int_kind
(rli->remaining_in_alignment, stk_bitsizetype))
;
1733 }
1734
1735 normalize_rli (rli);
1736 }
1737 else
1738 {
1739 rli->bitpos = size_binop (PLUS_EXPR, rli->bitpos, DECL_SIZE (field))size_binop_loc (((location_t) 0), PLUS_EXPR, rli->bitpos, (
(contains_struct_check ((field), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1739, __FUNCTION__))->decl_common.size))
;
1740 normalize_rli (rli);
1741 }
1742}
1743
1744/* Assuming that all the fields have been laid out, this function uses
1745 RLI to compute the final TYPE_SIZE, TYPE_ALIGN, etc. for the type
1746 indicated by RLI. */
1747
1748static void
1749finalize_record_size (record_layout_info rli)
1750{
1751 tree unpadded_size, unpadded_size_unit;
1752
1753 /* Now we want just byte and bit offsets, so set the offset alignment
1754 to be a byte and then normalize. */
1755 rli->offset_align = BITS_PER_UNIT(8);
1756 normalize_rli (rli);
1757
1758 /* Determine the desired alignment. */
1759#ifdef ROUND_TYPE_ALIGN
1760 SET_TYPE_ALIGN (rli->t, ROUND_TYPE_ALIGN (rli->t, TYPE_ALIGN (rli->t),((tree_class_check ((rli->t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1761, __FUNCTION__))->type_common.align = ffs_hwi (ROUND_TYPE_ALIGN
(rli->t, ((tree_class_check ((rli->t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1760, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((rli->t)->type_common.align - 1) : 0), rli->record_align
)))
1761 rli->record_align))((tree_class_check ((rli->t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1761, __FUNCTION__))->type_common.align = ffs_hwi (ROUND_TYPE_ALIGN
(rli->t, ((tree_class_check ((rli->t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1760, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((rli->t)->type_common.align - 1) : 0), rli->record_align
)))
;
1762#else
1763 SET_TYPE_ALIGN (rli->t, MAX (TYPE_ALIGN (rli->t), rli->record_align))((tree_class_check ((rli->t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1763, __FUNCTION__))->type_common.align = ffs_hwi (((((tree_class_check
((rli->t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1763, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((rli->t)->type_common.align - 1) : 0)) > (rli->
record_align) ? (((tree_class_check ((rli->t), (tcc_type),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1763, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((rli->t)->type_common.align - 1) : 0)) : (rli->record_align
))))
;
1764#endif
1765
1766 /* Compute the size so far. Be sure to allow for extra bits in the
1767 size in bytes. We have guaranteed above that it will be no more
1768 than a single byte. */
1769 unpadded_size = rli_size_so_far (rli);
1770 unpadded_size_unit = rli_size_unit_so_far (rli);
1771 if (! integer_zerop (rli->bitpos))
1772 unpadded_size_unit
1773 = size_binop (PLUS_EXPR, unpadded_size_unit, size_one_node)size_binop_loc (((location_t) 0), PLUS_EXPR, unpadded_size_unit
, global_trees[TI_SIZE_ONE])
;
1774
1775 /* Round the size up to be a multiple of the required alignment. */
1776 TYPE_SIZE (rli->t)((tree_class_check ((rli->t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1776, __FUNCTION__))->type_common.size)
= round_up (unpadded_size, TYPE_ALIGN (rli->t))round_up_loc (((location_t) 0), unpadded_size, ((tree_class_check
((rli->t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1776, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((rli->t)->type_common.align - 1) : 0))
;
1777 TYPE_SIZE_UNIT (rli->t)((tree_class_check ((rli->t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1777, __FUNCTION__))->type_common.size_unit)
1778 = round_up (unpadded_size_unit, TYPE_ALIGN_UNIT (rli->t))round_up_loc (((location_t) 0), unpadded_size_unit, (((tree_class_check
((rli->t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1778, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((rli->t)->type_common.align - 1) : 0) / (8)))
;
1779
1780 if (TREE_CONSTANT (unpadded_size)((non_type_check ((unpadded_size), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1780, __FUNCTION__))->base.constant_flag)
1781 && simple_cst_equal (unpadded_size, TYPE_SIZE (rli->t)((tree_class_check ((rli->t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1781, __FUNCTION__))->type_common.size)
) == 0
1782 && input_location != BUILTINS_LOCATION((location_t) 1)
1783 && !TYPE_ARTIFICIAL (rli->t)((tree_class_check ((rli->t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1783, __FUNCTION__))->base.nowarning_flag)
)
1784 warning (OPT_Wpadded, "padding struct size to alignment boundary");
1785
1786 if (warn_packedglobal_options.x_warn_packed && TREE_CODE (rli->t)((enum tree_code) (rli->t)->base.code) == RECORD_TYPE
1787 && TYPE_PACKED (rli->t)((tree_class_check ((rli->t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1787, __FUNCTION__))->base.u.bits.packed_flag)
&& ! rli->packed_maybe_necessary
1788 && TREE_CONSTANT (unpadded_size)((non_type_check ((unpadded_size), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1788, __FUNCTION__))->base.constant_flag)
)
1789 {
1790 tree unpacked_size;
1791
1792#ifdef ROUND_TYPE_ALIGN
1793 rli->unpacked_align
1794 = ROUND_TYPE_ALIGN (rli->t, TYPE_ALIGN (rli->t)((tree_class_check ((rli->t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1794, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((rli->t)->type_common.align - 1) : 0)
, rli->unpacked_align);
1795#else
1796 rli->unpacked_align = MAX (TYPE_ALIGN (rli->t), rli->unpacked_align)((((tree_class_check ((rli->t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1796, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((rli->t)->type_common.align - 1) : 0)) > (rli->
unpacked_align) ? (((tree_class_check ((rli->t), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1796, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((rli->t)->type_common.align - 1) : 0)) : (rli->unpacked_align
))
;
1797#endif
1798
1799 unpacked_size = round_up (TYPE_SIZE (rli->t), rli->unpacked_align)round_up_loc (((location_t) 0), ((tree_class_check ((rli->
t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1799, __FUNCTION__))->type_common.size), rli->unpacked_align
)
;
1800 if (simple_cst_equal (unpacked_size, TYPE_SIZE (rli->t)((tree_class_check ((rli->t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1800, __FUNCTION__))->type_common.size)
))
1801 {
1802 if (TYPE_NAME (rli->t)((tree_class_check ((rli->t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1802, __FUNCTION__))->type_common.name)
)
1803 {
1804 tree name;
1805
1806 if (TREE_CODE (TYPE_NAME (rli->t))((enum tree_code) (((tree_class_check ((rli->t), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1806, __FUNCTION__))->type_common.name))->base.code)
== IDENTIFIER_NODE)
1807 name = TYPE_NAME (rli->t)((tree_class_check ((rli->t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1807, __FUNCTION__))->type_common.name)
;
1808 else
1809 name = DECL_NAME (TYPE_NAME (rli->t))((contains_struct_check ((((tree_class_check ((rli->t), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1809, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1809, __FUNCTION__))->decl_minimal.name)
;
1810
1811 if (STRICT_ALIGNMENT0)
1812 warning (OPT_Wpacked, "packed attribute causes inefficient "
1813 "alignment for %qE", name);
1814 else
1815 warning (OPT_Wpacked,
1816 "packed attribute is unnecessary for %qE", name);
1817 }
1818 else
1819 {
1820 if (STRICT_ALIGNMENT0)
1821 warning (OPT_Wpacked,
1822 "packed attribute causes inefficient alignment");
1823 else
1824 warning (OPT_Wpacked, "packed attribute is unnecessary");
1825 }
1826 }
1827 }
1828}
1829
1830/* Compute the TYPE_MODE for the TYPE (which is a RECORD_TYPE). */
1831
1832void
1833compute_record_mode (tree type)
1834{
1835 tree field;
1836 machine_mode mode = VOIDmode((void) 0, E_VOIDmode);
1837
1838 /* Most RECORD_TYPEs have BLKmode, so we start off assuming that.
1839 However, if possible, we use a mode that fits in a register
1840 instead, in order to allow for better optimization down the
1841 line. */
1842 SET_TYPE_MODE (type, BLKmode)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1842, __FUNCTION__))->type_common.mode = (((void) 0, E_BLKmode
)))
;
1843
1844 poly_uint64 type_size;
1845 if (!poly_int_tree_p (TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1845, __FUNCTION__))->type_common.size)
, &type_size))
1846 return;
1847
1848 /* A record which has any BLKmode members must itself be
1849 BLKmode; it can't go in a register. Unless the member is
1850 BLKmode only because it isn't aligned. */
1851 for (field = TYPE_FIELDS (type)((tree_check3 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1851, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values)
; field; field = DECL_CHAIN (field)(((contains_struct_check (((contains_struct_check ((field), (
TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1851, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1851, __FUNCTION__))->common.chain))
)
1852 {
1853 if (TREE_CODE (field)((enum tree_code) (field)->base.code) != FIELD_DECL)
1854 continue;
1855
1856 poly_uint64 field_size;
1857 if (TREE_CODE (TREE_TYPE (field))((enum tree_code) (((contains_struct_check ((field), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1857, __FUNCTION__))->typed.type))->base.code)
== ERROR_MARK
1858 || (TYPE_MODE (TREE_TYPE (field))((((enum tree_code) ((tree_class_check ((((contains_struct_check
((field), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1858, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1858, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(((contains_struct_check ((field), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1858, __FUNCTION__))->typed.type)) : (((contains_struct_check
((field), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1858, __FUNCTION__))->typed.type))->type_common.mode)
== BLKmode((void) 0, E_BLKmode)
1859 && ! TYPE_NO_FORCE_BLK (TREE_TYPE (field))((tree_class_check ((((contains_struct_check ((field), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1859, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1859, __FUNCTION__))->type_common.no_force_blk_flag)
1860 && !(TYPE_SIZE (TREE_TYPE (field))((tree_class_check ((((contains_struct_check ((field), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1860, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1860, __FUNCTION__))->type_common.size)
!= 0
1861 && integer_zerop (TYPE_SIZE (TREE_TYPE (field))((tree_class_check ((((contains_struct_check ((field), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1861, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1861, __FUNCTION__))->type_common.size)
)))
1862 || !tree_fits_poly_uint64_p (bit_position (field))
1863 || DECL_SIZE (field)((contains_struct_check ((field), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1863, __FUNCTION__))->decl_common.size)
== 0
1864 || !poly_int_tree_p (DECL_SIZE (field)((contains_struct_check ((field), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1864, __FUNCTION__))->decl_common.size)
, &field_size))
1865 return;
1866
1867 /* If this field is the whole struct, remember its mode so
1868 that, say, we can put a double in a class into a DF
1869 register instead of forcing it to live in the stack. */
1870 if (known_eq (field_size, type_size)(!maybe_ne (field_size, type_size))
1871 /* Partial int types (e.g. __int20) may have TYPE_SIZE equal to
1872 wider types (e.g. int32), despite precision being less. Ensure
1873 that the TYPE_MODE of the struct does not get set to the partial
1874 int mode if there is a wider type also in the struct. */
1875 && known_gt (GET_MODE_PRECISION (DECL_MODE (field)),(!maybe_le (GET_MODE_PRECISION (((contains_struct_check ((field
), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1875, __FUNCTION__))->decl_common.mode)), GET_MODE_PRECISION
(mode)))
1876 GET_MODE_PRECISION (mode))(!maybe_le (GET_MODE_PRECISION (((contains_struct_check ((field
), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1875, __FUNCTION__))->decl_common.mode)), GET_MODE_PRECISION
(mode)))
)
1877 mode = DECL_MODE (field)((contains_struct_check ((field), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1877, __FUNCTION__))->decl_common.mode)
;
1878
1879 /* With some targets, it is sub-optimal to access an aligned
1880 BLKmode structure as a scalar. */
1881 if (targetm.member_type_forces_blk (field, mode))
1882 return;
1883 }
1884
1885 /* If we only have one real field; use its mode if that mode's size
1886 matches the type's size. This generally only applies to RECORD_TYPE.
1887 For UNION_TYPE, if the widest field is MODE_INT then use that mode.
1888 If the widest field is MODE_PARTIAL_INT, and the union will be passed
1889 by reference, then use that mode. */
1890 if ((TREE_CODE (type)((enum tree_code) (type)->base.code) == RECORD_TYPE
1891 || (TREE_CODE (type)((enum tree_code) (type)->base.code) == UNION_TYPE
1892 && (GET_MODE_CLASS (mode)((enum mode_class) mode_class[mode]) == MODE_INT
1893 || (GET_MODE_CLASS (mode)((enum mode_class) mode_class[mode]) == MODE_PARTIAL_INT
1894 && (targetm.calls.pass_by_reference
1895 (pack_cumulative_args (0),
1896 function_arg_info (type, mode, /*named=*/false)))))))
1897 && mode != VOIDmode((void) 0, E_VOIDmode)
1898 && known_eq (GET_MODE_BITSIZE (mode), type_size)(!maybe_ne (GET_MODE_BITSIZE (mode), type_size)))
1899 ;
1900 else
1901 mode = mode_for_size_tree (TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1901, __FUNCTION__))->type_common.size)
, MODE_INT, 1).else_blk ();
1902
1903 /* If structure's known alignment is less than what the scalar
1904 mode would need, and it matters, then stick with BLKmode. */
1905 if (mode != BLKmode((void) 0, E_BLKmode)
1906 && STRICT_ALIGNMENT0
1907 && ! (TYPE_ALIGN (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1907, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((type)->type_common.align - 1) : 0)
>= BIGGEST_ALIGNMENT(((global_options.x_target_flags & (1U << 12)) != 0
) ? 32 : (((global_options.x_ix86_isa_flags & (1UL <<
15)) != 0) ? 512 : (((global_options.x_ix86_isa_flags & (
1UL << 8)) != 0) ? 256 : 128)))
1908 || TYPE_ALIGN (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1908, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((type)->type_common.align - 1) : 0)
>= GET_MODE_ALIGNMENT (mode)get_mode_alignment (mode)))
1909 {
1910 /* If this is the only reason this type is BLKmode, then
1911 don't force containing types to be BLKmode. */
1912 TYPE_NO_FORCE_BLK (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1912, __FUNCTION__))->type_common.no_force_blk_flag)
= 1;
1913 mode = BLKmode((void) 0, E_BLKmode);
1914 }
1915
1916 SET_TYPE_MODE (type, mode)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1916, __FUNCTION__))->type_common.mode = (mode))
;
1917}
1918
1919/* Compute TYPE_SIZE and TYPE_ALIGN for TYPE, once it has been laid
1920 out. */
1921
1922static void
1923finalize_type_size (tree type)
1924{
1925 /* Normally, use the alignment corresponding to the mode chosen.
1926 However, where strict alignment is not required, avoid
1927 over-aligning structures, since most compilers do not do this
1928 alignment. */
1929 if (TYPE_MODE (type)((((enum tree_code) ((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1929, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(type) : (type)->type_common.mode)
!= BLKmode((void) 0, E_BLKmode)
1930 && TYPE_MODE (type)((((enum tree_code) ((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1930, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(type) : (type)->type_common.mode)
!= VOIDmode((void) 0, E_VOIDmode)
1931 && (STRICT_ALIGNMENT0 || !AGGREGATE_TYPE_P (type)(((enum tree_code) (type)->base.code) == ARRAY_TYPE || (((
enum tree_code) (type)->base.code) == RECORD_TYPE || ((enum
tree_code) (type)->base.code) == UNION_TYPE || ((enum tree_code
) (type)->base.code) == QUAL_UNION_TYPE))
))
1932 {
1933 unsigned mode_align = GET_MODE_ALIGNMENT (TYPE_MODE (type))get_mode_alignment (((((enum tree_code) ((tree_class_check ((
type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1933, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(type) : (type)->type_common.mode))
;
1934
1935 /* Don't override a larger alignment requirement coming from a user
1936 alignment of one of the fields. */
1937 if (mode_align >= TYPE_ALIGN (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1937, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((type)->type_common.align - 1) : 0)
)
1938 {
1939 SET_TYPE_ALIGN (type, mode_align)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1939, __FUNCTION__))->type_common.align = ffs_hwi (mode_align
))
;
1940 TYPE_USER_ALIGN (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1940, __FUNCTION__))->base.u.bits.user_align)
= 0;
1941 }
1942 }
1943
1944 /* Do machine-dependent extra alignment. */
1945#ifdef ROUND_TYPE_ALIGN
1946 SET_TYPE_ALIGN (type,((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1947, __FUNCTION__))->type_common.align = ffs_hwi (ROUND_TYPE_ALIGN
(type, ((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1947, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((type)->type_common.align - 1) : 0), (8))))
1947 ROUND_TYPE_ALIGN (type, TYPE_ALIGN (type), BITS_PER_UNIT))((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1947, __FUNCTION__))->type_common.align = ffs_hwi (ROUND_TYPE_ALIGN
(type, ((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1947, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((type)->type_common.align - 1) : 0), (8))))
;
1948#endif
1949
1950 /* If we failed to find a simple way to calculate the unit size
1951 of the type, find it by division. */
1952 if (TYPE_SIZE_UNIT (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1952, __FUNCTION__))->type_common.size_unit)
== 0 && TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1952, __FUNCTION__))->type_common.size)
!= 0)
1953 /* TYPE_SIZE (type) is computed in bitsizetype. After the division, the
1954 result will fit in sizetype. We will get more efficient code using
1955 sizetype, so we force a conversion. */
1956 TYPE_SIZE_UNIT (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1956, __FUNCTION__))->type_common.size_unit)
1957 = fold_convert (sizetype,fold_convert_loc (((location_t) 0), sizetype_tab[(int) stk_sizetype
], size_binop_loc (((location_t) 0), FLOOR_DIV_EXPR, ((tree_class_check
((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1958, __FUNCTION__))->type_common.size), global_trees[TI_BITSIZE_UNIT
]))
1958 size_binop (FLOOR_DIV_EXPR, TYPE_SIZE (type),fold_convert_loc (((location_t) 0), sizetype_tab[(int) stk_sizetype
], size_binop_loc (((location_t) 0), FLOOR_DIV_EXPR, ((tree_class_check
((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1958, __FUNCTION__))->type_common.size), global_trees[TI_BITSIZE_UNIT
]))
1959 bitsize_unit_node))fold_convert_loc (((location_t) 0), sizetype_tab[(int) stk_sizetype
], size_binop_loc (((location_t) 0), FLOOR_DIV_EXPR, ((tree_class_check
((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1958, __FUNCTION__))->type_common.size), global_trees[TI_BITSIZE_UNIT
]))
;
1960
1961 if (TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1961, __FUNCTION__))->type_common.size)
!= 0)
1962 {
1963 TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1963, __FUNCTION__))->type_common.size)
= round_up (TYPE_SIZE (type), TYPE_ALIGN (type))round_up_loc (((location_t) 0), ((tree_class_check ((type), (
tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1963, __FUNCTION__))->type_common.size), ((tree_class_check
((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1963, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((type)->type_common.align - 1) : 0))
;
1964 TYPE_SIZE_UNIT (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1964, __FUNCTION__))->type_common.size_unit)
1965 = round_up (TYPE_SIZE_UNIT (type), TYPE_ALIGN_UNIT (type))round_up_loc (((location_t) 0), ((tree_class_check ((type), (
tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1965, __FUNCTION__))->type_common.size_unit), (((tree_class_check
((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1965, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((type)->type_common.align - 1) : 0) / (8)))
;
1966 }
1967
1968 /* Evaluate nonconstant sizes only once, either now or as soon as safe. */
1969 if (TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1969, __FUNCTION__))->type_common.size)
!= 0 && TREE_CODE (TYPE_SIZE (type))((enum tree_code) (((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1969, __FUNCTION__))->type_common.size))->base.code)
!= INTEGER_CST)
1970 TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1970, __FUNCTION__))->type_common.size)
= variable_size (TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1970, __FUNCTION__))->type_common.size)
);
1971 if (TYPE_SIZE_UNIT (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1971, __FUNCTION__))->type_common.size_unit)
!= 0
1972 && TREE_CODE (TYPE_SIZE_UNIT (type))((enum tree_code) (((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1972, __FUNCTION__))->type_common.size_unit))->base.code
)
!= INTEGER_CST)
1973 TYPE_SIZE_UNIT (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1973, __FUNCTION__))->type_common.size_unit)
= variable_size (TYPE_SIZE_UNIT (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1973, __FUNCTION__))->type_common.size_unit)
);
1974
1975 /* Handle empty records as per the x86-64 psABI. */
1976 TYPE_EMPTY_P (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1976, __FUNCTION__))->type_common.empty_flag)
= targetm.calls.empty_record_p (type);
1977
1978 /* Also layout any other variants of the type. */
1979 if (TYPE_NEXT_VARIANT (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1979, __FUNCTION__))->type_common.next_variant)
1980 || type != TYPE_MAIN_VARIANT (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1980, __FUNCTION__))->type_common.main_variant)
)
1981 {
1982 tree variant;
1983 /* Record layout info of this variant. */
1984 tree size = TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1984, __FUNCTION__))->type_common.size)
;
1985 tree size_unit = TYPE_SIZE_UNIT (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1985, __FUNCTION__))->type_common.size_unit)
;
1986 unsigned int align = TYPE_ALIGN (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1986, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((type)->type_common.align - 1) : 0)
;
1987 unsigned int precision = TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1987, __FUNCTION__))->type_common.precision)
;
1988 unsigned int user_align = TYPE_USER_ALIGN (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1988, __FUNCTION__))->base.u.bits.user_align)
;
1989 machine_mode mode = TYPE_MODE (type)((((enum tree_code) ((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1989, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(type) : (type)->type_common.mode)
;
1990 bool empty_p = TYPE_EMPTY_P (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1990, __FUNCTION__))->type_common.empty_flag)
;
1991
1992 /* Copy it into all variants. */
1993 for (variant = TYPE_MAIN_VARIANT (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1993, __FUNCTION__))->type_common.main_variant)
;
1994 variant != 0;
1995 variant = TYPE_NEXT_VARIANT (variant)((tree_class_check ((variant), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1995, __FUNCTION__))->type_common.next_variant)
)
1996 {
1997 TYPE_SIZE (variant)((tree_class_check ((variant), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1997, __FUNCTION__))->type_common.size)
= size;
1998 TYPE_SIZE_UNIT (variant)((tree_class_check ((variant), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 1998, __FUNCTION__))->type_common.size_unit)
= size_unit;
1999 unsigned valign = align;
2000 if (TYPE_USER_ALIGN (variant)((tree_class_check ((variant), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2000, __FUNCTION__))->base.u.bits.user_align)
)
2001 valign = MAX (valign, TYPE_ALIGN (variant))((valign) > (((tree_class_check ((variant), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2001, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((variant)->type_common.align - 1) : 0)) ? (valign) : (((
tree_class_check ((variant), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2001, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((variant)->type_common.align - 1) : 0)))
;
2002 else
2003 TYPE_USER_ALIGN (variant)((tree_class_check ((variant), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2003, __FUNCTION__))->base.u.bits.user_align)
= user_align;
2004 SET_TYPE_ALIGN (variant, valign)((tree_class_check ((variant), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2004, __FUNCTION__))->type_common.align = ffs_hwi (valign
))
;
2005 TYPE_PRECISION (variant)((tree_class_check ((variant), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2005, __FUNCTION__))->type_common.precision)
= precision;
2006 SET_TYPE_MODE (variant, mode)((tree_class_check ((variant), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2006, __FUNCTION__))->type_common.mode = (mode))
;
2007 TYPE_EMPTY_P (variant)((tree_class_check ((variant), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2007, __FUNCTION__))->type_common.empty_flag)
= empty_p;
2008 }
2009 }
2010}
2011
2012/* Return a new underlying object for a bitfield started with FIELD. */
2013
2014static tree
2015start_bitfield_representative (tree field)
2016{
2017 tree repr = make_node (FIELD_DECL);
2018 DECL_FIELD_OFFSET (repr)((tree_check ((repr), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2018, __FUNCTION__, (FIELD_DECL)))->field_decl.offset)
= DECL_FIELD_OFFSET (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2018, __FUNCTION__, (FIELD_DECL)))->field_decl.offset)
;
2019 /* Force the representative to begin at a BITS_PER_UNIT aligned
2020 boundary - C++ may use tail-padding of a base object to
2021 continue packing bits so the bitfield region does not start
2022 at bit zero (see g++.dg/abi/bitfield5.C for example).
2023 Unallocated bits may happen for other reasons as well,
2024 for example Ada which allows explicit bit-granular structure layout. */
2025 DECL_FIELD_BIT_OFFSET (repr)((tree_check ((repr), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2025, __FUNCTION__, (FIELD_DECL)))->field_decl.bit_offset
)
2026 = size_binop (BIT_AND_EXPR,size_binop_loc (((location_t) 0), BIT_AND_EXPR, ((tree_check (
(field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2027, __FUNCTION__, (FIELD_DECL)))->field_decl.bit_offset
), size_int_kind (~((8) - 1), stk_bitsizetype))
2027 DECL_FIELD_BIT_OFFSET (field),size_binop_loc (((location_t) 0), BIT_AND_EXPR, ((tree_check (
(field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2027, __FUNCTION__, (FIELD_DECL)))->field_decl.bit_offset
), size_int_kind (~((8) - 1), stk_bitsizetype))
2028 bitsize_int (~(BITS_PER_UNIT - 1)))size_binop_loc (((location_t) 0), BIT_AND_EXPR, ((tree_check (
(field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2027, __FUNCTION__, (FIELD_DECL)))->field_decl.bit_offset
), size_int_kind (~((8) - 1), stk_bitsizetype))
;
2029 SET_DECL_OFFSET_ALIGN (repr, DECL_OFFSET_ALIGN (field))((tree_check ((repr), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2029, __FUNCTION__, (FIELD_DECL)))->decl_common.off_align
= ffs_hwi ((((unsigned long)1) << (tree_check ((field)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2029, __FUNCTION__, (FIELD_DECL)))->decl_common.off_align
)) - 1)
;
2030 DECL_SIZE (repr)((contains_struct_check ((repr), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2030, __FUNCTION__))->decl_common.size)
= DECL_SIZE (field)((contains_struct_check ((field), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2030, __FUNCTION__))->decl_common.size)
;
2031 DECL_SIZE_UNIT (repr)((contains_struct_check ((repr), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2031, __FUNCTION__))->decl_common.size_unit)
= DECL_SIZE_UNIT (field)((contains_struct_check ((field), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2031, __FUNCTION__))->decl_common.size_unit)
;
2032 DECL_PACKED (repr)((tree_check ((repr), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2032, __FUNCTION__, (FIELD_DECL)))->base.u.bits.packed_flag
)
= DECL_PACKED (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2032, __FUNCTION__, (FIELD_DECL)))->base.u.bits.packed_flag
)
;
2033 DECL_CONTEXT (repr)((contains_struct_check ((repr), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2033, __FUNCTION__))->decl_minimal.context)
= DECL_CONTEXT (field)((contains_struct_check ((field), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2033, __FUNCTION__))->decl_minimal.context)
;
2034 /* There are no indirect accesses to this field. If we introduce
2035 some then they have to use the record alias set. This makes
2036 sure to properly conflict with [indirect] accesses to addressable
2037 fields of the bitfield group. */
2038 DECL_NONADDRESSABLE_P (repr)((tree_check ((repr), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2038, __FUNCTION__, (FIELD_DECL)))->decl_common.decl_flag_2
)
= 1;
2039 return repr;
2040}
2041
2042/* Finish up a bitfield group that was started by creating the underlying
2043 object REPR with the last field in the bitfield group FIELD. */
2044
2045static void
2046finish_bitfield_representative (tree repr, tree field)
2047{
2048 unsigned HOST_WIDE_INTlong bitsize, maxbitsize;
2049 tree nextf, size;
2050
2051 size = size_diffop (DECL_FIELD_OFFSET (field),size_diffop_loc (((location_t) 0), ((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2051, __FUNCTION__, (FIELD_DECL)))->field_decl.offset), (
(tree_check ((repr), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2052, __FUNCTION__, (FIELD_DECL)))->field_decl.offset))
2052 DECL_FIELD_OFFSET (repr))size_diffop_loc (((location_t) 0), ((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2051, __FUNCTION__, (FIELD_DECL)))->field_decl.offset), (
(tree_check ((repr), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2052, __FUNCTION__, (FIELD_DECL)))->field_decl.offset))
;
2053 while (TREE_CODE (size)((enum tree_code) (size)->base.code) == COMPOUND_EXPR)
2054 size = TREE_OPERAND (size, 1)(*((const_cast<tree*> (tree_operand_check ((size), (1),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2054, __FUNCTION__)))))
;
2055 gcc_assert (tree_fits_uhwi_p (size))((void)(!(tree_fits_uhwi_p (size)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2055, __FUNCTION__), 0 : 0))
;
2056 bitsize = (tree_to_uhwi (size) * BITS_PER_UNIT(8)
2057 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2057, __FUNCTION__, (FIELD_DECL)))->field_decl.bit_offset
)
)
2058 - tree_to_uhwi (DECL_FIELD_BIT_OFFSET (repr)((tree_check ((repr), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2058, __FUNCTION__, (FIELD_DECL)))->field_decl.bit_offset
)
)
2059 + tree_to_uhwi (DECL_SIZE (field)((contains_struct_check ((field), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2059, __FUNCTION__))->decl_common.size)
));
2060
2061 /* Round up bitsize to multiples of BITS_PER_UNIT. */
2062 bitsize = (bitsize + BITS_PER_UNIT(8) - 1) & ~(BITS_PER_UNIT(8) - 1);
2063
2064 /* Now nothing tells us how to pad out bitsize ... */
2065 nextf = DECL_CHAIN (field)(((contains_struct_check (((contains_struct_check ((field), (
TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2065, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2065, __FUNCTION__))->common.chain))
;
2066 while (nextf && TREE_CODE (nextf)((enum tree_code) (nextf)->base.code) != FIELD_DECL)
2067 nextf = DECL_CHAIN (nextf)(((contains_struct_check (((contains_struct_check ((nextf), (
TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2067, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2067, __FUNCTION__))->common.chain))
;
2068 if (nextf)
2069 {
2070 tree maxsize;
2071 /* If there was an error, the field may be not laid out
2072 correctly. Don't bother to do anything. */
2073 if (TREE_TYPE (nextf)((contains_struct_check ((nextf), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2073, __FUNCTION__))->typed.type)
== error_mark_nodeglobal_trees[TI_ERROR_MARK])
2074 return;
2075 maxsize = size_diffop (DECL_FIELD_OFFSET (nextf),size_diffop_loc (((location_t) 0), ((tree_check ((nextf), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2075, __FUNCTION__, (FIELD_DECL)))->field_decl.offset), (
(tree_check ((repr), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2076, __FUNCTION__, (FIELD_DECL)))->field_decl.offset))
2076 DECL_FIELD_OFFSET (repr))size_diffop_loc (((location_t) 0), ((tree_check ((nextf), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2075, __FUNCTION__, (FIELD_DECL)))->field_decl.offset), (
(tree_check ((repr), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2076, __FUNCTION__, (FIELD_DECL)))->field_decl.offset))
;
2077 if (tree_fits_uhwi_p (maxsize))
2078 {
2079 maxbitsize = (tree_to_uhwi (maxsize) * BITS_PER_UNIT(8)
2080 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (nextf)((tree_check ((nextf), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2080, __FUNCTION__, (FIELD_DECL)))->field_decl.bit_offset
)
)
2081 - tree_to_uhwi (DECL_FIELD_BIT_OFFSET (repr)((tree_check ((repr), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2081, __FUNCTION__, (FIELD_DECL)))->field_decl.bit_offset
)
));
2082 /* If the group ends within a bitfield nextf does not need to be
2083 aligned to BITS_PER_UNIT. Thus round up. */
2084 maxbitsize = (maxbitsize + BITS_PER_UNIT(8) - 1) & ~(BITS_PER_UNIT(8) - 1);
2085 }
2086 else
2087 maxbitsize = bitsize;
2088 }
2089 else
2090 {
2091 /* Note that if the C++ FE sets up tail-padding to be re-used it
2092 creates a as-base variant of the type with TYPE_SIZE adjusted
2093 accordingly. So it is safe to include tail-padding here. */
2094 tree aggsize = lang_hooks.types.unit_size_without_reusable_padding
2095 (DECL_CONTEXT (field)((contains_struct_check ((field), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2095, __FUNCTION__))->decl_minimal.context)
);
2096 tree maxsize = size_diffop (aggsize, DECL_FIELD_OFFSET (repr))size_diffop_loc (((location_t) 0), aggsize, ((tree_check ((repr
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2096, __FUNCTION__, (FIELD_DECL)))->field_decl.offset))
;
2097 /* We cannot generally rely on maxsize to fold to an integer constant,
2098 so use bitsize as fallback for this case. */
2099 if (tree_fits_uhwi_p (maxsize))
2100 maxbitsize = (tree_to_uhwi (maxsize) * BITS_PER_UNIT(8)
2101 - tree_to_uhwi (DECL_FIELD_BIT_OFFSET (repr)((tree_check ((repr), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2101, __FUNCTION__, (FIELD_DECL)))->field_decl.bit_offset
)
));
2102 else
2103 maxbitsize = bitsize;
2104 }
2105
2106 /* Only if we don't artificially break up the representative in
2107 the middle of a large bitfield with different possibly
2108 overlapping representatives. And all representatives start
2109 at byte offset. */
2110 gcc_assert (maxbitsize % BITS_PER_UNIT == 0)((void)(!(maxbitsize % (8) == 0) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2110, __FUNCTION__), 0 : 0))
;
2111
2112 /* Find the smallest nice mode to use. */
2113 opt_scalar_int_mode mode_iter;
2114 FOR_EACH_MODE_IN_CLASS (mode_iter, MODE_INT)for (mode_iterator::start (&(mode_iter), MODE_INT); mode_iterator
::iterate_p (&(mode_iter)); mode_iterator::get_wider (&
(mode_iter)))
2115 if (GET_MODE_BITSIZE (mode_iter.require ()) >= bitsize)
2116 break;
2117
2118 scalar_int_mode mode;
2119 if (!mode_iter.exists (&mode)
2120 || GET_MODE_BITSIZE (mode) > maxbitsize
2121 || GET_MODE_BITSIZE (mode) > MAX_FIXED_MODE_SIZEGET_MODE_BITSIZE (((global_options.x_ix86_isa_flags & (1UL
<< 1)) != 0) ? (scalar_int_mode ((scalar_int_mode::from_int
) E_TImode)) : (scalar_int_mode ((scalar_int_mode::from_int) E_DImode
)))
)
2122 {
2123 /* We really want a BLKmode representative only as a last resort,
2124 considering the member b in
2125 struct { int a : 7; int b : 17; int c; } __attribute__((packed));
2126 Otherwise we simply want to split the representative up
2127 allowing for overlaps within the bitfield region as required for
2128 struct { int a : 7; int b : 7;
2129 int c : 10; int d; } __attribute__((packed));
2130 [0, 15] HImode for a and b, [8, 23] HImode for c. */
2131 DECL_SIZE (repr)((contains_struct_check ((repr), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2131, __FUNCTION__))->decl_common.size)
= bitsize_int (bitsize)size_int_kind (bitsize, stk_bitsizetype);
2132 DECL_SIZE_UNIT (repr)((contains_struct_check ((repr), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2132, __FUNCTION__))->decl_common.size_unit)
= size_int (bitsize / BITS_PER_UNIT)size_int_kind (bitsize / (8), stk_sizetype);
2133 SET_DECL_MODE (repr, BLKmode)((contains_struct_check ((repr), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2133, __FUNCTION__))->decl_common.mode = (((void) 0, E_BLKmode
)))
;
2134 TREE_TYPE (repr)((contains_struct_check ((repr), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2134, __FUNCTION__))->typed.type)
= build_array_type_nelts (unsigned_char_type_nodeinteger_types[itk_unsigned_char],
2135 bitsize / BITS_PER_UNIT(8));
2136 }
2137 else
2138 {
2139 unsigned HOST_WIDE_INTlong modesize = GET_MODE_BITSIZE (mode);
2140 DECL_SIZE (repr)((contains_struct_check ((repr), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2140, __FUNCTION__))->decl_common.size)
= bitsize_int (modesize)size_int_kind (modesize, stk_bitsizetype);
2141 DECL_SIZE_UNIT (repr)((contains_struct_check ((repr), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2141, __FUNCTION__))->decl_common.size_unit)
= size_int (modesize / BITS_PER_UNIT)size_int_kind (modesize / (8), stk_sizetype);
2142 SET_DECL_MODE (repr, mode)((contains_struct_check ((repr), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2142, __FUNCTION__))->decl_common.mode = (mode))
;
2143 TREE_TYPE (repr)((contains_struct_check ((repr), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2143, __FUNCTION__))->typed.type)
= lang_hooks.types.type_for_mode (mode, 1);
2144 }
2145
2146 /* Remember whether the bitfield group is at the end of the
2147 structure or not. */
2148 DECL_CHAIN (repr)(((contains_struct_check (((contains_struct_check ((repr), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2148, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2148, __FUNCTION__))->common.chain))
= nextf;
2149}
2150
2151/* Compute and set FIELD_DECLs for the underlying objects we should
2152 use for bitfield access for the structure T. */
2153
2154void
2155finish_bitfield_layout (tree t)
2156{
2157 tree field, prev;
2158 tree repr = NULL_TREE(tree) nullptr;
2159
2160 /* Unions would be special, for the ease of type-punning optimizations
2161 we could use the underlying type as hint for the representative
2162 if the bitfield would fit and the representative would not exceed
2163 the union in size. */
2164 if (TREE_CODE (t)((enum tree_code) (t)->base.code) != RECORD_TYPE)
2165 return;
2166
2167 for (prev = NULL_TREE(tree) nullptr, field = TYPE_FIELDS (t)((tree_check3 ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2167, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values)
;
2168 field; field = DECL_CHAIN (field)(((contains_struct_check (((contains_struct_check ((field), (
TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2168, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2168, __FUNCTION__))->common.chain))
)
2169 {
2170 if (TREE_CODE (field)((enum tree_code) (field)->base.code) != FIELD_DECL)
2171 continue;
2172
2173 /* In the C++ memory model, consecutive bit fields in a structure are
2174 considered one memory location and updating a memory location
2175 may not store into adjacent memory locations. */
2176 if (!repr
2177 && DECL_BIT_FIELD_TYPE (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2177, __FUNCTION__, (FIELD_DECL)))->field_decl.bit_field_type
)
)
2178 {
2179 /* Start new representative. */
2180 repr = start_bitfield_representative (field);
2181 }
2182 else if (repr
2183 && ! DECL_BIT_FIELD_TYPE (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2183, __FUNCTION__, (FIELD_DECL)))->field_decl.bit_field_type
)
)
2184 {
2185 /* Finish off new representative. */
2186 finish_bitfield_representative (repr, prev);
2187 repr = NULL_TREE(tree) nullptr;
2188 }
2189 else if (DECL_BIT_FIELD_TYPE (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2189, __FUNCTION__, (FIELD_DECL)))->field_decl.bit_field_type
)
)
2190 {
2191 gcc_assert (repr != NULL_TREE)((void)(!(repr != (tree) nullptr) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2191, __FUNCTION__), 0 : 0))
;
2192
2193 /* Zero-size bitfields finish off a representative and
2194 do not have a representative themselves. This is
2195 required by the C++ memory model. */
2196 if (integer_zerop (DECL_SIZE (field)((contains_struct_check ((field), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2196, __FUNCTION__))->decl_common.size)
))
2197 {
2198 finish_bitfield_representative (repr, prev);
2199 repr = NULL_TREE(tree) nullptr;
2200 }
2201
2202 /* We assume that either DECL_FIELD_OFFSET of the representative
2203 and each bitfield member is a constant or they are equal.
2204 This is because we need to be able to compute the bit-offset
2205 of each field relative to the representative in get_bit_range
2206 during RTL expansion.
2207 If these constraints are not met, simply force a new
2208 representative to be generated. That will at most
2209 generate worse code but still maintain correctness with
2210 respect to the C++ memory model. */
2211 else if (!((tree_fits_uhwi_p (DECL_FIELD_OFFSET (repr)((tree_check ((repr), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2211, __FUNCTION__, (FIELD_DECL)))->field_decl.offset)
)
2212 && tree_fits_uhwi_p (DECL_FIELD_OFFSET (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2212, __FUNCTION__, (FIELD_DECL)))->field_decl.offset)
))
2213 || operand_equal_p (DECL_FIELD_OFFSET (repr)((tree_check ((repr), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2213, __FUNCTION__, (FIELD_DECL)))->field_decl.offset)
,
2214 DECL_FIELD_OFFSET (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2214, __FUNCTION__, (FIELD_DECL)))->field_decl.offset)
, 0)))
2215 {
2216 finish_bitfield_representative (repr, prev);
2217 repr = start_bitfield_representative (field);
2218 }
2219 }
2220 else
2221 continue;
2222
2223 if (repr)
2224 DECL_BIT_FIELD_REPRESENTATIVE (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2224, __FUNCTION__, (FIELD_DECL)))->field_decl.qualifier
)
= repr;
2225
2226 prev = field;
2227 }
2228
2229 if (repr)
2230 finish_bitfield_representative (repr, prev);
2231}
2232
2233/* Do all of the work required to layout the type indicated by RLI,
2234 once the fields have been laid out. This function will call `free'
2235 for RLI, unless FREE_P is false. Passing a value other than false
2236 for FREE_P is bad practice; this option only exists to support the
2237 G++ 3.2 ABI. */
2238
2239void
2240finish_record_layout (record_layout_info rli, int free_p)
2241{
2242 tree variant;
2243
2244 /* Compute the final size. */
2245 finalize_record_size (rli);
2246
2247 /* Compute the TYPE_MODE for the record. */
2248 compute_record_mode (rli->t);
2249
2250 /* Perform any last tweaks to the TYPE_SIZE, etc. */
2251 finalize_type_size (rli->t);
2252
2253 /* Compute bitfield representatives. */
2254 finish_bitfield_layout (rli->t);
2255
2256 /* Propagate TYPE_PACKED and TYPE_REVERSE_STORAGE_ORDER to variants.
2257 With C++ templates, it is too early to do this when the attribute
2258 is being parsed. */
2259 for (variant = TYPE_NEXT_VARIANT (rli->t)((tree_class_check ((rli->t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2259, __FUNCTION__))->type_common.next_variant)
; variant;
2260 variant = TYPE_NEXT_VARIANT (variant)((tree_class_check ((variant), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2260, __FUNCTION__))->type_common.next_variant)
)
2261 {
2262 TYPE_PACKED (variant)((tree_class_check ((variant), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2262, __FUNCTION__))->base.u.bits.packed_flag)
= TYPE_PACKED (rli->t)((tree_class_check ((rli->t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2262, __FUNCTION__))->base.u.bits.packed_flag)
;
2263 TYPE_REVERSE_STORAGE_ORDER (variant)((tree_check4 ((variant), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2263, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))->base.u.bits.saturating_flag)
2264 = TYPE_REVERSE_STORAGE_ORDER (rli->t)((tree_check4 ((rli->t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2264, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))->base.u.bits.saturating_flag)
;
2265 }
2266
2267 /* Lay out any static members. This is done now because their type
2268 may use the record's type. */
2269 while (!vec_safe_is_empty (rli->pending_statics))
2270 layout_decl (rli->pending_statics->pop (), 0);
2271
2272 /* Clean up. */
2273 if (free_p)
2274 {
2275 vec_free (rli->pending_statics);
2276 free (rli);
2277 }
2278}
2279
2280
2281/* Finish processing a builtin RECORD_TYPE type TYPE. It's name is
2282 NAME, its fields are chained in reverse on FIELDS.
2283
2284 If ALIGN_TYPE is non-null, it is given the same alignment as
2285 ALIGN_TYPE. */
2286
2287void
2288finish_builtin_struct (tree type, const char *name, tree fields,
2289 tree align_type)
2290{
2291 tree tail, next;
2292
2293 for (tail = NULL_TREE(tree) nullptr; fields; tail = fields, fields = next)
2294 {
2295 DECL_FIELD_CONTEXT (fields)((tree_check ((fields), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2295, __FUNCTION__, (FIELD_DECL)))->decl_minimal.context
)
= type;
2296 next = DECL_CHAIN (fields)(((contains_struct_check (((contains_struct_check ((fields), (
TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2296, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2296, __FUNCTION__))->common.chain))
;
2297 DECL_CHAIN (fields)(((contains_struct_check (((contains_struct_check ((fields), (
TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2297, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2297, __FUNCTION__))->common.chain))
= tail;
2298 }
2299 TYPE_FIELDS (type)((tree_check3 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2299, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values)
= tail;
2300
2301 if (align_type)
2302 {
2303 SET_TYPE_ALIGN (type, TYPE_ALIGN (align_type))((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2303, __FUNCTION__))->type_common.align = ffs_hwi (((tree_class_check
((align_type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2303, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((align_type)->type_common.align - 1) : 0)))
;
2304 TYPE_USER_ALIGN (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2304, __FUNCTION__))->base.u.bits.user_align)
= TYPE_USER_ALIGN (align_type)((tree_class_check ((align_type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2304, __FUNCTION__))->base.u.bits.user_align)
;
2305 SET_TYPE_WARN_IF_NOT_ALIGN (type,((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2306, __FUNCTION__))->type_common.warn_if_not_align = ffs_hwi
(((tree_class_check ((align_type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2306, __FUNCTION__))->type_common.warn_if_not_align ? ((
unsigned)1) << ((align_type)->type_common.warn_if_not_align
- 1) : 0)))
2306 TYPE_WARN_IF_NOT_ALIGN (align_type))((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2306, __FUNCTION__))->type_common.warn_if_not_align = ffs_hwi
(((tree_class_check ((align_type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2306, __FUNCTION__))->type_common.warn_if_not_align ? ((
unsigned)1) << ((align_type)->type_common.warn_if_not_align
- 1) : 0)))
;
2307 }
2308
2309 layout_type (type);
2310#if 0 /* not yet, should get fixed properly later */
2311 TYPE_NAME (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2311, __FUNCTION__))->type_common.name)
= make_type_decl (get_identifier (name)(__builtin_constant_p (name) ? get_identifier_with_length ((name
), strlen (name)) : get_identifier (name))
, type);
2312#else
2313 TYPE_NAME (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2313, __FUNCTION__))->type_common.name)
= build_decl (BUILTINS_LOCATION((location_t) 1),
2314 TYPE_DECL, get_identifier (name)(__builtin_constant_p (name) ? get_identifier_with_length ((name
), strlen (name)) : get_identifier (name))
, type);
2315#endif
2316 TYPE_STUB_DECL (type)(((contains_struct_check (((tree_class_check ((type), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2316, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2316, __FUNCTION__))->common.chain))
= TYPE_NAME (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2316, __FUNCTION__))->type_common.name)
;
2317 layout_decl (TYPE_NAME (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2317, __FUNCTION__))->type_common.name)
, 0);
2318}
2319
2320/* Calculate the mode, size, and alignment for TYPE.
2321 For an array type, calculate the element separation as well.
2322 Record TYPE on the chain of permanent or temporary types
2323 so that dbxout will find out about it.
2324
2325 TYPE_SIZE of a type is nonzero if the type has been laid out already.
2326 layout_type does nothing on such a type.
2327
2328 If the type is incomplete, its TYPE_SIZE remains zero. */
2329
2330void
2331layout_type (tree type)
2332{
2333 gcc_assert (type)((void)(!(type) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2333, __FUNCTION__), 0 : 0))
;
2334
2335 if (type == error_mark_nodeglobal_trees[TI_ERROR_MARK])
2336 return;
2337
2338 /* We don't want finalize_type_size to copy an alignment attribute to
2339 variants that don't have it. */
2340 type = TYPE_MAIN_VARIANT (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2340, __FUNCTION__))->type_common.main_variant)
;
2341
2342 /* Do nothing if type has been laid out before. */
2343 if (TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2343, __FUNCTION__))->type_common.size)
)
2344 return;
2345
2346 switch (TREE_CODE (type)((enum tree_code) (type)->base.code))
2347 {
2348 case LANG_TYPE:
2349 /* This kind of type is the responsibility
2350 of the language-specific code. */
2351 gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2351, __FUNCTION__))
;
2352
2353 case BOOLEAN_TYPE:
2354 case INTEGER_TYPE:
2355 case ENUMERAL_TYPE:
2356 {
2357 scalar_int_mode mode
2358 = smallest_int_mode_for_size (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2358, __FUNCTION__))->type_common.precision)
);
2359 SET_TYPE_MODE (type, mode)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2359, __FUNCTION__))->type_common.mode = (mode))
;
2360 TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2360, __FUNCTION__))->type_common.size)
= bitsize_int (GET_MODE_BITSIZE (mode))size_int_kind (GET_MODE_BITSIZE (mode), stk_bitsizetype);
2361 /* Don't set TYPE_PRECISION here, as it may be set by a bitfield. */
2362 TYPE_SIZE_UNIT (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2362, __FUNCTION__))->type_common.size_unit)
= size_int (GET_MODE_SIZE (mode))size_int_kind (GET_MODE_SIZE (mode), stk_sizetype);
2363 break;
2364 }
2365
2366 case REAL_TYPE:
2367 {
2368 /* Allow the caller to choose the type mode, which is how decimal
2369 floats are distinguished from binary ones. */
2370 if (TYPE_MODE (type)((((enum tree_code) ((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2370, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(type) : (type)->type_common.mode)
== VOIDmode((void) 0, E_VOIDmode))
2371 SET_TYPE_MODE((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2372, __FUNCTION__))->type_common.mode = (float_mode_for_size
(((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2372, __FUNCTION__))->type_common.precision)).require ()
))
2372 (type, float_mode_for_size (TYPE_PRECISION (type)).require ())((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2372, __FUNCTION__))->type_common.mode = (float_mode_for_size
(((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2372, __FUNCTION__))->type_common.precision)).require ()
))
;
2373 scalar_float_mode mode = as_a <scalar_float_mode> (TYPE_MODE (type)((((enum tree_code) ((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2373, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(type) : (type)->type_common.mode)
);
2374 TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2374, __FUNCTION__))->type_common.size)
= bitsize_int (GET_MODE_BITSIZE (mode))size_int_kind (GET_MODE_BITSIZE (mode), stk_bitsizetype);
2375 TYPE_SIZE_UNIT (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2375, __FUNCTION__))->type_common.size_unit)
= size_int (GET_MODE_SIZE (mode))size_int_kind (GET_MODE_SIZE (mode), stk_sizetype);
2376 break;
2377 }
2378
2379 case FIXED_POINT_TYPE:
2380 {
2381 /* TYPE_MODE (type) has been set already. */
2382 scalar_mode mode = SCALAR_TYPE_MODE (type)(as_a <scalar_mode> ((tree_class_check ((type), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2382, __FUNCTION__))->type_common.mode))
;
2383 TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2383, __FUNCTION__))->type_common.size)
= bitsize_int (GET_MODE_BITSIZE (mode))size_int_kind (GET_MODE_BITSIZE (mode), stk_bitsizetype);
2384 TYPE_SIZE_UNIT (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2384, __FUNCTION__))->type_common.size_unit)
= size_int (GET_MODE_SIZE (mode))size_int_kind (GET_MODE_SIZE (mode), stk_sizetype);
2385 break;
2386 }
2387
2388 case COMPLEX_TYPE:
2389 TYPE_UNSIGNED (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2389, __FUNCTION__))->base.u.bits.unsigned_flag)
= TYPE_UNSIGNED (TREE_TYPE (type))((tree_class_check ((((contains_struct_check ((type), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2389, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2389, __FUNCTION__))->base.u.bits.unsigned_flag)
;
2390 SET_TYPE_MODE (type,((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2391, __FUNCTION__))->type_common.mode = (((machine_mode
) mode_complex[((((enum tree_code) ((tree_class_check ((((contains_struct_check
((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2391, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2391, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(((contains_struct_check ((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2391, __FUNCTION__))->typed.type)) : (((contains_struct_check
((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2391, __FUNCTION__))->typed.type))->type_common.mode)
])))
2391 GET_MODE_COMPLEX_MODE (TYPE_MODE (TREE_TYPE (type))))((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2391, __FUNCTION__))->type_common.mode = (((machine_mode
) mode_complex[((((enum tree_code) ((tree_class_check ((((contains_struct_check
((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2391, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2391, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(((contains_struct_check ((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2391, __FUNCTION__))->typed.type)) : (((contains_struct_check
((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2391, __FUNCTION__))->typed.type))->type_common.mode)
])))
;
2392
2393 TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2393, __FUNCTION__))->type_common.size)
= bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type)))size_int_kind (GET_MODE_BITSIZE (((((enum tree_code) ((tree_class_check
((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2393, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(type) : (type)->type_common.mode)), stk_bitsizetype)
;
2394 TYPE_SIZE_UNIT (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2394, __FUNCTION__))->type_common.size_unit)
= size_int (GET_MODE_SIZE (TYPE_MODE (type)))size_int_kind (GET_MODE_SIZE (((((enum tree_code) ((tree_class_check
((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2394, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(type) : (type)->type_common.mode)), stk_sizetype)
;
2395 break;
2396
2397 case VECTOR_TYPE:
2398 {
2399 poly_uint64 nunits = TYPE_VECTOR_SUBPARTS (type);
2400 tree innertype = TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2400, __FUNCTION__))->typed.type)
;
2401
2402 /* Find an appropriate mode for the vector type. */
2403 if (TYPE_MODE (type)((((enum tree_code) ((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2403, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(type) : (type)->type_common.mode)
== VOIDmode((void) 0, E_VOIDmode))
2404 SET_TYPE_MODE (type,((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2406, __FUNCTION__))->type_common.mode = (mode_for_vector
((as_a <scalar_mode> ((tree_class_check ((innertype), (
tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2405, __FUNCTION__))->type_common.mode)), nunits).else_blk
()))
2405 mode_for_vector (SCALAR_TYPE_MODE (innertype),((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2406, __FUNCTION__))->type_common.mode = (mode_for_vector
((as_a <scalar_mode> ((tree_class_check ((innertype), (
tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2405, __FUNCTION__))->type_common.mode)), nunits).else_blk
()))
2406 nunits).else_blk ())((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2406, __FUNCTION__))->type_common.mode = (mode_for_vector
((as_a <scalar_mode> ((tree_class_check ((innertype), (
tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2405, __FUNCTION__))->type_common.mode)), nunits).else_blk
()))
;
2407
2408 TYPE_SATURATING (type)((tree_not_check4 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2408, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))->base.u.bits.saturating_flag)
= TYPE_SATURATING (TREE_TYPE (type))((tree_not_check4 ((((contains_struct_check ((type), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2408, __FUNCTION__))->typed.type)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2408, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))->base.u.bits.saturating_flag)
;
2409 TYPE_UNSIGNED (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2409, __FUNCTION__))->base.u.bits.unsigned_flag)
= TYPE_UNSIGNED (TREE_TYPE (type))((tree_class_check ((((contains_struct_check ((type), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2409, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2409, __FUNCTION__))->base.u.bits.unsigned_flag)
;
2410 /* Several boolean vector elements may fit in a single unit. */
2411 if (VECTOR_BOOLEAN_TYPE_P (type)(((enum tree_code) (type)->base.code) == VECTOR_TYPE &&
((enum tree_code) (((contains_struct_check ((type), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2411, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
)
2412 && type->type_common.mode != BLKmode((void) 0, E_BLKmode))
2413 TYPE_SIZE_UNIT (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2413, __FUNCTION__))->type_common.size_unit)
2414 = size_int (GET_MODE_SIZE (type->type_common.mode))size_int_kind (GET_MODE_SIZE (type->type_common.mode), stk_sizetype
)
;
2415 else
2416 TYPE_SIZE_UNIT (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2416, __FUNCTION__))->type_common.size_unit)
= int_const_binop (MULT_EXPR,
2417 TYPE_SIZE_UNIT (innertype)((tree_class_check ((innertype), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2417, __FUNCTION__))->type_common.size_unit)
,
2418 size_int (nunits)size_int_kind (nunits, stk_sizetype));
2419 TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2419, __FUNCTION__))->type_common.size)
= int_const_binop
2420 (MULT_EXPR,
2421 bits_from_bytes (TYPE_SIZE_UNIT (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2421, __FUNCTION__))->type_common.size_unit)
),
2422 bitsize_int (BITS_PER_UNIT)size_int_kind ((8), stk_bitsizetype));
2423
2424 /* For vector types, we do not default to the mode's alignment.
2425 Instead, query a target hook, defaulting to natural alignment.
2426 This prevents ABI changes depending on whether or not native
2427 vector modes are supported. */
2428 SET_TYPE_ALIGN (type, targetm.vector_alignment (type))((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2428, __FUNCTION__))->type_common.align = ffs_hwi (targetm
.vector_alignment (type)))
;
2429
2430 /* However, if the underlying mode requires a bigger alignment than
2431 what the target hook provides, we cannot use the mode. For now,
2432 simply reject that case. */
2433 gcc_assert (TYPE_ALIGN (type)((void)(!(((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2433, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((type)->type_common.align - 1) : 0) >= get_mode_alignment
(((((enum tree_code) ((tree_class_check ((type), (tcc_type),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2434, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(type) : (type)->type_common.mode))) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2434, __FUNCTION__), 0 : 0))
2434 >= GET_MODE_ALIGNMENT (TYPE_MODE (type)))((void)(!(((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2433, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((type)->type_common.align - 1) : 0) >= get_mode_alignment
(((((enum tree_code) ((tree_class_check ((type), (tcc_type),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2434, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(type) : (type)->type_common.mode))) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2434, __FUNCTION__), 0 : 0))
;
2435 break;
2436 }
2437
2438 case VOID_TYPE:
2439 /* This is an incomplete type and so doesn't have a size. */
2440 SET_TYPE_ALIGN (type, 1)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2440, __FUNCTION__))->type_common.align = ffs_hwi (1))
;
2441 TYPE_USER_ALIGN (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2441, __FUNCTION__))->base.u.bits.user_align)
= 0;
2442 SET_TYPE_MODE (type, VOIDmode)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2442, __FUNCTION__))->type_common.mode = (((void) 0, E_VOIDmode
)))
;
2443 break;
2444
2445 case OFFSET_TYPE:
2446 TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2446, __FUNCTION__))->type_common.size)
= bitsize_int (POINTER_SIZE)size_int_kind ((((global_options.x_ix86_isa_flags & (1UL <<
58)) != 0) ? 32 : ((8) * (((global_options.x_ix86_isa_flags &
(1UL << 1)) != 0) ? 8 : 4))), stk_bitsizetype)
;
2447 TYPE_SIZE_UNIT (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2447, __FUNCTION__))->type_common.size_unit)
= size_int (POINTER_SIZE_UNITS)size_int_kind ((((((global_options.x_ix86_isa_flags & (1UL
<< 58)) != 0) ? 32 : ((8) * (((global_options.x_ix86_isa_flags
& (1UL << 1)) != 0) ? 8 : 4))) + (8) - 1) / (8)), stk_sizetype
)
;
2448 /* A pointer might be MODE_PARTIAL_INT, but ptrdiff_t must be
2449 integral, which may be an __intN. */
2450 SET_TYPE_MODE (type, int_mode_for_size (POINTER_SIZE, 0).require ())((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2450, __FUNCTION__))->type_common.mode = (int_mode_for_size
((((global_options.x_ix86_isa_flags & (1UL << 58))
!= 0) ? 32 : ((8) * (((global_options.x_ix86_isa_flags &
(1UL << 1)) != 0) ? 8 : 4))), 0).require ()))
;
2451 TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2451, __FUNCTION__))->type_common.precision)
= POINTER_SIZE(((global_options.x_ix86_isa_flags & (1UL << 58)) !=
0) ? 32 : ((8) * (((global_options.x_ix86_isa_flags & (1UL
<< 1)) != 0) ? 8 : 4)))
;
2452 break;
2453
2454 case FUNCTION_TYPE:
2455 case METHOD_TYPE:
2456 /* It's hard to see what the mode and size of a function ought to
2457 be, but we do know the alignment is FUNCTION_BOUNDARY, so
2458 make it consistent with that. */
2459 SET_TYPE_MODE (type,((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2460, __FUNCTION__))->type_common.mode = (int_mode_for_size
(8, 0).else_blk ()))
2460 int_mode_for_size (FUNCTION_BOUNDARY, 0).else_blk ())((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2460, __FUNCTION__))->type_common.mode = (int_mode_for_size
(8, 0).else_blk ()))
;
2461 TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2461, __FUNCTION__))->type_common.size)
= bitsize_int (FUNCTION_BOUNDARY)size_int_kind (8, stk_bitsizetype);
2462 TYPE_SIZE_UNIT (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2462, __FUNCTION__))->type_common.size_unit)
= size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT)size_int_kind (8 / (8), stk_sizetype);
2463 break;
2464
2465 case POINTER_TYPE:
2466 case REFERENCE_TYPE:
2467 {
2468 scalar_int_mode mode = SCALAR_INT_TYPE_MODE (type)(as_a <scalar_int_mode> ((tree_class_check ((type), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2468, __FUNCTION__))->type_common.mode))
;
2469 TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2469, __FUNCTION__))->type_common.size)
= bitsize_int (GET_MODE_BITSIZE (mode))size_int_kind (GET_MODE_BITSIZE (mode), stk_bitsizetype);
2470 TYPE_SIZE_UNIT (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2470, __FUNCTION__))->type_common.size_unit)
= size_int (GET_MODE_SIZE (mode))size_int_kind (GET_MODE_SIZE (mode), stk_sizetype);
2471 TYPE_UNSIGNED (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2471, __FUNCTION__))->base.u.bits.unsigned_flag)
= 1;
2472 TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2472, __FUNCTION__))->type_common.precision)
= GET_MODE_PRECISION (mode);
2473 }
2474 break;
2475
2476 case ARRAY_TYPE:
2477 {
2478 tree index = TYPE_DOMAIN (type)((tree_check ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2478, __FUNCTION__, (ARRAY_TYPE)))->type_non_common.values
)
;
2479 tree element = TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2479, __FUNCTION__))->typed.type)
;
2480
2481 /* We need to know both bounds in order to compute the size. */
2482 if (index && TYPE_MAX_VALUE (index)((tree_check5 ((index), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2482, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.maxval
)
&& TYPE_MIN_VALUE (index)((tree_check5 ((index), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2482, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.minval
)
2483 && TYPE_SIZE (element)((tree_class_check ((element), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2483, __FUNCTION__))->type_common.size)
)
2484 {
2485 tree ub = TYPE_MAX_VALUE (index)((tree_check5 ((index), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2485, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.maxval
)
;
2486 tree lb = TYPE_MIN_VALUE (index)((tree_check5 ((index), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2486, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.minval
)
;
2487 tree element_size = TYPE_SIZE (element)((tree_class_check ((element), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2487, __FUNCTION__))->type_common.size)
;
2488 tree length;
2489
2490 /* Make sure that an array of zero-sized element is zero-sized
2491 regardless of its extent. */
2492 if (integer_zerop (element_size))
2493 length = size_zero_nodeglobal_trees[TI_SIZE_ZERO];
2494
2495 /* The computation should happen in the original signedness so
2496 that (possible) negative values are handled appropriately
2497 when determining overflow. */
2498 else
2499 {
2500 /* ??? When it is obvious that the range is signed
2501 represent it using ssizetype. */
2502 if (TREE_CODE (lb)((enum tree_code) (lb)->base.code) == INTEGER_CST
2503 && TREE_CODE (ub)((enum tree_code) (ub)->base.code) == INTEGER_CST
2504 && TYPE_UNSIGNED (TREE_TYPE (lb))((tree_class_check ((((contains_struct_check ((lb), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2504, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2504, __FUNCTION__))->base.u.bits.unsigned_flag)
2505 && tree_int_cst_lt (ub, lb))
2506 {
2507 lb = wide_int_to_tree (ssizetypesizetype_tab[(int) stk_ssizetype],
2508 offset_int::from (wi::to_wide (lb),
2509 SIGNED));
2510 ub = wide_int_to_tree (ssizetypesizetype_tab[(int) stk_ssizetype],
2511 offset_int::from (wi::to_wide (ub),
2512 SIGNED));
2513 }
2514 length
2515 = fold_convert (sizetype,fold_convert_loc (((location_t) 0), sizetype_tab[(int) stk_sizetype
], size_binop_loc (((location_t) 0), PLUS_EXPR, build_int_cst
(((contains_struct_check ((lb), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2517, __FUNCTION__))->typed.type), 1), size_binop_loc ((
(location_t) 0), MINUS_EXPR, ub, lb)))
2516 size_binop (PLUS_EXPR,fold_convert_loc (((location_t) 0), sizetype_tab[(int) stk_sizetype
], size_binop_loc (((location_t) 0), PLUS_EXPR, build_int_cst
(((contains_struct_check ((lb), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2517, __FUNCTION__))->typed.type), 1), size_binop_loc ((
(location_t) 0), MINUS_EXPR, ub, lb)))
2517 build_int_cst (TREE_TYPE (lb), 1),fold_convert_loc (((location_t) 0), sizetype_tab[(int) stk_sizetype
], size_binop_loc (((location_t) 0), PLUS_EXPR, build_int_cst
(((contains_struct_check ((lb), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2517, __FUNCTION__))->typed.type), 1), size_binop_loc ((
(location_t) 0), MINUS_EXPR, ub, lb)))
2518 size_binop (MINUS_EXPR, ub, lb)))fold_convert_loc (((location_t) 0), sizetype_tab[(int) stk_sizetype
], size_binop_loc (((location_t) 0), PLUS_EXPR, build_int_cst
(((contains_struct_check ((lb), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2517, __FUNCTION__))->typed.type), 1), size_binop_loc ((
(location_t) 0), MINUS_EXPR, ub, lb)))
;
2519 }
2520
2521 /* ??? We have no way to distinguish a null-sized array from an
2522 array spanning the whole sizetype range, so we arbitrarily
2523 decide that [0, -1] is the only valid representation. */
2524 if (integer_zerop (length)
2525 && TREE_OVERFLOW (length)((tree_class_check ((length), (tcc_constant), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2525, __FUNCTION__))->base.public_flag)
2526 && integer_zerop (lb))
2527 length = size_zero_nodeglobal_trees[TI_SIZE_ZERO];
2528
2529 TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2529, __FUNCTION__))->type_common.size)
= size_binop (MULT_EXPR, element_size,size_binop_loc (((location_t) 0), MULT_EXPR, element_size, bits_from_bytes
(length))
2530 bits_from_bytes (length))size_binop_loc (((location_t) 0), MULT_EXPR, element_size, bits_from_bytes
(length))
;
2531
2532 /* If we know the size of the element, calculate the total size
2533 directly, rather than do some division thing below. This
2534 optimization helps Fortran assumed-size arrays (where the
2535 size of the array is determined at runtime) substantially. */
2536 if (TYPE_SIZE_UNIT (element)((tree_class_check ((element), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2536, __FUNCTION__))->type_common.size_unit)
)
2537 TYPE_SIZE_UNIT (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2537, __FUNCTION__))->type_common.size_unit)
2538 = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (element), length)size_binop_loc (((location_t) 0), MULT_EXPR, ((tree_class_check
((element), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2538, __FUNCTION__))->type_common.size_unit), length)
;
2539 }
2540
2541 /* Now round the alignment and size,
2542 using machine-dependent criteria if any. */
2543
2544 unsigned align = TYPE_ALIGN (element)((tree_class_check ((element), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2544, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((element)->type_common.align - 1) : 0)
;
2545 if (TYPE_USER_ALIGN (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2545, __FUNCTION__))->base.u.bits.user_align)
)
2546 align = MAX (align, TYPE_ALIGN (type))((align) > (((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2546, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((type)->type_common.align - 1) : 0)) ? (align) : (((tree_class_check
((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2546, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((type)->type_common.align - 1) : 0)))
;
2547 else
2548 TYPE_USER_ALIGN (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2548, __FUNCTION__))->base.u.bits.user_align)
= TYPE_USER_ALIGN (element)((tree_class_check ((element), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2548, __FUNCTION__))->base.u.bits.user_align)
;
2549 if (!TYPE_WARN_IF_NOT_ALIGN (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2549, __FUNCTION__))->type_common.warn_if_not_align ? ((
unsigned)1) << ((type)->type_common.warn_if_not_align
- 1) : 0)
)
2550 SET_TYPE_WARN_IF_NOT_ALIGN (type,((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2551, __FUNCTION__))->type_common.warn_if_not_align = ffs_hwi
(((tree_class_check ((element), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2551, __FUNCTION__))->type_common.warn_if_not_align ? ((
unsigned)1) << ((element)->type_common.warn_if_not_align
- 1) : 0)))
2551 TYPE_WARN_IF_NOT_ALIGN (element))((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2551, __FUNCTION__))->type_common.warn_if_not_align = ffs_hwi
(((tree_class_check ((element), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2551, __FUNCTION__))->type_common.warn_if_not_align ? ((
unsigned)1) << ((element)->type_common.warn_if_not_align
- 1) : 0)))
;
2552#ifdef ROUND_TYPE_ALIGN
2553 align = ROUND_TYPE_ALIGN (type, align, BITS_PER_UNIT(8));
2554#else
2555 align = MAX (align, BITS_PER_UNIT)((align) > ((8)) ? (align) : ((8)));
2556#endif
2557 SET_TYPE_ALIGN (type, align)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2557, __FUNCTION__))->type_common.align = ffs_hwi (align
))
;
2558 SET_TYPE_MODE (type, BLKmode)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2558, __FUNCTION__))->type_common.mode = (((void) 0, E_BLKmode
)))
;
2559 if (TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2559, __FUNCTION__))->type_common.size)
!= 0
2560 && ! targetm.member_type_forces_blk (type, VOIDmode((void) 0, E_VOIDmode))
2561 /* BLKmode elements force BLKmode aggregate;
2562 else extract/store fields may lose. */
2563 && (TYPE_MODE (TREE_TYPE (type))((((enum tree_code) ((tree_class_check ((((contains_struct_check
((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2563, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2563, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(((contains_struct_check ((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2563, __FUNCTION__))->typed.type)) : (((contains_struct_check
((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2563, __FUNCTION__))->typed.type))->type_common.mode)
!= BLKmode((void) 0, E_BLKmode)
2564 || TYPE_NO_FORCE_BLK (TREE_TYPE (type))((tree_class_check ((((contains_struct_check ((type), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2564, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2564, __FUNCTION__))->type_common.no_force_blk_flag)
))
2565 {
2566 SET_TYPE_MODE (type, mode_for_array (TREE_TYPE (type),((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2567, __FUNCTION__))->type_common.mode = (mode_for_array
(((contains_struct_check ((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2566, __FUNCTION__))->typed.type), ((tree_class_check ((
type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2567, __FUNCTION__))->type_common.size))))
2567 TYPE_SIZE (type)))((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2567, __FUNCTION__))->type_common.mode = (mode_for_array
(((contains_struct_check ((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2566, __FUNCTION__))->typed.type), ((tree_class_check ((
type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2567, __FUNCTION__))->type_common.size))))
;
2568 if (TYPE_MODE (type)((((enum tree_code) ((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2568, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(type) : (type)->type_common.mode)
!= BLKmode((void) 0, E_BLKmode)
2569 && STRICT_ALIGNMENT0 && TYPE_ALIGN (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2569, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((type)->type_common.align - 1) : 0)
< BIGGEST_ALIGNMENT(((global_options.x_target_flags & (1U << 12)) != 0
) ? 32 : (((global_options.x_ix86_isa_flags & (1UL <<
15)) != 0) ? 512 : (((global_options.x_ix86_isa_flags & (
1UL << 8)) != 0) ? 256 : 128)))
2570 && TYPE_ALIGN (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2570, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((type)->type_common.align - 1) : 0)
< GET_MODE_ALIGNMENT (TYPE_MODE (type))get_mode_alignment (((((enum tree_code) ((tree_class_check ((
type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2570, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(type) : (type)->type_common.mode))
)
2571 {
2572 TYPE_NO_FORCE_BLK (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2572, __FUNCTION__))->type_common.no_force_blk_flag)
= 1;
2573 SET_TYPE_MODE (type, BLKmode)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2573, __FUNCTION__))->type_common.mode = (((void) 0, E_BLKmode
)))
;
2574 }
2575 }
2576 if (AGGREGATE_TYPE_P (element)(((enum tree_code) (element)->base.code) == ARRAY_TYPE || (
((enum tree_code) (element)->base.code) == RECORD_TYPE || (
(enum tree_code) (element)->base.code) == UNION_TYPE || ((
enum tree_code) (element)->base.code) == QUAL_UNION_TYPE))
)
2577 TYPE_TYPELESS_STORAGE (type)((tree_check4 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2577, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))->type_common.typeless_storage)
= TYPE_TYPELESS_STORAGE (element)((tree_check4 ((element), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2577, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))->type_common.typeless_storage)
;
2578 /* When the element size is constant, check that it is at least as
2579 large as the element alignment. */
2580 if (TYPE_SIZE_UNIT (element)((tree_class_check ((element), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2580, __FUNCTION__))->type_common.size_unit)
2581 && TREE_CODE (TYPE_SIZE_UNIT (element))((enum tree_code) (((tree_class_check ((element), (tcc_type),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2581, __FUNCTION__))->type_common.size_unit))->base.code
)
== INTEGER_CST
2582 /* If TYPE_SIZE_UNIT overflowed, then it is certainly larger than
2583 TYPE_ALIGN_UNIT. */
2584 && !TREE_OVERFLOW (TYPE_SIZE_UNIT (element))((tree_class_check ((((tree_class_check ((element), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2584, __FUNCTION__))->type_common.size_unit)), (tcc_constant
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2584, __FUNCTION__))->base.public_flag)
2585 && !integer_zerop (TYPE_SIZE_UNIT (element)((tree_class_check ((element), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2585, __FUNCTION__))->type_common.size_unit)
))
2586 {
2587 if (compare_tree_int (TYPE_SIZE_UNIT (element)((tree_class_check ((element), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2587, __FUNCTION__))->type_common.size_unit)
,
2588 TYPE_ALIGN_UNIT (element)(((tree_class_check ((element), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2588, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((element)->type_common.align - 1) : 0) / (8))
) < 0)
2589 error ("alignment of array elements is greater than "
2590 "element size");
2591 else if (TYPE_ALIGN_UNIT (element)(((tree_class_check ((element), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2591, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((element)->type_common.align - 1) : 0) / (8))
> 1
2592 && (wi::zext (wi::to_wide (TYPE_SIZE_UNIT (element)((tree_class_check ((element), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2592, __FUNCTION__))->type_common.size_unit)
),
2593 ffs_hwi (TYPE_ALIGN_UNIT (element)(((tree_class_check ((element), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2593, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((element)->type_common.align - 1) : 0) / (8))
) - 1)
2594 != 0))
2595 error ("size of array element is not a multiple of its "
2596 "alignment");
2597 }
2598 break;
2599 }
2600
2601 case RECORD_TYPE:
2602 case UNION_TYPE:
2603 case QUAL_UNION_TYPE:
2604 {
2605 tree field;
2606 record_layout_info rli;
2607
2608 /* Initialize the layout information. */
2609 rli = start_record_layout (type);
2610
2611 /* If this is a QUAL_UNION_TYPE, we want to process the fields
2612 in the reverse order in building the COND_EXPR that denotes
2613 its size. We reverse them again later. */
2614 if (TREE_CODE (type)((enum tree_code) (type)->base.code) == QUAL_UNION_TYPE)
2615 TYPE_FIELDS (type)((tree_check3 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2615, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values)
= nreverse (TYPE_FIELDS (type)((tree_check3 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2615, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values)
);
2616
2617 /* Place all the fields. */
2618 for (field = TYPE_FIELDS (type)((tree_check3 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2618, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values)
; field; field = DECL_CHAIN (field)(((contains_struct_check (((contains_struct_check ((field), (
TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2618, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2618, __FUNCTION__))->common.chain))
)
2619 place_field (rli, field);
2620
2621 if (TREE_CODE (type)((enum tree_code) (type)->base.code) == QUAL_UNION_TYPE)
2622 TYPE_FIELDS (type)((tree_check3 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2622, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values)
= nreverse (TYPE_FIELDS (type)((tree_check3 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2622, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values)
);
2623
2624 /* Finish laying out the record. */
2625 finish_record_layout (rli, /*free_p=*/true);
2626 }
2627 break;
2628
2629 default:
2630 gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2630, __FUNCTION__))
;
2631 }
2632
2633 /* Compute the final TYPE_SIZE, TYPE_ALIGN, etc. for TYPE. For
2634 records and unions, finish_record_layout already called this
2635 function. */
2636 if (!RECORD_OR_UNION_TYPE_P (type)(((enum tree_code) (type)->base.code) == RECORD_TYPE || ((
enum tree_code) (type)->base.code) == UNION_TYPE || ((enum
tree_code) (type)->base.code) == QUAL_UNION_TYPE)
)
2637 finalize_type_size (type);
2638
2639 /* We should never see alias sets on incomplete aggregates. And we
2640 should not call layout_type on not incomplete aggregates. */
2641 if (AGGREGATE_TYPE_P (type)(((enum tree_code) (type)->base.code) == ARRAY_TYPE || (((
enum tree_code) (type)->base.code) == RECORD_TYPE || ((enum
tree_code) (type)->base.code) == UNION_TYPE || ((enum tree_code
) (type)->base.code) == QUAL_UNION_TYPE))
)
2642 gcc_assert (!TYPE_ALIAS_SET_KNOWN_P (type))((void)(!(!((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2642, __FUNCTION__))->type_common.alias_set != -1)) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2642, __FUNCTION__), 0 : 0))
;
2643}
2644
2645/* Return the least alignment required for type TYPE. */
2646
2647unsigned int
2648min_align_of_type (tree type)
2649{
2650 unsigned int align = TYPE_ALIGN (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2650, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
((type)->type_common.align - 1) : 0)
;
2651 if (!TYPE_USER_ALIGN (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2651, __FUNCTION__))->base.u.bits.user_align)
)
2652 {
2653 align = MIN (align, BIGGEST_ALIGNMENT)((align) < ((((global_options.x_target_flags & (1U <<
12)) != 0) ? 32 : (((global_options.x_ix86_isa_flags & (
1UL << 15)) != 0) ? 512 : (((global_options.x_ix86_isa_flags
& (1UL << 8)) != 0) ? 256 : 128)))) ? (align) : ((
((global_options.x_target_flags & (1U << 12)) != 0)
? 32 : (((global_options.x_ix86_isa_flags & (1UL <<
15)) != 0) ? 512 : (((global_options.x_ix86_isa_flags & (
1UL << 8)) != 0) ? 256 : 128)))))
;
2654#ifdef BIGGEST_FIELD_ALIGNMENT
2655 align = MIN (align, BIGGEST_FIELD_ALIGNMENT)((align) < (BIGGEST_FIELD_ALIGNMENT) ? (align) : (BIGGEST_FIELD_ALIGNMENT
))
;
2656#endif
2657 unsigned int field_align = align;
2658#ifdef ADJUST_FIELD_ALIGN
2659 field_align = ADJUST_FIELD_ALIGN (NULL_TREE, type, field_align)x86_field_alignment ((type), (field_align));
2660#endif
2661 align = MIN (align, field_align)((align) < (field_align) ? (align) : (field_align));
2662 }
2663 return align / BITS_PER_UNIT(8);
2664}
2665
2666/* Create and return a type for signed integers of PRECISION bits. */
2667
2668tree
2669make_signed_type (int precision)
2670{
2671 tree type = make_node (INTEGER_TYPE);
2672
2673 TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2673, __FUNCTION__))->type_common.precision)
= precision;
2674
2675 fixup_signed_type (type);
2676 return type;
2677}
2678
2679/* Create and return a type for unsigned integers of PRECISION bits. */
2680
2681tree
2682make_unsigned_type (int precision)
2683{
2684 tree type = make_node (INTEGER_TYPE);
2685
2686 TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2686, __FUNCTION__))->type_common.precision)
= precision;
2687
2688 fixup_unsigned_type (type);
2689 return type;
2690}
2691
2692/* Create and return a type for fract of PRECISION bits, UNSIGNEDP,
2693 and SATP. */
2694
2695tree
2696make_fract_type (int precision, int unsignedp, int satp)
2697{
2698 tree type = make_node (FIXED_POINT_TYPE);
2699
2700 TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2700, __FUNCTION__))->type_common.precision)
= precision;
2701
2702 if (satp)
2703 TYPE_SATURATING (type)((tree_not_check4 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2703, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))->base.u.bits.saturating_flag)
= 1;
2704
2705 /* Lay out the type: set its alignment, size, etc. */
2706 TYPE_UNSIGNED (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2706, __FUNCTION__))->base.u.bits.unsigned_flag)
= unsignedp;
2707 enum mode_class mclass = unsignedp ? MODE_UFRACT : MODE_FRACT;
2708 SET_TYPE_MODE (type, mode_for_size (precision, mclass, 0).require ())((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2708, __FUNCTION__))->type_common.mode = (mode_for_size (
precision, mclass, 0).require ()))
;
2709 layout_type (type);
2710
2711 return type;
2712}
2713
2714/* Create and return a type for accum of PRECISION bits, UNSIGNEDP,
2715 and SATP. */
2716
2717tree
2718make_accum_type (int precision, int unsignedp, int satp)
2719{
2720 tree type = make_node (FIXED_POINT_TYPE);
2721
2722 TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2722, __FUNCTION__))->type_common.precision)
= precision;
2723
2724 if (satp)
2725 TYPE_SATURATING (type)((tree_not_check4 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2725, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))->base.u.bits.saturating_flag)
= 1;
2726
2727 /* Lay out the type: set its alignment, size, etc. */
2728 TYPE_UNSIGNED (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2728, __FUNCTION__))->base.u.bits.unsigned_flag)
= unsignedp;
2729 enum mode_class mclass = unsignedp ? MODE_UACCUM : MODE_ACCUM;
2730 SET_TYPE_MODE (type, mode_for_size (precision, mclass, 0).require ())((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2730, __FUNCTION__))->type_common.mode = (mode_for_size (
precision, mclass, 0).require ()))
;
2731 layout_type (type);
2732
2733 return type;
2734}
2735
2736/* Initialize sizetypes so layout_type can use them. */
2737
2738void
2739initialize_sizetypes (void)
2740{
2741 int precision, bprecision;
2742
2743 /* Get sizetypes precision from the SIZE_TYPE target macro. */
2744 if (strcmp (SIZETYPE(((global_options.x_ix86_isa_flags & (1UL << 4)) !=
0) ? "long unsigned int" : "unsigned int")
, "unsigned int") == 0)
2745 precision = INT_TYPE_SIZE32;
2746 else if (strcmp (SIZETYPE(((global_options.x_ix86_isa_flags & (1UL << 4)) !=
0) ? "long unsigned int" : "unsigned int")
, "long unsigned int") == 0)
2747 precision = LONG_TYPE_SIZE(((global_options.x_ix86_isa_flags & (1UL << 58)) !=
0) ? 32 : ((8) * (((global_options.x_ix86_isa_flags & (1UL
<< 1)) != 0) ? 8 : 4)))
;
2748 else if (strcmp (SIZETYPE(((global_options.x_ix86_isa_flags & (1UL << 4)) !=
0) ? "long unsigned int" : "unsigned int")
, "long long unsigned int") == 0)
2749 precision = LONG_LONG_TYPE_SIZE64;
2750 else if (strcmp (SIZETYPE(((global_options.x_ix86_isa_flags & (1UL << 4)) !=
0) ? "long unsigned int" : "unsigned int")
, "short unsigned int") == 0)
2751 precision = SHORT_TYPE_SIZE16;
2752 else
2753 {
2754 int i;
2755
2756 precision = -1;
2757 for (i = 0; i < NUM_INT_N_ENTS1; i++)
2758 if (int_n_enabled_p[i])
2759 {
2760 char name[50], altname[50];
2761 sprintf (name, "__int%d unsigned", int_n_data[i].bitsize);
2762 sprintf (altname, "__int%d__ unsigned", int_n_data[i].bitsize);
2763
2764 if (strcmp (name, SIZETYPE(((global_options.x_ix86_isa_flags & (1UL << 4)) !=
0) ? "long unsigned int" : "unsigned int")
) == 0
2765 || strcmp (altname, SIZETYPE(((global_options.x_ix86_isa_flags & (1UL << 4)) !=
0) ? "long unsigned int" : "unsigned int")
) == 0)
2766 {
2767 precision = int_n_data[i].bitsize;
2768 }
2769 }
2770 if (precision == -1)
2771 gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2771, __FUNCTION__))
;
2772 }
2773
2774 bprecision
2775 = MIN (precision + LOG2_BITS_PER_UNIT + 1, MAX_FIXED_MODE_SIZE)((precision + 3 + 1) < (GET_MODE_BITSIZE (((global_options
.x_ix86_isa_flags & (1UL << 1)) != 0) ? (scalar_int_mode
((scalar_int_mode::from_int) E_TImode)) : (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)))) ? (precision + 3 + 1
) : (GET_MODE_BITSIZE (((global_options.x_ix86_isa_flags &
(1UL << 1)) != 0) ? (scalar_int_mode ((scalar_int_mode
::from_int) E_TImode)) : (scalar_int_mode ((scalar_int_mode::
from_int) E_DImode)))))
;
2776 bprecision = GET_MODE_PRECISION (smallest_int_mode_for_size (bprecision));
2777 if (bprecision > HOST_BITS_PER_DOUBLE_INT(2 * 64))
2778 bprecision = HOST_BITS_PER_DOUBLE_INT(2 * 64);
2779
2780 /* Create stubs for sizetype and bitsizetype so we can create constants. */
2781 sizetypesizetype_tab[(int) stk_sizetype] = make_node (INTEGER_TYPE);
2782 TYPE_NAME (sizetype)((tree_class_check ((sizetype_tab[(int) stk_sizetype]), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2782, __FUNCTION__))->type_common.name)
= get_identifier ("sizetype")(__builtin_constant_p ("sizetype") ? get_identifier_with_length
(("sizetype"), strlen ("sizetype")) : get_identifier ("sizetype"
))
;
2783 TYPE_PRECISION (sizetype)((tree_class_check ((sizetype_tab[(int) stk_sizetype]), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2783, __FUNCTION__))->type_common.precision)
= precision;
2784 TYPE_UNSIGNED (sizetype)((tree_class_check ((sizetype_tab[(int) stk_sizetype]), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2784, __FUNCTION__))->base.u.bits.unsigned_flag)
= 1;
2785 bitsizetypesizetype_tab[(int) stk_bitsizetype] = make_node (INTEGER_TYPE);
2786 TYPE_NAME (bitsizetype)((tree_class_check ((sizetype_tab[(int) stk_bitsizetype]), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2786, __FUNCTION__))->type_common.name)
= get_identifier ("bitsizetype")(__builtin_constant_p ("bitsizetype") ? get_identifier_with_length
(("bitsizetype"), strlen ("bitsizetype")) : get_identifier (
"bitsizetype"))
;
2787 TYPE_PRECISION (bitsizetype)((tree_class_check ((sizetype_tab[(int) stk_bitsizetype]), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2787, __FUNCTION__))->type_common.precision)
= bprecision;
2788 TYPE_UNSIGNED (bitsizetype)((tree_class_check ((sizetype_tab[(int) stk_bitsizetype]), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2788, __FUNCTION__))->base.u.bits.unsigned_flag)
= 1;
2789
2790 /* Now layout both types manually. */
2791 scalar_int_mode mode = smallest_int_mode_for_size (precision);
2792 SET_TYPE_MODE (sizetype, mode)((tree_class_check ((sizetype_tab[(int) stk_sizetype]), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2792, __FUNCTION__))->type_common.mode = (mode))
;
2793 SET_TYPE_ALIGN (sizetype, GET_MODE_ALIGNMENT (TYPE_MODE (sizetype)))((tree_class_check ((sizetype_tab[(int) stk_sizetype]), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2793, __FUNCTION__))->type_common.align = ffs_hwi (get_mode_alignment
(((((enum tree_code) ((tree_class_check ((sizetype_tab[(int)
stk_sizetype]), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2793, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(sizetype_tab[(int) stk_sizetype]) : (sizetype_tab[(int) stk_sizetype
])->type_common.mode))))
;
2794 TYPE_SIZE (sizetype)((tree_class_check ((sizetype_tab[(int) stk_sizetype]), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2794, __FUNCTION__))->type_common.size)
= bitsize_int (precision)size_int_kind (precision, stk_bitsizetype);
2795 TYPE_SIZE_UNIT (sizetype)((tree_class_check ((sizetype_tab[(int) stk_sizetype]), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2795, __FUNCTION__))->type_common.size_unit)
= size_int (GET_MODE_SIZE (mode))size_int_kind (GET_MODE_SIZE (mode), stk_sizetype);
2796 set_min_and_max_values_for_integral_type (sizetypesizetype_tab[(int) stk_sizetype], precision, UNSIGNED);
2797
2798 mode = smallest_int_mode_for_size (bprecision);
2799 SET_TYPE_MODE (bitsizetype, mode)((tree_class_check ((sizetype_tab[(int) stk_bitsizetype]), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2799, __FUNCTION__))->type_common.mode = (mode))
;
2800 SET_TYPE_ALIGN (bitsizetype, GET_MODE_ALIGNMENT (TYPE_MODE (bitsizetype)))((tree_class_check ((sizetype_tab[(int) stk_bitsizetype]), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2800, __FUNCTION__))->type_common.align = ffs_hwi (get_mode_alignment
(((((enum tree_code) ((tree_class_check ((sizetype_tab[(int)
stk_bitsizetype]), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2800, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(sizetype_tab[(int) stk_bitsizetype]) : (sizetype_tab[(int) stk_bitsizetype
])->type_common.mode))))
;
2801 TYPE_SIZE (bitsizetype)((tree_class_check ((sizetype_tab[(int) stk_bitsizetype]), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2801, __FUNCTION__))->type_common.size)
= bitsize_int (bprecision)size_int_kind (bprecision, stk_bitsizetype);
2802 TYPE_SIZE_UNIT (bitsizetype)((tree_class_check ((sizetype_tab[(int) stk_bitsizetype]), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2802, __FUNCTION__))->type_common.size_unit)
= size_int (GET_MODE_SIZE (mode))size_int_kind (GET_MODE_SIZE (mode), stk_sizetype);
2803 set_min_and_max_values_for_integral_type (bitsizetypesizetype_tab[(int) stk_bitsizetype], bprecision, UNSIGNED);
2804
2805 /* Create the signed variants of *sizetype. */
2806 ssizetypesizetype_tab[(int) stk_ssizetype] = make_signed_type (TYPE_PRECISION (sizetype)((tree_class_check ((sizetype_tab[(int) stk_sizetype]), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2806, __FUNCTION__))->type_common.precision)
);
2807 TYPE_NAME (ssizetype)((tree_class_check ((sizetype_tab[(int) stk_ssizetype]), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2807, __FUNCTION__))->type_common.name)
= get_identifier ("ssizetype")(__builtin_constant_p ("ssizetype") ? get_identifier_with_length
(("ssizetype"), strlen ("ssizetype")) : get_identifier ("ssizetype"
))
;
2808 sbitsizetypesizetype_tab[(int) stk_sbitsizetype] = make_signed_type (TYPE_PRECISION (bitsizetype)((tree_class_check ((sizetype_tab[(int) stk_bitsizetype]), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2808, __FUNCTION__))->type_common.precision)
);
2809 TYPE_NAME (sbitsizetype)((tree_class_check ((sizetype_tab[(int) stk_sbitsizetype]), (
tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2809, __FUNCTION__))->type_common.name)
= get_identifier ("sbitsizetype")(__builtin_constant_p ("sbitsizetype") ? get_identifier_with_length
(("sbitsizetype"), strlen ("sbitsizetype")) : get_identifier
("sbitsizetype"))
;
2810}
2811
2812/* TYPE is an integral type, i.e., an INTEGRAL_TYPE, ENUMERAL_TYPE
2813 or BOOLEAN_TYPE. Set TYPE_MIN_VALUE and TYPE_MAX_VALUE
2814 for TYPE, based on the PRECISION and whether or not the TYPE
2815 IS_UNSIGNED. PRECISION need not correspond to a width supported
2816 natively by the hardware; for example, on a machine with 8-bit,
2817 16-bit, and 32-bit register modes, PRECISION might be 7, 23, or
2818 61. */
2819
2820void
2821set_min_and_max_values_for_integral_type (tree type,
2822 int precision,
2823 signop sgn)
2824{
2825 /* For bitfields with zero width we end up creating integer types
2826 with zero precision. Don't assign any minimum/maximum values
2827 to those types, they don't have any valid value. */
2828 if (precision < 1)
2829 return;
2830
2831 TYPE_MIN_VALUE (type)((tree_check5 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2831, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.minval
)
2832 = wide_int_to_tree (type, wi::min_value (precision, sgn));
2833 TYPE_MAX_VALUE (type)((tree_check5 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2833, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.maxval
)
2834 = wide_int_to_tree (type, wi::max_value (precision, sgn));
2835}
2836
2837/* Set the extreme values of TYPE based on its precision in bits,
2838 then lay it out. Used when make_signed_type won't do
2839 because the tree code is not INTEGER_TYPE. */
2840
2841void
2842fixup_signed_type (tree type)
2843{
2844 int precision = TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2844, __FUNCTION__))->type_common.precision)
;
2845
2846 set_min_and_max_values_for_integral_type (type, precision, SIGNED);
2847
2848 /* Lay out the type: set its alignment, size, etc. */
2849 layout_type (type);
2850}
2851
2852/* Set the extreme values of TYPE based on its precision in bits,
2853 then lay it out. This is used both in `make_unsigned_type'
2854 and for enumeral types. */
2855
2856void
2857fixup_unsigned_type (tree type)
2858{
2859 int precision = TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2859, __FUNCTION__))->type_common.precision)
;
2860
2861 TYPE_UNSIGNED (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 2861, __FUNCTION__))->base.u.bits.unsigned_flag)
= 1;
2862
2863 set_min_and_max_values_for_integral_type (type, precision, UNSIGNED);
2864
2865 /* Lay out the type: set its alignment, size, etc. */
2866 layout_type (type);
2867}
2868
2869/* Construct an iterator for a bitfield that spans BITSIZE bits,
2870 starting at BITPOS.
2871
2872 BITREGION_START is the bit position of the first bit in this
2873 sequence of bit fields. BITREGION_END is the last bit in this
2874 sequence. If these two fields are non-zero, we should restrict the
2875 memory access to that range. Otherwise, we are allowed to touch
2876 any adjacent non bit-fields.
2877
2878 ALIGN is the alignment of the underlying object in bits.
2879 VOLATILEP says whether the bitfield is volatile. */
2880
2881bit_field_mode_iterator
2882::bit_field_mode_iterator (HOST_WIDE_INTlong bitsize, HOST_WIDE_INTlong bitpos,
2883 poly_int64 bitregion_start,
2884 poly_int64 bitregion_end,
2885 unsigned int align, bool volatilep)
2886: m_mode (NARROWEST_INT_MODE(scalar_int_mode (scalar_int_mode::from_int (class_narrowest_mode
[MODE_INT])))
), m_bitsize (bitsize),
2887 m_bitpos (bitpos), m_bitregion_start (bitregion_start),
2888 m_bitregion_end (bitregion_end), m_align (align),
2889 m_volatilep (volatilep), m_count (0)
2890{
2891 if (known_eq (m_bitregion_end, 0)(!maybe_ne (m_bitregion_end, 0)))
2892 {
2893 /* We can assume that any aligned chunk of ALIGN bits that overlaps
2894 the bitfield is mapped and won't trap, provided that ALIGN isn't
2895 too large. The cap is the biggest required alignment for data,
2896 or at least the word size. And force one such chunk at least. */
2897 unsigned HOST_WIDE_INTlong units
2898 = MIN (align, MAX (BIGGEST_ALIGNMENT, BITS_PER_WORD))((align) < ((((((global_options.x_target_flags & (1U <<
12)) != 0) ? 32 : (((global_options.x_ix86_isa_flags & (
1UL << 15)) != 0) ? 512 : (((global_options.x_ix86_isa_flags
& (1UL << 8)) != 0) ? 256 : 128)))) > (((8) * (
((global_options.x_ix86_isa_flags & (1UL << 1)) != 0
) ? 8 : 4))) ? ((((global_options.x_target_flags & (1U <<
12)) != 0) ? 32 : (((global_options.x_ix86_isa_flags & (
1UL << 15)) != 0) ? 512 : (((global_options.x_ix86_isa_flags
& (1UL << 8)) != 0) ? 256 : 128)))) : (((8) * (((global_options
.x_ix86_isa_flags & (1UL << 1)) != 0) ? 8 : 4))))) ?
(align) : ((((((global_options.x_target_flags & (1U <<
12)) != 0) ? 32 : (((global_options.x_ix86_isa_flags & (
1UL << 15)) != 0) ? 512 : (((global_options.x_ix86_isa_flags
& (1UL << 8)) != 0) ? 256 : 128)))) > (((8) * (
((global_options.x_ix86_isa_flags & (1UL << 1)) != 0
) ? 8 : 4))) ? ((((global_options.x_target_flags & (1U <<
12)) != 0) ? 32 : (((global_options.x_ix86_isa_flags & (
1UL << 15)) != 0) ? 512 : (((global_options.x_ix86_isa_flags
& (1UL << 8)) != 0) ? 256 : 128)))) : (((8) * (((global_options
.x_ix86_isa_flags & (1UL << 1)) != 0) ? 8 : 4))))))
;
2899 if (bitsize <= 0)
2900 bitsize = 1;
2901 HOST_WIDE_INTlong end = bitpos + bitsize + units - 1;
2902 m_bitregion_end = end - end % units - 1;
2903 }
2904}
2905
2906/* Calls to this function return successively larger modes that can be used
2907 to represent the bitfield. Return true if another bitfield mode is
2908 available, storing it in *OUT_MODE if so. */
2909
2910bool
2911bit_field_mode_iterator::next_mode (scalar_int_mode *out_mode)
2912{
2913 scalar_int_mode mode;
2914 for (; m_mode.exists (&mode); m_mode = GET_MODE_WIDER_MODE (mode))
2915 {
2916 unsigned int unit = GET_MODE_BITSIZE (mode);
2917
2918 /* Skip modes that don't have full precision. */
2919 if (unit != GET_MODE_PRECISION (mode))
2920 continue;
2921
2922 /* Stop if the mode is too wide to handle efficiently. */
2923 if (unit > MAX_FIXED_MODE_SIZEGET_MODE_BITSIZE (((global_options.x_ix86_isa_flags & (1UL
<< 1)) != 0) ? (scalar_int_mode ((scalar_int_mode::from_int
) E_TImode)) : (scalar_int_mode ((scalar_int_mode::from_int) E_DImode
)))
)
2924 break;
2925
2926 /* Don't deliver more than one multiword mode; the smallest one
2927 should be used. */
2928 if (m_count > 0 && unit > BITS_PER_WORD((8) * (((global_options.x_ix86_isa_flags & (1UL <<
1)) != 0) ? 8 : 4))
)
2929 break;
2930
2931 /* Skip modes that are too small. */
2932 unsigned HOST_WIDE_INTlong substart = (unsigned HOST_WIDE_INTlong) m_bitpos % unit;
2933 unsigned HOST_WIDE_INTlong subend = substart + m_bitsize;
2934 if (subend > unit)
2935 continue;
2936
2937 /* Stop if the mode goes outside the bitregion. */
2938 HOST_WIDE_INTlong start = m_bitpos - substart;
2939 if (maybe_ne (m_bitregion_start, 0)
2940 && maybe_lt (start, m_bitregion_start))
2941 break;
2942 HOST_WIDE_INTlong end = start + unit;
2943 if (maybe_gt (end, m_bitregion_end + 1)maybe_lt (m_bitregion_end + 1, end))
2944 break;
2945
2946 /* Stop if the mode requires too much alignment. */
2947 if (GET_MODE_ALIGNMENT (mode)get_mode_alignment (mode) > m_align
2948 && targetm.slow_unaligned_access (mode, m_align))
2949 break;
2950
2951 *out_mode = mode;
2952 m_mode = GET_MODE_WIDER_MODE (mode);
2953 m_count++;
2954 return true;
2955 }
2956 return false;
2957}
2958
2959/* Return true if smaller modes are generally preferred for this kind
2960 of bitfield. */
2961
2962bool
2963bit_field_mode_iterator::prefer_smaller_modes ()
2964{
2965 return (m_volatilep
2966 ? targetm.narrow_volatile_bitfield ()
2967 : !SLOW_BYTE_ACCESS0);
2968}
2969
2970/* Find the best machine mode to use when referencing a bit field of length
2971 BITSIZE bits starting at BITPOS.
2972
2973 BITREGION_START is the bit position of the first bit in this
2974 sequence of bit fields. BITREGION_END is the last bit in this
2975 sequence. If these two fields are non-zero, we should restrict the
2976 memory access to that range. Otherwise, we are allowed to touch
2977 any adjacent non bit-fields.
2978
2979 The chosen mode must have no more than LARGEST_MODE_BITSIZE bits.
2980 INT_MAX is a suitable value for LARGEST_MODE_BITSIZE if the caller
2981 doesn't want to apply a specific limit.
2982
2983 If no mode meets all these conditions, we return VOIDmode.
2984
2985 The underlying object is known to be aligned to a boundary of ALIGN bits.
2986
2987 If VOLATILEP is false and SLOW_BYTE_ACCESS is false, we return the
2988 smallest mode meeting these conditions.
2989
2990 If VOLATILEP is false and SLOW_BYTE_ACCESS is true, we return the
2991 largest mode (but a mode no wider than UNITS_PER_WORD) that meets
2992 all the conditions.
2993
2994 If VOLATILEP is true the narrow_volatile_bitfields target hook is used to
2995 decide which of the above modes should be used. */
2996
2997bool
2998get_best_mode (int bitsize, int bitpos,
2999 poly_uint64 bitregion_start, poly_uint64 bitregion_end,
3000 unsigned int align,
3001 unsigned HOST_WIDE_INTlong largest_mode_bitsize, bool volatilep,
3002 scalar_int_mode *best_mode)
3003{
3004 bit_field_mode_iterator iter (bitsize, bitpos, bitregion_start,
3005 bitregion_end, align, volatilep);
3006 scalar_int_mode mode;
3007 bool found = false;
3008 while (iter.next_mode (&mode)
3009 /* ??? For historical reasons, reject modes that would normally
3010 receive greater alignment, even if unaligned accesses are
3011 acceptable. This has both advantages and disadvantages.
3012 Removing this check means that something like:
3013
3014 struct s { unsigned int x; unsigned int y; };
3015 int f (struct s *s) { return s->x == 0 && s->y == 0; }
3016
3017 can be implemented using a single load and compare on
3018 64-bit machines that have no alignment restrictions.
3019 For example, on powerpc64-linux-gnu, we would generate:
3020
3021 ld 3,0(3)
3022 cntlzd 3,3
3023 srdi 3,3,6
3024 blr
3025
3026 rather than:
3027
3028 lwz 9,0(3)
3029 cmpwi 7,9,0
3030 bne 7,.L3
3031 lwz 3,4(3)
3032 cntlzw 3,3
3033 srwi 3,3,5
3034 extsw 3,3
3035 blr
3036 .p2align 4,,15
3037 .L3:
3038 li 3,0
3039 blr
3040
3041 However, accessing more than one field can make life harder
3042 for the gimple optimizers. For example, gcc.dg/vect/bb-slp-5.c
3043 has a series of unsigned short copies followed by a series of
3044 unsigned short comparisons. With this check, both the copies
3045 and comparisons remain 16-bit accesses and FRE is able
3046 to eliminate the latter. Without the check, the comparisons
3047 can be done using 2 64-bit operations, which FRE isn't able
3048 to handle in the same way.
3049
3050 Either way, it would probably be worth disabling this check
3051 during expand. One particular example where removing the
3052 check would help is the get_best_mode call in store_bit_field.
3053 If we are given a memory bitregion of 128 bits that is aligned
3054 to a 64-bit boundary, and the bitfield we want to modify is
3055 in the second half of the bitregion, this check causes
3056 store_bitfield to turn the memory into a 64-bit reference
3057 to the _first_ half of the region. We later use
3058 adjust_bitfield_address to get a reference to the correct half,
3059 but doing so looks to adjust_bitfield_address as though we are
3060 moving past the end of the original object, so it drops the
3061 associated MEM_EXPR and MEM_OFFSET. Removing the check
3062 causes store_bit_field to keep a 128-bit memory reference,
3063 so that the final bitfield reference still has a MEM_EXPR
3064 and MEM_OFFSET. */
3065 && GET_MODE_ALIGNMENT (mode)get_mode_alignment (mode) <= align
3066 && GET_MODE_BITSIZE (mode) <= largest_mode_bitsize)
3067 {
3068 *best_mode = mode;
3069 found = true;
3070 if (iter.prefer_smaller_modes ())
3071 break;
3072 }
3073
3074 return found;
3075}
3076
3077/* Gets minimal and maximal values for MODE (signed or unsigned depending on
3078 SIGN). The returned constants are made to be usable in TARGET_MODE. */
3079
3080void
3081get_mode_bounds (scalar_int_mode mode, int sign,
3082 scalar_int_mode target_mode,
3083 rtx *mmin, rtx *mmax)
3084{
3085 unsigned size = GET_MODE_PRECISION (mode);
3086 unsigned HOST_WIDE_INTlong min_val, max_val;
3087
3088 gcc_assert (size <= HOST_BITS_PER_WIDE_INT)((void)(!(size <= 64) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/stor-layout.c"
, 3088, __FUNCTION__), 0 : 0))
;
3089
3090 /* Special case BImode, which has values 0 and STORE_FLAG_VALUE. */
3091 if (mode == BImode(scalar_int_mode ((scalar_int_mode::from_int) E_BImode)))
3092 {
3093 if (STORE_FLAG_VALUE1 < 0)
3094 {
3095 min_val = STORE_FLAG_VALUE1;
3096 max_val = 0;
3097 }
3098 else
3099 {
3100 min_val = 0;
3101 max_val = STORE_FLAG_VALUE1;
3102 }
3103 }
3104 else if (sign)
3105 {
3106 min_val = -(HOST_WIDE_INT_1U1UL << (size - 1));
3107 max_val = (HOST_WIDE_INT_1U1UL << (size - 1)) - 1;
3108 }
3109 else
3110 {
3111 min_val = 0;
3112 max_val = (HOST_WIDE_INT_1U1UL << (size - 1) << 1) - 1;
3113 }
3114
3115 *mmin = gen_int_mode (min_val, target_mode);
3116 *mmax = gen_int_mode (max_val, target_mode);
3117}
3118
3119#include "gt-stor-layout.h"

/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h

1/* Definitions for the ubiquitous 'tree' type for GNU compilers.
2 Copyright (C) 1989-2021 Free Software Foundation, Inc.
3
4This file is part of GCC.
5
6GCC is free software; you can redistribute it and/or modify it under
7the terms of the GNU General Public License as published by the Free
8Software Foundation; either version 3, or (at your option) any later
9version.
10
11GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12WARRANTY; without even the implied warranty of MERCHANTABILITY or
13FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14for more details.
15
16You should have received a copy of the GNU General Public License
17along with GCC; see the file COPYING3. If not see
18<http://www.gnu.org/licenses/>. */
19
20#ifndef GCC_TREE_H
21#define GCC_TREE_H
22
23#include "tree-core.h"
24
25/* Convert a target-independent built-in function code to a combined_fn. */
26
27inline combined_fn
28as_combined_fn (built_in_function fn)
29{
30 return combined_fn (int (fn));
31}
32
33/* Convert an internal function code to a combined_fn. */
34
35inline combined_fn
36as_combined_fn (internal_fn fn)
37{
38 return combined_fn (int (fn) + int (END_BUILTINS));
39}
40
41/* Return true if CODE is a target-independent built-in function. */
42
43inline bool
44builtin_fn_p (combined_fn code)
45{
46 return int (code) < int (END_BUILTINS);
47}
48
49/* Return the target-independent built-in function represented by CODE.
50 Only valid if builtin_fn_p (CODE). */
51
52inline built_in_function
53as_builtin_fn (combined_fn code)
54{
55 gcc_checking_assert (builtin_fn_p (code))((void)(!(builtin_fn_p (code)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 55, __FUNCTION__), 0 : 0))
;
56 return built_in_function (int (code));
57}
58
59/* Return true if CODE is an internal function. */
60
61inline bool
62internal_fn_p (combined_fn code)
63{
64 return int (code) >= int (END_BUILTINS);
65}
66
67/* Return the internal function represented by CODE. Only valid if
68 internal_fn_p (CODE). */
69
70inline internal_fn
71as_internal_fn (combined_fn code)
72{
73 gcc_checking_assert (internal_fn_p (code))((void)(!(internal_fn_p (code)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 73, __FUNCTION__), 0 : 0))
;
74 return internal_fn (int (code) - int (END_BUILTINS));
75}
76
77/* Macros for initializing `tree_contains_struct'. */
78#define MARK_TS_BASE(C)(tree_contains_struct[C][TS_BASE] = true) \
79 (tree_contains_struct[C][TS_BASE] = true)
80
81#define MARK_TS_TYPED(C)((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true)
\
82 (MARK_TS_BASE (C)(tree_contains_struct[C][TS_BASE] = true), \
83 tree_contains_struct[C][TS_TYPED] = true)
84
85#define MARK_TS_COMMON(C)(((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true), tree_contains_struct[C][TS_COMMON] = true
)
\
86 (MARK_TS_TYPED (C)((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true)
, \
87 tree_contains_struct[C][TS_COMMON] = true)
88
89#define MARK_TS_TYPE_COMMON(C)((((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true), tree_contains_struct[C][TS_COMMON] = true
), tree_contains_struct[C][TS_TYPE_COMMON] = true)
\
90 (MARK_TS_COMMON (C)(((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true), tree_contains_struct[C][TS_COMMON] = true
)
, \
91 tree_contains_struct[C][TS_TYPE_COMMON] = true)
92
93#define MARK_TS_TYPE_WITH_LANG_SPECIFIC(C)(((((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true), tree_contains_struct[C][TS_COMMON] = true
), tree_contains_struct[C][TS_TYPE_COMMON] = true), tree_contains_struct
[C][TS_TYPE_WITH_LANG_SPECIFIC] = true)
\
94 (MARK_TS_TYPE_COMMON (C)((((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true), tree_contains_struct[C][TS_COMMON] = true
), tree_contains_struct[C][TS_TYPE_COMMON] = true)
, \
95 tree_contains_struct[C][TS_TYPE_WITH_LANG_SPECIFIC] = true)
96
97#define MARK_TS_TYPE_NON_COMMON(C)((((((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true), tree_contains_struct[C][TS_COMMON] = true
), tree_contains_struct[C][TS_TYPE_COMMON] = true), tree_contains_struct
[C][TS_TYPE_WITH_LANG_SPECIFIC] = true), tree_contains_struct
[C][TS_TYPE_NON_COMMON] = true)
\
98 (MARK_TS_TYPE_WITH_LANG_SPECIFIC (C)(((((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true), tree_contains_struct[C][TS_COMMON] = true
), tree_contains_struct[C][TS_TYPE_COMMON] = true), tree_contains_struct
[C][TS_TYPE_WITH_LANG_SPECIFIC] = true)
, \
99 tree_contains_struct[C][TS_TYPE_NON_COMMON] = true) \
100
101#define MARK_TS_DECL_MINIMAL(C)((((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true), tree_contains_struct[C][TS_COMMON] = true
), tree_contains_struct[C][TS_DECL_MINIMAL] = true)
\
102 (MARK_TS_COMMON (C)(((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true), tree_contains_struct[C][TS_COMMON] = true
)
, \
103 tree_contains_struct[C][TS_DECL_MINIMAL] = true)
104
105#define MARK_TS_DECL_COMMON(C)(((((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true), tree_contains_struct[C][TS_COMMON] = true
), tree_contains_struct[C][TS_DECL_MINIMAL] = true), tree_contains_struct
[C][TS_DECL_COMMON] = true)
\
106 (MARK_TS_DECL_MINIMAL (C)((((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true), tree_contains_struct[C][TS_COMMON] = true
), tree_contains_struct[C][TS_DECL_MINIMAL] = true)
, \
107 tree_contains_struct[C][TS_DECL_COMMON] = true)
108
109#define MARK_TS_DECL_WRTL(C)((((((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true), tree_contains_struct[C][TS_COMMON] = true
), tree_contains_struct[C][TS_DECL_MINIMAL] = true), tree_contains_struct
[C][TS_DECL_COMMON] = true), tree_contains_struct[C][TS_DECL_WRTL
] = true)
\
110 (MARK_TS_DECL_COMMON (C)(((((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true), tree_contains_struct[C][TS_COMMON] = true
), tree_contains_struct[C][TS_DECL_MINIMAL] = true), tree_contains_struct
[C][TS_DECL_COMMON] = true)
, \
111 tree_contains_struct[C][TS_DECL_WRTL] = true)
112
113#define MARK_TS_DECL_WITH_VIS(C)(((((((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true), tree_contains_struct[C][TS_COMMON] = true
), tree_contains_struct[C][TS_DECL_MINIMAL] = true), tree_contains_struct
[C][TS_DECL_COMMON] = true), tree_contains_struct[C][TS_DECL_WRTL
] = true), tree_contains_struct[C][TS_DECL_WITH_VIS] = true)
\
114 (MARK_TS_DECL_WRTL (C)((((((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true), tree_contains_struct[C][TS_COMMON] = true
), tree_contains_struct[C][TS_DECL_MINIMAL] = true), tree_contains_struct
[C][TS_DECL_COMMON] = true), tree_contains_struct[C][TS_DECL_WRTL
] = true)
, \
115 tree_contains_struct[C][TS_DECL_WITH_VIS] = true)
116
117#define MARK_TS_DECL_NON_COMMON(C)((((((((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true), tree_contains_struct[C][TS_COMMON] = true
), tree_contains_struct[C][TS_DECL_MINIMAL] = true), tree_contains_struct
[C][TS_DECL_COMMON] = true), tree_contains_struct[C][TS_DECL_WRTL
] = true), tree_contains_struct[C][TS_DECL_WITH_VIS] = true),
tree_contains_struct[C][TS_DECL_NON_COMMON] = true)
\
118 (MARK_TS_DECL_WITH_VIS (C)(((((((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true), tree_contains_struct[C][TS_COMMON] = true
), tree_contains_struct[C][TS_DECL_MINIMAL] = true), tree_contains_struct
[C][TS_DECL_COMMON] = true), tree_contains_struct[C][TS_DECL_WRTL
] = true), tree_contains_struct[C][TS_DECL_WITH_VIS] = true)
, \
119 tree_contains_struct[C][TS_DECL_NON_COMMON] = true)
120
121#define MARK_TS_EXP(C)(((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true), tree_contains_struct[C][TS_EXP] = true
)
\
122 (MARK_TS_TYPED (C)((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true)
, \
123 tree_contains_struct[C][TS_EXP] = true)
124
125/* Returns the string representing CLASS. */
126
127#define TREE_CODE_CLASS_STRING(CLASS)tree_code_class_strings[(int) (CLASS)]\
128 tree_code_class_strings[(int) (CLASS)]
129
130#define TREE_CODE_CLASS(CODE)tree_code_type[(int) (CODE)] tree_code_type[(int) (CODE)]
131
132/* Nonzero if NODE represents an exceptional code. */
133
134#define EXCEPTIONAL_CLASS_P(NODE)(tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))] == tcc_exceptional)
\
135 (TREE_CODE_CLASS (TREE_CODE (NODE))tree_code_type[(int) (((enum tree_code) (NODE)->base.code)
)]
== tcc_exceptional)
136
137/* Nonzero if NODE represents a constant. */
138
139#define CONSTANT_CLASS_P(NODE)(tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))] == tcc_constant)
\
140 (TREE_CODE_CLASS (TREE_CODE (NODE))tree_code_type[(int) (((enum tree_code) (NODE)->base.code)
)]
== tcc_constant)
141
142/* Nonzero if NODE represents a constant, or is a location wrapper
143 around such a node. */
144
145#define CONSTANT_CLASS_OR_WRAPPER_P(NODE)((tree_code_type[(int) (((enum tree_code) (tree_strip_any_location_wrapper
(NODE))->base.code))] == tcc_constant))
\
146 (CONSTANT_CLASS_P (tree_strip_any_location_wrapper (NODE))(tree_code_type[(int) (((enum tree_code) (tree_strip_any_location_wrapper
(NODE))->base.code))] == tcc_constant)
)
147
148/* Nonzero if NODE represents a type. */
149
150#define TYPE_P(NODE)(tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))] == tcc_type)
\
151 (TREE_CODE_CLASS (TREE_CODE (NODE))tree_code_type[(int) (((enum tree_code) (NODE)->base.code)
)]
== tcc_type)
152
153/* Nonzero if NODE represents a declaration. */
154
155#define DECL_P(NODE)(tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))] == tcc_declaration)
\
156 (TREE_CODE_CLASS (TREE_CODE (NODE))tree_code_type[(int) (((enum tree_code) (NODE)->base.code)
)]
== tcc_declaration)
157
158/* True if NODE designates a variable declaration. */
159#define VAR_P(NODE)(((enum tree_code) (NODE)->base.code) == VAR_DECL) \
160 (TREE_CODE (NODE)((enum tree_code) (NODE)->base.code) == VAR_DECL)
161
162/* Nonzero if DECL represents a VAR_DECL or FUNCTION_DECL. */
163
164#define VAR_OR_FUNCTION_DECL_P(DECL)(((enum tree_code) (DECL)->base.code) == VAR_DECL || ((enum
tree_code) (DECL)->base.code) == FUNCTION_DECL)
\
165 (TREE_CODE (DECL)((enum tree_code) (DECL)->base.code) == VAR_DECL || TREE_CODE (DECL)((enum tree_code) (DECL)->base.code) == FUNCTION_DECL)
166
167/* Nonzero if NODE represents a INDIRECT_REF. Keep these checks in
168 ascending code order. */
169
170#define INDIRECT_REF_P(NODE)(((enum tree_code) (NODE)->base.code) == INDIRECT_REF)\
171 (TREE_CODE (NODE)((enum tree_code) (NODE)->base.code) == INDIRECT_REF)
172
173/* Nonzero if NODE represents a reference. */
174
175#define REFERENCE_CLASS_P(NODE)(tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))] == tcc_reference)
\
176 (TREE_CODE_CLASS (TREE_CODE (NODE))tree_code_type[(int) (((enum tree_code) (NODE)->base.code)
)]
== tcc_reference)
177
178/* Nonzero if NODE represents a comparison. */
179
180#define COMPARISON_CLASS_P(NODE)(tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))] == tcc_comparison)
\
181 (TREE_CODE_CLASS (TREE_CODE (NODE))tree_code_type[(int) (((enum tree_code) (NODE)->base.code)
)]
== tcc_comparison)
182
183/* Nonzero if NODE represents a unary arithmetic expression. */
184
185#define UNARY_CLASS_P(NODE)(tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))] == tcc_unary)
\
186 (TREE_CODE_CLASS (TREE_CODE (NODE))tree_code_type[(int) (((enum tree_code) (NODE)->base.code)
)]
== tcc_unary)
187
188/* Nonzero if NODE represents a binary arithmetic expression. */
189
190#define BINARY_CLASS_P(NODE)(tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))] == tcc_binary)
\
191 (TREE_CODE_CLASS (TREE_CODE (NODE))tree_code_type[(int) (((enum tree_code) (NODE)->base.code)
)]
== tcc_binary)
192
193/* Nonzero if NODE represents a statement expression. */
194
195#define STATEMENT_CLASS_P(NODE)(tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))] == tcc_statement)
\
196 (TREE_CODE_CLASS (TREE_CODE (NODE))tree_code_type[(int) (((enum tree_code) (NODE)->base.code)
)]
== tcc_statement)
197
198/* Nonzero if NODE represents a function call-like expression with a
199 variable-length operand vector. */
200
201#define VL_EXP_CLASS_P(NODE)(tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))] == tcc_vl_exp)
\
202 (TREE_CODE_CLASS (TREE_CODE (NODE))tree_code_type[(int) (((enum tree_code) (NODE)->base.code)
)]
== tcc_vl_exp)
203
204/* Nonzero if NODE represents any other expression. */
205
206#define EXPRESSION_CLASS_P(NODE)(tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))] == tcc_expression)
\
207 (TREE_CODE_CLASS (TREE_CODE (NODE))tree_code_type[(int) (((enum tree_code) (NODE)->base.code)
)]
== tcc_expression)
208
209/* Returns nonzero iff NODE represents a type or declaration. */
210
211#define IS_TYPE_OR_DECL_P(NODE)((tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))] == tcc_type) || (tree_code_type[(int) (((enum tree_code) (
NODE)->base.code))] == tcc_declaration))
\
212 (TYPE_P (NODE)(tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))] == tcc_type)
|| DECL_P (NODE)(tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))] == tcc_declaration)
)
213
214/* Returns nonzero iff CLASS is the tree-code class of an
215 expression. */
216
217#define IS_EXPR_CODE_CLASS(CLASS)((CLASS) >= tcc_reference && (CLASS) <= tcc_expression
)
\
218 ((CLASS) >= tcc_reference && (CLASS) <= tcc_expression)
219
220/* Returns nonzero iff NODE is an expression of some kind. */
221
222#define EXPR_P(NODE)((tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))]) >= tcc_reference && (tree_code_type[(int) (((
enum tree_code) (NODE)->base.code))]) <= tcc_expression
)
IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (NODE)))((tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))]) >= tcc_reference && (tree_code_type[(int) (((
enum tree_code) (NODE)->base.code))]) <= tcc_expression
)
223
224#define TREE_CODE_LENGTH(CODE)tree_code_length[(int) (CODE)] tree_code_length[(int) (CODE)]
225
226
227/* Helper macros for math builtins. */
228
229#define CASE_FLT_FN(FN)case FN: case FNF: case FNL case FN: case FN##F: case FN##L
230#define CASE_FLT_FN_FLOATN_NX(FN)case FNF16: case FNF32: case FNF64: case FNF128: case FNF32X:
case FNF64X: case FNF128X
\
231 case FN##F16: case FN##F32: case FN##F64: case FN##F128: \
232 case FN##F32X: case FN##F64X: case FN##F128X
233#define CASE_FLT_FN_REENT(FN)case FN_R: case FNF_R: case FNL_R case FN##_R: case FN##F_R: case FN##L_R
234#define CASE_INT_FN(FN)case FN: case FNL: case FNLL: case FNIMAX case FN: case FN##L: case FN##LL: case FN##IMAX
235
236#define NULL_TREE(tree) nullptr (tree) NULLnullptr
237
238/* Define accessors for the fields that all tree nodes have
239 (though some fields are not used for all kinds of nodes). */
240
241/* The tree-code says what kind of node it is.
242 Codes are defined in tree.def. */
243#define TREE_CODE(NODE)((enum tree_code) (NODE)->base.code) ((enum tree_code) (NODE)->base.code)
244#define TREE_SET_CODE(NODE, VALUE)((NODE)->base.code = (VALUE)) ((NODE)->base.code = (VALUE))
245
246/* When checking is enabled, errors will be generated if a tree node
247 is accessed incorrectly. The macros die with a fatal error. */
248#if defined ENABLE_TREE_CHECKING1 && (GCC_VERSION(4 * 1000 + 2) >= 2007)
249
250#define TREE_CHECK(T, CODE)(tree_check ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 250, __FUNCTION__, (CODE)))
\
251(tree_check ((T), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__251, __FUNCTION__, (CODE)))
252
253#define TREE_NOT_CHECK(T, CODE)(tree_not_check ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 253, __FUNCTION__, (CODE)))
\
254(tree_not_check ((T), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__254, __FUNCTION__, (CODE)))
255
256#define TREE_CHECK2(T, CODE1, CODE2)(tree_check2 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 256, __FUNCTION__, (CODE1), (CODE2)))
\
257(tree_check2 ((T), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__257, __FUNCTION__, (CODE1), (CODE2)))
258
259#define TREE_NOT_CHECK2(T, CODE1, CODE2)(tree_not_check2 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 259, __FUNCTION__, (CODE1), (CODE2)))
\
260(tree_not_check2 ((T), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__260, __FUNCTION__, (CODE1), (CODE2)))
261
262#define TREE_CHECK3(T, CODE1, CODE2, CODE3)(tree_check3 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 262, __FUNCTION__, (CODE1), (CODE2), (CODE3)))
\
263(tree_check3 ((T), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__263, __FUNCTION__, (CODE1), (CODE2), (CODE3)))
264
265#define TREE_NOT_CHECK3(T, CODE1, CODE2, CODE3)(tree_not_check3 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 265, __FUNCTION__, (CODE1), (CODE2), (CODE3)))
\
266(tree_not_check3 ((T), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__266, __FUNCTION__, \
267 (CODE1), (CODE2), (CODE3)))
268
269#define TREE_CHECK4(T, CODE1, CODE2, CODE3, CODE4)(tree_check4 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 269, __FUNCTION__, (CODE1), (CODE2), (CODE3), (CODE4)))
\
270(tree_check4 ((T), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__270, __FUNCTION__, \
271 (CODE1), (CODE2), (CODE3), (CODE4)))
272
273#define TREE_NOT_CHECK4(T, CODE1, CODE2, CODE3, CODE4)(tree_not_check4 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 273, __FUNCTION__, (CODE1), (CODE2), (CODE3), (CODE4)))
\
274(tree_not_check4 ((T), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__274, __FUNCTION__, \
275 (CODE1), (CODE2), (CODE3), (CODE4)))
276
277#define TREE_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5)(tree_check5 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 277, __FUNCTION__, (CODE1), (CODE2), (CODE3), (CODE4), (CODE5
)))
\
278(tree_check5 ((T), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__278, __FUNCTION__, \
279 (CODE1), (CODE2), (CODE3), (CODE4), (CODE5)))
280
281#define TREE_NOT_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5)(tree_not_check5 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 281, __FUNCTION__, (CODE1), (CODE2), (CODE3), (CODE4), (CODE5
)))
\
282(tree_not_check5 ((T), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__282, __FUNCTION__, \
283 (CODE1), (CODE2), (CODE3), (CODE4), (CODE5)))
284
285#define CONTAINS_STRUCT_CHECK(T, STRUCT)(contains_struct_check ((T), (STRUCT), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 285, __FUNCTION__))
\
286(contains_struct_check ((T), (STRUCT), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__286, __FUNCTION__))
287
288#define TREE_CLASS_CHECK(T, CLASS)(tree_class_check ((T), (CLASS), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 288, __FUNCTION__))
\
289(tree_class_check ((T), (CLASS), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__289, __FUNCTION__))
290
291#define TREE_RANGE_CHECK(T, CODE1, CODE2)(tree_range_check ((T), (CODE1), (CODE2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 291, __FUNCTION__))
\
292(tree_range_check ((T), (CODE1), (CODE2), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__292, __FUNCTION__))
293
294#define OMP_CLAUSE_SUBCODE_CHECK(T, CODE)(omp_clause_subcode_check ((T), (CODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 294, __FUNCTION__))
\
295(omp_clause_subcode_check ((T), (CODE), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__295, __FUNCTION__))
296
297#define OMP_CLAUSE_RANGE_CHECK(T, CODE1, CODE2)(omp_clause_range_check ((T), (CODE1), (CODE2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 297, __FUNCTION__))
\
298(omp_clause_range_check ((T), (CODE1), (CODE2), \
299 __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__299, __FUNCTION__))
300
301/* These checks have to be special cased. */
302#define EXPR_CHECK(T)(expr_check ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 302, __FUNCTION__))
\
303(expr_check ((T), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__303, __FUNCTION__))
304
305/* These checks have to be special cased. */
306#define NON_TYPE_CHECK(T)(non_type_check ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 306, __FUNCTION__))
\
307(non_type_check ((T), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__307, __FUNCTION__))
308
309/* These checks have to be special cased. */
310#define ANY_INTEGRAL_TYPE_CHECK(T)(any_integral_type_check ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 310, __FUNCTION__))
\
311(any_integral_type_check ((T), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__311, __FUNCTION__))
312
313#define TREE_INT_CST_ELT_CHECK(T, I)(*tree_int_cst_elt_check ((T), (I), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 313, __FUNCTION__))
\
314(*tree_int_cst_elt_check ((T), (I), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__314, __FUNCTION__))
315
316#define TREE_VEC_ELT_CHECK(T, I)(*((const_cast<tree *> (tree_vec_elt_check ((T), (I), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 316, __FUNCTION__)))))
\
317(*(CONST_CAST2 (tree *, typeof (T)*, \(const_cast<tree *> (tree_vec_elt_check ((T), (I), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 318, __FUNCTION__)))
318 tree_vec_elt_check ((T), (I), __FILE__, __LINE__, __FUNCTION__))(const_cast<tree *> (tree_vec_elt_check ((T), (I), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 318, __FUNCTION__)))
))
319
320#define OMP_CLAUSE_ELT_CHECK(T, I)(*(omp_clause_elt_check ((T), (I), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 320, __FUNCTION__)))
\
321(*(omp_clause_elt_check ((T), (I), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__321, __FUNCTION__)))
322
323/* Special checks for TREE_OPERANDs. */
324#define TREE_OPERAND_CHECK(T, I)(*((const_cast<tree*> (tree_operand_check ((T), (I), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 324, __FUNCTION__)))))
\
325(*(CONST_CAST2 (tree*, typeof (T)*, \(const_cast<tree*> (tree_operand_check ((T), (I), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 326, __FUNCTION__)))
326 tree_operand_check ((T), (I), __FILE__, __LINE__, __FUNCTION__))(const_cast<tree*> (tree_operand_check ((T), (I), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 326, __FUNCTION__)))
))
327
328#define TREE_OPERAND_CHECK_CODE(T, CODE, I)(*(tree_operand_check_code ((T), (CODE), (I), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 328, __FUNCTION__)))
\
329(*(tree_operand_check_code ((T), (CODE), (I), \
330 __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__330, __FUNCTION__)))
331
332/* Nodes are chained together for many purposes.
333 Types are chained together to record them for being output to the debugger
334 (see the function `chain_type').
335 Decls in the same scope are chained together to record the contents
336 of the scope.
337 Statement nodes for successive statements used to be chained together.
338 Often lists of things are represented by TREE_LIST nodes that
339 are chained together. */
340
341#define TREE_CHAIN(NODE)((contains_struct_check ((NODE), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 341, __FUNCTION__))->common.chain)
\
342(CONTAINS_STRUCT_CHECK (NODE, TS_COMMON)(contains_struct_check ((NODE), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 342, __FUNCTION__))
->common.chain)
343
344/* In all nodes that are expressions, this is the data type of the expression.
345 In POINTER_TYPE nodes, this is the type that the pointer points to.
346 In ARRAY_TYPE nodes, this is the type of the elements.
347 In VECTOR_TYPE nodes, this is the type of the elements. */
348#define TREE_TYPE(NODE)((contains_struct_check ((NODE), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 348, __FUNCTION__))->typed.type)
\
349(CONTAINS_STRUCT_CHECK (NODE, TS_TYPED)(contains_struct_check ((NODE), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 349, __FUNCTION__))
->typed.type)
350
351extern void tree_contains_struct_check_failed (const_tree,
352 const enum tree_node_structure_enum,
353 const char *, int, const char *)
354 ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
355
356extern void tree_check_failed (const_tree, const char *, int, const char *,
357 ...) ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
358extern void tree_not_check_failed (const_tree, const char *, int, const char *,
359 ...) ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
360extern void tree_class_check_failed (const_tree, const enum tree_code_class,
361 const char *, int, const char *)
362 ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
363extern void tree_range_check_failed (const_tree, const char *, int,
364 const char *, enum tree_code,
365 enum tree_code)
366 ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
367extern void tree_not_class_check_failed (const_tree,
368 const enum tree_code_class,
369 const char *, int, const char *)
370 ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
371extern void tree_int_cst_elt_check_failed (int, int, const char *,
372 int, const char *)
373 ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
374extern void tree_vec_elt_check_failed (int, int, const char *,
375 int, const char *)
376 ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
377extern void phi_node_elt_check_failed (int, int, const char *,
378 int, const char *)
379 ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
380extern void tree_operand_check_failed (int, const_tree,
381 const char *, int, const char *)
382 ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
383extern void omp_clause_check_failed (const_tree, const char *, int,
384 const char *, enum omp_clause_code)
385 ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
386extern void omp_clause_operand_check_failed (int, const_tree, const char *,
387 int, const char *)
388 ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
389extern void omp_clause_range_check_failed (const_tree, const char *, int,
390 const char *, enum omp_clause_code,
391 enum omp_clause_code)
392 ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
393
394#else /* not ENABLE_TREE_CHECKING, or not gcc */
395
396#define CONTAINS_STRUCT_CHECK(T, ENUM)(contains_struct_check ((T), (ENUM), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 396, __FUNCTION__))
(T)
397#define TREE_CHECK(T, CODE)(tree_check ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 397, __FUNCTION__, (CODE)))
(T)
398#define TREE_NOT_CHECK(T, CODE)(tree_not_check ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 398, __FUNCTION__, (CODE)))
(T)
399#define TREE_CHECK2(T, CODE1, CODE2)(tree_check2 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 399, __FUNCTION__, (CODE1), (CODE2)))
(T)
400#define TREE_NOT_CHECK2(T, CODE1, CODE2)(tree_not_check2 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 400, __FUNCTION__, (CODE1), (CODE2)))
(T)
401#define TREE_CHECK3(T, CODE1, CODE2, CODE3)(tree_check3 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 401, __FUNCTION__, (CODE1), (CODE2), (CODE3)))
(T)
402#define TREE_NOT_CHECK3(T, CODE1, CODE2, CODE3)(tree_not_check3 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 402, __FUNCTION__, (CODE1), (CODE2), (CODE3)))
(T)
403#define TREE_CHECK4(T, CODE1, CODE2, CODE3, CODE4)(tree_check4 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 403, __FUNCTION__, (CODE1), (CODE2), (CODE3), (CODE4)))
(T)
404#define TREE_NOT_CHECK4(T, CODE1, CODE2, CODE3, CODE4)(tree_not_check4 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 404, __FUNCTION__, (CODE1), (CODE2), (CODE3), (CODE4)))
(T)
405#define TREE_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5)(tree_check5 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 405, __FUNCTION__, (CODE1), (CODE2), (CODE3), (CODE4), (CODE5
)))
(T)
406#define TREE_NOT_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5)(tree_not_check5 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 406, __FUNCTION__, (CODE1), (CODE2), (CODE3), (CODE4), (CODE5
)))
(T)
407#define TREE_CLASS_CHECK(T, CODE)(tree_class_check ((T), (CODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 407, __FUNCTION__))
(T)
408#define TREE_RANGE_CHECK(T, CODE1, CODE2)(tree_range_check ((T), (CODE1), (CODE2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 408, __FUNCTION__))
(T)
409#define EXPR_CHECK(T)(expr_check ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 409, __FUNCTION__))
(T)
410#define NON_TYPE_CHECK(T)(non_type_check ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 410, __FUNCTION__))
(T)
411#define TREE_INT_CST_ELT_CHECK(T, I)(*tree_int_cst_elt_check ((T), (I), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 411, __FUNCTION__))
((T)->int_cst.val[I])
412#define TREE_VEC_ELT_CHECK(T, I)(*((const_cast<tree *> (tree_vec_elt_check ((T), (I), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 412, __FUNCTION__)))))
((T)->vec.a[I])
413#define TREE_OPERAND_CHECK(T, I)(*((const_cast<tree*> (tree_operand_check ((T), (I), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 413, __FUNCTION__)))))
((T)->exp.operands[I])
414#define TREE_OPERAND_CHECK_CODE(T, CODE, I)(*(tree_operand_check_code ((T), (CODE), (I), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 414, __FUNCTION__)))
((T)->exp.operands[I])
415#define OMP_CLAUSE_ELT_CHECK(T, i)(*(omp_clause_elt_check ((T), (i), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 415, __FUNCTION__)))
((T)->omp_clause.ops[i])
416#define OMP_CLAUSE_RANGE_CHECK(T, CODE1, CODE2)(omp_clause_range_check ((T), (CODE1), (CODE2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 416, __FUNCTION__))
(T)
417#define OMP_CLAUSE_SUBCODE_CHECK(T, CODE)(omp_clause_subcode_check ((T), (CODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 417, __FUNCTION__))
(T)
418#define ANY_INTEGRAL_TYPE_CHECK(T)(any_integral_type_check ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 418, __FUNCTION__))
(T)
419
420#define TREE_CHAIN(NODE)((contains_struct_check ((NODE), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 420, __FUNCTION__))->common.chain)
((NODE)->common.chain)
421#define TREE_TYPE(NODE)((contains_struct_check ((NODE), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 421, __FUNCTION__))->typed.type)
((NODE)->typed.type)
422
423#endif
424
425#define TREE_BLOCK(NODE)(tree_block (NODE)) (tree_block (NODE))
426#define TREE_SET_BLOCK(T, B)(tree_set_block ((T), (B))) (tree_set_block ((T), (B)))
427
428#include "tree-check.h"
429
430#define TYPE_CHECK(T)(tree_class_check ((T), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 430, __FUNCTION__))
TREE_CLASS_CHECK (T, tcc_type)(tree_class_check ((T), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 430, __FUNCTION__))
431#define DECL_MINIMAL_CHECK(T)(contains_struct_check ((T), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 431, __FUNCTION__))
CONTAINS_STRUCT_CHECK (T, TS_DECL_MINIMAL)(contains_struct_check ((T), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 431, __FUNCTION__))
432#define DECL_COMMON_CHECK(T)(contains_struct_check ((T), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 432, __FUNCTION__))
CONTAINS_STRUCT_CHECK (T, TS_DECL_COMMON)(contains_struct_check ((T), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 432, __FUNCTION__))
433#define DECL_WRTL_CHECK(T)(contains_struct_check ((T), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 433, __FUNCTION__))
CONTAINS_STRUCT_CHECK (T, TS_DECL_WRTL)(contains_struct_check ((T), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 433, __FUNCTION__))
434#define DECL_WITH_VIS_CHECK(T)(contains_struct_check ((T), (TS_DECL_WITH_VIS), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 434, __FUNCTION__))
CONTAINS_STRUCT_CHECK (T, TS_DECL_WITH_VIS)(contains_struct_check ((T), (TS_DECL_WITH_VIS), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 434, __FUNCTION__))
435#define DECL_NON_COMMON_CHECK(T)(contains_struct_check ((T), (TS_DECL_NON_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 435, __FUNCTION__))
CONTAINS_STRUCT_CHECK (T, TS_DECL_NON_COMMON)(contains_struct_check ((T), (TS_DECL_NON_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 435, __FUNCTION__))
436#define CST_CHECK(T)(tree_class_check ((T), (tcc_constant), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 436, __FUNCTION__))
TREE_CLASS_CHECK (T, tcc_constant)(tree_class_check ((T), (tcc_constant), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 436, __FUNCTION__))
437#define STMT_CHECK(T)(tree_class_check ((T), (tcc_statement), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 437, __FUNCTION__))
TREE_CLASS_CHECK (T, tcc_statement)(tree_class_check ((T), (tcc_statement), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 437, __FUNCTION__))
438#define VL_EXP_CHECK(T)(tree_class_check ((T), (tcc_vl_exp), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 438, __FUNCTION__))
TREE_CLASS_CHECK (T, tcc_vl_exp)(tree_class_check ((T), (tcc_vl_exp), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 438, __FUNCTION__))
439#define FUNC_OR_METHOD_CHECK(T)(tree_check2 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 439, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))
TREE_CHECK2 (T, FUNCTION_TYPE, METHOD_TYPE)(tree_check2 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 439, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))
440#define PTR_OR_REF_CHECK(T)(tree_check2 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 440, __FUNCTION__, (POINTER_TYPE), (REFERENCE_TYPE)))
TREE_CHECK2 (T, POINTER_TYPE, REFERENCE_TYPE)(tree_check2 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 440, __FUNCTION__, (POINTER_TYPE), (REFERENCE_TYPE)))
441
442#define RECORD_OR_UNION_CHECK(T)(tree_check3 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 442, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))
\
443 TREE_CHECK3 (T, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE)(tree_check3 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 443, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))
444#define NOT_RECORD_OR_UNION_CHECK(T)(tree_not_check3 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 444, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))
\
445 TREE_NOT_CHECK3 (T, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE)(tree_not_check3 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 445, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))
446#define ARRAY_OR_INTEGER_TYPE_CHECK(T)(tree_check2 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 446, __FUNCTION__, (ARRAY_TYPE), (INTEGER_TYPE)))
\
447 TREE_CHECK2 (T, ARRAY_TYPE, INTEGER_TYPE)(tree_check2 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 447, __FUNCTION__, (ARRAY_TYPE), (INTEGER_TYPE)))
448
449#define NUMERICAL_TYPE_CHECK(T)(tree_check5 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 449, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))
\
450 TREE_CHECK5 (T, INTEGER_TYPE, ENUMERAL_TYPE, BOOLEAN_TYPE, REAL_TYPE, \(tree_check5 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 451, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))
451 FIXED_POINT_TYPE)(tree_check5 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 451, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))
452
453/* Here is how primitive or already-canonicalized types' hash codes
454 are made. */
455#define TYPE_HASH(TYPE)(((tree_class_check ((TYPE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 455, __FUNCTION__))->type_common.uid))
(TYPE_UID (TYPE)((tree_class_check ((TYPE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 455, __FUNCTION__))->type_common.uid)
)
456
457/* A simple hash function for an arbitrary tree node. This must not be
458 used in hash tables which are saved to a PCH. */
459#define TREE_HASH(NODE)((size_t) (NODE) & 0777777) ((size_t) (NODE) & 0777777)
460
461/* Tests if CODE is a conversion expr (NOP_EXPR or CONVERT_EXPR). */
462#define CONVERT_EXPR_CODE_P(CODE)((CODE) == NOP_EXPR || (CODE) == CONVERT_EXPR) \
463 ((CODE) == NOP_EXPR || (CODE) == CONVERT_EXPR)
464
465/* Similarly, but accept an expression instead of a tree code. */
466#define CONVERT_EXPR_P(EXP)((((enum tree_code) (EXP)->base.code)) == NOP_EXPR || (((enum
tree_code) (EXP)->base.code)) == CONVERT_EXPR)
CONVERT_EXPR_CODE_P (TREE_CODE (EXP))((((enum tree_code) (EXP)->base.code)) == NOP_EXPR || (((enum
tree_code) (EXP)->base.code)) == CONVERT_EXPR)
467
468/* Generate case for NOP_EXPR, CONVERT_EXPR. */
469
470#define CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR \
471 case NOP_EXPR: \
472 case CONVERT_EXPR
473
474/* Given an expression as a tree, strip any conversion that generates
475 no instruction. Accepts both tree and const_tree arguments since
476 we are not modifying the tree itself. */
477
478#define STRIP_NOPS(EXP)(EXP) = tree_strip_nop_conversions ((const_cast<union tree_node
*> (((EXP)))))
\
479 (EXP) = tree_strip_nop_conversions (CONST_CAST_TREE (EXP)(const_cast<union tree_node *> (((EXP)))))
480
481/* Like STRIP_NOPS, but don't let the signedness change either. */
482
483#define STRIP_SIGN_NOPS(EXP)(EXP) = tree_strip_sign_nop_conversions ((const_cast<union
tree_node *> (((EXP)))))
\
484 (EXP) = tree_strip_sign_nop_conversions (CONST_CAST_TREE (EXP)(const_cast<union tree_node *> (((EXP)))))
485
486/* Like STRIP_NOPS, but don't alter the TREE_TYPE either. */
487
488#define STRIP_TYPE_NOPS(EXP)while ((((((enum tree_code) (EXP)->base.code)) == NOP_EXPR
|| (((enum tree_code) (EXP)->base.code)) == CONVERT_EXPR)
|| ((enum tree_code) (EXP)->base.code) == NON_LVALUE_EXPR
) && (*((const_cast<tree*> (tree_operand_check (
(EXP), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 488, __FUNCTION__))))) != global_trees[TI_ERROR_MARK] &&
(((contains_struct_check ((EXP), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 488, __FUNCTION__))->typed.type) == ((contains_struct_check
(((*((const_cast<tree*> (tree_operand_check ((EXP), (0
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 488, __FUNCTION__)))))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 488, __FUNCTION__))->typed.type))) (EXP) = (*((const_cast
<tree*> (tree_operand_check ((EXP), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 488, __FUNCTION__)))))
\
489 while ((CONVERT_EXPR_P (EXP)((((enum tree_code) (EXP)->base.code)) == NOP_EXPR || (((enum
tree_code) (EXP)->base.code)) == CONVERT_EXPR)
\
490 || TREE_CODE (EXP)((enum tree_code) (EXP)->base.code) == NON_LVALUE_EXPR) \
491 && TREE_OPERAND (EXP, 0)(*((const_cast<tree*> (tree_operand_check ((EXP), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 491, __FUNCTION__)))))
!= error_mark_nodeglobal_trees[TI_ERROR_MARK] \
492 && (TREE_TYPE (EXP)((contains_struct_check ((EXP), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 492, __FUNCTION__))->typed.type)
\
493 == TREE_TYPE (TREE_OPERAND (EXP, 0))((contains_struct_check (((*((const_cast<tree*> (tree_operand_check
((EXP), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 493, __FUNCTION__)))))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 493, __FUNCTION__))->typed.type)
)) \
494 (EXP) = TREE_OPERAND (EXP, 0)(*((const_cast<tree*> (tree_operand_check ((EXP), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 494, __FUNCTION__)))))
495
496/* Remove unnecessary type conversions according to
497 tree_ssa_useless_type_conversion. */
498
499#define STRIP_USELESS_TYPE_CONVERSION(EXP)(EXP) = tree_ssa_strip_useless_type_conversions (EXP) \
500 (EXP) = tree_ssa_strip_useless_type_conversions (EXP)
501
502/* Remove any VIEW_CONVERT_EXPR or NON_LVALUE_EXPR that's purely
503 in use to provide a location_t. */
504
505#define STRIP_ANY_LOCATION_WRAPPER(EXP)(EXP) = tree_strip_any_location_wrapper ((const_cast<union
tree_node *> (((EXP)))))
\
506 (EXP) = tree_strip_any_location_wrapper (CONST_CAST_TREE (EXP)(const_cast<union tree_node *> (((EXP)))))
507
508/* Nonzero if TYPE represents a vector type. */
509
510#define VECTOR_TYPE_P(TYPE)(((enum tree_code) (TYPE)->base.code) == VECTOR_TYPE) (TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == VECTOR_TYPE)
511
512/* Nonzero if TYPE represents a vector of booleans. */
513
514#define VECTOR_BOOLEAN_TYPE_P(TYPE)(((enum tree_code) (TYPE)->base.code) == VECTOR_TYPE &&
((enum tree_code) (((contains_struct_check ((TYPE), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 514, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
)
\
515 (TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == VECTOR_TYPE \
516 && TREE_CODE (TREE_TYPE (TYPE))((enum tree_code) (((contains_struct_check ((TYPE), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 516, __FUNCTION__))->typed.type))->base.code)
== BOOLEAN_TYPE)
517
518/* Nonzero if TYPE represents an integral type. Note that we do not
519 include COMPLEX types here. Keep these checks in ascending code
520 order. */
521
522#define INTEGRAL_TYPE_P(TYPE)(((enum tree_code) (TYPE)->base.code) == ENUMERAL_TYPE || (
(enum tree_code) (TYPE)->base.code) == BOOLEAN_TYPE || ((enum
tree_code) (TYPE)->base.code) == INTEGER_TYPE)
\
523 (TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == ENUMERAL_TYPE \
524 || TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == BOOLEAN_TYPE \
525 || TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == INTEGER_TYPE)
526
527/* Nonzero if TYPE represents an integral type, including complex
528 and vector integer types. */
529
530#define ANY_INTEGRAL_TYPE_P(TYPE)((((enum tree_code) (TYPE)->base.code) == ENUMERAL_TYPE ||
((enum tree_code) (TYPE)->base.code) == BOOLEAN_TYPE || (
(enum tree_code) (TYPE)->base.code) == INTEGER_TYPE) || ((
((enum tree_code) (TYPE)->base.code) == COMPLEX_TYPE || ((
(enum tree_code) (TYPE)->base.code) == VECTOR_TYPE)) &&
(((enum tree_code) (((contains_struct_check ((TYPE), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 530, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
|| ((enum tree_code) (((contains_struct_check ((TYPE), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 530, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((TYPE), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 530, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)))
\
531 (INTEGRAL_TYPE_P (TYPE)(((enum tree_code) (TYPE)->base.code) == ENUMERAL_TYPE || (
(enum tree_code) (TYPE)->base.code) == BOOLEAN_TYPE || ((enum
tree_code) (TYPE)->base.code) == INTEGER_TYPE)
\
532 || ((TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == COMPLEX_TYPE \
533 || VECTOR_TYPE_P (TYPE)(((enum tree_code) (TYPE)->base.code) == VECTOR_TYPE)) \
534 && INTEGRAL_TYPE_P (TREE_TYPE (TYPE))(((enum tree_code) (((contains_struct_check ((TYPE), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 534, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
|| ((enum tree_code) (((contains_struct_check ((TYPE), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 534, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((TYPE), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 534, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
))
535
536/* Nonzero if TYPE represents a non-saturating fixed-point type. */
537
538#define NON_SAT_FIXED_POINT_TYPE_P(TYPE)(((enum tree_code) (TYPE)->base.code) == FIXED_POINT_TYPE &&
!((tree_not_check4 ((TYPE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 538, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))->base.u.bits.saturating_flag))
\
539 (TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == FIXED_POINT_TYPE && !TYPE_SATURATING (TYPE)((tree_not_check4 ((TYPE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 539, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))->base.u.bits.saturating_flag)
)
540
541/* Nonzero if TYPE represents a saturating fixed-point type. */
542
543#define SAT_FIXED_POINT_TYPE_P(TYPE)(((enum tree_code) (TYPE)->base.code) == FIXED_POINT_TYPE &&
((tree_not_check4 ((TYPE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 543, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))->base.u.bits.saturating_flag))
\
544 (TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == FIXED_POINT_TYPE && TYPE_SATURATING (TYPE)((tree_not_check4 ((TYPE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 544, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))->base.u.bits.saturating_flag)
)
545
546/* Nonzero if TYPE represents a fixed-point type. */
547
548#define FIXED_POINT_TYPE_P(TYPE)(((enum tree_code) (TYPE)->base.code) == FIXED_POINT_TYPE) (TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == FIXED_POINT_TYPE)
549
550/* Nonzero if TYPE represents a scalar floating-point type. */
551
552#define SCALAR_FLOAT_TYPE_P(TYPE)(((enum tree_code) (TYPE)->base.code) == REAL_TYPE) (TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == REAL_TYPE)
553
554/* Nonzero if TYPE represents a complex floating-point type. */
555
556#define COMPLEX_FLOAT_TYPE_P(TYPE)(((enum tree_code) (TYPE)->base.code) == COMPLEX_TYPE &&
((enum tree_code) (((contains_struct_check ((TYPE), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 556, __FUNCTION__))->typed.type))->base.code) == REAL_TYPE
)
\
557 (TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == COMPLEX_TYPE \
558 && TREE_CODE (TREE_TYPE (TYPE))((enum tree_code) (((contains_struct_check ((TYPE), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 558, __FUNCTION__))->typed.type))->base.code)
== REAL_TYPE)
559
560/* Nonzero if TYPE represents a vector integer type. */
561
562#define VECTOR_INTEGER_TYPE_P(TYPE)((((enum tree_code) (TYPE)->base.code) == VECTOR_TYPE) &&
((enum tree_code) (((contains_struct_check ((TYPE), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 562, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
\
563 (VECTOR_TYPE_P (TYPE)(((enum tree_code) (TYPE)->base.code) == VECTOR_TYPE) \
564 && TREE_CODE (TREE_TYPE (TYPE))((enum tree_code) (((contains_struct_check ((TYPE), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 564, __FUNCTION__))->typed.type))->base.code)
== INTEGER_TYPE)
565
566
567/* Nonzero if TYPE represents a vector floating-point type. */
568
569#define VECTOR_FLOAT_TYPE_P(TYPE)((((enum tree_code) (TYPE)->base.code) == VECTOR_TYPE) &&
((enum tree_code) (((contains_struct_check ((TYPE), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 569, __FUNCTION__))->typed.type))->base.code) == REAL_TYPE
)
\
570 (VECTOR_TYPE_P (TYPE)(((enum tree_code) (TYPE)->base.code) == VECTOR_TYPE) \
571 && TREE_CODE (TREE_TYPE (TYPE))((enum tree_code) (((contains_struct_check ((TYPE), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 571, __FUNCTION__))->typed.type))->base.code)
== REAL_TYPE)
572
573/* Nonzero if TYPE represents a floating-point type, including complex
574 and vector floating-point types. The vector and complex check does
575 not use the previous two macros to enable early folding. */
576
577#define FLOAT_TYPE_P(TYPE)((((enum tree_code) (TYPE)->base.code) == REAL_TYPE) || ((
((enum tree_code) (TYPE)->base.code) == COMPLEX_TYPE || ((
(enum tree_code) (TYPE)->base.code) == VECTOR_TYPE)) &&
(((enum tree_code) (((contains_struct_check ((TYPE), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 577, __FUNCTION__))->typed.type))->base.code) == REAL_TYPE
)))
\
578 (SCALAR_FLOAT_TYPE_P (TYPE)(((enum tree_code) (TYPE)->base.code) == REAL_TYPE) \
579 || ((TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == COMPLEX_TYPE \
580 || VECTOR_TYPE_P (TYPE)(((enum tree_code) (TYPE)->base.code) == VECTOR_TYPE)) \
581 && SCALAR_FLOAT_TYPE_P (TREE_TYPE (TYPE))(((enum tree_code) (((contains_struct_check ((TYPE), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 581, __FUNCTION__))->typed.type))->base.code) == REAL_TYPE
)
))
582
583/* Nonzero if TYPE represents a decimal floating-point type. */
584#define DECIMAL_FLOAT_TYPE_P(TYPE)((((enum tree_code) (TYPE)->base.code) == REAL_TYPE) &&
(((enum mode_class) mode_class[((((enum tree_code) ((tree_class_check
((TYPE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 584, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(TYPE) : (TYPE)->type_common.mode)]) == MODE_DECIMAL_FLOAT
))
\
585 (SCALAR_FLOAT_TYPE_P (TYPE)(((enum tree_code) (TYPE)->base.code) == REAL_TYPE) \
586 && DECIMAL_FLOAT_MODE_P (TYPE_MODE (TYPE))(((enum mode_class) mode_class[((((enum tree_code) ((tree_class_check
((TYPE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 586, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(TYPE) : (TYPE)->type_common.mode)]) == MODE_DECIMAL_FLOAT
)
)
587
588/* Nonzero if TYPE is a record or union type. */
589#define RECORD_OR_UNION_TYPE_P(TYPE)(((enum tree_code) (TYPE)->base.code) == RECORD_TYPE || ((
enum tree_code) (TYPE)->base.code) == UNION_TYPE || ((enum
tree_code) (TYPE)->base.code) == QUAL_UNION_TYPE)
\
590 (TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == RECORD_TYPE \
591 || TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == UNION_TYPE \
592 || TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == QUAL_UNION_TYPE)
593
594/* Nonzero if TYPE represents an aggregate (multi-component) type.
595 Keep these checks in ascending code order. */
596
597#define AGGREGATE_TYPE_P(TYPE)(((enum tree_code) (TYPE)->base.code) == ARRAY_TYPE || (((
enum tree_code) (TYPE)->base.code) == RECORD_TYPE || ((enum
tree_code) (TYPE)->base.code) == UNION_TYPE || ((enum tree_code
) (TYPE)->base.code) == QUAL_UNION_TYPE))
\
598 (TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == ARRAY_TYPE || RECORD_OR_UNION_TYPE_P (TYPE)(((enum tree_code) (TYPE)->base.code) == RECORD_TYPE || ((
enum tree_code) (TYPE)->base.code) == UNION_TYPE || ((enum
tree_code) (TYPE)->base.code) == QUAL_UNION_TYPE)
)
599
600/* Nonzero if TYPE represents a pointer or reference type.
601 (It should be renamed to INDIRECT_TYPE_P.) Keep these checks in
602 ascending code order. */
603
604#define POINTER_TYPE_P(TYPE)(((enum tree_code) (TYPE)->base.code) == POINTER_TYPE || (
(enum tree_code) (TYPE)->base.code) == REFERENCE_TYPE)
\
605 (TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == POINTER_TYPE || TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == REFERENCE_TYPE)
606
607/* Nonzero if TYPE represents a pointer to function. */
608#define FUNCTION_POINTER_TYPE_P(TYPE)((((enum tree_code) (TYPE)->base.code) == POINTER_TYPE || (
(enum tree_code) (TYPE)->base.code) == REFERENCE_TYPE) &&
((enum tree_code) (((contains_struct_check ((TYPE), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 608, __FUNCTION__))->typed.type))->base.code) == FUNCTION_TYPE
)
\
609 (POINTER_TYPE_P (TYPE)(((enum tree_code) (TYPE)->base.code) == POINTER_TYPE || (
(enum tree_code) (TYPE)->base.code) == REFERENCE_TYPE)
&& TREE_CODE (TREE_TYPE (TYPE))((enum tree_code) (((contains_struct_check ((TYPE), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 609, __FUNCTION__))->typed.type))->base.code)
== FUNCTION_TYPE)
610
611/* Nonzero if this type is a complete type. */
612#define COMPLETE_TYPE_P(NODE)(((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 612, __FUNCTION__))->type_common.size) != (tree) nullptr
)
(TYPE_SIZE (NODE)((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 612, __FUNCTION__))->type_common.size)
!= NULL_TREE(tree) nullptr)
613
614/* Nonzero if this type is the (possibly qualified) void type. */
615#define VOID_TYPE_P(NODE)(((enum tree_code) (NODE)->base.code) == VOID_TYPE) (TREE_CODE (NODE)((enum tree_code) (NODE)->base.code) == VOID_TYPE)
616
617/* Nonzero if this type is complete or is cv void. */
618#define COMPLETE_OR_VOID_TYPE_P(NODE)((((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 618, __FUNCTION__))->type_common.size) != (tree) nullptr
) || (((enum tree_code) (NODE)->base.code) == VOID_TYPE))
\
619 (COMPLETE_TYPE_P (NODE)(((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 619, __FUNCTION__))->type_common.size) != (tree) nullptr
)
|| VOID_TYPE_P (NODE)(((enum tree_code) (NODE)->base.code) == VOID_TYPE))
620
621/* Nonzero if this type is complete or is an array with unspecified bound. */
622#define COMPLETE_OR_UNBOUND_ARRAY_TYPE_P(NODE)((((tree_class_check ((((enum tree_code) (NODE)->base.code
) == ARRAY_TYPE ? ((contains_struct_check ((NODE), (TS_TYPED)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 622, __FUNCTION__))->typed.type) : (NODE)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 622, __FUNCTION__))->type_common.size) != (tree) nullptr
))
\
623 (COMPLETE_TYPE_P (TREE_CODE (NODE) == ARRAY_TYPE ? TREE_TYPE (NODE) : (NODE))(((tree_class_check ((((enum tree_code) (NODE)->base.code)
== ARRAY_TYPE ? ((contains_struct_check ((NODE), (TS_TYPED),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 623, __FUNCTION__))->typed.type) : (NODE)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 623, __FUNCTION__))->type_common.size) != (tree) nullptr
)
)
624
625#define FUNC_OR_METHOD_TYPE_P(NODE)(((enum tree_code) (NODE)->base.code) == FUNCTION_TYPE || (
(enum tree_code) (NODE)->base.code) == METHOD_TYPE)
\
626 (TREE_CODE (NODE)((enum tree_code) (NODE)->base.code) == FUNCTION_TYPE || TREE_CODE (NODE)((enum tree_code) (NODE)->base.code) == METHOD_TYPE)
627
628#define OPAQUE_TYPE_P(NODE)(((enum tree_code) (NODE)->base.code) == OPAQUE_TYPE) \
629 (TREE_CODE (NODE)((enum tree_code) (NODE)->base.code) == OPAQUE_TYPE)
630
631/* Define many boolean fields that all tree nodes have. */
632
633/* In VAR_DECL, PARM_DECL and RESULT_DECL nodes, nonzero means address
634 of this is needed. So it cannot be in a register.
635 In a FUNCTION_DECL it has no meaning.
636 In LABEL_DECL nodes, it means a goto for this label has been seen
637 from a place outside all binding contours that restore stack levels.
638 In an artificial SSA_NAME that points to a stack partition with at least
639 two variables, it means that at least one variable has TREE_ADDRESSABLE.
640 In ..._TYPE nodes, it means that objects of this type must be fully
641 addressable. This means that pieces of this object cannot go into
642 register parameters, for example. If this a function type, this
643 means that the value must be returned in memory.
644 In CONSTRUCTOR nodes, it means object constructed must be in memory.
645 In IDENTIFIER_NODEs, this means that some extern decl for this name
646 had its address taken. That matters for inline functions.
647 In a STMT_EXPR, it means we want the result of the enclosed expression. */
648#define TREE_ADDRESSABLE(NODE)((NODE)->base.addressable_flag) ((NODE)->base.addressable_flag)
649
650/* Set on a CALL_EXPR if the call is in a tail position, ie. just before the
651 exit of a function. Calls for which this is true are candidates for tail
652 call optimizations. */
653#define CALL_EXPR_TAILCALL(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 653, __FUNCTION__, (CALL_EXPR)))->base.addressable_flag)
\
654 (CALL_EXPR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 654, __FUNCTION__, (CALL_EXPR)))
->base.addressable_flag)
655
656/* Set on a CALL_EXPR if the call has been marked as requiring tail call
657 optimization for correctness. */
658#define CALL_EXPR_MUST_TAIL_CALL(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 658, __FUNCTION__, (CALL_EXPR)))->base.static_flag)
\
659 (CALL_EXPR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 659, __FUNCTION__, (CALL_EXPR)))
->base.static_flag)
660
661/* Used as a temporary field on a CASE_LABEL_EXPR to indicate that the
662 CASE_LOW operand has been processed. */
663#define CASE_LOW_SEEN(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 663, __FUNCTION__, (CASE_LABEL_EXPR)))->base.addressable_flag
)
\
664 (CASE_LABEL_EXPR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 664, __FUNCTION__, (CASE_LABEL_EXPR)))
->base.addressable_flag)
665
666#define PREDICT_EXPR_OUTCOME(NODE)((enum prediction) ((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 666, __FUNCTION__, (PREDICT_EXPR)))->base.addressable_flag
))
\
667 ((enum prediction) (PREDICT_EXPR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 667, __FUNCTION__, (PREDICT_EXPR)))
->base.addressable_flag))
668#define SET_PREDICT_EXPR_OUTCOME(NODE, OUTCOME)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 668, __FUNCTION__, (PREDICT_EXPR)))->base.addressable_flag
= (int) OUTCOME)
\
669 (PREDICT_EXPR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 669, __FUNCTION__, (PREDICT_EXPR)))
->base.addressable_flag = (int) OUTCOME)
670#define PREDICT_EXPR_PREDICTOR(NODE)((enum br_predictor)tree_to_shwi ((*((const_cast<tree*>
(tree_operand_check (((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 670, __FUNCTION__, (PREDICT_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 670, __FUNCTION__)))))))
\
671 ((enum br_predictor)tree_to_shwi (TREE_OPERAND (PREDICT_EXPR_CHECK (NODE), 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 671, __FUNCTION__, (PREDICT_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 671, __FUNCTION__)))))
))
672
673/* In a VAR_DECL, nonzero means allocate static storage.
674 In a FUNCTION_DECL, nonzero if function has been defined.
675 In a CONSTRUCTOR, nonzero means allocate static storage. */
676#define TREE_STATIC(NODE)((NODE)->base.static_flag) ((NODE)->base.static_flag)
677
678/* In an ADDR_EXPR, nonzero means do not use a trampoline. */
679#define TREE_NO_TRAMPOLINE(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 679, __FUNCTION__, (ADDR_EXPR)))->base.static_flag)
(ADDR_EXPR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 679, __FUNCTION__, (ADDR_EXPR)))
->base.static_flag)
680
681/* In a TARGET_EXPR or WITH_CLEANUP_EXPR, means that the pertinent cleanup
682 should only be executed if an exception is thrown, not on normal exit
683 of its scope. */
684#define CLEANUP_EH_ONLY(NODE)((NODE)->base.static_flag) ((NODE)->base.static_flag)
685
686/* In a TRY_CATCH_EXPR, means that the handler should be considered a
687 separate cleanup in honor_protect_cleanup_actions. */
688#define TRY_CATCH_IS_CLEANUP(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 688, __FUNCTION__, (TRY_CATCH_EXPR)))->base.static_flag)
\
689 (TRY_CATCH_EXPR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 689, __FUNCTION__, (TRY_CATCH_EXPR)))
->base.static_flag)
690
691/* Used as a temporary field on a CASE_LABEL_EXPR to indicate that the
692 CASE_HIGH operand has been processed. */
693#define CASE_HIGH_SEEN(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 693, __FUNCTION__, (CASE_LABEL_EXPR)))->base.static_flag
)
\
694 (CASE_LABEL_EXPR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 694, __FUNCTION__, (CASE_LABEL_EXPR)))
->base.static_flag)
695
696/* Used to mark scoped enums. */
697#define ENUM_IS_SCOPED(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 697, __FUNCTION__, (ENUMERAL_TYPE)))->base.static_flag)
(ENUMERAL_TYPE_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 697, __FUNCTION__, (ENUMERAL_TYPE)))
->base.static_flag)
698
699/* Determines whether an ENUMERAL_TYPE has defined the list of constants. */
700#define ENUM_IS_OPAQUE(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 700, __FUNCTION__, (ENUMERAL_TYPE)))->base.private_flag)
(ENUMERAL_TYPE_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 700, __FUNCTION__, (ENUMERAL_TYPE)))
->base.private_flag)
701
702/* In an expr node (usually a conversion) this means the node was made
703 implicitly and should not lead to any sort of warning. In a decl node,
704 warnings concerning the decl should be suppressed. This is used at
705 least for used-before-set warnings, and it set after one warning is
706 emitted. */
707#define TREE_NO_WARNING(NODE)((NODE)->base.nowarning_flag) ((NODE)->base.nowarning_flag)
708
709/* Nonzero if we should warn about the change in empty class parameter
710 passing ABI in this TU. */
711#define TRANSLATION_UNIT_WARN_EMPTY_P(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 711, __FUNCTION__, (TRANSLATION_UNIT_DECL)))->decl_common
.decl_flag_0)
\
712 (TRANSLATION_UNIT_DECL_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 712, __FUNCTION__, (TRANSLATION_UNIT_DECL)))
->decl_common.decl_flag_0)
713
714/* Nonzero if this type is "empty" according to the particular psABI. */
715#define TYPE_EMPTY_P(NODE)((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 715, __FUNCTION__))->type_common.empty_flag)
(TYPE_CHECK (NODE)(tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 715, __FUNCTION__))
->type_common.empty_flag)
716
717/* Used to indicate that this TYPE represents a compiler-generated entity. */
718#define TYPE_ARTIFICIAL(NODE)((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 718, __FUNCTION__))->base.nowarning_flag)
(TYPE_CHECK (NODE)(tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 718, __FUNCTION__))
->base.nowarning_flag)
719
720/* True if the type is indivisible at the source level, i.e. if its
721 component parts cannot be accessed directly. This is used to suppress
722 normal GNU extensions for target-specific vector types. */
723#define TYPE_INDIVISIBLE_P(NODE)((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 723, __FUNCTION__))->type_common.indivisible_p)
(TYPE_CHECK (NODE)(tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 723, __FUNCTION__))
->type_common.indivisible_p)
724
725/* In an IDENTIFIER_NODE, this means that assemble_name was called with
726 this string as an argument. */
727#define TREE_SYMBOL_REFERENCED(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 727, __FUNCTION__, (IDENTIFIER_NODE)))->base.static_flag
)
\
728 (IDENTIFIER_NODE_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 728, __FUNCTION__, (IDENTIFIER_NODE)))
->base.static_flag)
729
730/* Nonzero in a pointer or reference type means the data pointed to
731 by this type can alias anything. */
732#define TYPE_REF_CAN_ALIAS_ALL(NODE)((tree_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 732, __FUNCTION__, (POINTER_TYPE), (REFERENCE_TYPE)))->base
.static_flag)
\
733 (PTR_OR_REF_CHECK (NODE)(tree_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 733, __FUNCTION__, (POINTER_TYPE), (REFERENCE_TYPE)))
->base.static_flag)
734
735/* In an INTEGER_CST, REAL_CST, COMPLEX_CST, or VECTOR_CST, this means
736 there was an overflow in folding. */
737
738#define TREE_OVERFLOW(NODE)((tree_class_check ((NODE), (tcc_constant), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 738, __FUNCTION__))->base.public_flag)
(CST_CHECK (NODE)(tree_class_check ((NODE), (tcc_constant), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 738, __FUNCTION__))
->base.public_flag)
739
740/* TREE_OVERFLOW can only be true for EXPR of CONSTANT_CLASS_P. */
741
742#define TREE_OVERFLOW_P(EXPR)((tree_code_type[(int) (((enum tree_code) (EXPR)->base.code
))] == tcc_constant) && ((tree_class_check ((EXPR), (
tcc_constant), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 742, __FUNCTION__))->base.public_flag))
\
743 (CONSTANT_CLASS_P (EXPR)(tree_code_type[(int) (((enum tree_code) (EXPR)->base.code
))] == tcc_constant)
&& TREE_OVERFLOW (EXPR)((tree_class_check ((EXPR), (tcc_constant), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 743, __FUNCTION__))->base.public_flag)
)
744
745/* In a VAR_DECL, FUNCTION_DECL, NAMESPACE_DECL or TYPE_DECL,
746 nonzero means name is to be accessible from outside this translation unit.
747 In an IDENTIFIER_NODE, nonzero means an external declaration
748 accessible from outside this translation unit was previously seen
749 for this name in an inner scope. */
750#define TREE_PUBLIC(NODE)((NODE)->base.public_flag) ((NODE)->base.public_flag)
751
752/* In a _TYPE, indicates whether TYPE_CACHED_VALUES contains a vector
753 of cached values, or is something else. */
754#define TYPE_CACHED_VALUES_P(NODE)((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 754, __FUNCTION__))->base.public_flag)
(TYPE_CHECK (NODE)(tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 754, __FUNCTION__))
->base.public_flag)
755
756/* In a SAVE_EXPR, indicates that the original expression has already
757 been substituted with a VAR_DECL that contains the value. */
758#define SAVE_EXPR_RESOLVED_P(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 758, __FUNCTION__, (SAVE_EXPR)))->base.public_flag)
\
759 (SAVE_EXPR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 759, __FUNCTION__, (SAVE_EXPR)))
->base.public_flag)
760
761/* Set on a CALL_EXPR if this stdarg call should be passed the argument
762 pack. */
763#define CALL_EXPR_VA_ARG_PACK(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 763, __FUNCTION__, (CALL_EXPR)))->base.public_flag)
\
764 (CALL_EXPR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 764, __FUNCTION__, (CALL_EXPR)))
->base.public_flag)
765
766/* In any expression, decl, or constant, nonzero means it has side effects or
767 reevaluation of the whole expression could produce a different value.
768 This is set if any subexpression is a function call, a side effect or a
769 reference to a volatile variable. In a ..._DECL, this is set only if the
770 declaration said `volatile'. This will never be set for a constant. */
771#define TREE_SIDE_EFFECTS(NODE)((non_type_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 771, __FUNCTION__))->base.side_effects_flag)
\
772 (NON_TYPE_CHECK (NODE)(non_type_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 772, __FUNCTION__))
->base.side_effects_flag)
773
774/* In a LABEL_DECL, nonzero means this label had its address taken
775 and therefore can never be deleted and is a jump target for
776 computed gotos. */
777#define FORCED_LABEL(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 777, __FUNCTION__, (LABEL_DECL)))->base.side_effects_flag
)
(LABEL_DECL_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 777, __FUNCTION__, (LABEL_DECL)))
->base.side_effects_flag)
778
779/* Whether a case or a user-defined label is allowed to fall through to.
780 This is used to implement -Wimplicit-fallthrough. */
781#define FALLTHROUGH_LABEL_P(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 781, __FUNCTION__, (LABEL_DECL)))->base.private_flag)
\
782 (LABEL_DECL_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 782, __FUNCTION__, (LABEL_DECL)))
->base.private_flag)
783
784/* Set on the artificial label created for break; stmt from a switch.
785 This is used to implement -Wimplicit-fallthrough. */
786#define SWITCH_BREAK_LABEL_P(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 786, __FUNCTION__, (LABEL_DECL)))->base.protected_flag)
\
787 (LABEL_DECL_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 787, __FUNCTION__, (LABEL_DECL)))
->base.protected_flag)
788
789/* Nonzero means this expression is volatile in the C sense:
790 its address should be of type `volatile WHATEVER *'.
791 In other words, the declared item is volatile qualified.
792 This is used in _DECL nodes and _REF nodes.
793 On a FUNCTION_DECL node, this means the function does not
794 return normally. This is the same effect as setting
795 the attribute noreturn on the function in C.
796
797 In a ..._TYPE node, means this type is volatile-qualified.
798 But use TYPE_VOLATILE instead of this macro when the node is a type,
799 because eventually we may make that a different bit.
800
801 If this bit is set in an expression, so is TREE_SIDE_EFFECTS. */
802#define TREE_THIS_VOLATILE(NODE)((NODE)->base.volatile_flag) ((NODE)->base.volatile_flag)
803
804/* Nonzero means this node will not trap. In an INDIRECT_REF, means
805 accessing the memory pointed to won't generate a trap. However,
806 this only applies to an object when used appropriately: it doesn't
807 mean that writing a READONLY mem won't trap.
808
809 In ARRAY_REF and ARRAY_RANGE_REF means that we know that the index
810 (or slice of the array) always belongs to the range of the array.
811 I.e. that the access will not trap, provided that the access to
812 the base to the array will not trap. */
813#define TREE_THIS_NOTRAP(NODE)((tree_check5 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 813, __FUNCTION__, (INDIRECT_REF), (MEM_REF), (TARGET_MEM_REF
), (ARRAY_REF), (ARRAY_RANGE_REF)))->base.nothrow_flag)
\
814 (TREE_CHECK5 (NODE, INDIRECT_REF, MEM_REF, TARGET_MEM_REF, ARRAY_REF, \(tree_check5 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 815, __FUNCTION__, (INDIRECT_REF), (MEM_REF), (TARGET_MEM_REF
), (ARRAY_REF), (ARRAY_RANGE_REF)))
815 ARRAY_RANGE_REF)(tree_check5 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 815, __FUNCTION__, (INDIRECT_REF), (MEM_REF), (TARGET_MEM_REF
), (ARRAY_REF), (ARRAY_RANGE_REF)))
->base.nothrow_flag)
816
817/* In a VAR_DECL, PARM_DECL or FIELD_DECL, or any kind of ..._REF node,
818 nonzero means it may not be the lhs of an assignment.
819 Nonzero in a FUNCTION_DECL means this function should be treated
820 as "const" function (can only read its arguments). */
821#define TREE_READONLY(NODE)((non_type_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 821, __FUNCTION__))->base.readonly_flag)
(NON_TYPE_CHECK (NODE)(non_type_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 821, __FUNCTION__))
->base.readonly_flag)
822
823/* Value of expression is constant. Always on in all ..._CST nodes. May
824 also appear in an expression or decl where the value is constant. */
825#define TREE_CONSTANT(NODE)((non_type_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 825, __FUNCTION__))->base.constant_flag)
(NON_TYPE_CHECK (NODE)(non_type_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 825, __FUNCTION__))
->base.constant_flag)
826
827/* Nonzero if NODE, a type, has had its sizes gimplified. */
828#define TYPE_SIZES_GIMPLIFIED(NODE)((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 828, __FUNCTION__))->base.constant_flag)
\
829 (TYPE_CHECK (NODE)(tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 829, __FUNCTION__))
->base.constant_flag)
830
831/* In a decl (most significantly a FIELD_DECL), means an unsigned field. */
832#define DECL_UNSIGNED(NODE)((contains_struct_check ((NODE), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 832, __FUNCTION__))->base.u.bits.unsigned_flag)
\
833 (DECL_COMMON_CHECK (NODE)(contains_struct_check ((NODE), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 833, __FUNCTION__))
->base.u.bits.unsigned_flag)
834
835/* In integral and pointer types, means an unsigned type. */
836#define TYPE_UNSIGNED(NODE)((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 836, __FUNCTION__))->base.u.bits.unsigned_flag)
(TYPE_CHECK (NODE)(tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 836, __FUNCTION__))
->base.u.bits.unsigned_flag)
837
838/* Same as TYPE_UNSIGNED but converted to SIGNOP. */
839#define TYPE_SIGN(NODE)((signop) ((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 839, __FUNCTION__))->base.u.bits.unsigned_flag))
((signop) TYPE_UNSIGNED (NODE)((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 839, __FUNCTION__))->base.u.bits.unsigned_flag)
)
840
841/* True if overflow wraps around for the given integral or pointer type. That
842 is, TYPE_MAX + 1 == TYPE_MIN. */
843#define TYPE_OVERFLOW_WRAPS(TYPE)((((enum tree_code) (TYPE)->base.code) == POINTER_TYPE || (
(enum tree_code) (TYPE)->base.code) == REFERENCE_TYPE) ? global_options
.x_flag_wrapv_pointer : ((any_integral_type_check ((TYPE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 843, __FUNCTION__))->base.u.bits.unsigned_flag || global_options
.x_flag_wrapv))
\
844 (POINTER_TYPE_P (TYPE)(((enum tree_code) (TYPE)->base.code) == POINTER_TYPE || (
(enum tree_code) (TYPE)->base.code) == REFERENCE_TYPE)
\
845 ? flag_wrapv_pointerglobal_options.x_flag_wrapv_pointer \
846 : (ANY_INTEGRAL_TYPE_CHECK(TYPE)(any_integral_type_check ((TYPE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 846, __FUNCTION__))
->base.u.bits.unsigned_flag \
847 || flag_wrapvglobal_options.x_flag_wrapv))
848
849/* True if overflow is undefined for the given integral or pointer type.
850 We may optimize on the assumption that values in the type never overflow.
851
852 IMPORTANT NOTE: Any optimization based on TYPE_OVERFLOW_UNDEFINED
853 must issue a warning based on warn_strict_overflow. In some cases
854 it will be appropriate to issue the warning immediately, and in
855 other cases it will be appropriate to simply set a flag and let the
856 caller decide whether a warning is appropriate or not. */
857#define TYPE_OVERFLOW_UNDEFINED(TYPE)((((enum tree_code) (TYPE)->base.code) == POINTER_TYPE || (
(enum tree_code) (TYPE)->base.code) == REFERENCE_TYPE) ? !
global_options.x_flag_wrapv_pointer : (!(any_integral_type_check
((TYPE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 857, __FUNCTION__))->base.u.bits.unsigned_flag &&
!global_options.x_flag_wrapv && !global_options.x_flag_trapv
))
\
858 (POINTER_TYPE_P (TYPE)(((enum tree_code) (TYPE)->base.code) == POINTER_TYPE || (
(enum tree_code) (TYPE)->base.code) == REFERENCE_TYPE)
\
859 ? !flag_wrapv_pointerglobal_options.x_flag_wrapv_pointer \
860 : (!ANY_INTEGRAL_TYPE_CHECK(TYPE)(any_integral_type_check ((TYPE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 860, __FUNCTION__))
->base.u.bits.unsigned_flag \
861 && !flag_wrapvglobal_options.x_flag_wrapv && !flag_trapvglobal_options.x_flag_trapv))
862
863/* True if overflow for the given integral type should issue a
864 trap. */
865#define TYPE_OVERFLOW_TRAPS(TYPE)(!(any_integral_type_check ((TYPE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 865, __FUNCTION__))->base.u.bits.unsigned_flag &&
global_options.x_flag_trapv)
\
866 (!ANY_INTEGRAL_TYPE_CHECK(TYPE)(any_integral_type_check ((TYPE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 866, __FUNCTION__))
->base.u.bits.unsigned_flag && flag_trapvglobal_options.x_flag_trapv)
867
868/* True if an overflow is to be preserved for sanitization. */
869#define TYPE_OVERFLOW_SANITIZED(TYPE)((((enum tree_code) (TYPE)->base.code) == ENUMERAL_TYPE ||
((enum tree_code) (TYPE)->base.code) == BOOLEAN_TYPE || (
(enum tree_code) (TYPE)->base.code) == INTEGER_TYPE) &&
!((((enum tree_code) (TYPE)->base.code) == POINTER_TYPE ||
((enum tree_code) (TYPE)->base.code) == REFERENCE_TYPE) ?
global_options.x_flag_wrapv_pointer : ((any_integral_type_check
((TYPE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 869, __FUNCTION__))->base.u.bits.unsigned_flag || global_options
.x_flag_wrapv)) && (global_options.x_flag_sanitize &
SANITIZE_SI_OVERFLOW))
\
870 (INTEGRAL_TYPE_P (TYPE)(((enum tree_code) (TYPE)->base.code) == ENUMERAL_TYPE || (
(enum tree_code) (TYPE)->base.code) == BOOLEAN_TYPE || ((enum
tree_code) (TYPE)->base.code) == INTEGER_TYPE)
\
871 && !TYPE_OVERFLOW_WRAPS (TYPE)((((enum tree_code) (TYPE)->base.code) == POINTER_TYPE || (
(enum tree_code) (TYPE)->base.code) == REFERENCE_TYPE) ? global_options
.x_flag_wrapv_pointer : ((any_integral_type_check ((TYPE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 871, __FUNCTION__))->base.u.bits.unsigned_flag || global_options
.x_flag_wrapv))
\
872 && (flag_sanitizeglobal_options.x_flag_sanitize & SANITIZE_SI_OVERFLOW))
873
874/* Nonzero in a VAR_DECL or STRING_CST means assembler code has been written.
875 Nonzero in a FUNCTION_DECL means that the function has been compiled.
876 This is interesting in an inline function, since it might not need
877 to be compiled separately.
878 Nonzero in a RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, ENUMERAL_TYPE
879 or TYPE_DECL if the debugging info for the type has been written.
880 In a BLOCK node, nonzero if reorder_blocks has already seen this block.
881 In an SSA_NAME node, nonzero if the SSA_NAME occurs in an abnormal
882 PHI node. */
883#define TREE_ASM_WRITTEN(NODE)((NODE)->base.asm_written_flag) ((NODE)->base.asm_written_flag)
884
885/* Nonzero in a _DECL if the name is used in its scope.
886 Nonzero in an expr node means inhibit warning if value is unused.
887 In IDENTIFIER_NODEs, this means that some extern decl for this name
888 was used.
889 In a BLOCK, this means that the block contains variables that are used. */
890#define TREE_USED(NODE)((NODE)->base.used_flag) ((NODE)->base.used_flag)
891
892/* In a FUNCTION_DECL, nonzero means a call to the function cannot
893 throw an exception. In a CALL_EXPR, nonzero means the call cannot
894 throw. We can't easily check the node type here as the C++
895 frontend also uses this flag (for AGGR_INIT_EXPR). */
896#define TREE_NOTHROW(NODE)((NODE)->base.nothrow_flag) ((NODE)->base.nothrow_flag)
897
898/* In a CALL_EXPR, means that it's safe to use the target of the call
899 expansion as the return slot for a call that returns in memory. */
900#define CALL_EXPR_RETURN_SLOT_OPT(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 900, __FUNCTION__, (CALL_EXPR)))->base.private_flag)
\
901 (CALL_EXPR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 901, __FUNCTION__, (CALL_EXPR)))
->base.private_flag)
902
903/* In a RESULT_DECL, PARM_DECL and VAR_DECL, means that it is
904 passed by invisible reference (and the TREE_TYPE is a pointer to the true
905 type). */
906#define DECL_BY_REFERENCE(NODE)((tree_check3 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 906, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL)))
->decl_common.decl_by_reference_flag)
\
907 (TREE_CHECK3 (NODE, VAR_DECL, PARM_DECL, \(tree_check3 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 908, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL)))
908 RESULT_DECL)(tree_check3 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 908, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL)))
->decl_common.decl_by_reference_flag)
909
910/* In VAR_DECL and PARM_DECL, set when the decl has been used except for
911 being set. */
912#define DECL_READ_P(NODE)((tree_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 912, __FUNCTION__, (VAR_DECL), (PARM_DECL)))->decl_common
.decl_read_flag)
\
913 (TREE_CHECK2 (NODE, VAR_DECL, PARM_DECL)(tree_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 913, __FUNCTION__, (VAR_DECL), (PARM_DECL)))
->decl_common.decl_read_flag)
914
915/* In VAR_DECL or RESULT_DECL, set when significant code movement precludes
916 attempting to share the stack slot with some other variable. */
917#define DECL_NONSHAREABLE(NODE)((tree_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 917, __FUNCTION__, (VAR_DECL), (RESULT_DECL)))->decl_common
.decl_nonshareable_flag)
\
918 (TREE_CHECK2 (NODE, VAR_DECL, \(tree_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 919, __FUNCTION__, (VAR_DECL), (RESULT_DECL)))
919 RESULT_DECL)(tree_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 919, __FUNCTION__, (VAR_DECL), (RESULT_DECL)))
->decl_common.decl_nonshareable_flag)
920
921/* In a PARM_DECL, set for Fortran hidden string length arguments that some
922 buggy callers don't pass to the callee. */
923#define DECL_HIDDEN_STRING_LENGTH(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 923, __FUNCTION__, (PARM_DECL)))->decl_common.decl_nonshareable_flag
)
\
924 (TREE_CHECK (NODE, PARM_DECL)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 924, __FUNCTION__, (PARM_DECL)))
->decl_common.decl_nonshareable_flag)
925
926/* In a CALL_EXPR, means that the call is the jump from a thunk to the
927 thunked-to function. Be careful to avoid using this macro when one of the
928 next two applies instead. */
929#define CALL_FROM_THUNK_P(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 929, __FUNCTION__, (CALL_EXPR)))->base.protected_flag)
(CALL_EXPR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 929, __FUNCTION__, (CALL_EXPR)))
->base.protected_flag)
930
931/* In a CALL_EXPR, if the function being called is BUILT_IN_ALLOCA, means that
932 it has been built for the declaration of a variable-sized object and, if the
933 function being called is BUILT_IN_MEMCPY, means that it has been built for
934 the assignment of a variable-sized object. */
935#define CALL_ALLOCA_FOR_VAR_P(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 935, __FUNCTION__, (CALL_EXPR)))->base.protected_flag)
\
936 (CALL_EXPR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 936, __FUNCTION__, (CALL_EXPR)))
->base.protected_flag)
937
938/* In a CALL_EXPR, if the function being called is DECL_IS_OPERATOR_NEW_P or
939 DECL_IS_OPERATOR_DELETE_P, true for allocator calls from C++ new or delete
940 expressions. */
941#define CALL_FROM_NEW_OR_DELETE_P(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 941, __FUNCTION__, (CALL_EXPR)))->base.protected_flag)
\
942 (CALL_EXPR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 942, __FUNCTION__, (CALL_EXPR)))
->base.protected_flag)
943
944/* Used in classes in C++. */
945#define TREE_PRIVATE(NODE)((NODE)->base.private_flag) ((NODE)->base.private_flag)
946/* Used in classes in C++. */
947#define TREE_PROTECTED(NODE)((NODE)->base.protected_flag) ((NODE)->base.protected_flag)
948
949/* True if reference type NODE is a C++ rvalue reference. */
950#define TYPE_REF_IS_RVALUE(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 950, __FUNCTION__, (REFERENCE_TYPE)))->base.private_flag
)
\
951 (REFERENCE_TYPE_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 951, __FUNCTION__, (REFERENCE_TYPE)))
->base.private_flag)
952
953/* Nonzero in a _DECL if the use of the name is defined as a
954 deprecated feature by __attribute__((deprecated)). */
955#define TREE_DEPRECATED(NODE)((NODE)->base.deprecated_flag) \
956 ((NODE)->base.deprecated_flag)
957
958/* Nonzero indicates an IDENTIFIER_NODE that names an anonymous
959 aggregate, (as created by anon_aggr_name_format). */
960#define IDENTIFIER_ANON_P(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 960, __FUNCTION__, (IDENTIFIER_NODE)))->base.private_flag
)
\
961 (IDENTIFIER_NODE_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 961, __FUNCTION__, (IDENTIFIER_NODE)))
->base.private_flag)
962
963/* Nonzero in an IDENTIFIER_NODE if the name is a local alias, whose
964 uses are to be substituted for uses of the TREE_CHAINed identifier. */
965#define IDENTIFIER_TRANSPARENT_ALIAS(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 965, __FUNCTION__, (IDENTIFIER_NODE)))->base.deprecated_flag
)
\
966 (IDENTIFIER_NODE_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 966, __FUNCTION__, (IDENTIFIER_NODE)))
->base.deprecated_flag)
967
968/* In an aggregate type, indicates that the scalar fields of the type are
969 stored in reverse order from the target order. This effectively
970 toggles BYTES_BIG_ENDIAN and WORDS_BIG_ENDIAN within the type. */
971#define TYPE_REVERSE_STORAGE_ORDER(NODE)((tree_check4 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 971, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))->base.u.bits.saturating_flag)
\
972 (TREE_CHECK4 (NODE, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, ARRAY_TYPE)(tree_check4 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 972, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))
->base.u.bits.saturating_flag)
973
974/* In a non-aggregate type, indicates a saturating type. */
975#define TYPE_SATURATING(NODE)((tree_not_check4 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 975, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))->base.u.bits.saturating_flag)
\
976 (TREE_NOT_CHECK4 (NODE, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, ARRAY_TYPE)(tree_not_check4 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 976, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))
->base.u.bits.saturating_flag)
977
978/* In a BIT_FIELD_REF and MEM_REF, indicates that the reference is to a group
979 of bits stored in reverse order from the target order. This effectively
980 toggles both BYTES_BIG_ENDIAN and WORDS_BIG_ENDIAN for the reference.
981
982 The overall strategy is to preserve the invariant that every scalar in
983 memory is associated with a single storage order, i.e. all accesses to
984 this scalar are done with the same storage order. This invariant makes
985 it possible to factor out the storage order in most transformations, as
986 only the address and/or the value (in target order) matter for them.
987 But, of course, the storage order must be preserved when the accesses
988 themselves are rewritten or transformed. */
989#define REF_REVERSE_STORAGE_ORDER(NODE)((tree_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 989, __FUNCTION__, (BIT_FIELD_REF), (MEM_REF)))->base.default_def_flag
)
\
990 (TREE_CHECK2 (NODE, BIT_FIELD_REF, MEM_REF)(tree_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 990, __FUNCTION__, (BIT_FIELD_REF), (MEM_REF)))
->base.default_def_flag)
991
992 /* In an ADDR_EXPR, indicates that this is a pointer to nested function
993 represented by a descriptor instead of a trampoline. */
994#define FUNC_ADDR_BY_DESCRIPTOR(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 994, __FUNCTION__, (ADDR_EXPR)))->base.default_def_flag)
\
995 (TREE_CHECK (NODE, ADDR_EXPR)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 995, __FUNCTION__, (ADDR_EXPR)))
->base.default_def_flag)
996
997/* In a CALL_EXPR, indicates that this is an indirect call for which
998 pointers to nested function are descriptors instead of trampolines. */
999#define CALL_EXPR_BY_DESCRIPTOR(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 999, __FUNCTION__, (CALL_EXPR)))->base.default_def_flag)
\
1000 (TREE_CHECK (NODE, CALL_EXPR)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1000, __FUNCTION__, (CALL_EXPR)))
->base.default_def_flag)
1001
1002/* These flags are available for each language front end to use internally. */
1003#define TREE_LANG_FLAG_0(NODE)((tree_not_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1003, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)
\
1004 (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)(tree_not_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1004, __FUNCTION__, (TREE_VEC), (SSA_NAME)))
->base.u.bits.lang_flag_0)
1005#define TREE_LANG_FLAG_1(NODE)((tree_not_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1005, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_1)
\
1006 (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)(tree_not_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1006, __FUNCTION__, (TREE_VEC), (SSA_NAME)))
->base.u.bits.lang_flag_1)
1007#define TREE_LANG_FLAG_2(NODE)((tree_not_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1007, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2)
\
1008 (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)(tree_not_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1008, __FUNCTION__, (TREE_VEC), (SSA_NAME)))
->base.u.bits.lang_flag_2)
1009#define TREE_LANG_FLAG_3(NODE)((tree_not_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1009, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_3)
\
1010 (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)(tree_not_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1010, __FUNCTION__, (TREE_VEC), (SSA_NAME)))
->base.u.bits.lang_flag_3)
1011#define TREE_LANG_FLAG_4(NODE)((tree_not_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1011, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_4)
\
1012 (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)(tree_not_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1012, __FUNCTION__, (TREE_VEC), (SSA_NAME)))
->base.u.bits.lang_flag_4)
1013#define TREE_LANG_FLAG_5(NODE)((tree_not_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1013, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_5)
\
1014 (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)(tree_not_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1014, __FUNCTION__, (TREE_VEC), (SSA_NAME)))
->base.u.bits.lang_flag_5)
1015#define TREE_LANG_FLAG_6(NODE)((tree_not_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1015, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_6)
\
1016 (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)(tree_not_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1016, __FUNCTION__, (TREE_VEC), (SSA_NAME)))
->base.u.bits.lang_flag_6)
1017
1018/* Define additional fields and accessors for nodes representing constants. */
1019
1020#define TREE_INT_CST_NUNITS(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1020, __FUNCTION__, (INTEGER_CST)))->base.u.int_length.unextended
)
\
1021 (INTEGER_CST_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1021, __FUNCTION__, (INTEGER_CST)))
->base.u.int_length.unextended)
1022#define TREE_INT_CST_EXT_NUNITS(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1022, __FUNCTION__, (INTEGER_CST)))->base.u.int_length.extended
)
\
1023 (INTEGER_CST_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1023, __FUNCTION__, (INTEGER_CST)))
->base.u.int_length.extended)
1024#define TREE_INT_CST_OFFSET_NUNITS(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1024, __FUNCTION__, (INTEGER_CST)))->base.u.int_length.offset
)
\
1025 (INTEGER_CST_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1025, __FUNCTION__, (INTEGER_CST)))
->base.u.int_length.offset)
1026#define TREE_INT_CST_ELT(NODE, I)(*tree_int_cst_elt_check ((NODE), (I), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1026, __FUNCTION__))
TREE_INT_CST_ELT_CHECK (NODE, I)(*tree_int_cst_elt_check ((NODE), (I), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1026, __FUNCTION__))
1027#define TREE_INT_CST_LOW(NODE)((unsigned long) (*tree_int_cst_elt_check ((NODE), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1027, __FUNCTION__)))
\
1028 ((unsigned HOST_WIDE_INTlong) TREE_INT_CST_ELT (NODE, 0)(*tree_int_cst_elt_check ((NODE), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1028, __FUNCTION__))
)
1029
1030/* Return true if NODE is a POLY_INT_CST. This is only ever true on
1031 targets with variable-sized modes. */
1032#define POLY_INT_CST_P(NODE)(1 > 1 && ((enum tree_code) (NODE)->base.code) ==
POLY_INT_CST)
\
1033 (NUM_POLY_INT_COEFFS1 > 1 && TREE_CODE (NODE)((enum tree_code) (NODE)->base.code) == POLY_INT_CST)
1034
1035/* In a POLY_INT_CST node. */
1036#define POLY_INT_CST_COEFF(NODE, I)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1036, __FUNCTION__, (POLY_INT_CST)))->poly_int_cst.coeffs
[I])
\
1037 (POLY_INT_CST_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1037, __FUNCTION__, (POLY_INT_CST)))
->poly_int_cst.coeffs[I])
1038
1039#define TREE_REAL_CST_PTR(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1039, __FUNCTION__, (REAL_CST)))->real_cst.real_cst_ptr)
(REAL_CST_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1039, __FUNCTION__, (REAL_CST)))
->real_cst.real_cst_ptr)
1040#define TREE_REAL_CST(NODE)(*((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1040, __FUNCTION__, (REAL_CST)))->real_cst.real_cst_ptr)
)
(*TREE_REAL_CST_PTR (NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1040, __FUNCTION__, (REAL_CST)))->real_cst.real_cst_ptr)
)
1041
1042#define TREE_FIXED_CST_PTR(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1042, __FUNCTION__, (FIXED_CST)))->fixed_cst.fixed_cst_ptr
)
\
1043 (FIXED_CST_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1043, __FUNCTION__, (FIXED_CST)))
->fixed_cst.fixed_cst_ptr)
1044#define TREE_FIXED_CST(NODE)(*((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1044, __FUNCTION__, (FIXED_CST)))->fixed_cst.fixed_cst_ptr
))
(*TREE_FIXED_CST_PTR (NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1044, __FUNCTION__, (FIXED_CST)))->fixed_cst.fixed_cst_ptr
)
)
1045
1046/* In a STRING_CST */
1047/* In C terms, this is sizeof, not strlen. */
1048#define TREE_STRING_LENGTH(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1048, __FUNCTION__, (STRING_CST)))->string.length)
(STRING_CST_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1048, __FUNCTION__, (STRING_CST)))
->string.length)
1049#define TREE_STRING_POINTER(NODE)((const char *)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1049, __FUNCTION__, (STRING_CST)))->string.str))
\
1050 ((const char *)(STRING_CST_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1050, __FUNCTION__, (STRING_CST)))
->string.str))
1051
1052/* In a COMPLEX_CST node. */
1053#define TREE_REALPART(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1053, __FUNCTION__, (COMPLEX_CST)))->complex.real)
(COMPLEX_CST_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1053, __FUNCTION__, (COMPLEX_CST)))
->complex.real)
1054#define TREE_IMAGPART(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1054, __FUNCTION__, (COMPLEX_CST)))->complex.imag)
(COMPLEX_CST_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1054, __FUNCTION__, (COMPLEX_CST)))
->complex.imag)
1055
1056/* In a VECTOR_CST node. See generic.texi for details. */
1057#define VECTOR_CST_NELTS(NODE)(TYPE_VECTOR_SUBPARTS (((contains_struct_check ((NODE), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1057, __FUNCTION__))->typed.type)))
(TYPE_VECTOR_SUBPARTS (TREE_TYPE (NODE)((contains_struct_check ((NODE), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1057, __FUNCTION__))->typed.type)
))
1058#define VECTOR_CST_ELT(NODE,IDX)vector_cst_elt (NODE, IDX) vector_cst_elt (NODE, IDX)
1059
1060#define VECTOR_CST_LOG2_NPATTERNS(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1060, __FUNCTION__, (VECTOR_CST)))->base.u.vector_cst.log2_npatterns
)
\
1061 (VECTOR_CST_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1061, __FUNCTION__, (VECTOR_CST)))
->base.u.vector_cst.log2_npatterns)
1062#define VECTOR_CST_NPATTERNS(NODE)(1U << ((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1062, __FUNCTION__, (VECTOR_CST)))->base.u.vector_cst.log2_npatterns
))
\
1063 (1U << VECTOR_CST_LOG2_NPATTERNS (NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1063, __FUNCTION__, (VECTOR_CST)))->base.u.vector_cst.log2_npatterns
)
)
1064#define VECTOR_CST_NELTS_PER_PATTERN(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1064, __FUNCTION__, (VECTOR_CST)))->base.u.vector_cst.nelts_per_pattern
)
\
1065 (VECTOR_CST_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1065, __FUNCTION__, (VECTOR_CST)))
->base.u.vector_cst.nelts_per_pattern)
1066#define VECTOR_CST_DUPLICATE_P(NODE)(((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1066, __FUNCTION__, (VECTOR_CST)))->base.u.vector_cst.nelts_per_pattern
) == 1)
\
1067 (VECTOR_CST_NELTS_PER_PATTERN (NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1067, __FUNCTION__, (VECTOR_CST)))->base.u.vector_cst.nelts_per_pattern
)
== 1)
1068#define VECTOR_CST_STEPPED_P(NODE)(((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1068, __FUNCTION__, (VECTOR_CST)))->base.u.vector_cst.nelts_per_pattern
) == 3)
\
1069 (VECTOR_CST_NELTS_PER_PATTERN (NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1069, __FUNCTION__, (VECTOR_CST)))->base.u.vector_cst.nelts_per_pattern
)
== 3)
1070#define VECTOR_CST_ENCODED_ELTS(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1070, __FUNCTION__, (VECTOR_CST)))->vector.elts)
\
1071 (VECTOR_CST_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1071, __FUNCTION__, (VECTOR_CST)))
->vector.elts)
1072#define VECTOR_CST_ENCODED_ELT(NODE, ELT)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1072, __FUNCTION__, (VECTOR_CST)))->vector.elts[ELT])
\
1073 (VECTOR_CST_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1073, __FUNCTION__, (VECTOR_CST)))
->vector.elts[ELT])
1074
1075/* Define fields and accessors for some special-purpose tree nodes. */
1076
1077#define IDENTIFIER_LENGTH(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1077, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.len
)
\
1078 (IDENTIFIER_NODE_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1078, __FUNCTION__, (IDENTIFIER_NODE)))
->identifier.id.len)
1079#define IDENTIFIER_POINTER(NODE)((const char *) (tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1079, __FUNCTION__, (IDENTIFIER_NODE)))->identifi