Bug Summary

File:build/gcc/cp/tree.c
Warning:line 3704, column 7
Called C++ object pointer is null

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 tree.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 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/gcc -resource-dir /usr/lib64/clang/13.0.0 -D IN_GCC_FRONTEND -D IN_GCC -D HAVE_CONFIG_H -I . -I cp -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/cp -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/11/../../../../include/c++/11 -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/11/../../../../include/c++/11/x86_64-suse-linux -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/11/../../../../include/c++/11/backward -internal-isystem /usr/lib64/clang/13.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/11/../../../../x86_64-suse-linux/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 -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/clang-static-analyzer/2021-11-20-133755-20252-1/report-eEBPYX.plist -x c++ /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c

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

1/* Language-dependent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987-2021 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
4
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published by
9the Free Software Foundation; either version 3, or (at your option)
10any later version.
11
12GCC is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
18along with GCC; see the file COPYING3. If not see
19<http://www.gnu.org/licenses/>. */
20
21#include "config.h"
22#include "system.h"
23#include "coretypes.h"
24#include "tree.h"
25#include "cp-tree.h"
26#include "gimple-expr.h"
27#include "cgraph.h"
28#include "stor-layout.h"
29#include "print-tree.h"
30#include "tree-iterator.h"
31#include "tree-inline.h"
32#include "debug.h"
33#include "convert.h"
34#include "gimplify.h"
35#include "stringpool.h"
36#include "attribs.h"
37#include "flags.h"
38#include "selftest.h"
39
40static tree bot_manip (tree *, int *, void *);
41static tree bot_replace (tree *, int *, void *);
42static hashval_t list_hash_pieces (tree, tree, tree);
43static tree build_target_expr (tree, tree, tsubst_flags_t);
44static tree count_trees_r (tree *, int *, void *);
45static tree verify_stmt_tree_r (tree *, int *, void *);
46
47static tree handle_init_priority_attribute (tree *, tree, tree, int, bool *);
48static tree handle_abi_tag_attribute (tree *, tree, tree, int, bool *);
49
50/* If REF is an lvalue, returns the kind of lvalue that REF is.
51 Otherwise, returns clk_none. */
52
53cp_lvalue_kind
54lvalue_kind (const_tree ref)
55{
56 cp_lvalue_kind op1_lvalue_kind = clk_none;
57 cp_lvalue_kind op2_lvalue_kind = clk_none;
58
59 /* Expressions of reference type are sometimes wrapped in
60 INDIRECT_REFs. INDIRECT_REFs are just internal compiler
61 representation, not part of the language, so we have to look
62 through them. */
63 if (REFERENCE_REF_P (ref)((((enum tree_code) (ref)->base.code) == INDIRECT_REF) &&
((contains_struct_check (((*((const_cast<tree*> (tree_operand_check
((ref), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 63, __FUNCTION__)))))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 63, __FUNCTION__))->typed.type) && (((enum tree_code
) (((contains_struct_check (((*((const_cast<tree*> (tree_operand_check
(((ref)), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 63, __FUNCTION__)))))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 63, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
))
)
64 return lvalue_kind (TREE_OPERAND (ref, 0)(*((const_cast<tree*> (tree_operand_check ((ref), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 64, __FUNCTION__)))))
);
65
66 if (TREE_TYPE (ref)((contains_struct_check ((ref), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 66, __FUNCTION__))->typed.type)
67 && TYPE_REF_P (TREE_TYPE (ref))(((enum tree_code) (((contains_struct_check ((ref), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 67, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
)
)
68 {
69 /* unnamed rvalue references are rvalues */
70 if (TYPE_REF_IS_RVALUE (TREE_TYPE (ref))((tree_check ((((contains_struct_check ((ref), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 70, __FUNCTION__))->typed.type)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 70, __FUNCTION__, (REFERENCE_TYPE)))->base.private_flag)
71 && TREE_CODE (ref)((enum tree_code) (ref)->base.code) != PARM_DECL
72 && !VAR_P (ref)(((enum tree_code) (ref)->base.code) == VAR_DECL)
73 && TREE_CODE (ref)((enum tree_code) (ref)->base.code) != COMPONENT_REF
74 /* Functions are always lvalues. */
75 && TREE_CODE (TREE_TYPE (TREE_TYPE (ref)))((enum tree_code) (((contains_struct_check ((((contains_struct_check
((ref), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 75, __FUNCTION__))->typed.type)), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 75, __FUNCTION__))->typed.type))->base.code)
!= FUNCTION_TYPE)
76 {
77 op1_lvalue_kind = clk_rvalueref;
78 if (implicit_rvalue_p (ref))
79 op1_lvalue_kind |= clk_implicit_rval;
80 return op1_lvalue_kind;
81 }
82
83 /* lvalue references and named rvalue references are lvalues. */
84 return clk_ordinary;
85 }
86
87 if (ref == current_class_ptr(*((cfun + 0) && ((cfun + 0)->language) ? &((cfun
+ 0)->language)->x_current_class_ptr : &scope_chain
->x_current_class_ptr))
)
88 return clk_none;
89
90 /* Expressions with cv void type are prvalues. */
91 if (TREE_TYPE (ref)((contains_struct_check ((ref), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 91, __FUNCTION__))->typed.type)
&& VOID_TYPE_P (TREE_TYPE (ref))(((enum tree_code) (((contains_struct_check ((ref), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 91, __FUNCTION__))->typed.type))->base.code) == VOID_TYPE
)
)
92 return clk_none;
93
94 switch (TREE_CODE (ref)((enum tree_code) (ref)->base.code))
95 {
96 case SAVE_EXPR:
97 return clk_none;
98
99 /* preincrements and predecrements are valid lvals, provided
100 what they refer to are valid lvals. */
101 case PREINCREMENT_EXPR:
102 case PREDECREMENT_EXPR:
103 case TRY_CATCH_EXPR:
104 case REALPART_EXPR:
105 case IMAGPART_EXPR:
106 case VIEW_CONVERT_EXPR:
107 return lvalue_kind (TREE_OPERAND (ref, 0)(*((const_cast<tree*> (tree_operand_check ((ref), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 107, __FUNCTION__)))))
);
108
109 case ARRAY_REF:
110 {
111 tree op1 = TREE_OPERAND (ref, 0)(*((const_cast<tree*> (tree_operand_check ((ref), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 111, __FUNCTION__)))))
;
112 if (TREE_CODE (TREE_TYPE (op1))((enum tree_code) (((contains_struct_check ((op1), (TS_TYPED)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 112, __FUNCTION__))->typed.type))->base.code)
== ARRAY_TYPE)
113 {
114 op1_lvalue_kind = lvalue_kind (op1);
115 if (op1_lvalue_kind == clk_class)
116 /* in the case of an array operand, the result is an lvalue if
117 that operand is an lvalue and an xvalue otherwise */
118 op1_lvalue_kind = clk_rvalueref;
119 return op1_lvalue_kind;
120 }
121 else
122 return clk_ordinary;
123 }
124
125 case MEMBER_REF:
126 case DOTSTAR_EXPR:
127 if (TREE_CODE (ref)((enum tree_code) (ref)->base.code) == MEMBER_REF)
128 op1_lvalue_kind = clk_ordinary;
129 else
130 op1_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 0)(*((const_cast<tree*> (tree_operand_check ((ref), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 130, __FUNCTION__)))))
);
131 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (ref, 1)))(((enum tree_code) (((contains_struct_check (((*((const_cast<
tree*> (tree_operand_check ((ref), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 131, __FUNCTION__)))))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 131, __FUNCTION__))->typed.type))->base.code) == RECORD_TYPE
&& (((tree_class_check (((tree_check ((((contains_struct_check
(((*((const_cast<tree*> (tree_operand_check ((ref), (1
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 131, __FUNCTION__)))))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 131, __FUNCTION__))->typed.type)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 131, __FUNCTION__, (RECORD_TYPE)))), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 131, __FUNCTION__))->type_common.lang_flag_2)))
)
132 op1_lvalue_kind = clk_none;
133 else if (op1_lvalue_kind == clk_class)
134 /* The result of a .* expression whose second operand is a pointer to a
135 data member is an lvalue if the first operand is an lvalue and an
136 xvalue otherwise. */
137 op1_lvalue_kind = clk_rvalueref;
138 return op1_lvalue_kind;
139
140 case COMPONENT_REF:
141 if (BASELINK_P (TREE_OPERAND (ref, 1))(((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
((ref), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 141, __FUNCTION__))))))->base.code) == BASELINK)
)
142 {
143 tree fn = BASELINK_FUNCTIONS (TREE_OPERAND (ref, 1))(((struct tree_baselink*) (tree_check (((*((const_cast<tree
*> (tree_operand_check ((ref), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 143, __FUNCTION__)))))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 143, __FUNCTION__, (BASELINK))))->functions)
;
144
145 /* For static member function recurse on the BASELINK, we can get
146 here e.g. from reference_binding. If BASELINK_FUNCTIONS is
147 OVERLOAD, the overload is resolved first if possible through
148 resolve_address_of_overloaded_function. */
149 if (TREE_CODE (fn)((enum tree_code) (fn)->base.code) == FUNCTION_DECL && DECL_STATIC_FUNCTION_P (fn)(__extension__ ({ struct lang_decl *lt = ((contains_struct_check
(((((enum tree_code) (fn)->base.code) == TEMPLATE_DECL ? (
(struct tree_template_decl *)(const_cast<union tree_node *
> ((((tree_check ((fn), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 149, __FUNCTION__, (TEMPLATE_DECL))))))))->result : fn))
, (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 149, __FUNCTION__))->decl_common.lang_specific); if (!((
(enum tree_code) (fn)->base.code) == FUNCTION_DECL || (((enum
tree_code) (fn)->base.code) == TEMPLATE_DECL && (
(struct tree_template_decl *)(const_cast<union tree_node *
> ((((tree_check ((fn), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 149, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) nullptr && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((fn),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 149, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->base
.code) == FUNCTION_DECL)) || lt->u.base.selector != lds_fn
) lang_check_failed ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 149, __FUNCTION__); &lt->u.fn; })->static_function
)
)
150 return lvalue_kind (TREE_OPERAND (ref, 1)(*((const_cast<tree*> (tree_operand_check ((ref), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 150, __FUNCTION__)))))
);
151 }
152 op1_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 0)(*((const_cast<tree*> (tree_operand_check ((ref), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 152, __FUNCTION__)))))
);
153 if (op1_lvalue_kind == clk_class)
154 /* If E1 is an lvalue, then E1.E2 is an lvalue;
155 otherwise E1.E2 is an xvalue. */
156 op1_lvalue_kind = clk_rvalueref;
157
158 /* Look at the member designator. */
159 if (!op1_lvalue_kind)
160 ;
161 else if (is_overloaded_fn (TREE_OPERAND (ref, 1)(*((const_cast<tree*> (tree_operand_check ((ref), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 161, __FUNCTION__)))))
))
162 /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some
163 situations. If we're seeing a COMPONENT_REF, it's a non-static
164 member, so it isn't an lvalue. */
165 op1_lvalue_kind = clk_none;
166 else if (TREE_CODE (TREE_OPERAND (ref, 1))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
((ref), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 166, __FUNCTION__))))))->base.code)
!= FIELD_DECL)
167 /* This can be IDENTIFIER_NODE in a template. */;
168 else if (DECL_C_BIT_FIELD (TREE_OPERAND (ref, 1))(((contains_struct_check (((tree_check (((*((const_cast<tree
*> (tree_operand_check ((ref), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 168, __FUNCTION__)))))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 168, __FUNCTION__, (FIELD_DECL)))), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 168, __FUNCTION__))->decl_common.lang_flag_4) == 1)
)
169 {
170 /* Clear the ordinary bit. If this object was a class
171 rvalue we want to preserve that information. */
172 op1_lvalue_kind &= ~clk_ordinary;
173 /* The lvalue is for a bitfield. */
174 op1_lvalue_kind |= clk_bitfield;
175 }
176 else if (DECL_PACKED (TREE_OPERAND (ref, 1))((tree_check (((*((const_cast<tree*> (tree_operand_check
((ref), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 176, __FUNCTION__)))))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 176, __FUNCTION__, (FIELD_DECL)))->base.u.bits.packed_flag
)
)
177 op1_lvalue_kind |= clk_packed;
178
179 return op1_lvalue_kind;
180
181 case STRING_CST:
182 case COMPOUND_LITERAL_EXPR:
183 return clk_ordinary;
184
185 case CONST_DECL:
186 /* CONST_DECL without TREE_STATIC are enumeration values and
187 thus not lvalues. With TREE_STATIC they are used by ObjC++
188 in objc_build_string_object and need to be considered as
189 lvalues. */
190 if (! TREE_STATIC (ref)((ref)->base.static_flag))
191 return clk_none;
192 /* FALLTHRU */
193 case VAR_DECL:
194 if (VAR_P (ref)(((enum tree_code) (ref)->base.code) == VAR_DECL) && DECL_HAS_VALUE_EXPR_P (ref)((tree_check3 ((ref), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 194, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL)))
->decl_common.decl_flag_2)
)
195 return lvalue_kind (DECL_VALUE_EXPR (CONST_CAST_TREE (ref))(decl_value_expr_lookup ((contains_struct_check (((const_cast
<union tree_node *> (((ref))))), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 195, __FUNCTION__))))
);
196
197 if (TREE_READONLY (ref)((non_type_check ((ref), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 197, __FUNCTION__))->base.readonly_flag)
&& ! TREE_STATIC (ref)((ref)->base.static_flag)
198 && DECL_LANG_SPECIFIC (ref)((contains_struct_check ((ref), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 198, __FUNCTION__))->decl_common.lang_specific)
199 && DECL_IN_AGGR_P (ref)(((contains_struct_check ((ref), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 199, __FUNCTION__))->decl_common.lang_flag_3))
)
200 return clk_none;
201 /* FALLTHRU */
202 case INDIRECT_REF:
203 case ARROW_EXPR:
204 case PARM_DECL:
205 case RESULT_DECL:
206 case PLACEHOLDER_EXPR:
207 return clk_ordinary;
208
209 /* A scope ref in a template, left as SCOPE_REF to support later
210 access checking. */
211 case SCOPE_REF:
212 gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE (ref)))((void)(!(!type_dependent_expression_p ((const_cast<union tree_node
*> (((ref)))))) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 212, __FUNCTION__), 0 : 0))
;
213 {
214 tree op = TREE_OPERAND (ref, 1)(*((const_cast<tree*> (tree_operand_check ((ref), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 214, __FUNCTION__)))))
;
215 if (TREE_CODE (op)((enum tree_code) (op)->base.code) == FIELD_DECL)
216 return (DECL_C_BIT_FIELD (op)(((contains_struct_check (((tree_check ((op), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 216, __FUNCTION__, (FIELD_DECL)))), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 216, __FUNCTION__))->decl_common.lang_flag_4) == 1)
? clk_bitfield : clk_ordinary);
217 else
218 return lvalue_kind (op);
219 }
220
221 case MAX_EXPR:
222 case MIN_EXPR:
223 /* Disallow <? and >? as lvalues if either argument side-effects. */
224 if (TREE_SIDE_EFFECTS (TREE_OPERAND (ref, 0))((non_type_check (((*((const_cast<tree*> (tree_operand_check
((ref), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 224, __FUNCTION__)))))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 224, __FUNCTION__))->base.side_effects_flag)
225 || TREE_SIDE_EFFECTS (TREE_OPERAND (ref, 1))((non_type_check (((*((const_cast<tree*> (tree_operand_check
((ref), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 225, __FUNCTION__)))))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 225, __FUNCTION__))->base.side_effects_flag)
)
226 return clk_none;
227 op1_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 0)(*((const_cast<tree*> (tree_operand_check ((ref), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 227, __FUNCTION__)))))
);
228 op2_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 1)(*((const_cast<tree*> (tree_operand_check ((ref), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 228, __FUNCTION__)))))
);
229 break;
230
231 case COND_EXPR:
232 if (processing_template_declscope_chain->x_processing_template_decl)
233 {
234 /* Within templates, a REFERENCE_TYPE will indicate whether
235 the COND_EXPR result is an ordinary lvalue or rvalueref.
236 Since REFERENCE_TYPEs are handled above, if we reach this
237 point, we know we got a plain rvalue. Unless we have a
238 type-dependent expr, that is, but we shouldn't be testing
239 lvalueness if we can't even tell the types yet! */
240 gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE (ref)))((void)(!(!type_dependent_expression_p ((const_cast<union tree_node
*> (((ref)))))) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 240, __FUNCTION__), 0 : 0))
;
241 goto default_;
242 }
243 {
244 tree op1 = TREE_OPERAND (ref, 1)(*((const_cast<tree*> (tree_operand_check ((ref), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 244, __FUNCTION__)))))
;
245 if (!op1) op1 = TREE_OPERAND (ref, 0)(*((const_cast<tree*> (tree_operand_check ((ref), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 245, __FUNCTION__)))))
;
246 tree op2 = TREE_OPERAND (ref, 2)(*((const_cast<tree*> (tree_operand_check ((ref), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 246, __FUNCTION__)))))
;
247 op1_lvalue_kind = lvalue_kind (op1);
248 op2_lvalue_kind = lvalue_kind (op2);
249 if (!op1_lvalue_kind != !op2_lvalue_kind)
250 {
251 /* The second or the third operand (but not both) is a
252 throw-expression; the result is of the type
253 and value category of the other. */
254 if (op1_lvalue_kind && TREE_CODE (op2)((enum tree_code) (op2)->base.code) == THROW_EXPR)
255 op2_lvalue_kind = op1_lvalue_kind;
256 else if (op2_lvalue_kind && TREE_CODE (op1)((enum tree_code) (op1)->base.code) == THROW_EXPR)
257 op1_lvalue_kind = op2_lvalue_kind;
258 }
259 }
260 break;
261
262 case MODOP_EXPR:
263 /* We expect to see unlowered MODOP_EXPRs only during
264 template processing. */
265 gcc_assert (processing_template_decl)((void)(!(scope_chain->x_processing_template_decl) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 265, __FUNCTION__), 0 : 0))
;
266 return clk_ordinary;
267
268 case MODIFY_EXPR:
269 case TYPEID_EXPR:
270 return clk_ordinary;
271
272 case COMPOUND_EXPR:
273 return lvalue_kind (TREE_OPERAND (ref, 1)(*((const_cast<tree*> (tree_operand_check ((ref), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 273, __FUNCTION__)))))
);
274
275 case TARGET_EXPR:
276 return clk_class;
277
278 case VA_ARG_EXPR:
279 return (CLASS_TYPE_P (TREE_TYPE (ref))(((((enum tree_code) (((contains_struct_check ((ref), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 279, __FUNCTION__))->typed.type))->base.code)) == RECORD_TYPE
|| (((enum tree_code) (((contains_struct_check ((ref), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 279, __FUNCTION__))->typed.type))->base.code)) == UNION_TYPE
) && ((tree_class_check ((((contains_struct_check ((ref
), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 279, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 279, __FUNCTION__))->type_common.lang_flag_5))
? clk_class : clk_none);
280
281 case CALL_EXPR:
282 /* We can see calls outside of TARGET_EXPR in templates. */
283 if (CLASS_TYPE_P (TREE_TYPE (ref))(((((enum tree_code) (((contains_struct_check ((ref), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 283, __FUNCTION__))->typed.type))->base.code)) == RECORD_TYPE
|| (((enum tree_code) (((contains_struct_check ((ref), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 283, __FUNCTION__))->typed.type))->base.code)) == UNION_TYPE
) && ((tree_class_check ((((contains_struct_check ((ref
), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 283, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 283, __FUNCTION__))->type_common.lang_flag_5))
)
284 return clk_class;
285 return clk_none;
286
287 case FUNCTION_DECL:
288 /* All functions (except non-static-member functions) are
289 lvalues. */
290 return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref)(((enum tree_code) (((contains_struct_check ((ref), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 290, __FUNCTION__))->typed.type))->base.code) == METHOD_TYPE
)
291 ? clk_none : clk_ordinary);
292
293 case BASELINK:
294 /* We now represent a reference to a single static member function
295 with a BASELINK. */
296 /* This CONST_CAST is okay because BASELINK_FUNCTIONS returns
297 its argument unmodified and we assign it to a const_tree. */
298 return lvalue_kind (BASELINK_FUNCTIONS (CONST_CAST_TREE (ref))(((struct tree_baselink*) (tree_check (((const_cast<union tree_node
*> (((ref))))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 298, __FUNCTION__, (BASELINK))))->functions)
);
299
300 case NON_DEPENDENT_EXPR:
301 case PAREN_EXPR:
302 return lvalue_kind (TREE_OPERAND (ref, 0)(*((const_cast<tree*> (tree_operand_check ((ref), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 302, __FUNCTION__)))))
);
303
304 case TEMPLATE_PARM_INDEX:
305 if (CLASS_TYPE_P (TREE_TYPE (ref))(((((enum tree_code) (((contains_struct_check ((ref), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 305, __FUNCTION__))->typed.type))->base.code)) == RECORD_TYPE
|| (((enum tree_code) (((contains_struct_check ((ref), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 305, __FUNCTION__))->typed.type))->base.code)) == UNION_TYPE
) && ((tree_class_check ((((contains_struct_check ((ref
), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 305, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 305, __FUNCTION__))->type_common.lang_flag_5))
)
306 /* A template parameter object is an lvalue. */
307 return clk_ordinary;
308 return clk_none;
309
310 default:
311 default_:
312 if (!TREE_TYPE (ref)((contains_struct_check ((ref), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 312, __FUNCTION__))->typed.type)
)
313 return clk_none;
314 if (CLASS_TYPE_P (TREE_TYPE (ref))(((((enum tree_code) (((contains_struct_check ((ref), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 314, __FUNCTION__))->typed.type))->base.code)) == RECORD_TYPE
|| (((enum tree_code) (((contains_struct_check ((ref), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 314, __FUNCTION__))->typed.type))->base.code)) == UNION_TYPE
) && ((tree_class_check ((((contains_struct_check ((ref
), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 314, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 314, __FUNCTION__))->type_common.lang_flag_5))
315 || TREE_CODE (TREE_TYPE (ref))((enum tree_code) (((contains_struct_check ((ref), (TS_TYPED)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 315, __FUNCTION__))->typed.type))->base.code)
== ARRAY_TYPE)
316 return clk_class;
317 return clk_none;
318 }
319
320 /* If one operand is not an lvalue at all, then this expression is
321 not an lvalue. */
322 if (!op1_lvalue_kind || !op2_lvalue_kind)
323 return clk_none;
324
325 /* Otherwise, it's an lvalue, and it has all the odd properties
326 contributed by either operand. */
327 op1_lvalue_kind = op1_lvalue_kind | op2_lvalue_kind;
328 /* It's not an ordinary lvalue if it involves any other kind. */
329 if ((op1_lvalue_kind & ~clk_ordinary) != clk_none)
330 op1_lvalue_kind &= ~clk_ordinary;
331 /* It can't be both a pseudo-lvalue and a non-addressable lvalue.
332 A COND_EXPR of those should be wrapped in a TARGET_EXPR. */
333 if ((op1_lvalue_kind & (clk_rvalueref|clk_class))
334 && (op1_lvalue_kind & (clk_bitfield|clk_packed)))
335 op1_lvalue_kind = clk_none;
336 return op1_lvalue_kind;
337}
338
339/* Returns the kind of lvalue that REF is, in the sense of [basic.lval]. */
340
341cp_lvalue_kind
342real_lvalue_p (const_tree ref)
343{
344 cp_lvalue_kind kind = lvalue_kind (ref);
345 if (kind & (clk_rvalueref|clk_class))
346 return clk_none;
347 else
348 return kind;
349}
350
351/* c-common wants us to return bool. */
352
353bool
354lvalue_p (const_tree t)
355{
356 return real_lvalue_p (t);
357}
358
359/* This differs from lvalue_p in that xvalues are included. */
360
361bool
362glvalue_p (const_tree ref)
363{
364 cp_lvalue_kind kind = lvalue_kind (ref);
365 if (kind & clk_class)
366 return false;
367 else
368 return (kind != clk_none);
369}
370
371/* This differs from glvalue_p in that class prvalues are included. */
372
373bool
374obvalue_p (const_tree ref)
375{
376 return (lvalue_kind (ref) != clk_none);
377}
378
379/* Returns true if REF is an xvalue (the result of dereferencing an rvalue
380 reference), false otherwise. */
381
382bool
383xvalue_p (const_tree ref)
384{
385 return (lvalue_kind (ref) == clk_rvalueref);
386}
387
388/* True if REF is a bit-field. */
389
390bool
391bitfield_p (const_tree ref)
392{
393 return (lvalue_kind (ref) & clk_bitfield);
394}
395
396/* C++-specific version of stabilize_reference. */
397
398tree
399cp_stabilize_reference (tree ref)
400{
401 STRIP_ANY_LOCATION_WRAPPER (ref)(ref) = tree_strip_any_location_wrapper ((const_cast<union
tree_node *> (((ref)))))
;
402 switch (TREE_CODE (ref)((enum tree_code) (ref)->base.code))
403 {
404 case NON_DEPENDENT_EXPR:
405 /* We aren't actually evaluating this. */
406 return ref;
407
408 /* We need to treat specially anything stabilize_reference doesn't
409 handle specifically. */
410 case VAR_DECL:
411 case PARM_DECL:
412 case RESULT_DECL:
413 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
414 case FLOAT_EXPR:
415 case FIX_TRUNC_EXPR:
416 case INDIRECT_REF:
417 case COMPONENT_REF:
418 case BIT_FIELD_REF:
419 case ARRAY_REF:
420 case ARRAY_RANGE_REF:
421 case ERROR_MARK:
422 break;
423 default:
424 cp_lvalue_kind kind = lvalue_kind (ref);
425 if ((kind & ~clk_class) != clk_none)
426 {
427 tree type = unlowered_expr_type (ref);
428 bool rval = !!(kind & clk_rvalueref);
429 type = cp_build_reference_type (type, rval);
430 /* This inhibits warnings in, eg, cxx_mark_addressable
431 (c++/60955). */
432 warning_sentinel s (extra_warningsglobal_options.x_extra_warnings);
433 ref = build_static_cast (input_location, type, ref,
434 tf_error);
435 }
436 }
437
438 return stabilize_reference (ref);
439}
440
441/* Test whether DECL is a builtin that may appear in a
442 constant-expression. */
443
444bool
445builtin_valid_in_constant_expr_p (const_tree decl)
446{
447 STRIP_ANY_LOCATION_WRAPPER (decl)(decl) = tree_strip_any_location_wrapper ((const_cast<union
tree_node *> (((decl)))))
;
448 if (TREE_CODE (decl)((enum tree_code) (decl)->base.code) != FUNCTION_DECL)
449 /* Not a function. */
450 return false;
451 if (DECL_BUILT_IN_CLASS (decl)((built_in_class) (tree_check ((decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 451, __FUNCTION__, (FUNCTION_DECL)))->function_decl.built_in_class
)
!= BUILT_IN_NORMAL)
452 {
453 if (fndecl_built_in_p (decl, BUILT_IN_FRONTEND))
454 switch (DECL_FE_FUNCTION_CODE (decl))
455 {
456 case CP_BUILT_IN_IS_CONSTANT_EVALUATED:
457 case CP_BUILT_IN_SOURCE_LOCATION:
458 case CP_BUILT_IN_IS_CORRESPONDING_MEMBER:
459 case CP_BUILT_IN_IS_POINTER_INTERCONVERTIBLE_WITH_CLASS:
460 return true;
461 default:
462 break;
463 }
464 /* Not a built-in. */
465 return false;
466 }
467 switch (DECL_FUNCTION_CODE (decl))
468 {
469 /* These always have constant results like the corresponding
470 macros/symbol. */
471 case BUILT_IN_FILE:
472 case BUILT_IN_FUNCTION:
473 case BUILT_IN_LINE:
474
475 /* The following built-ins are valid in constant expressions
476 when their arguments are. */
477 case BUILT_IN_ADD_OVERFLOW_P:
478 case BUILT_IN_SUB_OVERFLOW_P:
479 case BUILT_IN_MUL_OVERFLOW_P:
480
481 /* These have constant results even if their operands are
482 non-constant. */
483 case BUILT_IN_CONSTANT_P:
484 case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE:
485 return true;
486 default:
487 return false;
488 }
489}
490
491/* Build a TARGET_EXPR, initializing the DECL with the VALUE. */
492
493static tree
494build_target_expr (tree decl, tree value, tsubst_flags_t complain)
495{
496 tree t;
497 tree type = TREE_TYPE (decl)((contains_struct_check ((decl), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 497, __FUNCTION__))->typed.type)
;
498
499 value = mark_rvalue_use (value);
500
501 gcc_checking_assert (VOID_TYPE_P (TREE_TYPE (value))((void)(!((((enum tree_code) (((contains_struct_check ((value
), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 501, __FUNCTION__))->typed.type))->base.code) == VOID_TYPE
) || ((contains_struct_check ((decl), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 502, __FUNCTION__))->typed.type) == ((contains_struct_check
((value), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 502, __FUNCTION__))->typed.type) || ((((enum tree_code) (
((contains_struct_check ((value), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 504, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
) && ((enum tree_code) (value)->base.code) == CALL_EXPR
) || useless_type_conversion_p (((contains_struct_check ((decl
), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 506, __FUNCTION__))->typed.type), ((contains_struct_check
((value), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 507, __FUNCTION__))->typed.type))) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 507, __FUNCTION__), 0 : 0))
502 || TREE_TYPE (decl) == TREE_TYPE (value)((void)(!((((enum tree_code) (((contains_struct_check ((value
), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 501, __FUNCTION__))->typed.type))->base.code) == VOID_TYPE
) || ((contains_struct_check ((decl), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 502, __FUNCTION__))->typed.type) == ((contains_struct_check
((value), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 502, __FUNCTION__))->typed.type) || ((((enum tree_code) (
((contains_struct_check ((value), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 504, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
) && ((enum tree_code) (value)->base.code) == CALL_EXPR
) || useless_type_conversion_p (((contains_struct_check ((decl
), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 506, __FUNCTION__))->typed.type), ((contains_struct_check
((value), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 507, __FUNCTION__))->typed.type))) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 507, __FUNCTION__), 0 : 0))
503 /* On ARM ctors return 'this'. */((void)(!((((enum tree_code) (((contains_struct_check ((value
), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 501, __FUNCTION__))->typed.type))->base.code) == VOID_TYPE
) || ((contains_struct_check ((decl), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 502, __FUNCTION__))->typed.type) == ((contains_struct_check
((value), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 502, __FUNCTION__))->typed.type) || ((((enum tree_code) (
((contains_struct_check ((value), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 504, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
) && ((enum tree_code) (value)->base.code) == CALL_EXPR
) || useless_type_conversion_p (((contains_struct_check ((decl
), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 506, __FUNCTION__))->typed.type), ((contains_struct_check
((value), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 507, __FUNCTION__))->typed.type))) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 507, __FUNCTION__), 0 : 0))
504 || (TYPE_PTR_P (TREE_TYPE (value))((void)(!((((enum tree_code) (((contains_struct_check ((value
), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 501, __FUNCTION__))->typed.type))->base.code) == VOID_TYPE
) || ((contains_struct_check ((decl), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 502, __FUNCTION__))->typed.type) == ((contains_struct_check
((value), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 502, __FUNCTION__))->typed.type) || ((((enum tree_code) (
((contains_struct_check ((value), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 504, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
) && ((enum tree_code) (value)->base.code) == CALL_EXPR
) || useless_type_conversion_p (((contains_struct_check ((decl
), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 506, __FUNCTION__))->typed.type), ((contains_struct_check
((value), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 507, __FUNCTION__))->typed.type))) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 507, __FUNCTION__), 0 : 0))
505 && TREE_CODE (value) == CALL_EXPR)((void)(!((((enum tree_code) (((contains_struct_check ((value
), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 501, __FUNCTION__))->typed.type))->base.code) == VOID_TYPE
) || ((contains_struct_check ((decl), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 502, __FUNCTION__))->typed.type) == ((contains_struct_check
((value), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 502, __FUNCTION__))->typed.type) || ((((enum tree_code) (
((contains_struct_check ((value), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 504, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
) && ((enum tree_code) (value)->base.code) == CALL_EXPR
) || useless_type_conversion_p (((contains_struct_check ((decl
), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 506, __FUNCTION__))->typed.type), ((contains_struct_check
((value), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 507, __FUNCTION__))->typed.type))) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 507, __FUNCTION__), 0 : 0))
506 || useless_type_conversion_p (TREE_TYPE (decl),((void)(!((((enum tree_code) (((contains_struct_check ((value
), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 501, __FUNCTION__))->typed.type))->base.code) == VOID_TYPE
) || ((contains_struct_check ((decl), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 502, __FUNCTION__))->typed.type) == ((contains_struct_check
((value), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 502, __FUNCTION__))->typed.type) || ((((enum tree_code) (
((contains_struct_check ((value), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 504, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
) && ((enum tree_code) (value)->base.code) == CALL_EXPR
) || useless_type_conversion_p (((contains_struct_check ((decl
), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 506, __FUNCTION__))->typed.type), ((contains_struct_check
((value), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 507, __FUNCTION__))->typed.type))) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 507, __FUNCTION__), 0 : 0))
507 TREE_TYPE (value)))((void)(!((((enum tree_code) (((contains_struct_check ((value
), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 501, __FUNCTION__))->typed.type))->base.code) == VOID_TYPE
) || ((contains_struct_check ((decl), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 502, __FUNCTION__))->typed.type) == ((contains_struct_check
((value), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 502, __FUNCTION__))->typed.type) || ((((enum tree_code) (
((contains_struct_check ((value), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 504, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
) && ((enum tree_code) (value)->base.code) == CALL_EXPR
) || useless_type_conversion_p (((contains_struct_check ((decl
), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 506, __FUNCTION__))->typed.type), ((contains_struct_check
((value), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 507, __FUNCTION__))->typed.type))) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 507, __FUNCTION__), 0 : 0))
;
508
509 /* Set TREE_READONLY for optimization, such as gimplify_init_constructor
510 moving a constant aggregate into .rodata. */
511 if (CP_TYPE_CONST_NON_VOLATILE_P (type)((cp_type_quals (type) & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE
)) == TYPE_QUAL_CONST)
512 && !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)(((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 512, __FUNCTION__))->type_common.lang_flag_4))
513 && !VOID_TYPE_P (TREE_TYPE (value))(((enum tree_code) (((contains_struct_check ((value), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 513, __FUNCTION__))->typed.type))->base.code) == VOID_TYPE
)
514 && reduced_constant_expression_p (value))
515 TREE_READONLY (decl)((non_type_check ((decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 515, __FUNCTION__))->base.readonly_flag)
= true;
516
517 if (complain & tf_no_cleanup)
518 /* The caller is building a new-expr and does not need a cleanup. */
519 t = NULL_TREE(tree) nullptr;
520 else
521 {
522 t = cxx_maybe_build_cleanup (decl, complain);
523 if (t == error_mark_nodeglobal_trees[TI_ERROR_MARK])
524 return error_mark_nodeglobal_trees[TI_ERROR_MARK];
525 }
526 t = build4 (TARGET_EXPR, type, decl, value, t, NULL_TREE(tree) nullptr);
527 if (location_t eloc = cp_expr_location (value))
528 SET_EXPR_LOCATION (t, eloc)(expr_check (((t)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 528, __FUNCTION__))->exp.locus = (eloc)
;
529 /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
530 ignore the TARGET_EXPR. If there really turn out to be no
531 side-effects, then the optimizer should be able to get rid of
532 whatever code is generated anyhow. */
533 TREE_SIDE_EFFECTS (t)((non_type_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 533, __FUNCTION__))->base.side_effects_flag)
= 1;
534
535 return t;
536}
537
538/* Return an undeclared local temporary of type TYPE for use in building a
539 TARGET_EXPR. */
540
541tree
542build_local_temp (tree type)
543{
544 tree slot = build_decl (input_location,
545 VAR_DECL, NULL_TREE(tree) nullptr, type);
546 DECL_ARTIFICIAL (slot)((contains_struct_check ((slot), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 546, __FUNCTION__))->decl_common.artificial_flag)
= 1;
547 DECL_IGNORED_P (slot)((contains_struct_check ((slot), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 547, __FUNCTION__))->decl_common.ignored_flag)
= 1;
548 DECL_CONTEXT (slot)((contains_struct_check ((slot), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 548, __FUNCTION__))->decl_minimal.context)
= current_function_decl;
549 layout_decl (slot, 0);
550 return slot;
551}
552
553/* Return whether DECL is such a local temporary (or one from
554 create_tmp_var_raw). */
555
556bool
557is_local_temp (tree decl)
558{
559 return (VAR_P (decl)(((enum tree_code) (decl)->base.code) == VAR_DECL) && DECL_ARTIFICIAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 559, __FUNCTION__))->decl_common.artificial_flag)
560 && !TREE_STATIC (decl)((decl)->base.static_flag)
561 && DECL_FUNCTION_SCOPE_P (decl)(((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 561, __FUNCTION__))->decl_minimal.context) && ((
enum tree_code) (((contains_struct_check ((decl), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 561, __FUNCTION__))->decl_minimal.context))->base.code
) == FUNCTION_DECL)
);
562}
563
564/* Set various status flags when building an AGGR_INIT_EXPR object T. */
565
566static void
567process_aggr_init_operands (tree t)
568{
569 bool side_effects;
570
571 side_effects = TREE_SIDE_EFFECTS (t)((non_type_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 571, __FUNCTION__))->base.side_effects_flag)
;
572 if (!side_effects)
573 {
574 int i, n;
575 n = TREE_OPERAND_LENGTH (t)tree_operand_length (t);
576 for (i = 1; i < n; i++)
577 {
578 tree op = TREE_OPERAND (t, i)(*((const_cast<tree*> (tree_operand_check ((t), (i), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 578, __FUNCTION__)))))
;
579 if (op && TREE_SIDE_EFFECTS (op)((non_type_check ((op), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 579, __FUNCTION__))->base.side_effects_flag)
)
580 {
581 side_effects = 1;
582 break;
583 }
584 }
585 }
586 TREE_SIDE_EFFECTS (t)((non_type_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 586, __FUNCTION__))->base.side_effects_flag)
= side_effects;
587}
588
589/* Build an AGGR_INIT_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE,
590 FN, and SLOT. NARGS is the number of call arguments which are specified
591 as a tree array ARGS. */
592
593static tree
594build_aggr_init_array (tree return_type, tree fn, tree slot, int nargs,
595 tree *args)
596{
597 tree t;
598 int i;
599
600 t = build_vl_exp (AGGR_INIT_EXPR, nargs + 3);
601 TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 601, __FUNCTION__))->typed.type)
= return_type;
602 AGGR_INIT_EXPR_FN (t)(*((const_cast<tree*> (tree_operand_check (((tree_check
((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 602, __FUNCTION__, (AGGR_INIT_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 602, __FUNCTION__)))))
= fn;
603 AGGR_INIT_EXPR_SLOT (t)(*((const_cast<tree*> (tree_operand_check (((tree_check
((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 603, __FUNCTION__, (AGGR_INIT_EXPR)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 603, __FUNCTION__)))))
= slot;
604 for (i = 0; i < nargs; i++)
605 AGGR_INIT_EXPR_ARG (t, i)(*((const_cast<tree*> (tree_operand_check (((tree_check
((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 605, __FUNCTION__, (AGGR_INIT_EXPR)))), ((i) + 3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 605, __FUNCTION__)))))
= args[i];
606 process_aggr_init_operands (t);
607 return t;
608}
609
610/* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
611 target. TYPE is the type to be initialized.
612
613 Build an AGGR_INIT_EXPR to represent the initialization. This function
614 differs from build_cplus_new in that an AGGR_INIT_EXPR can only be used
615 to initialize another object, whereas a TARGET_EXPR can either
616 initialize another object or create its own temporary object, and as a
617 result building up a TARGET_EXPR requires that the type's destructor be
618 callable. */
619
620tree
621build_aggr_init_expr (tree type, tree init)
622{
623 tree fn;
624 tree slot;
625 tree rval;
626 int is_ctor;
627
628 gcc_assert (!VOID_TYPE_P (type))((void)(!(!(((enum tree_code) (type)->base.code) == VOID_TYPE
)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 628, __FUNCTION__), 0 : 0))
;
629
630 /* Don't build AGGR_INIT_EXPR in a template. */
631 if (processing_template_declscope_chain->x_processing_template_decl)
632 return init;
633
634 fn = cp_get_callee (init);
635 if (fn == NULL_TREE(tree) nullptr)
636 return convert (type, init);
637
638 is_ctor = (TREE_CODE (fn)((enum tree_code) (fn)->base.code) == ADDR_EXPR
639 && TREE_CODE (TREE_OPERAND (fn, 0))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
((fn), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 639, __FUNCTION__))))))->base.code)
== FUNCTION_DECL
640 && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn, 0))((tree_check (((((enum tree_code) ((*((const_cast<tree*>
(tree_operand_check ((fn), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 640, __FUNCTION__))))))->base.code) == TEMPLATE_DECL ? (
(struct tree_template_decl *)(const_cast<union tree_node *
> ((((tree_check (((*((const_cast<tree*> (tree_operand_check
((fn), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 640, __FUNCTION__)))))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 640, __FUNCTION__, (TEMPLATE_DECL))))))))->result : (*((
const_cast<tree*> (tree_operand_check ((fn), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 640, __FUNCTION__))))))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 640, __FUNCTION__, (FUNCTION_DECL)))->decl_with_vis.cxx_constructor
)
);
641
642 /* We split the CALL_EXPR into its function and its arguments here.
643 Then, in expand_expr, we put them back together. The reason for
644 this is that this expression might be a default argument
645 expression. In that case, we need a new temporary every time the
646 expression is used. That's what break_out_target_exprs does; it
647 replaces every AGGR_INIT_EXPR with a copy that uses a fresh
648 temporary slot. Then, expand_expr builds up a call-expression
649 using the new slot. */
650
651 /* If we don't need to use a constructor to create an object of this
652 type, don't mess with AGGR_INIT_EXPR. */
653 if (is_ctor || TREE_ADDRESSABLE (type)((type)->base.addressable_flag))
654 {
655 slot = build_local_temp (type);
656
657 if (TREE_CODE (init)((enum tree_code) (init)->base.code) == CALL_EXPR)
658 {
659 rval = build_aggr_init_array (void_type_nodeglobal_trees[TI_VOID_TYPE], fn, slot,
660 call_expr_nargs (init)(((int)((unsigned long) (*tree_int_cst_elt_check (((tree_class_check
((init), (tcc_vl_exp), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 660, __FUNCTION__))->exp.operands[0]), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 660, __FUNCTION__)))) - 3)
,
661 CALL_EXPR_ARGP (init)(&((*((const_cast<tree*> (tree_operand_check (((tree_check
((init), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 661, __FUNCTION__, (CALL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 661, __FUNCTION__)))))) + 3)
);
662 AGGR_INIT_FROM_THUNK_P (rval)((tree_check ((rval), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 662, __FUNCTION__, (AGGR_INIT_EXPR)))->base.protected_flag
)
663 = CALL_FROM_THUNK_P (init)((tree_check ((init), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 663, __FUNCTION__, (CALL_EXPR)))->base.protected_flag)
;
664 }
665 else
666 {
667 rval = build_aggr_init_array (void_type_nodeglobal_trees[TI_VOID_TYPE], fn, slot,
668 aggr_init_expr_nargs (init)(((int)((unsigned long) (*tree_int_cst_elt_check (((tree_class_check
((init), (tcc_vl_exp), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 668, __FUNCTION__))->exp.operands[0]), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 668, __FUNCTION__)))) - 3)
,
669 AGGR_INIT_EXPR_ARGP (init)(&((*((const_cast<tree*> (tree_operand_check (((tree_check
((init), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 669, __FUNCTION__, (AGGR_INIT_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 669, __FUNCTION__)))))) + 3)
);
670 AGGR_INIT_FROM_THUNK_P (rval)((tree_check ((rval), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 670, __FUNCTION__, (AGGR_INIT_EXPR)))->base.protected_flag
)
671 = AGGR_INIT_FROM_THUNK_P (init)((tree_check ((init), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 671, __FUNCTION__, (AGGR_INIT_EXPR)))->base.protected_flag
)
;
672 }
673 TREE_SIDE_EFFECTS (rval)((non_type_check ((rval), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 673, __FUNCTION__))->base.side_effects_flag)
= 1;
674 AGGR_INIT_VIA_CTOR_P (rval)((tree_not_check2 (((tree_check ((rval), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 674, __FUNCTION__, (AGGR_INIT_EXPR)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 674, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)
= is_ctor;
675 TREE_NOTHROW (rval)((rval)->base.nothrow_flag) = TREE_NOTHROW (init)((init)->base.nothrow_flag);
676 CALL_EXPR_OPERATOR_SYNTAX (rval)((tree_not_check2 (((tree_check2 (((rval)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 676, __FUNCTION__, (CALL_EXPR), (AGGR_INIT_EXPR)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 676, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_6)
= CALL_EXPR_OPERATOR_SYNTAX (init)((tree_not_check2 (((tree_check2 (((init)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 676, __FUNCTION__, (CALL_EXPR), (AGGR_INIT_EXPR)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 676, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_6)
;
677 CALL_EXPR_ORDERED_ARGS (rval)((tree_not_check2 (((tree_check2 (((rval)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 677, __FUNCTION__, (CALL_EXPR), (AGGR_INIT_EXPR)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 677, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_3)
= CALL_EXPR_ORDERED_ARGS (init)((tree_not_check2 (((tree_check2 (((init)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 677, __FUNCTION__, (CALL_EXPR), (AGGR_INIT_EXPR)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 677, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_3)
;
678 CALL_EXPR_REVERSE_ARGS (rval)((tree_not_check2 (((tree_check2 (((rval)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 678, __FUNCTION__, (CALL_EXPR), (AGGR_INIT_EXPR)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 678, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_5)
= CALL_EXPR_REVERSE_ARGS (init)((tree_not_check2 (((tree_check2 (((init)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 678, __FUNCTION__, (CALL_EXPR), (AGGR_INIT_EXPR)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 678, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_5)
;
679 }
680 else
681 rval = init;
682
683 return rval;
684}
685
686/* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
687 target. TYPE is the type that this initialization should appear to
688 have.
689
690 Build an encapsulation of the initialization to perform
691 and return it so that it can be processed by language-independent
692 and language-specific expression expanders. */
693
694tree
695build_cplus_new (tree type, tree init, tsubst_flags_t complain)
696{
697 /* This function should cope with what build_special_member_call
698 can produce. When performing parenthesized aggregate initialization,
699 it can produce a { }. */
700 if (BRACE_ENCLOSED_INITIALIZER_P (init)(((enum tree_code) (init)->base.code) == CONSTRUCTOR &&
((contains_struct_check ((init), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 700, __FUNCTION__))->typed.type) == cp_global_trees[CPTI_INIT_LIST_TYPE
])
)
701 {
702 gcc_assert (cxx_dialect >= cxx20)((void)(!(cxx_dialect >= cxx20) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 702, __FUNCTION__), 0 : 0))
;
703 return finish_compound_literal (type, init, complain);
704 }
705
706 tree rval = build_aggr_init_expr (type, init);
707 tree slot;
708
709 if (init == error_mark_nodeglobal_trees[TI_ERROR_MARK])
710 return error_mark_nodeglobal_trees[TI_ERROR_MARK];
711
712 if (!complete_type_or_maybe_complain (type, init, complain))
713 return error_mark_nodeglobal_trees[TI_ERROR_MARK];
714
715 /* Make sure that we're not trying to create an instance of an
716 abstract class. */
717 if (abstract_virtuals_error_sfinae (NULL_TREE(tree) nullptr, type, complain))
718 return error_mark_nodeglobal_trees[TI_ERROR_MARK];
719
720 if (TREE_CODE (rval)((enum tree_code) (rval)->base.code) == AGGR_INIT_EXPR)
721 slot = AGGR_INIT_EXPR_SLOT (rval)(*((const_cast<tree*> (tree_operand_check (((tree_check
((rval), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 721, __FUNCTION__, (AGGR_INIT_EXPR)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 721, __FUNCTION__)))))
;
722 else if (TREE_CODE (rval)((enum tree_code) (rval)->base.code) == CALL_EXPR
723 || TREE_CODE (rval)((enum tree_code) (rval)->base.code) == CONSTRUCTOR)
724 slot = build_local_temp (type);
725 else
726 return rval;
727
728 rval = build_target_expr (slot, rval, complain);
729
730 if (rval != error_mark_nodeglobal_trees[TI_ERROR_MARK])
731 TARGET_EXPR_IMPLICIT_P (rval)((tree_not_check2 (((tree_check ((rval), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 731, __FUNCTION__, (TARGET_EXPR)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 731, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)
= 1;
732
733 return rval;
734}
735
736/* Subroutine of build_vec_init_expr: Build up a single element
737 intialization as a proxy for the full array initialization to get things
738 marked as used and any appropriate diagnostics.
739
740 Since we're deferring building the actual constructor calls until
741 gimplification time, we need to build one now and throw it away so
742 that the relevant constructor gets mark_used before cgraph decides
743 what functions are needed. Here we assume that init is either
744 NULL_TREE, void_type_node (indicating value-initialization), or
745 another array to copy. */
746
747static tree
748build_vec_init_elt (tree type, tree init, tsubst_flags_t complain)
749{
750 tree inner_type = strip_array_types (type);
751
752 if (integer_zerop (array_type_nelts_total (type))
753 || !CLASS_TYPE_P (inner_type)(((((enum tree_code) (inner_type)->base.code)) == RECORD_TYPE
|| (((enum tree_code) (inner_type)->base.code)) == UNION_TYPE
) && ((tree_class_check ((inner_type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 753, __FUNCTION__))->type_common.lang_flag_5))
)
754 /* No interesting initialization to do. */
755 return integer_zero_nodeglobal_trees[TI_INTEGER_ZERO];
756 else if (init == void_type_nodeglobal_trees[TI_VOID_TYPE])
757 return build_value_init (inner_type, complain);
758
759 gcc_assert (init == NULL_TREE((void)(!(init == (tree) nullptr || (same_type_ignoring_top_level_qualifiers_p
(type, ((contains_struct_check ((init), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 761, __FUNCTION__))->typed.type)))) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 761, __FUNCTION__), 0 : 0))
760 || (same_type_ignoring_top_level_qualifiers_p((void)(!(init == (tree) nullptr || (same_type_ignoring_top_level_qualifiers_p
(type, ((contains_struct_check ((init), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 761, __FUNCTION__))->typed.type)))) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 761, __FUNCTION__), 0 : 0))
761 (type, TREE_TYPE (init))))((void)(!(init == (tree) nullptr || (same_type_ignoring_top_level_qualifiers_p
(type, ((contains_struct_check ((init), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 761, __FUNCTION__))->typed.type)))) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 761, __FUNCTION__), 0 : 0))
;
762
763 releasing_vec argvec;
764 if (init)
765 {
766 tree init_type = strip_array_types (TREE_TYPE (init)((contains_struct_check ((init), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 766, __FUNCTION__))->typed.type)
);
767 tree dummy = build_dummy_object (init_type);
768 if (!lvalue_p (init))
769 dummy = move (dummy);
770 argvec->quick_push (dummy);
771 }
772 init = build_special_member_call (NULL_TREE(tree) nullptr, complete_ctor_identifiercp_global_trees[CPTI_COMPLETE_CTOR_IDENTIFIER],
773 &argvec, inner_type, LOOKUP_NORMAL((1 << 0)),
774 complain);
775
776 /* For a trivial constructor, build_over_call creates a TARGET_EXPR. But
777 we don't want one here because we aren't creating a temporary. */
778 if (TREE_CODE (init)((enum tree_code) (init)->base.code) == TARGET_EXPR)
779 init = TARGET_EXPR_INITIAL (init)(*(tree_operand_check_code ((init), (TARGET_EXPR), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 779, __FUNCTION__)))
;
780
781 return init;
782}
783
784/* Return a TARGET_EXPR which expresses the initialization of an array to
785 be named later, either default-initialization or copy-initialization
786 from another array of the same type. */
787
788tree
789build_vec_init_expr (tree type, tree init, tsubst_flags_t complain)
790{
791 tree slot;
792 bool value_init = false;
793 tree elt_init;
794 if (init && TREE_CODE (init)((enum tree_code) (init)->base.code) == CONSTRUCTOR)
795 {
796 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (init))((void)(!(!(((enum tree_code) (init)->base.code) == CONSTRUCTOR
&& ((contains_struct_check ((init), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 796, __FUNCTION__))->typed.type) == cp_global_trees[CPTI_INIT_LIST_TYPE
])) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 796, __FUNCTION__), 0 : 0))
;
797 /* We built any needed constructor calls in digest_init. */
798 elt_init = init;
799 }
800 else
801 elt_init = build_vec_init_elt (type, init, complain);
802
803 if (init == void_type_nodeglobal_trees[TI_VOID_TYPE])
804 {
805 value_init = true;
806 init = NULL_TREE(tree) nullptr;
807 }
808
809 slot = build_local_temp (type);
810 init = build2 (VEC_INIT_EXPR, type, slot, init);
811 TREE_SIDE_EFFECTS (init)((non_type_check ((init), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 811, __FUNCTION__))->base.side_effects_flag)
= true;
812 SET_EXPR_LOCATION (init, input_location)(expr_check (((init)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 812, __FUNCTION__))->exp.locus = (input_location)
;
813
814 if (cxx_dialect >= cxx11
815 && potential_constant_expression (elt_init))
816 VEC_INIT_EXPR_IS_CONSTEXPR (init)((tree_not_check2 (((tree_check ((init), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 816, __FUNCTION__, (VEC_INIT_EXPR)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 816, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)
= true;
817 VEC_INIT_EXPR_VALUE_INIT (init)((tree_not_check2 (((tree_check ((init), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 817, __FUNCTION__, (VEC_INIT_EXPR)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 817, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_1)
= value_init;
818
819 return init;
820}
821
822/* Give a helpful diagnostic for a non-constexpr VEC_INIT_EXPR in a context
823 that requires a constant expression. */
824
825void
826diagnose_non_constexpr_vec_init (tree expr)
827{
828 tree type = TREE_TYPE (VEC_INIT_EXPR_SLOT (expr))((contains_struct_check (((*((const_cast<tree*> (tree_operand_check
(((tree_check ((expr), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 828, __FUNCTION__, (VEC_INIT_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 828, __FUNCTION__)))))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 828, __FUNCTION__))->typed.type)
;
829 tree init, elt_init;
830 if (VEC_INIT_EXPR_VALUE_INIT (expr)((tree_not_check2 (((tree_check ((expr), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 830, __FUNCTION__, (VEC_INIT_EXPR)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 830, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_1)
)
831 init = void_type_nodeglobal_trees[TI_VOID_TYPE];
832 else
833 init = VEC_INIT_EXPR_INIT (expr)(*((const_cast<tree*> (tree_operand_check (((tree_check
((expr), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 833, __FUNCTION__, (VEC_INIT_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 833, __FUNCTION__)))))
;
834
835 elt_init = build_vec_init_elt (type, init, tf_warning_or_error);
836 require_potential_constant_expression (elt_init);
837}
838
839tree
840build_array_copy (tree init)
841{
842 return build_vec_init_expr (TREE_TYPE (init)((contains_struct_check ((init), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 842, __FUNCTION__))->typed.type)
, init, tf_warning_or_error);
843}
844
845/* Build a TARGET_EXPR using INIT to initialize a new temporary of the
846 indicated TYPE. */
847
848tree
849build_target_expr_with_type (tree init, tree type, tsubst_flags_t complain)
850{
851 gcc_assert (!VOID_TYPE_P (type))((void)(!(!(((enum tree_code) (type)->base.code) == VOID_TYPE
)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 851, __FUNCTION__), 0 : 0))
;
852 gcc_assert (!VOID_TYPE_P (TREE_TYPE (init)))((void)(!(!(((enum tree_code) (((contains_struct_check ((init
), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 852, __FUNCTION__))->typed.type))->base.code) == VOID_TYPE
)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 852, __FUNCTION__), 0 : 0))
;
853
854 if (TREE_CODE (init)((enum tree_code) (init)->base.code) == TARGET_EXPR
855 || init == error_mark_nodeglobal_trees[TI_ERROR_MARK])
856 return init;
857 else if (CLASS_TYPE_P (type)(((((enum tree_code) (type)->base.code)) == RECORD_TYPE ||
(((enum tree_code) (type)->base.code)) == UNION_TYPE) &&
((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 857, __FUNCTION__))->type_common.lang_flag_5))
&& type_has_nontrivial_copy_init (type)
858 && TREE_CODE (init)((enum tree_code) (init)->base.code) != COND_EXPR
859 && TREE_CODE (init)((enum tree_code) (init)->base.code) != CONSTRUCTOR
860 && TREE_CODE (init)((enum tree_code) (init)->base.code) != VA_ARG_EXPR
861 && TREE_CODE (init)((enum tree_code) (init)->base.code) != CALL_EXPR)
862 /* We need to build up a copy constructor call. COND_EXPR is a special
863 case because we already have copies on the arms and we don't want
864 another one here. A CONSTRUCTOR is aggregate initialization, which
865 is handled separately. A VA_ARG_EXPR is magic creation of an
866 aggregate; there's no additional work to be done. A CALL_EXPR
867 already creates a prvalue. */
868 return force_rvalue (init, complain);
869
870 return force_target_expr (type, init, complain);
871}
872
873/* Like the above function, but without the checking. This function should
874 only be used by code which is deliberately trying to subvert the type
875 system, such as call_builtin_trap. Or build_over_call, to avoid
876 infinite recursion. */
877
878tree
879force_target_expr (tree type, tree init, tsubst_flags_t complain)
880{
881 tree slot;
882
883 gcc_assert (!VOID_TYPE_P (type))((void)(!(!(((enum tree_code) (type)->base.code) == VOID_TYPE
)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 883, __FUNCTION__), 0 : 0))
;
884
885 slot = build_local_temp (type);
886 return build_target_expr (slot, init, complain);
887}
888
889/* Like build_target_expr_with_type, but use the type of INIT. */
890
891tree
892get_target_expr_sfinae (tree init, tsubst_flags_t complain)
893{
894 if (TREE_CODE (init)((enum tree_code) (init)->base.code) == AGGR_INIT_EXPR)
895 return build_target_expr (AGGR_INIT_EXPR_SLOT (init)(*((const_cast<tree*> (tree_operand_check (((tree_check
((init), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 895, __FUNCTION__, (AGGR_INIT_EXPR)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 895, __FUNCTION__)))))
, init, complain);
896 else if (TREE_CODE (init)((enum tree_code) (init)->base.code) == VEC_INIT_EXPR)
897 return build_target_expr (VEC_INIT_EXPR_SLOT (init)(*((const_cast<tree*> (tree_operand_check (((tree_check
((init), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 897, __FUNCTION__, (VEC_INIT_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 897, __FUNCTION__)))))
, init, complain);
898 else
899 {
900 init = convert_bitfield_to_declared_type (init);
901 return build_target_expr_with_type (init, TREE_TYPE (init)((contains_struct_check ((init), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 901, __FUNCTION__))->typed.type)
, complain);
902 }
903}
904
905tree
906get_target_expr (tree init)
907{
908 return get_target_expr_sfinae (init, tf_warning_or_error);
909}
910
911/* If EXPR is a bitfield reference, convert it to the declared type of
912 the bitfield, and return the resulting expression. Otherwise,
913 return EXPR itself. */
914
915tree
916convert_bitfield_to_declared_type (tree expr)
917{
918 tree bitfield_type;
919
920 bitfield_type = is_bitfield_expr_with_lowered_type (expr);
921 if (bitfield_type)
922 expr = convert_to_integer_nofold (TYPE_MAIN_VARIANT (bitfield_type)((tree_class_check ((bitfield_type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 922, __FUNCTION__))->type_common.main_variant)
,
923 expr);
924 return expr;
925}
926
927/* EXPR is being used in an rvalue context. Return a version of EXPR
928 that is marked as an rvalue. */
929
930tree
931rvalue (tree expr)
932{
933 tree type;
934
935 if (error_operand_p (expr))
936 return expr;
937
938 expr = mark_rvalue_use (expr);
939
940 /* [basic.lval]
941
942 Non-class rvalues always have cv-unqualified types. */
943 type = TREE_TYPE (expr)((contains_struct_check ((expr), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 943, __FUNCTION__))->typed.type)
;
944 if (!CLASS_TYPE_P (type)(((((enum tree_code) (type)->base.code)) == RECORD_TYPE ||
(((enum tree_code) (type)->base.code)) == UNION_TYPE) &&
((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 944, __FUNCTION__))->type_common.lang_flag_5))
&& cv_qualified_p (type))
945 type = cv_unqualified (type);
946
947 /* We need to do this for rvalue refs as well to get the right answer
948 from decltype; see c++/36628. */
949 if (!processing_template_declscope_chain->x_processing_template_decl && glvalue_p (expr))
950 {
951 /* But don't use this function for class lvalues; use move (to treat an
952 lvalue as an xvalue) or force_rvalue (to make a prvalue copy). */
953 gcc_checking_assert (!CLASS_TYPE_P (type))((void)(!(!(((((enum tree_code) (type)->base.code)) == RECORD_TYPE
|| (((enum tree_code) (type)->base.code)) == UNION_TYPE) &&
((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 953, __FUNCTION__))->type_common.lang_flag_5))) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 953, __FUNCTION__), 0 : 0))
;
954 expr = build1 (NON_LVALUE_EXPR, type, expr);
955 }
956 else if (type != TREE_TYPE (expr)((contains_struct_check ((expr), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 956, __FUNCTION__))->typed.type)
)
957 expr = build_nop (type, expr);
958
959 return expr;
960}
961
962
963struct cplus_array_info
964{
965 tree type;
966 tree domain;
967};
968
969struct cplus_array_hasher : ggc_ptr_hash<tree_node>
970{
971 typedef cplus_array_info *compare_type;
972
973 static hashval_t hash (tree t);
974 static bool equal (tree, cplus_array_info *);
975};
976
977/* Hash an ARRAY_TYPE. K is really of type `tree'. */
978
979hashval_t
980cplus_array_hasher::hash (tree t)
981{
982 hashval_t hash;
983
984 hash = TYPE_UID (TREE_TYPE (t))((tree_class_check ((((contains_struct_check ((t), (TS_TYPED)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 984, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 984, __FUNCTION__))->type_common.uid)
;
985 if (TYPE_DOMAIN (t)((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 985, __FUNCTION__, (ARRAY_TYPE)))->type_non_common.values
)
)
986 hash ^= TYPE_UID (TYPE_DOMAIN (t))((tree_class_check ((((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 986, __FUNCTION__, (ARRAY_TYPE)))->type_non_common.values
)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 986, __FUNCTION__))->type_common.uid)
;
987 return hash;
988}
989
990/* Compare two ARRAY_TYPEs. K1 is really of type `tree', K2 is really
991 of type `cplus_array_info*'. */
992
993bool
994cplus_array_hasher::equal (tree t1, cplus_array_info *t2)
995{
996 return (TREE_TYPE (t1)((contains_struct_check ((t1), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 996, __FUNCTION__))->typed.type)
== t2->type && TYPE_DOMAIN (t1)((tree_check ((t1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 996, __FUNCTION__, (ARRAY_TYPE)))->type_non_common.values
)
== t2->domain);
997}
998
999/* Hash table containing dependent array types, which are unsuitable for
1000 the language-independent type hash table. */
1001static GTY (()) hash_table<cplus_array_hasher> *cplus_array_htab;
1002
1003/* Build an ARRAY_TYPE without laying it out. */
1004
1005static tree
1006build_min_array_type (tree elt_type, tree index_type)
1007{
1008 tree t = cxx_make_type (ARRAY_TYPE);
1009 TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1009, __FUNCTION__))->typed.type)
= elt_type;
1010 TYPE_DOMAIN (t)((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1010, __FUNCTION__, (ARRAY_TYPE)))->type_non_common.values
)
= index_type;
1011 return t;
1012}
1013
1014/* Set TYPE_CANONICAL like build_array_type_1, but using
1015 build_cplus_array_type. */
1016
1017static void
1018set_array_type_canon (tree t, tree elt_type, tree index_type, bool dep)
1019{
1020 /* Set the canonical type for this new node. */
1021 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type)(((tree_class_check ((elt_type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1021, __FUNCTION__))->type_common.canonical) == (tree) nullptr
)
1022 || (index_type && TYPE_STRUCTURAL_EQUALITY_P (index_type)(((tree_class_check ((index_type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1022, __FUNCTION__))->type_common.canonical) == (tree) nullptr
)
))
1023 SET_TYPE_STRUCTURAL_EQUALITY (t)(((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1023, __FUNCTION__))->type_common.canonical) = (tree) nullptr
)
;
1024 else if (TYPE_CANONICAL (elt_type)((tree_class_check ((elt_type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1024, __FUNCTION__))->type_common.canonical)
!= elt_type
1025 || (index_type && TYPE_CANONICAL (index_type)((tree_class_check ((index_type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1025, __FUNCTION__))->type_common.canonical)
!= index_type))
1026 TYPE_CANONICAL (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1026, __FUNCTION__))->type_common.canonical)
1027 = build_cplus_array_type (TYPE_CANONICAL (elt_type)((tree_class_check ((elt_type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1027, __FUNCTION__))->type_common.canonical)
,
1028 index_type
1029 ? TYPE_CANONICAL (index_type)((tree_class_check ((index_type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1029, __FUNCTION__))->type_common.canonical)
: index_type,
1030 dep);
1031 else
1032 TYPE_CANONICAL (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1032, __FUNCTION__))->type_common.canonical)
= t;
1033}
1034
1035/* Like build_array_type, but handle special C++ semantics: an array of a
1036 variant element type is a variant of the array of the main variant of
1037 the element type. IS_DEPENDENT is -ve if we should determine the
1038 dependency. Otherwise its bool value indicates dependency. */
1039
1040tree
1041build_cplus_array_type (tree elt_type, tree index_type, int dependent)
1042{
1043 tree t;
1044
1045 if (elt_type == error_mark_nodeglobal_trees[TI_ERROR_MARK] || index_type == error_mark_nodeglobal_trees[TI_ERROR_MARK])
1046 return error_mark_nodeglobal_trees[TI_ERROR_MARK];
1047
1048 if (dependent < 0)
1049 dependent = (uses_template_parms (elt_type)
1050 || (index_type && uses_template_parms (index_type)));
1051
1052 if (elt_type != TYPE_MAIN_VARIANT (elt_type)((tree_class_check ((elt_type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1052, __FUNCTION__))->type_common.main_variant)
)
1053 /* Start with an array of the TYPE_MAIN_VARIANT. */
1054 t = build_cplus_array_type (TYPE_MAIN_VARIANT (elt_type)((tree_class_check ((elt_type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1054, __FUNCTION__))->type_common.main_variant)
,
1055 index_type, dependent);
1056 else if (dependent)
1057 {
1058 /* Since type_hash_canon calls layout_type, we need to use our own
1059 hash table. */
1060 cplus_array_info cai;
1061 hashval_t hash;
1062
1063 if (cplus_array_htab == NULLnullptr)
1064 cplus_array_htab = hash_table<cplus_array_hasher>::create_ggc (61);
1065
1066 hash = TYPE_UID (elt_type)((tree_class_check ((elt_type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1066, __FUNCTION__))->type_common.uid)
;
1067 if (index_type)
1068 hash ^= TYPE_UID (index_type)((tree_class_check ((index_type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1068, __FUNCTION__))->type_common.uid)
;
1069 cai.type = elt_type;
1070 cai.domain = index_type;
1071
1072 tree *e = cplus_array_htab->find_slot_with_hash (&cai, hash, INSERT);
1073 if (*e)
1074 /* We have found the type: we're done. */
1075 return (tree) *e;
1076 else
1077 {
1078 /* Build a new array type. */
1079 t = build_min_array_type (elt_type, index_type);
1080
1081 /* Store it in the hash table. */
1082 *e = t;
1083
1084 /* Set the canonical type for this new node. */
1085 set_array_type_canon (t, elt_type, index_type, dependent);
1086
1087 /* Mark it as dependent now, this saves time later. */
1088 TYPE_DEPENDENT_P_VALID (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1088, __FUNCTION__))->type_common.lang_flag_6)
= true;
1089 TYPE_DEPENDENT_P (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1089, __FUNCTION__))->type_common.lang_flag_0)
= true;
1090 }
1091 }
1092 else
1093 {
1094 bool typeless_storage = is_byte_access_type (elt_type);
1095 t = build_array_type (elt_type, index_type, typeless_storage);
1096
1097 /* Mark as non-dependenty now, this will save time later. */
1098 TYPE_DEPENDENT_P_VALID (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1098, __FUNCTION__))->type_common.lang_flag_6)
= true;
1099 }
1100
1101 /* Now check whether we already have this array variant. */
1102 if (elt_type != TYPE_MAIN_VARIANT (elt_type)((tree_class_check ((elt_type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1102, __FUNCTION__))->type_common.main_variant)
)
1103 {
1104 tree m = t;
1105 for (t = m; t; t = TYPE_NEXT_VARIANT (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1105, __FUNCTION__))->type_common.next_variant)
)
1106 if (TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1106, __FUNCTION__))->typed.type)
== elt_type
1107 && TYPE_NAME (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1107, __FUNCTION__))->type_common.name)
== NULL_TREE(tree) nullptr
1108 && TYPE_ATTRIBUTES (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1108, __FUNCTION__))->type_common.attributes)
== NULL_TREE(tree) nullptr)
1109 break;
1110 if (!t)
1111 {
1112 t = build_min_array_type (elt_type, index_type);
1113 /* Mark dependency now, this saves time later. */
1114 TYPE_DEPENDENT_P_VALID (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1114, __FUNCTION__))->type_common.lang_flag_6)
= true;
1115 TYPE_DEPENDENT_P (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1115, __FUNCTION__))->type_common.lang_flag_0)
= dependent;
1116 set_array_type_canon (t, elt_type, index_type, dependent);
1117 if (!dependent)
1118 {
1119 layout_type (t);
1120 /* Make sure sizes are shared with the main variant.
1121 layout_type can't be called after setting TYPE_NEXT_VARIANT,
1122 as it will overwrite alignment etc. of all variants. */
1123 TYPE_SIZE (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1123, __FUNCTION__))->type_common.size)
= TYPE_SIZE (m)((tree_class_check ((m), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1123, __FUNCTION__))->type_common.size)
;
1124 TYPE_SIZE_UNIT (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1124, __FUNCTION__))->type_common.size_unit)
= TYPE_SIZE_UNIT (m)((tree_class_check ((m), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1124, __FUNCTION__))->type_common.size_unit)
;
1125 TYPE_TYPELESS_STORAGE (t)((tree_check4 ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1125, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))->type_common.typeless_storage)
= TYPE_TYPELESS_STORAGE (m)((tree_check4 ((m), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1125, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))->type_common.typeless_storage)
;
1126 }
1127
1128 TYPE_MAIN_VARIANT (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1128, __FUNCTION__))->type_common.main_variant)
= m;
1129 TYPE_NEXT_VARIANT (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1129, __FUNCTION__))->type_common.next_variant)
= TYPE_NEXT_VARIANT (m)((tree_class_check ((m), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1129, __FUNCTION__))->type_common.next_variant)
;
1130 TYPE_NEXT_VARIANT (m)((tree_class_check ((m), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1130, __FUNCTION__))->type_common.next_variant)
= t;
1131 }
1132 }
1133
1134 /* Avoid spurious warnings with VLAs (c++/54583). */
1135 if (TYPE_SIZE (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1135, __FUNCTION__))->type_common.size)
&& EXPR_P (TYPE_SIZE (t))((tree_code_type[(int) (((enum tree_code) (((tree_class_check
((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1135, __FUNCTION__))->type_common.size))->base.code))
]) >= tcc_reference && (tree_code_type[(int) (((enum
tree_code) (((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1135, __FUNCTION__))->type_common.size))->base.code))
]) <= tcc_expression)
)
1136 suppress_warning (TYPE_SIZE (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1136, __FUNCTION__))->type_common.size)
, OPT_Wunused);
1137
1138 /* Push these needs up to the ARRAY_TYPE so that initialization takes
1139 place more easily. */
1140 bool needs_ctor = (TYPE_NEEDS_CONSTRUCTING (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1140, __FUNCTION__))->type_common.needs_constructing_flag
)
1141 = TYPE_NEEDS_CONSTRUCTING (elt_type)((tree_class_check ((elt_type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1141, __FUNCTION__))->type_common.needs_constructing_flag
)
);
1142 bool needs_dtor = (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)(((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1142, __FUNCTION__))->type_common.lang_flag_4))
1143 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type)(((tree_class_check ((elt_type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1143, __FUNCTION__))->type_common.lang_flag_4))
);
1144
1145 if (!dependent && t == TYPE_MAIN_VARIANT (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1145, __FUNCTION__))->type_common.main_variant)
1146 && !COMPLETE_TYPE_P (t)(((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1146, __FUNCTION__))->type_common.size) != (tree) nullptr
)
&& COMPLETE_TYPE_P (elt_type)(((tree_class_check ((elt_type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1146, __FUNCTION__))->type_common.size) != (tree) nullptr
)
)
1147 {
1148 /* The element type has been completed since the last time we saw
1149 this array type; update the layout and 'tor flags for any variants
1150 that need it. */
1151 layout_type (t);
1152 for (tree v = TYPE_NEXT_VARIANT (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1152, __FUNCTION__))->type_common.next_variant)
; v; v = TYPE_NEXT_VARIANT (v)((tree_class_check ((v), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1152, __FUNCTION__))->type_common.next_variant)
)
1153 {
1154 TYPE_NEEDS_CONSTRUCTING (v)((tree_class_check ((v), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1154, __FUNCTION__))->type_common.needs_constructing_flag
)
= needs_ctor;
1155 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (v)(((tree_class_check ((v), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1155, __FUNCTION__))->type_common.lang_flag_4))
= needs_dtor;
1156 }
1157 }
1158
1159 return t;
1160}
1161
1162/* Return an ARRAY_TYPE with element type ELT and length N. */
1163
1164tree
1165build_array_of_n_type (tree elt, int n)
1166{
1167 return build_cplus_array_type (elt, build_index_type (size_int (n - 1)size_int_kind (n - 1, stk_sizetype)));
1168}
1169
1170/* True iff T is an array of unknown bound. */
1171
1172bool
1173array_of_unknown_bound_p (const_tree t)
1174{
1175 return (TREE_CODE (t)((enum tree_code) (t)->base.code) == ARRAY_TYPE
1176 && !TYPE_DOMAIN (t)((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1176, __FUNCTION__, (ARRAY_TYPE)))->type_non_common.values
)
);
1177}
1178
1179/* True iff T is an N3639 array of runtime bound (VLA). These were approved
1180 for C++14 but then removed. This should only be used for N3639
1181 specifically; code wondering more generally if something is a VLA should use
1182 vla_type_p. */
1183
1184bool
1185array_of_runtime_bound_p (tree t)
1186{
1187 if (!t || TREE_CODE (t)((enum tree_code) (t)->base.code) != ARRAY_TYPE)
1188 return false;
1189 if (variably_modified_type_p (TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1189, __FUNCTION__))->typed.type)
, NULL_TREE(tree) nullptr))
1190 return false;
1191 tree dom = TYPE_DOMAIN (t)((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1191, __FUNCTION__, (ARRAY_TYPE)))->type_non_common.values
)
;
1192 if (!dom)
1193 return false;
1194 tree max = TYPE_MAX_VALUE (dom)((tree_check5 ((dom), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1194, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.maxval
)
;
1195 return (!potential_rvalue_constant_expression (max)
1196 || (!value_dependent_expression_p (max) && !TREE_CONSTANT (max)((non_type_check ((max), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1196, __FUNCTION__))->base.constant_flag)
));
1197}
1198
1199/* True iff T is a variable length array. */
1200
1201bool
1202vla_type_p (tree t)
1203{
1204 for (; t && TREE_CODE (t)((enum tree_code) (t)->base.code) == ARRAY_TYPE;
1205 t = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1205, __FUNCTION__))->typed.type)
)
1206 if (tree dom = TYPE_DOMAIN (t)((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1206, __FUNCTION__, (ARRAY_TYPE)))->type_non_common.values
)
)
1207 {
1208 tree max = TYPE_MAX_VALUE (dom)((tree_check5 ((dom), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1208, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.maxval
)
;
1209 if (!potential_rvalue_constant_expression (max)
1210 || (!value_dependent_expression_p (max) && !TREE_CONSTANT (max)((non_type_check ((max), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1210, __FUNCTION__))->base.constant_flag)
))
1211 return true;
1212 }
1213 return false;
1214}
1215
1216
1217/* Return a reference type node of MODE referring to TO_TYPE. If MODE
1218 is VOIDmode the standard pointer mode will be picked. If RVAL is
1219 true, return an rvalue reference type, otherwise return an lvalue
1220 reference type. If a type node exists, reuse it, otherwise create
1221 a new one. */
1222tree
1223cp_build_reference_type_for_mode (tree to_type, machine_mode mode, bool rval)
1224{
1225 tree lvalue_ref, t;
1226
1227 if (to_type == error_mark_nodeglobal_trees[TI_ERROR_MARK])
1228 return error_mark_nodeglobal_trees[TI_ERROR_MARK];
1229
1230 if (TYPE_REF_P (to_type)(((enum tree_code) (to_type)->base.code) == REFERENCE_TYPE
)
)
1231 {
1232 rval = rval && TYPE_REF_IS_RVALUE (to_type)((tree_check ((to_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1232, __FUNCTION__, (REFERENCE_TYPE)))->base.private_flag
)
;
1233 to_type = TREE_TYPE (to_type)((contains_struct_check ((to_type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1233, __FUNCTION__))->typed.type)
;
1234 }
1235
1236 lvalue_ref = build_reference_type_for_mode (to_type, mode, false);
1237
1238 if (!rval)
1239 return lvalue_ref;
1240
1241 /* This code to create rvalue reference types is based on and tied
1242 to the code creating lvalue reference types in the middle-end
1243 functions build_reference_type_for_mode and build_reference_type.
1244
1245 It works by putting the rvalue reference type nodes after the
1246 lvalue reference nodes in the TYPE_NEXT_REF_TO linked list, so
1247 they will effectively be ignored by the middle end. */
1248
1249 for (t = lvalue_ref; (t = TYPE_NEXT_REF_TO (t)((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1249, __FUNCTION__, (REFERENCE_TYPE)))->type_non_common.
minval)
); )
1250 if (TYPE_REF_IS_RVALUE (t)((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1250, __FUNCTION__, (REFERENCE_TYPE)))->base.private_flag
)
)
1251 return t;
1252
1253 t = build_distinct_type_copy (lvalue_ref);
1254
1255 TYPE_REF_IS_RVALUE (t)((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1255, __FUNCTION__, (REFERENCE_TYPE)))->base.private_flag
)
= true;
1256 TYPE_NEXT_REF_TO (t)((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1256, __FUNCTION__, (REFERENCE_TYPE)))->type_non_common.
minval)
= TYPE_NEXT_REF_TO (lvalue_ref)((tree_check ((lvalue_ref), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1256, __FUNCTION__, (REFERENCE_TYPE)))->type_non_common.
minval)
;
1257 TYPE_NEXT_REF_TO (lvalue_ref)((tree_check ((lvalue_ref), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1257, __FUNCTION__, (REFERENCE_TYPE)))->type_non_common.
minval)
= t;
1258
1259 if (TYPE_STRUCTURAL_EQUALITY_P (to_type)(((tree_class_check ((to_type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1259, __FUNCTION__))->type_common.canonical) == (tree) nullptr
)
)
1260 SET_TYPE_STRUCTURAL_EQUALITY (t)(((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1260, __FUNCTION__))->type_common.canonical) = (tree) nullptr
)
;
1261 else if (TYPE_CANONICAL (to_type)((tree_class_check ((to_type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1261, __FUNCTION__))->type_common.canonical)
!= to_type)
1262 TYPE_CANONICAL (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1262, __FUNCTION__))->type_common.canonical)
1263 = cp_build_reference_type_for_mode (TYPE_CANONICAL (to_type)((tree_class_check ((to_type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1263, __FUNCTION__))->type_common.canonical)
, mode, rval);
1264 else
1265 TYPE_CANONICAL (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1265, __FUNCTION__))->type_common.canonical)
= t;
1266
1267 layout_type (t);
1268
1269 return t;
1270
1271}
1272
1273/* Return a reference type node referring to TO_TYPE. If RVAL is
1274 true, return an rvalue reference type, otherwise return an lvalue
1275 reference type. If a type node exists, reuse it, otherwise create
1276 a new one. */
1277tree
1278cp_build_reference_type (tree to_type, bool rval)
1279{
1280 return cp_build_reference_type_for_mode (to_type, VOIDmode((void) 0, E_VOIDmode), rval);
1281}
1282
1283/* Returns EXPR cast to rvalue reference type, like std::move. */
1284
1285tree
1286move (tree expr)
1287{
1288 tree type = TREE_TYPE (expr)((contains_struct_check ((expr), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1288, __FUNCTION__))->typed.type)
;
1289 gcc_assert (!TYPE_REF_P (type))((void)(!(!(((enum tree_code) (type)->base.code) == REFERENCE_TYPE
)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1289, __FUNCTION__), 0 : 0))
;
1290 type = cp_build_reference_type (type, /*rval*/true);
1291 return build_static_cast (input_location, type, expr,
1292 tf_warning_or_error);
1293}
1294
1295/* Used by the C++ front end to build qualified array types. However,
1296 the C version of this function does not properly maintain canonical
1297 types (which are not used in C). */
1298tree
1299c_build_qualified_type (tree type, int type_quals, tree /* orig_qual_type */,
1300 size_t /* orig_qual_indirect */)
1301{
1302 return cp_build_qualified_type (type, type_quals)cp_build_qualified_type_real ((type), (type_quals), tf_warning_or_error
)
;
1303}
1304
1305
1306/* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles
1307 arrays correctly. In particular, if TYPE is an array of T's, and
1308 TYPE_QUALS is non-empty, returns an array of qualified T's.
1309
1310 FLAGS determines how to deal with ill-formed qualifications. If
1311 tf_ignore_bad_quals is set, then bad qualifications are dropped
1312 (this is permitted if TYPE was introduced via a typedef or template
1313 type parameter). If bad qualifications are dropped and tf_warning
1314 is set, then a warning is issued for non-const qualifications. If
1315 tf_ignore_bad_quals is not set and tf_error is not set, we
1316 return error_mark_node. Otherwise, we issue an error, and ignore
1317 the qualifications.
1318
1319 Qualification of a reference type is valid when the reference came
1320 via a typedef or template type argument. [dcl.ref] No such
1321 dispensation is provided for qualifying a function type. [dcl.fct]
1322 DR 295 queries this and the proposed resolution brings it into line
1323 with qualifying a reference. We implement the DR. We also behave
1324 in a similar manner for restricting non-pointer types. */
1325
1326tree
1327cp_build_qualified_type_real (tree type,
1328 int type_quals,
1329 tsubst_flags_t complain)
1330{
1331 tree result;
1332 int bad_quals = TYPE_UNQUALIFIED;
1333
1334 if (type == error_mark_nodeglobal_trees[TI_ERROR_MARK])
1335 return type;
1336
1337 if (type_quals == cp_type_quals (type))
1338 return type;
1339
1340 if (TREE_CODE (type)((enum tree_code) (type)->base.code) == ARRAY_TYPE)
1341 {
1342 /* In C++, the qualification really applies to the array element
1343 type. Obtain the appropriately qualified element type. */
1344 tree t;
1345 tree element_type
1346 = cp_build_qualified_type_real (TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1346, __FUNCTION__))->typed.type)
,
1347 type_quals,
1348 complain);
1349
1350 if (element_type == error_mark_nodeglobal_trees[TI_ERROR_MARK])
1351 return error_mark_nodeglobal_trees[TI_ERROR_MARK];
1352
1353 /* See if we already have an identically qualified type. Tests
1354 should be equivalent to those in check_qualified_type. */
1355 for (t = TYPE_MAIN_VARIANT (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1355, __FUNCTION__))->type_common.main_variant)
; t; t = TYPE_NEXT_VARIANT (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1355, __FUNCTION__))->type_common.next_variant)
)
1356 if (TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1356, __FUNCTION__))->typed.type)
== element_type
1357 && TYPE_NAME (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1357, __FUNCTION__))->type_common.name)
== TYPE_NAME (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1357, __FUNCTION__))->type_common.name)
1358 && TYPE_CONTEXT (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1358, __FUNCTION__))->type_common.context)
== TYPE_CONTEXT (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1358, __FUNCTION__))->type_common.context)
1359 && attribute_list_equal (TYPE_ATTRIBUTES (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1359, __FUNCTION__))->type_common.attributes)
,
1360 TYPE_ATTRIBUTES (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1360, __FUNCTION__))->type_common.attributes)
))
1361 break;
1362
1363 if (!t)
1364 {
1365 /* If we already know the dependentness, tell the array type
1366 constructor. This is important for module streaming, as we cannot
1367 dynamically determine that on read in. */
1368 t = build_cplus_array_type (element_type, TYPE_DOMAIN (type)((tree_check ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1368, __FUNCTION__, (ARRAY_TYPE)))->type_non_common.values
)
,
1369 TYPE_DEPENDENT_P_VALID (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1369, __FUNCTION__))->type_common.lang_flag_6)
1370 ? int (TYPE_DEPENDENT_P (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1370, __FUNCTION__))->type_common.lang_flag_0)
) : -1);
1371
1372 /* Keep the typedef name. */
1373 if (TYPE_NAME (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1373, __FUNCTION__))->type_common.name)
!= TYPE_NAME (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1373, __FUNCTION__))->type_common.name)
)
1374 {
1375 t = build_variant_type_copy (t);
1376 TYPE_NAME (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1376, __FUNCTION__))->type_common.name)
= TYPE_NAME (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1376, __FUNCTION__))->type_common.name)
;
1377 SET_TYPE_ALIGN (t, TYPE_ALIGN (type))((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1377, __FUNCTION__))->type_common.align = ffs_hwi ((((tree_class_check
((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1377, __FUNCTION__))->type_common.align) ? ((unsigned)1)
<< (((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1377, __FUNCTION__))->type_common.align) - 1) : 0)))
;
1378 TYPE_USER_ALIGN (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1378, __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/cp/tree.c"
, 1378, __FUNCTION__))->base.u.bits.user_align)
;
1379 }
1380 }
1381
1382 /* Even if we already had this variant, we update
1383 TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
1384 they changed since the variant was originally created.
1385
1386 This seems hokey; if there is some way to use a previous
1387 variant *without* coming through here,
1388 TYPE_NEEDS_CONSTRUCTING will never be updated. */
1389 TYPE_NEEDS_CONSTRUCTING (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1389, __FUNCTION__))->type_common.needs_constructing_flag
)
1390 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type))((tree_class_check ((((tree_class_check ((element_type), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1390, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1390, __FUNCTION__))->type_common.needs_constructing_flag
)
;
1391 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)(((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1391, __FUNCTION__))->type_common.lang_flag_4))
1392 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type))(((tree_class_check ((((tree_class_check ((element_type), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1392, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1392, __FUNCTION__))->type_common.lang_flag_4))
;
1393 return t;
1394 }
1395 else if (TREE_CODE (type)((enum tree_code) (type)->base.code) == TYPE_PACK_EXPANSION)
1396 {
1397 tree t = PACK_EXPANSION_PATTERN (type)(((enum tree_code) (type)->base.code) == TYPE_PACK_EXPANSION
? ((contains_struct_check ((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1397, __FUNCTION__))->typed.type) : (*((const_cast<tree
*> (tree_operand_check ((type), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1397, __FUNCTION__))))))
;
1398
1399 t = cp_build_qualified_type_real (t, type_quals, complain);
1400 return make_pack_expansion (t, complain);
1401 }
1402
1403 /* A reference or method type shall not be cv-qualified.
1404 [dcl.ref], [dcl.fct]. This used to be an error, but as of DR 295
1405 (in CD1) we always ignore extra cv-quals on functions. */
1406
1407 /* [dcl.ref/1] Cv-qualified references are ill-formed except when
1408 the cv-qualifiers are introduced through the use of a typedef-name
1409 ([dcl.typedef], [temp.param]) or decltype-specifier
1410 ([dcl.type.decltype]),in which case the cv-qualifiers are
1411 ignored. */
1412 if (type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)
1413 && (TYPE_REF_P (type)(((enum tree_code) (type)->base.code) == REFERENCE_TYPE)
1414 || FUNC_OR_METHOD_TYPE_P (type)(((enum tree_code) (type)->base.code) == FUNCTION_TYPE || (
(enum tree_code) (type)->base.code) == METHOD_TYPE)
))
1415 {
1416 if (TYPE_REF_P (type)(((enum tree_code) (type)->base.code) == REFERENCE_TYPE)
1417 && (!typedef_variant_p (type) || FUNC_OR_METHOD_TYPE_P (type)(((enum tree_code) (type)->base.code) == FUNCTION_TYPE || (
(enum tree_code) (type)->base.code) == METHOD_TYPE)
))
1418 bad_quals |= type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
1419 type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
1420 }
1421
1422 /* But preserve any function-cv-quals on a FUNCTION_TYPE. */
1423 if (TREE_CODE (type)((enum tree_code) (type)->base.code) == FUNCTION_TYPE)
1424 type_quals |= type_memfn_quals (type);
1425
1426 /* A restrict-qualified type must be a pointer (or reference)
1427 to object or incomplete type. */
1428 if ((type_quals & TYPE_QUAL_RESTRICT)
1429 && TREE_CODE (type)((enum tree_code) (type)->base.code) != TEMPLATE_TYPE_PARM
1430 && TREE_CODE (type)((enum tree_code) (type)->base.code) != TYPENAME_TYPE
1431 && !INDIRECT_TYPE_P (type)((((enum tree_code) (type)->base.code) == POINTER_TYPE) ||
(((enum tree_code) (type)->base.code) == REFERENCE_TYPE))
)
1432 {
1433 bad_quals |= TYPE_QUAL_RESTRICT;
1434 type_quals &= ~TYPE_QUAL_RESTRICT;
1435 }
1436
1437 if (bad_quals == TYPE_UNQUALIFIED
1438 || (complain & tf_ignore_bad_quals))
1439 /*OK*/;
1440 else if (!(complain & tf_error))
1441 return error_mark_nodeglobal_trees[TI_ERROR_MARK];
1442 else
1443 {
1444 tree bad_type = build_qualified_type (ptr_type_nodeglobal_trees[TI_PTR_TYPE], bad_quals);
1445 error ("%qV qualifiers cannot be applied to %qT",
1446 bad_type, type);
1447 }
1448
1449 /* Retrieve (or create) the appropriately qualified variant. */
1450 result = build_qualified_type (type, type_quals);
1451
1452 return result;
1453}
1454
1455/* Return TYPE with const and volatile removed. */
1456
1457tree
1458cv_unqualified (tree type)
1459{
1460 int quals;
1461
1462 if (type == error_mark_nodeglobal_trees[TI_ERROR_MARK])
1463 return type;
1464
1465 quals = cp_type_quals (type);
1466 quals &= ~(TYPE_QUAL_CONST|TYPE_QUAL_VOLATILE);
1467 return cp_build_qualified_type (type, quals)cp_build_qualified_type_real ((type), (quals), tf_warning_or_error
)
;
1468}
1469
1470/* Subroutine of strip_typedefs. We want to apply to RESULT the attributes
1471 from ATTRIBS that affect type identity, and no others. If any are not
1472 applied, set *remove_attributes to true. */
1473
1474static tree
1475apply_identity_attributes (tree result, tree attribs, bool *remove_attributes)
1476{
1477 tree first_ident = NULL_TREE(tree) nullptr;
1478 tree new_attribs = NULL_TREE(tree) nullptr;
1479 tree *p = &new_attribs;
1480
1481 if (OVERLOAD_TYPE_P (result)((((((enum tree_code) (result)->base.code)) == RECORD_TYPE
|| (((enum tree_code) (result)->base.code)) == UNION_TYPE
) && ((tree_class_check ((result), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1481, __FUNCTION__))->type_common.lang_flag_5)) || ((enum
tree_code) (result)->base.code) == ENUMERAL_TYPE)
)
1482 {
1483 /* On classes and enums all attributes are ingrained. */
1484 gcc_assert (attribs == TYPE_ATTRIBUTES (result))((void)(!(attribs == ((tree_class_check ((result), (tcc_type)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1484, __FUNCTION__))->type_common.attributes)) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1484, __FUNCTION__), 0 : 0))
;
1485 return result;
1486 }
1487
1488 for (tree a = attribs; a; a = TREE_CHAIN (a)((contains_struct_check ((a), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1488, __FUNCTION__))->common.chain)
)
1489 {
1490 const attribute_spec *as
1491 = lookup_attribute_spec (get_attribute_name (a));
1492 if (as && as->affects_type_identity)
1493 {
1494 if (!first_ident)
1495 first_ident = a;
1496 else if (first_ident == error_mark_nodeglobal_trees[TI_ERROR_MARK])
1497 {
1498 *p = tree_cons (TREE_PURPOSE (a)((tree_check ((a), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1498, __FUNCTION__, (TREE_LIST)))->list.purpose)
, TREE_VALUE (a)((tree_check ((a), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1498, __FUNCTION__, (TREE_LIST)))->list.value)
, NULL_TREE(tree) nullptr);
1499 p = &TREE_CHAIN (*p)((contains_struct_check ((*p), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1499, __FUNCTION__))->common.chain)
;
1500 }
1501 }
1502 else if (first_ident && first_ident != error_mark_nodeglobal_trees[TI_ERROR_MARK])
1503 {
1504 for (tree a2 = first_ident; a2 != a; a2 = TREE_CHAIN (a2)((contains_struct_check ((a2), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1504, __FUNCTION__))->common.chain)
)
1505 {
1506 *p = tree_cons (TREE_PURPOSE (a2)((tree_check ((a2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1506, __FUNCTION__, (TREE_LIST)))->list.purpose)
, TREE_VALUE (a2)((tree_check ((a2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1506, __FUNCTION__, (TREE_LIST)))->list.value)
, NULL_TREE(tree) nullptr);
1507 p = &TREE_CHAIN (*p)((contains_struct_check ((*p), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1507, __FUNCTION__))->common.chain)
;
1508 }
1509 first_ident = error_mark_nodeglobal_trees[TI_ERROR_MARK];
1510 }
1511 }
1512 if (first_ident != error_mark_nodeglobal_trees[TI_ERROR_MARK])
1513 new_attribs = first_ident;
1514
1515 if (first_ident == attribs)
1516 /* All attributes affected type identity. */;
1517 else
1518 *remove_attributes = true;
1519
1520 return cp_build_type_attribute_variant (result, new_attribs);
1521}
1522
1523/* Builds a qualified variant of T that is either not a typedef variant
1524 (the default behavior) or not a typedef variant of a user-facing type
1525 (if FLAGS contains STF_USER_FACING).
1526
1527 E.g. consider the following declarations:
1528 typedef const int ConstInt;
1529 typedef ConstInt* PtrConstInt;
1530 If T is PtrConstInt, this function returns a type representing
1531 const int*.
1532 In other words, if T is a typedef, the function returns the underlying type.
1533 The cv-qualification and attributes of the type returned match the
1534 input type.
1535 They will always be compatible types.
1536 The returned type is built so that all of its subtypes
1537 recursively have their typedefs stripped as well.
1538
1539 This is different from just returning TYPE_CANONICAL (T)
1540 Because of several reasons:
1541 * If T is a type that needs structural equality
1542 its TYPE_CANONICAL (T) will be NULL.
1543 * TYPE_CANONICAL (T) desn't carry type attributes
1544 and loses template parameter names.
1545
1546 If REMOVE_ATTRIBUTES is non-null, also strip attributes that don't
1547 affect type identity, and set the referent to true if any were
1548 stripped. */
1549
1550tree
1551strip_typedefs (tree t, bool *remove_attributes, unsigned int flags)
1552{
1553 tree result = NULLnullptr, type = NULLnullptr, t0 = NULLnullptr;
1554
1555 if (!t || t == error_mark_nodeglobal_trees[TI_ERROR_MARK])
1556 return t;
1557
1558 if (TREE_CODE (t)((enum tree_code) (t)->base.code) == TREE_LIST)
1559 {
1560 bool changed = false;
1561 releasing_vec vec;
1562 tree r = t;
1563 for (; t; t = TREE_CHAIN (t)((contains_struct_check ((t), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1563, __FUNCTION__))->common.chain)
)
1564 {
1565 gcc_assert (!TREE_PURPOSE (t))((void)(!(!((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1565, __FUNCTION__, (TREE_LIST)))->list.purpose)) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1565, __FUNCTION__), 0 : 0))
;
1566 tree elt = strip_typedefs (TREE_VALUE (t)((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1566, __FUNCTION__, (TREE_LIST)))->list.value)
, remove_attributes, flags);
1567 if (elt != TREE_VALUE (t)((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1567, __FUNCTION__, (TREE_LIST)))->list.value)
)
1568 changed = true;
1569 vec_safe_push (vec, elt);
1570 }
1571 if (changed)
1572 r = build_tree_list_vec (vec);
1573 return r;
1574 }
1575
1576 gcc_assert (TYPE_P (t))((void)(!((tree_code_type[(int) (((enum tree_code) (t)->base
.code))] == tcc_type)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1576, __FUNCTION__), 0 : 0))
;
1577
1578 if (t == TYPE_CANONICAL (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1578, __FUNCTION__))->type_common.canonical)
)
1579 return t;
1580
1581 if (!(flags & STF_STRIP_DEPENDENT)
1582 && dependent_alias_template_spec_p (t, nt_opaque))
1583 /* DR 1558: However, if the template-id is dependent, subsequent
1584 template argument substitution still applies to the template-id. */
1585 return t;
1586
1587 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
1588 {
1589 case POINTER_TYPE:
1590 type = strip_typedefs (TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1590, __FUNCTION__))->typed.type)
, remove_attributes, flags);
1591 result = build_pointer_type_for_mode (type, TYPE_MODE (t)((((enum tree_code) ((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1591, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(t) : (t)->type_common.mode)
, false);
1592 break;
1593 case REFERENCE_TYPE:
1594 type = strip_typedefs (TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1594, __FUNCTION__))->typed.type)
, remove_attributes, flags);
1595 result = cp_build_reference_type_for_mode (type, TYPE_MODE (t)((((enum tree_code) ((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1595, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(t) : (t)->type_common.mode)
, TYPE_REF_IS_RVALUE (t)((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1595, __FUNCTION__, (REFERENCE_TYPE)))->base.private_flag
)
);
1596 break;
1597 case OFFSET_TYPE:
1598 t0 = strip_typedefs (TYPE_OFFSET_BASETYPE (t)((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1598, __FUNCTION__, (OFFSET_TYPE)))->type_non_common.maxval
)
, remove_attributes, flags);
1599 type = strip_typedefs (TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1599, __FUNCTION__))->typed.type)
, remove_attributes, flags);
1600 result = build_offset_type (t0, type);
1601 break;
1602 case RECORD_TYPE:
1603 if (TYPE_PTRMEMFUNC_P (t)(((enum tree_code) (t)->base.code) == RECORD_TYPE &&
(((tree_class_check (((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1603, __FUNCTION__, (RECORD_TYPE)))), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1603, __FUNCTION__))->type_common.lang_flag_2)))
)
1604 {
1605 t0 = strip_typedefs (TYPE_PTRMEMFUNC_FN_TYPE (t)(cp_build_qualified_type_real ((((contains_struct_check ((((tree_check3
((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1605, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values)), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1605, __FUNCTION__))->typed.type)), (cp_type_quals (t)),
tf_warning_or_error))
,
1606 remove_attributes, flags);
1607 result = build_ptrmemfunc_type (t0);
1608 }
1609 break;
1610 case ARRAY_TYPE:
1611 type = strip_typedefs (TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1611, __FUNCTION__))->typed.type)
, remove_attributes, flags);
1612 t0 = strip_typedefs (TYPE_DOMAIN (t)((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1612, __FUNCTION__, (ARRAY_TYPE)))->type_non_common.values
)
, remove_attributes, flags);
1613 gcc_checking_assert (TYPE_DEPENDENT_P_VALID (t)((void)(!(((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1613, __FUNCTION__))->type_common.lang_flag_6) || !dependent_type_p
(t)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1614, __FUNCTION__), 0 : 0))
1614 || !dependent_type_p (t))((void)(!(((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1613, __FUNCTION__))->type_common.lang_flag_6) || !dependent_type_p
(t)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1614, __FUNCTION__), 0 : 0))
;
1615 result = build_cplus_array_type (type, t0, TYPE_DEPENDENT_P (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1615, __FUNCTION__))->type_common.lang_flag_0)
);
1616 break;
1617 case FUNCTION_TYPE:
1618 case METHOD_TYPE:
1619 {
1620 tree arg_types = NULLnullptr, arg_node, arg_node2, arg_type;
1621 bool changed;
1622
1623 /* Because we stomp on TREE_PURPOSE of TYPE_ARG_TYPES in many places
1624 around the compiler (e.g. cp_parser_late_parsing_default_args), we
1625 can't expect that re-hashing a function type will find a previous
1626 equivalent type, so try to reuse the input type if nothing has
1627 changed. If the type is itself a variant, that will change. */
1628 bool is_variant = typedef_variant_p (t);
1629 if (remove_attributes
1630 && (TYPE_ATTRIBUTES (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1630, __FUNCTION__))->type_common.attributes)
|| TYPE_USER_ALIGN (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1630, __FUNCTION__))->base.u.bits.user_align)
))
1631 is_variant = true;
1632
1633 type = strip_typedefs (TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1633, __FUNCTION__))->typed.type)
, remove_attributes, flags);
1634 tree canon_spec = (flag_noexcept_type
1635 ? canonical_eh_spec (TYPE_RAISES_EXCEPTIONS (t)((tree_class_check (((tree_check2 ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1635, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1635, __FUNCTION__))->type_non_common.lang_1)
)
1636 : NULL_TREE(tree) nullptr);
1637 changed = (type != TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1637, __FUNCTION__))->typed.type)
|| is_variant
1638 || TYPE_RAISES_EXCEPTIONS (t)((tree_class_check (((tree_check2 ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1638, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1638, __FUNCTION__))->type_non_common.lang_1)
!= canon_spec);
1639
1640 for (arg_node = TYPE_ARG_TYPES (t)((tree_check2 ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1640, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))->type_non_common
.values)
;
1641 arg_node;
1642 arg_node = TREE_CHAIN (arg_node)((contains_struct_check ((arg_node), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1642, __FUNCTION__))->common.chain)
)
1643 {
1644 if (arg_node == void_list_nodeglobal_trees[TI_VOID_LIST_NODE])
1645 break;
1646 arg_type = strip_typedefs (TREE_VALUE (arg_node)((tree_check ((arg_node), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1646, __FUNCTION__, (TREE_LIST)))->list.value)
,
1647 remove_attributes, flags);
1648 gcc_assert (arg_type)((void)(!(arg_type) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1648, __FUNCTION__), 0 : 0))
;
1649 if (arg_type == TREE_VALUE (arg_node)((tree_check ((arg_node), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1649, __FUNCTION__, (TREE_LIST)))->list.value)
&& !changed)
1650 continue;
1651
1652 if (!changed)
1653 {
1654 changed = true;
1655 for (arg_node2 = TYPE_ARG_TYPES (t)((tree_check2 ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1655, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))->type_non_common
.values)
;
1656 arg_node2 != arg_node;
1657 arg_node2 = TREE_CHAIN (arg_node2)((contains_struct_check ((arg_node2), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1657, __FUNCTION__))->common.chain)
)
1658 arg_types
1659 = tree_cons (TREE_PURPOSE (arg_node2)((tree_check ((arg_node2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1659, __FUNCTION__, (TREE_LIST)))->list.purpose)
,
1660 TREE_VALUE (arg_node2)((tree_check ((arg_node2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1660, __FUNCTION__, (TREE_LIST)))->list.value)
, arg_types);
1661 }
1662
1663 arg_types
1664 = tree_cons (TREE_PURPOSE (arg_node)((tree_check ((arg_node), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1664, __FUNCTION__, (TREE_LIST)))->list.purpose)
, arg_type, arg_types);
1665 }
1666
1667 if (!changed)
1668 return t;
1669
1670 if (arg_types)
1671 arg_types = nreverse (arg_types);
1672
1673 /* A list of parameters not ending with an ellipsis
1674 must end with void_list_node. */
1675 if (arg_node)
1676 arg_types = chainon (arg_types, void_list_nodeglobal_trees[TI_VOID_LIST_NODE]);
1677
1678 if (TREE_CODE (t)((enum tree_code) (t)->base.code) == METHOD_TYPE)
1679 {
1680 tree class_type = TREE_TYPE (TREE_VALUE (arg_types))((contains_struct_check ((((tree_check ((arg_types), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1680, __FUNCTION__, (TREE_LIST)))->list.value)), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1680, __FUNCTION__))->typed.type)
;
1681 gcc_assert (class_type)((void)(!(class_type) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1681, __FUNCTION__), 0 : 0))
;
1682 result =
1683 build_method_type_directly (class_type, type,
1684 TREE_CHAIN (arg_types)((contains_struct_check ((arg_types), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1684, __FUNCTION__))->common.chain)
);
1685 }
1686 else
1687 {
1688 result = build_function_type (type, arg_types);
1689 result = apply_memfn_quals (result, type_memfn_quals (t));
1690 }
1691
1692 result = build_cp_fntype_variant (result,
1693 type_memfn_rqual (t), canon_spec,
1694 TYPE_HAS_LATE_RETURN_TYPE (t)(((tree_class_check (((tree_check2 ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1694, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1694, __FUNCTION__))->type_common.lang_flag_2))
);
1695 }
1696 break;
1697 case TYPENAME_TYPE:
1698 {
1699 bool changed = false;
1700 tree fullname = TYPENAME_TYPE_FULLNAME (t)(((tree_class_check (((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1700, __FUNCTION__, (TYPENAME_TYPE)))), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1700, __FUNCTION__))->type_non_common.values))
;
1701 if (TREE_CODE (fullname)((enum tree_code) (fullname)->base.code) == TEMPLATE_ID_EXPR
1702 && TREE_OPERAND (fullname, 1)(*((const_cast<tree*> (tree_operand_check ((fullname), (
1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1702, __FUNCTION__)))))
)
1703 {
1704 tree args = TREE_OPERAND (fullname, 1)(*((const_cast<tree*> (tree_operand_check ((fullname), (
1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1704, __FUNCTION__)))))
;
1705 tree new_args = copy_node (args);
1706 for (int i = 0; i < TREE_VEC_LENGTH (args)((tree_check ((args), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1706, __FUNCTION__, (TREE_VEC)))->base.u.length)
; ++i)
1707 {
1708 tree arg = TREE_VEC_ELT (args, i)(*((const_cast<tree *> (tree_vec_elt_check ((args), (i)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1708, __FUNCTION__)))))
;
1709 tree strip_arg;
1710 if (TYPE_P (arg)(tree_code_type[(int) (((enum tree_code) (arg)->base.code)
)] == tcc_type)
)
1711 strip_arg = strip_typedefs (arg, remove_attributes, flags);
1712 else
1713 strip_arg = strip_typedefs_expr (arg, remove_attributes,
1714 flags);
1715 TREE_VEC_ELT (new_args, i)(*((const_cast<tree *> (tree_vec_elt_check ((new_args),
(i), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1715, __FUNCTION__)))))
= strip_arg;
1716 if (strip_arg != arg)
1717 changed = true;
1718 }
1719 if (changed)
1720 {
1721 NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_args)((contains_struct_check (((tree_check ((new_args), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1721, __FUNCTION__, (TREE_VEC)))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1721, __FUNCTION__))->common.chain)
1722 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (args)((contains_struct_check (((tree_check ((args), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1722, __FUNCTION__, (TREE_VEC)))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1722, __FUNCTION__))->common.chain)
;
1723 fullname
1724 = lookup_template_function (TREE_OPERAND (fullname, 0)(*((const_cast<tree*> (tree_operand_check ((fullname), (
0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1724, __FUNCTION__)))))
,
1725 new_args);
1726 }
1727 else
1728 ggc_free (new_args);
1729 }
1730 tree ctx = strip_typedefs (TYPE_CONTEXT (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1730, __FUNCTION__))->type_common.context)
, remove_attributes, flags);
1731 if (!changed && ctx == TYPE_CONTEXT (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1731, __FUNCTION__))->type_common.context)
&& !typedef_variant_p (t))
1732 return t;
1733 tree name = fullname;
1734 if (TREE_CODE (fullname)((enum tree_code) (fullname)->base.code) == TEMPLATE_ID_EXPR)
1735 name = TREE_OPERAND (fullname, 0)(*((const_cast<tree*> (tree_operand_check ((fullname), (
0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1735, __FUNCTION__)))))
;
1736 /* Use build_typename_type rather than make_typename_type because we
1737 don't want to resolve it here, just strip typedefs. */
1738 result = build_typename_type (ctx, name, fullname, typename_type);
1739 }
1740 break;
1741 case DECLTYPE_TYPE:
1742 result = strip_typedefs_expr (DECLTYPE_TYPE_EXPR (t)(((tree_class_check (((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1742, __FUNCTION__, (DECLTYPE_TYPE)))), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1742, __FUNCTION__))->type_non_common.values))
,
1743 remove_attributes, flags);
1744 if (result == DECLTYPE_TYPE_EXPR (t)(((tree_class_check (((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1744, __FUNCTION__, (DECLTYPE_TYPE)))), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1744, __FUNCTION__))->type_non_common.values))
)
1745 result = NULL_TREE(tree) nullptr;
1746 else
1747 result = (finish_decltype_type
1748 (result,
1749 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t)((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1749, __FUNCTION__, (DECLTYPE_TYPE))))->type_common.string_flag
,
1750 tf_none));
1751 break;
1752 case UNDERLYING_TYPE:
1753 type = strip_typedefs (UNDERLYING_TYPE_TYPE (t)(((tree_class_check (((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1753, __FUNCTION__, (UNDERLYING_TYPE)))), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1753, __FUNCTION__))->type_non_common.values))
,
1754 remove_attributes, flags);
1755 result = finish_underlying_type (type);
1756 break;
1757 case TYPE_PACK_EXPANSION:
1758 {
1759 tree pat = PACK_EXPANSION_PATTERN (t)(((enum tree_code) (t)->base.code) == TYPE_PACK_EXPANSION ?
((contains_struct_check ((t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1759, __FUNCTION__))->typed.type) : (*((const_cast<tree
*> (tree_operand_check ((t), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1759, __FUNCTION__))))))
;
1760 if (TYPE_P (pat)(tree_code_type[(int) (((enum tree_code) (pat)->base.code)
)] == tcc_type)
)
1761 {
1762 type = strip_typedefs (pat, remove_attributes, flags);
1763 if (type != pat)
1764 {
1765 result = copy_node (t);
1766 PACK_EXPANSION_PATTERN (result)(((enum tree_code) (result)->base.code) == TYPE_PACK_EXPANSION
? ((contains_struct_check ((result), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1766, __FUNCTION__))->typed.type) : (*((const_cast<tree
*> (tree_operand_check ((result), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1766, __FUNCTION__))))))
= type;
1767 }
1768 }
1769 }
1770 break;
1771 default:
1772 break;
1773 }
1774
1775 if (!result)
1776 {
1777 if (typedef_variant_p (t))
1778 {
1779 if ((flags & STF_USER_VISIBLE)
1780 && !user_facing_original_type_p (t))
1781 return t;
1782 /* If T is a non-template alias or typedef, we can assume that
1783 instantiating its definition will hit any substitution failure,
1784 so we don't need to retain it here as well. */
1785 if (!alias_template_specialization_p (t, nt_opaque))
1786 flags |= STF_STRIP_DEPENDENT;
1787 result = strip_typedefs (DECL_ORIGINAL_TYPE (TYPE_NAME (t))((tree_check ((((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1787, __FUNCTION__))->type_common.name)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1787, __FUNCTION__, (TYPE_DECL)))->decl_non_common.result
)
,
1788 remove_attributes, flags);
1789 }
1790 else
1791 result = TYPE_MAIN_VARIANT (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1791, __FUNCTION__))->type_common.main_variant)
;
1792 }
1793 /*gcc_assert (!typedef_variant_p (result)
1794 || dependent_alias_template_spec_p (result, nt_opaque)
1795 || ((flags & STF_USER_VISIBLE)
1796 && !user_facing_original_type_p (result)));*/
1797
1798 if (COMPLETE_TYPE_P (result)(((tree_class_check ((result), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1798, __FUNCTION__))->type_common.size) != (tree) nullptr
)
&& !COMPLETE_TYPE_P (t)(((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1798, __FUNCTION__))->type_common.size) != (tree) nullptr
)
)
1799 /* If RESULT is complete and T isn't, it's likely the case that T
1800 is a variant of RESULT which hasn't been updated yet. Skip the
1801 attribute handling. */;
1802 else
1803 {
1804 if (TYPE_USER_ALIGN (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1804, __FUNCTION__))->base.u.bits.user_align)
!= TYPE_USER_ALIGN (result)((tree_class_check ((result), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1804, __FUNCTION__))->base.u.bits.user_align)
1805 || TYPE_ALIGN (t)(((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1805, __FUNCTION__))->type_common.align) ? ((unsigned)1)
<< (((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1805, __FUNCTION__))->type_common.align) - 1) : 0)
!= TYPE_ALIGN (result)(((tree_class_check ((result), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1805, __FUNCTION__))->type_common.align) ? ((unsigned)1)
<< (((tree_class_check ((result), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1805, __FUNCTION__))->type_common.align) - 1) : 0)
)
1806 {
1807 gcc_assert (TYPE_USER_ALIGN (t))((void)(!(((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1807, __FUNCTION__))->base.u.bits.user_align)) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1807, __FUNCTION__), 0 : 0))
;
1808 if (remove_attributes)
1809 *remove_attributes = true;
1810 else
1811 {
1812 if (TYPE_ALIGN (t)(((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1812, __FUNCTION__))->type_common.align) ? ((unsigned)1)
<< (((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1812, __FUNCTION__))->type_common.align) - 1) : 0)
== TYPE_ALIGN (result)(((tree_class_check ((result), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1812, __FUNCTION__))->type_common.align) ? ((unsigned)1)
<< (((tree_class_check ((result), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1812, __FUNCTION__))->type_common.align) - 1) : 0)
)
1813 result = build_variant_type_copy (result);
1814 else
1815 result = build_aligned_type (result, TYPE_ALIGN (t)(((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1815, __FUNCTION__))->type_common.align) ? ((unsigned)1)
<< (((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1815, __FUNCTION__))->type_common.align) - 1) : 0)
);
1816 TYPE_USER_ALIGN (result)((tree_class_check ((result), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1816, __FUNCTION__))->base.u.bits.user_align)
= true;
1817 }
1818 }
1819
1820 if (TYPE_ATTRIBUTES (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1820, __FUNCTION__))->type_common.attributes)
)
1821 {
1822 if (remove_attributes)
1823 result = apply_identity_attributes (result, TYPE_ATTRIBUTES (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1823, __FUNCTION__))->type_common.attributes)
,
1824 remove_attributes);
1825 else
1826 result = cp_build_type_attribute_variant (result,
1827 TYPE_ATTRIBUTES (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1827, __FUNCTION__))->type_common.attributes)
);
1828 }
1829 }
1830
1831 return cp_build_qualified_type (result, cp_type_quals (t))cp_build_qualified_type_real ((result), (cp_type_quals (t)), tf_warning_or_error
)
;
1832}
1833
1834/* Like strip_typedefs above, but works on expressions, so that in
1835
1836 template<class T> struct A
1837 {
1838 typedef T TT;
1839 B<sizeof(TT)> b;
1840 };
1841
1842 sizeof(TT) is replaced by sizeof(T). */
1843
1844tree
1845strip_typedefs_expr (tree t, bool *remove_attributes, unsigned int flags)
1846{
1847 unsigned i,n;
1848 tree r, type, *ops;
1849 enum tree_code code;
1850
1851 if (t == NULL_TREE(tree) nullptr || t == error_mark_nodeglobal_trees[TI_ERROR_MARK])
1852 return t;
1853
1854 STRIP_ANY_LOCATION_WRAPPER (t)(t) = tree_strip_any_location_wrapper ((const_cast<union tree_node
*> (((t)))))
;
1855
1856 if (DECL_P (t)(tree_code_type[(int) (((enum tree_code) (t)->base.code))]
== tcc_declaration)
|| CONSTANT_CLASS_P (t)(tree_code_type[(int) (((enum tree_code) (t)->base.code))]
== tcc_constant)
)
1857 return t;
1858
1859 /* Some expressions have type operands, so let's handle types here rather
1860 than check TYPE_P in multiple places below. */
1861 if (TYPE_P (t)(tree_code_type[(int) (((enum tree_code) (t)->base.code))]
== tcc_type)
)
1862 return strip_typedefs (t, remove_attributes, flags);
1863
1864 code = TREE_CODE (t)((enum tree_code) (t)->base.code);
1865 switch (code)
1866 {
1867 case IDENTIFIER_NODE:
1868 case TEMPLATE_PARM_INDEX:
1869 case OVERLOAD:
1870 case BASELINK:
1871 case ARGUMENT_PACK_SELECT:
1872 return t;
1873
1874 case TRAIT_EXPR:
1875 {
1876 tree type1 = strip_typedefs (TRAIT_EXPR_TYPE1 (t)(((struct tree_trait_expr *)(tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1876, __FUNCTION__, (TRAIT_EXPR))))->type1)
,
1877 remove_attributes, flags);
1878 tree type2 = strip_typedefs (TRAIT_EXPR_TYPE2 (t)(((struct tree_trait_expr *)(tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1878, __FUNCTION__, (TRAIT_EXPR))))->type2)
,
1879 remove_attributes, flags);
1880 if (type1 == TRAIT_EXPR_TYPE1 (t)(((struct tree_trait_expr *)(tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1880, __FUNCTION__, (TRAIT_EXPR))))->type1)
1881 && type2 == TRAIT_EXPR_TYPE2 (t)(((struct tree_trait_expr *)(tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1881, __FUNCTION__, (TRAIT_EXPR))))->type2)
)
1882 return t;
1883 r = copy_node (t);
1884 TRAIT_EXPR_TYPE1 (r)(((struct tree_trait_expr *)(tree_check ((r), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1884, __FUNCTION__, (TRAIT_EXPR))))->type1)
= type1;
1885 TRAIT_EXPR_TYPE2 (r)(((struct tree_trait_expr *)(tree_check ((r), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1885, __FUNCTION__, (TRAIT_EXPR))))->type2)
= type2;
1886 return r;
1887 }
1888
1889 case TREE_LIST:
1890 {
1891 releasing_vec vec;
1892 bool changed = false;
1893 tree it;
1894 for (it = t; it; it = TREE_CHAIN (it)((contains_struct_check ((it), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1894, __FUNCTION__))->common.chain)
)
1895 {
1896 tree val = strip_typedefs_expr (TREE_VALUE (it)((tree_check ((it), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1896, __FUNCTION__, (TREE_LIST)))->list.value)
,
1897 remove_attributes, flags);
1898 vec_safe_push (vec, val);
1899 if (val != TREE_VALUE (it)((tree_check ((it), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1899, __FUNCTION__, (TREE_LIST)))->list.value)
)
1900 changed = true;
1901 gcc_assert (TREE_PURPOSE (it) == NULL_TREE)((void)(!(((tree_check ((it), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1901, __FUNCTION__, (TREE_LIST)))->list.purpose) == (tree
) nullptr) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1901, __FUNCTION__), 0 : 0))
;
1902 }
1903 if (changed)
1904 {
1905 r = NULL_TREE(tree) nullptr;
1906 FOR_EACH_VEC_ELT_REVERSE (*vec, i, it)for (i = (*vec).length () - 1; (*vec).iterate ((i), &(it)
); (i)--)
1907 r = tree_cons (NULL_TREE(tree) nullptr, it, r);
1908 }
1909 else
1910 r = t;
1911 return r;
1912 }
1913
1914 case TREE_VEC:
1915 {
1916 bool changed = false;
1917 releasing_vec vec;
1918 n = TREE_VEC_LENGTH (t)((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1918, __FUNCTION__, (TREE_VEC)))->base.u.length)
;
1919 vec_safe_reserve (vec, n);
1920 for (i = 0; i < n; ++i)
1921 {
1922 tree op = strip_typedefs_expr (TREE_VEC_ELT (t, i)(*((const_cast<tree *> (tree_vec_elt_check ((t), (i), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1922, __FUNCTION__)))))
,
1923 remove_attributes, flags);
1924 vec->quick_push (op);
1925 if (op != TREE_VEC_ELT (t, i)(*((const_cast<tree *> (tree_vec_elt_check ((t), (i), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1925, __FUNCTION__)))))
)
1926 changed = true;
1927 }
1928 if (changed)
1929 {
1930 r = copy_node (t);
1931 for (i = 0; i < n; ++i)
1932 TREE_VEC_ELT (r, i)(*((const_cast<tree *> (tree_vec_elt_check ((r), (i), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1932, __FUNCTION__)))))
= (*vec)[i];
1933 NON_DEFAULT_TEMPLATE_ARGS_COUNT (r)((contains_struct_check (((tree_check ((r), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1933, __FUNCTION__, (TREE_VEC)))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1933, __FUNCTION__))->common.chain)
1934 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (t)((contains_struct_check (((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1934, __FUNCTION__, (TREE_VEC)))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1934, __FUNCTION__))->common.chain)
;
1935 }
1936 else
1937 r = t;
1938 return r;
1939 }
1940
1941 case CONSTRUCTOR:
1942 {
1943 bool changed = false;
1944 vec<constructor_elt, va_gc> *vec
1945 = vec_safe_copy (CONSTRUCTOR_ELTS (t)((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1945, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts)
);
1946 n = CONSTRUCTOR_NELTS (t)(vec_safe_length (((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1946, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts)))
;
1947 type = strip_typedefs (TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1947, __FUNCTION__))->typed.type)
, remove_attributes, flags);
1948 for (i = 0; i < n; ++i)
1949 {
1950 constructor_elt *e = &(*vec)[i];
1951 tree op = strip_typedefs_expr (e->value, remove_attributes, flags);
1952 if (op != e->value)
1953 {
1954 changed = true;
1955 e->value = op;
1956 }
1957 gcc_checking_assert((void)(!(e->index == strip_typedefs_expr (e->index, remove_attributes
, flags)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1959, __FUNCTION__), 0 : 0))
1958 (e->index == strip_typedefs_expr (e->index, remove_attributes,((void)(!(e->index == strip_typedefs_expr (e->index, remove_attributes
, flags)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1959, __FUNCTION__), 0 : 0))
1959 flags))((void)(!(e->index == strip_typedefs_expr (e->index, remove_attributes
, flags)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1959, __FUNCTION__), 0 : 0))
;
1960 }
1961
1962 if (!changed && type == TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1962, __FUNCTION__))->typed.type)
)
1963 {
1964 vec_free (vec);
1965 return t;
1966 }
1967 else
1968 {
1969 r = copy_node (t);
1970 TREE_TYPE (r)((contains_struct_check ((r), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1970, __FUNCTION__))->typed.type)
= type;
1971 CONSTRUCTOR_ELTS (r)((tree_check ((r), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1971, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts)
= vec;
1972 return r;
1973 }
1974 }
1975
1976 case LAMBDA_EXPR:
1977 return t;
1978
1979 case STATEMENT_LIST:
1980 error ("statement-expression in a constant expression");
1981 return error_mark_nodeglobal_trees[TI_ERROR_MARK];
1982
1983 default:
1984 break;
1985 }
1986
1987 gcc_assert (EXPR_P (t))((void)(!(((tree_code_type[(int) (((enum tree_code) (t)->base
.code))]) >= tcc_reference && (tree_code_type[(int
) (((enum tree_code) (t)->base.code))]) <= tcc_expression
)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1987, __FUNCTION__), 0 : 0))
;
1988
1989 n = cp_tree_operand_length (t);
1990 ops = XALLOCAVEC (tree, n)((tree *) __builtin_alloca(sizeof (tree) * (n)));
1991 type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 1991, __FUNCTION__))->typed.type)
;
1992
1993 switch (code)
1994 {
1995 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1996 case IMPLICIT_CONV_EXPR:
1997 case DYNAMIC_CAST_EXPR:
1998 case STATIC_CAST_EXPR:
1999 case CONST_CAST_EXPR:
2000 case REINTERPRET_CAST_EXPR:
2001 case CAST_EXPR:
2002 case NEW_EXPR:
2003 type = strip_typedefs (type, remove_attributes, flags);
2004 /* fallthrough */
2005
2006 default:
2007 for (i = 0; i < n; ++i)
2008 ops[i] = strip_typedefs_expr (TREE_OPERAND (t, i)(*((const_cast<tree*> (tree_operand_check ((t), (i), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2008, __FUNCTION__)))))
,
2009 remove_attributes, flags);
2010 break;
2011 }
2012
2013 /* If nothing changed, return t. */
2014 for (i = 0; i < n; ++i)
2015 if (ops[i] != TREE_OPERAND (t, i)(*((const_cast<tree*> (tree_operand_check ((t), (i), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2015, __FUNCTION__)))))
)
2016 break;
2017 if (i == n && type == TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2017, __FUNCTION__))->typed.type)
)
2018 return t;
2019
2020 r = copy_node (t);
2021 TREE_TYPE (r)((contains_struct_check ((r), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2021, __FUNCTION__))->typed.type)
= type;
2022 for (i = 0; i < n; ++i)
2023 TREE_OPERAND (r, i)(*((const_cast<tree*> (tree_operand_check ((r), (i), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2023, __FUNCTION__)))))
= ops[i];
2024 return r;
2025}
2026
2027/* Makes a copy of BINFO and TYPE, which is to be inherited into a
2028 graph dominated by T. If BINFO is NULL, TYPE is a dependent base,
2029 and we do a shallow copy. If BINFO is non-NULL, we do a deep copy.
2030 VIRT indicates whether TYPE is inherited virtually or not.
2031 IGO_PREV points at the previous binfo of the inheritance graph
2032 order chain. The newly copied binfo's TREE_CHAIN forms this
2033 ordering.
2034
2035 The CLASSTYPE_VBASECLASSES vector of T is constructed in the
2036 correct order. That is in the order the bases themselves should be
2037 constructed in.
2038
2039 The BINFO_INHERITANCE of a virtual base class points to the binfo
2040 of the most derived type. ??? We could probably change this so that
2041 BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence
2042 remove a field. They currently can only differ for primary virtual
2043 virtual bases. */
2044
2045tree
2046copy_binfo (tree binfo, tree type, tree t, tree *igo_prev, int virt)
2047{
2048 tree new_binfo;
2049
2050 if (virt)
2051 {
2052 /* See if we've already made this virtual base. */
2053 new_binfo = binfo_for_vbase (type, t);
2054 if (new_binfo)
2055 return new_binfo;
2056 }
2057
2058 new_binfo = make_tree_binfo (binfo ? BINFO_N_BASE_BINFOS (binfo)((&(tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2058, __FUNCTION__, (TREE_BINFO)))->binfo.base_binfos)->
length ())
: 0);
2059 BINFO_TYPE (new_binfo)((contains_struct_check (((tree_check ((new_binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2059, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2059, __FUNCTION__))->typed.type)
= type;
2060
2061 /* Chain it into the inheritance graph. */
2062 TREE_CHAIN (*igo_prev)((contains_struct_check ((*igo_prev), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2062, __FUNCTION__))->common.chain)
= new_binfo;
2063 *igo_prev = new_binfo;
2064
2065 if (binfo && !BINFO_DEPENDENT_BASE_P (binfo)((tree_not_check2 (((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2065, __FUNCTION__, (TREE_BINFO)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2065, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_3)
)
2066 {
2067 int ix;
2068 tree base_binfo;
2069
2070 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), type))((void)(!(((((contains_struct_check (((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2070, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2070, __FUNCTION__))->typed.type)) == (type))) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2070, __FUNCTION__), 0 : 0))
;
2071
2072 BINFO_OFFSET (new_binfo)((tree_check ((new_binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2072, __FUNCTION__, (TREE_BINFO)))->binfo.offset)
= BINFO_OFFSET (binfo)((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2072, __FUNCTION__, (TREE_BINFO)))->binfo.offset)
;
2073 BINFO_VIRTUALS (new_binfo)((tree_check ((new_binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2073, __FUNCTION__, (TREE_BINFO)))->binfo.virtuals)
= BINFO_VIRTUALS (binfo)((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2073, __FUNCTION__, (TREE_BINFO)))->binfo.virtuals)
;
2074
2075 /* We do not need to copy the accesses, as they are read only. */
2076 BINFO_BASE_ACCESSES (new_binfo)((tree_check ((new_binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2076, __FUNCTION__, (TREE_BINFO)))->binfo.base_accesses)
= BINFO_BASE_ACCESSES (binfo)((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2076, __FUNCTION__, (TREE_BINFO)))->binfo.base_accesses)
;
2077
2078 /* Recursively copy base binfos of BINFO. */
2079 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo)((&(tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2079, __FUNCTION__, (TREE_BINFO)))->binfo.base_binfos)->
iterate ((ix), &(base_binfo)))
; ix++)
2080 {
2081 tree new_base_binfo;
2082 new_base_binfo = copy_binfo (base_binfo, BINFO_TYPE (base_binfo)((contains_struct_check (((tree_check ((base_binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2082, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2082, __FUNCTION__))->typed.type)
,
2083 t, igo_prev,
2084 BINFO_VIRTUAL_P (base_binfo)((tree_check ((base_binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2084, __FUNCTION__, (TREE_BINFO)))->base.static_flag)
);
2085
2086 if (!BINFO_INHERITANCE_CHAIN (new_base_binfo)((tree_check ((new_base_binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2086, __FUNCTION__, (TREE_BINFO)))->binfo.inheritance)
)
2087 BINFO_INHERITANCE_CHAIN (new_base_binfo)((tree_check ((new_base_binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2087, __FUNCTION__, (TREE_BINFO)))->binfo.inheritance)
= new_binfo;
2088 BINFO_BASE_APPEND (new_binfo, new_base_binfo)((&(tree_check ((new_binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2088, __FUNCTION__, (TREE_BINFO)))->binfo.base_binfos)->
quick_push ((new_base_binfo)))
;
2089 }
2090 }
2091 else
2092 BINFO_DEPENDENT_BASE_P (new_binfo)((tree_not_check2 (((tree_check ((new_binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2092, __FUNCTION__, (TREE_BINFO)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2092, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_3)
= 1;
2093
2094 if (virt)
2095 {
2096 /* Push it onto the list after any virtual bases it contains
2097 will have been pushed. */
2098 CLASSTYPE_VBASECLASSES (t)((((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2098, __FUNCTION__))->type_with_lang_specific.lang_specific
))->vbases)
->quick_push (new_binfo);
2099 BINFO_VIRTUAL_P (new_binfo)((tree_check ((new_binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2099, __FUNCTION__, (TREE_BINFO)))->base.static_flag)
= 1;
2100 BINFO_INHERITANCE_CHAIN (new_binfo)((tree_check ((new_binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2100, __FUNCTION__, (TREE_BINFO)))->binfo.inheritance)
= TYPE_BINFO (t)((tree_check3 ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2100, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.maxval)
;
2101 }
2102
2103 return new_binfo;
2104}
2105
2106/* Hashing of lists so that we don't make duplicates.
2107 The entry point is `list_hash_canon'. */
2108
2109struct list_proxy
2110{
2111 tree purpose;
2112 tree value;
2113 tree chain;
2114};
2115
2116struct list_hasher : ggc_ptr_hash<tree_node>
2117{
2118 typedef list_proxy *compare_type;
2119
2120 static hashval_t hash (tree);
2121 static bool equal (tree, list_proxy *);
2122};
2123
2124/* Now here is the hash table. When recording a list, it is added
2125 to the slot whose index is the hash code mod the table size.
2126 Note that the hash table is used for several kinds of lists.
2127 While all these live in the same table, they are completely independent,
2128 and the hash code is computed differently for each of these. */
2129
2130static GTY (()) hash_table<list_hasher> *list_hash_table;
2131
2132/* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy
2133 for a node we are thinking about adding). */
2134
2135bool
2136list_hasher::equal (tree t, list_proxy *proxy)
2137{
2138 return (TREE_VALUE (t)((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2138, __FUNCTION__, (TREE_LIST)))->list.value)
== proxy->value
2139 && TREE_PURPOSE (t)((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2139, __FUNCTION__, (TREE_LIST)))->list.purpose)
== proxy->purpose
2140 && TREE_CHAIN (t)((contains_struct_check ((t), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2140, __FUNCTION__))->common.chain)
== proxy->chain);
2141}
2142
2143/* Compute a hash code for a list (chain of TREE_LIST nodes
2144 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
2145 TREE_COMMON slots), by adding the hash codes of the individual entries. */
2146
2147static hashval_t
2148list_hash_pieces (tree purpose, tree value, tree chain)
2149{
2150 hashval_t hashcode = 0;
2151
2152 if (chain)
2153 hashcode += TREE_HASH (chain)((size_t) (chain) & 0777777);
2154
2155 if (value)
2156 hashcode += TREE_HASH (value)((size_t) (value) & 0777777);
2157 else
2158 hashcode += 1007;
2159 if (purpose)
2160 hashcode += TREE_HASH (purpose)((size_t) (purpose) & 0777777);
2161 else
2162 hashcode += 1009;
2163 return hashcode;
2164}
2165
2166/* Hash an already existing TREE_LIST. */
2167
2168hashval_t
2169list_hasher::hash (tree t)
2170{
2171 return list_hash_pieces (TREE_PURPOSE (t)((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2171, __FUNCTION__, (TREE_LIST)))->list.purpose)
,
2172 TREE_VALUE (t)((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2172, __FUNCTION__, (TREE_LIST)))->list.value)
,
2173 TREE_CHAIN (t)((contains_struct_check ((t), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2173, __FUNCTION__))->common.chain)
);
2174}
2175
2176/* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
2177 object for an identical list if one already exists. Otherwise, build a
2178 new one, and record it as the canonical object. */
2179
2180tree
2181hash_tree_cons (tree purpose, tree value, tree chain)
2182{
2183 int hashcode = 0;
2184 tree *slot;
2185 struct list_proxy proxy;
2186
2187 /* Hash the list node. */
2188 hashcode = list_hash_pieces (purpose, value, chain);
2189 /* Create a proxy for the TREE_LIST we would like to create. We
2190 don't actually create it so as to avoid creating garbage. */
2191 proxy.purpose = purpose;
2192 proxy.value = value;
2193 proxy.chain = chain;
2194 /* See if it is already in the table. */
2195 slot = list_hash_table->find_slot_with_hash (&proxy, hashcode, INSERT);
2196 /* If not, create a new node. */
2197 if (!*slot)
2198 *slot = tree_cons (purpose, value, chain);
2199 return (tree) *slot;
2200}
2201
2202/* Constructor for hashed lists. */
2203
2204tree
2205hash_tree_chain (tree value, tree chain)
2206{
2207 return hash_tree_cons (NULL_TREE(tree) nullptr, value, chain);
2208}
2209
2210void
2211debug_binfo (tree elem)
2212{
2213 HOST_WIDE_INTlong n;
2214 tree virtuals;
2215
2216 fprintf (stderrstderr, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC"%" "l" "d"
2217 "\nvtable type:\n",
2218 TYPE_NAME_STRING (BINFO_TYPE (elem))(((const char *) (tree_check (((((tree_class_check ((((contains_struct_check
(((tree_check ((elem), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2218, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2218, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2218, __FUNCTION__))->type_common.name) && (tree_code_type
[(int) (((enum tree_code) (((tree_class_check ((((contains_struct_check
(((tree_check ((elem), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2218, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2218, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2218, __FUNCTION__))->type_common.name))->base.code))
] == tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((((contains_struct_check (((tree_check ((elem), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2218, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2218, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2218, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2218, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((((contains_struct_check (((tree_check ((elem), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2218, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2218, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2218, __FUNCTION__))->type_common.name))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2218, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
))
,
2219 TREE_INT_CST_LOW (BINFO_OFFSET (elem))((unsigned long) (*tree_int_cst_elt_check ((((tree_check ((elem
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2219, __FUNCTION__, (TREE_BINFO)))->binfo.offset)), (0),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2219, __FUNCTION__)))
);
2220 debug_tree (BINFO_TYPE (elem)((contains_struct_check (((tree_check ((elem), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2220, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2220, __FUNCTION__))->typed.type)
);
2221 if (BINFO_VTABLE (elem)((tree_check ((elem), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2221, __FUNCTION__, (TREE_BINFO)))->binfo.vtable)
)
2222 fprintf (stderrstderr, "vtable decl \"%s\"\n",
2223 IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem)))((const char *) (tree_check ((((contains_struct_check ((get_vtbl_decl_for_binfo
(elem)), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2223, __FUNCTION__))->decl_minimal.name)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2223, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
)
);
2224 else
2225 fprintf (stderrstderr, "no vtable decl yet\n");
2226 fprintf (stderrstderr, "virtuals:\n");
2227 virtuals = BINFO_VIRTUALS (elem)((tree_check ((elem), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2227, __FUNCTION__, (TREE_BINFO)))->binfo.virtuals)
;
2228 n = 0;
2229
2230 while (virtuals)
2231 {
2232 tree fndecl = TREE_VALUE (virtuals)((tree_check ((virtuals), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2232, __FUNCTION__, (TREE_LIST)))->list.value)
;
2233 fprintf (stderrstderr, "%s [%ld =? %ld]\n",
2234 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl))((const char *) (tree_check ((decl_assembler_name (fndecl)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2234, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
)
,
2235 (long) n, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl))((unsigned long) (*tree_int_cst_elt_check ((((tree_check ((fndecl
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2235, __FUNCTION__, (FUNCTION_DECL)))->function_decl.vindex
)), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2235, __FUNCTION__)))
);
2236 ++n;
2237 virtuals = TREE_CHAIN (virtuals)((contains_struct_check ((virtuals), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2237, __FUNCTION__))->common.chain)
;
2238 }
2239}
2240
2241/* Build a representation for the qualified name SCOPE::NAME. TYPE is
2242 the type of the result expression, if known, or NULL_TREE if the
2243 resulting expression is type-dependent. If TEMPLATE_P is true,
2244 NAME is known to be a template because the user explicitly used the
2245 "template" keyword after the "::".
2246
2247 All SCOPE_REFs should be built by use of this function. */
2248
2249tree
2250build_qualified_name (tree type, tree scope, tree name, bool template_p)
2251{
2252 tree t;
2253 if (type == error_mark_nodeglobal_trees[TI_ERROR_MARK]
2254 || scope == error_mark_nodeglobal_trees[TI_ERROR_MARK]
2255 || name == error_mark_nodeglobal_trees[TI_ERROR_MARK])
2256 return error_mark_nodeglobal_trees[TI_ERROR_MARK];
2257 gcc_assert (TREE_CODE (name) != SCOPE_REF)((void)(!(((enum tree_code) (name)->base.code) != SCOPE_REF
) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2257, __FUNCTION__), 0 : 0))
;
2258 t = build2 (SCOPE_REF, type, scope, name);
2259 QUALIFIED_NAME_IS_TEMPLATE (t)(((tree_not_check2 (((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2259, __FUNCTION__, (SCOPE_REF)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2259, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_1))
= template_p;
2260 PTRMEM_OK_P (t)((tree_not_check2 (((tree_check3 (((t)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2260, __FUNCTION__, (ADDR_EXPR), (OFFSET_REF), (SCOPE_REF))
)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2260, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)
= true;
2261 if (type)
2262 t = convert_from_reference (t);
2263 return t;
2264}
2265
2266/* Like check_qualified_type, but also check ref-qualifier, exception
2267 specification, and whether the return type was specified after the
2268 parameters. */
2269
2270static bool
2271cp_check_qualified_type (const_tree cand, const_tree base, int type_quals,
2272 cp_ref_qualifier rqual, tree raises, bool late)
2273{
2274 return (TYPE_QUALS (cand)((int) ((((tree_class_check ((cand), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2274, __FUNCTION__))->base.readonly_flag) * TYPE_QUAL_CONST
) | (((tree_class_check ((cand), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2274, __FUNCTION__))->base.volatile_flag) * TYPE_QUAL_VOLATILE
) | (((tree_class_check ((cand), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2274, __FUNCTION__))->base.u.bits.atomic_flag) * TYPE_QUAL_ATOMIC
) | (((tree_class_check ((cand), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2274, __FUNCTION__))->type_common.restrict_flag) * TYPE_QUAL_RESTRICT
) | (((((tree_class_check ((cand), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2274, __FUNCTION__))->base.u.bits.address_space) & 0xFF
) << 8))))
== type_quals
2275 && check_base_type (cand, base)
2276 && comp_except_specs (raises, TYPE_RAISES_EXCEPTIONS (cand)((tree_class_check (((tree_check2 ((cand), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2276, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2276, __FUNCTION__))->type_non_common.lang_1)
,
2277 ce_exact)
2278 && TYPE_HAS_LATE_RETURN_TYPE (cand)(((tree_class_check (((tree_check2 ((cand), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2278, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2278, __FUNCTION__))->type_common.lang_flag_2))
== late
2279 && type_memfn_rqual (cand) == rqual);
2280}
2281
2282/* Build the FUNCTION_TYPE or METHOD_TYPE with the ref-qualifier RQUAL. */
2283
2284tree
2285build_ref_qualified_type (tree type, cp_ref_qualifier rqual)
2286{
2287 tree raises = TYPE_RAISES_EXCEPTIONS (type)((tree_class_check (((tree_check2 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2287, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2287, __FUNCTION__))->type_non_common.lang_1)
;
2288 bool late = TYPE_HAS_LATE_RETURN_TYPE (type)(((tree_class_check (((tree_check2 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2288, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2288, __FUNCTION__))->type_common.lang_flag_2))
;
2289 return build_cp_fntype_variant (type, rqual, raises, late);
2290}
2291
2292tree
2293make_binding_vec (tree name, unsigned clusters MEM_STAT_DECL)
2294{
2295 /* Stored in an unsigned short, but we're limited to the number of
2296 modules anyway. */
2297 gcc_checking_assert (clusters <= (unsigned short)(~0))((void)(!(clusters <= (unsigned short)(~0)) ? fancy_abort (
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2297, __FUNCTION__), 0 : 0))
;
2298 size_t length = (offsetof (tree_binding_vec, vec)__builtin_offsetof(tree_binding_vec, vec)
2299 + clusters * sizeof (binding_cluster));
2300 tree vec = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT);
2301 TREE_SET_CODE (vec, BINDING_VECTOR)((vec)->base.code = (BINDING_VECTOR));
2302 BINDING_VECTOR_NAME (vec)(((tree_binding_vec *)(tree_check ((vec), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2302, __FUNCTION__, (BINDING_VECTOR))))->name)
= name;
2303 BINDING_VECTOR_ALLOC_CLUSTERS (vec)((tree_check ((vec), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2303, __FUNCTION__, (BINDING_VECTOR)))->base.u.dependence_info
.clique)
= clusters;
2304 BINDING_VECTOR_NUM_CLUSTERS (vec)((tree_check ((vec), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2304, __FUNCTION__, (BINDING_VECTOR)))->base.u.dependence_info
.base)
= 0;
2305
2306 return vec;
2307}
2308
2309/* Make a raw overload node containing FN. */
2310
2311tree
2312ovl_make (tree fn, tree next)
2313{
2314 tree result = make_node (OVERLOAD);
2315
2316 if (TREE_CODE (fn)((enum tree_code) (fn)->base.code) == OVERLOAD)
2317 OVL_NESTED_P (result)((tree_not_check2 (((tree_check ((result), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2317, __FUNCTION__, (OVERLOAD)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2317, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_3)
= true;
2318
2319 TREE_TYPE (result)((contains_struct_check ((result), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2319, __FUNCTION__))->typed.type)
= (next || TREE_CODE (fn)((enum tree_code) (fn)->base.code) == TEMPLATE_DECL
2320 ? unknown_type_nodecp_global_trees[CPTI_UNKNOWN_TYPE] : TREE_TYPE (fn)((contains_struct_check ((fn), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2320, __FUNCTION__))->typed.type)
);
2321 if (next && TREE_CODE (next)((enum tree_code) (next)->base.code) == OVERLOAD && OVL_DEDUP_P (next)((tree_not_check2 (((tree_check ((next), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2321, __FUNCTION__, (OVERLOAD)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2321, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)
)
2322 OVL_DEDUP_P (result)((tree_not_check2 (((tree_check ((result), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2322, __FUNCTION__, (OVERLOAD)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2322, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)
= true;
2323 OVL_FUNCTION (result)(((struct tree_overload*)(tree_check ((result), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2323, __FUNCTION__, (OVERLOAD))))->function)
= fn;
2324 OVL_CHAIN (result)(((struct tree_overload*)(tree_check ((result), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2324, __FUNCTION__, (OVERLOAD))))->common.chain)
= next;
2325 return result;
2326}
2327
2328/* Add FN to the (potentially NULL) overload set OVL. USING_OR_HIDDEN is >
2329 zero if this is a using-decl. It is > 1 if we're exporting the
2330 using decl. USING_OR_HIDDEN is < 0, if FN is hidden. (A decl
2331 cannot be both using and hidden.) We keep the hidden decls first,
2332 but remaining ones are unordered. */
2333
2334tree
2335ovl_insert (tree fn, tree maybe_ovl, int using_or_hidden)
2336{
2337 tree result = maybe_ovl;
2338 tree insert_after = NULL_TREE(tree) nullptr;
2339
2340 /* Skip hidden. */
2341 for (; maybe_ovl && TREE_CODE (maybe_ovl)((enum tree_code) (maybe_ovl)->base.code) == OVERLOAD
2342 && OVL_HIDDEN_P (maybe_ovl)((tree_not_check2 (((tree_check ((maybe_ovl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2342, __FUNCTION__, (OVERLOAD)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2342, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2)
;
2343 maybe_ovl = OVL_CHAIN (maybe_ovl)(((struct tree_overload*)(tree_check ((maybe_ovl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2343, __FUNCTION__, (OVERLOAD))))->common.chain)
)
2344 {
2345 gcc_checking_assert (!OVL_LOOKUP_P (maybe_ovl))((void)(!(!((tree_not_check2 (((tree_check ((maybe_ovl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2345, __FUNCTION__, (OVERLOAD)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2345, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_4)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2345, __FUNCTION__), 0 : 0))
;
2346 insert_after = maybe_ovl;
2347 }
2348
2349 if (maybe_ovl || using_or_hidden || TREE_CODE (fn)((enum tree_code) (fn)->base.code) == TEMPLATE_DECL)
2350 {
2351 maybe_ovl = ovl_make (fn, maybe_ovl);
2352
2353 if (using_or_hidden < 0)
2354 OVL_HIDDEN_P (maybe_ovl)((tree_not_check2 (((tree_check ((maybe_ovl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2354, __FUNCTION__, (OVERLOAD)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2354, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2)
= true;
2355 if (using_or_hidden > 0)
2356 {
2357 OVL_DEDUP_P (maybe_ovl)((tree_not_check2 (((tree_check ((maybe_ovl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2357, __FUNCTION__, (OVERLOAD)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2357, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)
= OVL_USING_P (maybe_ovl)((tree_not_check2 (((tree_check ((maybe_ovl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2357, __FUNCTION__, (OVERLOAD)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2357, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_1)
= true;
2358 if (using_or_hidden > 1)
2359 OVL_EXPORT_P (maybe_ovl)((tree_not_check2 (((tree_check ((maybe_ovl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2359, __FUNCTION__, (OVERLOAD)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2359, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_5)
= true;
2360 }
2361 }
2362 else
2363 maybe_ovl = fn;
2364
2365 if (insert_after)
2366 {
2367 OVL_CHAIN (insert_after)(((struct tree_overload*)(tree_check ((insert_after), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2367, __FUNCTION__, (OVERLOAD))))->common.chain)
= maybe_ovl;
2368 TREE_TYPE (insert_after)((contains_struct_check ((insert_after), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2368, __FUNCTION__))->typed.type)
= unknown_type_nodecp_global_trees[CPTI_UNKNOWN_TYPE];
2369 }
2370 else
2371 result = maybe_ovl;
2372
2373 return result;
2374}
2375
2376/* Skip any hidden names at the beginning of OVL. */
2377
2378tree
2379ovl_skip_hidden (tree ovl)
2380{
2381 while (ovl && TREE_CODE (ovl)((enum tree_code) (ovl)->base.code) == OVERLOAD && OVL_HIDDEN_P (ovl)((tree_not_check2 (((tree_check ((ovl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2381, __FUNCTION__, (OVERLOAD)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2381, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2)
)
2382 ovl = OVL_CHAIN (ovl)(((struct tree_overload*)(tree_check ((ovl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2382, __FUNCTION__, (OVERLOAD))))->common.chain)
;
2383
2384 return ovl;
2385}
2386
2387/* NODE is an OVL_HIDDEN_P node that is now revealed. */
2388
2389tree
2390ovl_iterator::reveal_node (tree overload, tree node)
2391{
2392 /* We cannot have returned NODE as part of a lookup overload, so we
2393 don't have to worry about preserving that. */
2394
2395 OVL_HIDDEN_P (node)((tree_not_check2 (((tree_check ((node), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2395, __FUNCTION__, (OVERLOAD)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2395, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2)
= false;
2396 if (tree chain = OVL_CHAIN (node)(((struct tree_overload*)(tree_check ((node), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2396, __FUNCTION__, (OVERLOAD))))->common.chain)
)
2397 if (TREE_CODE (chain)((enum tree_code) (chain)->base.code) == OVERLOAD)
2398 {
2399 if (OVL_HIDDEN_P (chain)((tree_not_check2 (((tree_check ((chain), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2399, __FUNCTION__, (OVERLOAD)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2399, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2)
)
2400 {
2401 /* The node needs moving, and the simplest way is to remove it
2402 and reinsert. */
2403 overload = remove_node (overload, node);
2404 overload = ovl_insert (OVL_FUNCTION (node)(((struct tree_overload*)(tree_check ((node), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2404, __FUNCTION__, (OVERLOAD))))->function)
, overload);
2405 }
2406 else if (OVL_DEDUP_P (chain)((tree_not_check2 (((tree_check ((chain), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2406, __FUNCTION__, (OVERLOAD)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2406, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)
)
2407 OVL_DEDUP_P (node)((tree_not_check2 (((tree_check ((node), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2407, __FUNCTION__, (OVERLOAD)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2407, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)
= true;
2408 }
2409 return overload;
2410}
2411
2412/* NODE is on the overloads of OVL. Remove it.
2413 The removed node is unaltered and may continue to be iterated
2414 from (i.e. it is safe to remove a node from an overload one is
2415 currently iterating over). */
2416
2417tree
2418ovl_iterator::remove_node (tree overload, tree node)
2419{
2420 tree *slot = &overload;
2421 while (*slot != node)
2422 {
2423 tree probe = *slot;
2424 gcc_checking_assert (!OVL_LOOKUP_P (probe))((void)(!(!((tree_not_check2 (((tree_check ((probe), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2424, __FUNCTION__, (OVERLOAD)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2424, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_4)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2424, __FUNCTION__), 0 : 0))
;
2425
2426 slot = &OVL_CHAIN (probe)(((struct tree_overload*)(tree_check ((probe), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2426, __FUNCTION__, (OVERLOAD))))->common.chain)
;
2427 }
2428
2429 /* Stitch out NODE. We don't have to worry about now making a
2430 singleton overload (and consequently maybe setting its type),
2431 because all uses of this function will be followed by inserting a
2432 new node that must follow the place we've cut this out from. */
2433 if (TREE_CODE (node)((enum tree_code) (node)->base.code) != OVERLOAD)
2434 /* Cloned inherited ctors don't mark themselves as via_using. */
2435 *slot = NULL_TREE(tree) nullptr;
2436 else
2437 *slot = OVL_CHAIN (node)(((struct tree_overload*)(tree_check ((node), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2437, __FUNCTION__, (OVERLOAD))))->common.chain)
;
2438
2439 return overload;
2440}
2441
2442/* Mark or unmark a lookup set. */
2443
2444void
2445lookup_mark (tree ovl, bool val)
2446{
2447 for (lkp_iterator iter (ovl); iter; ++iter)
2448 {
2449 gcc_checking_assert (LOOKUP_SEEN_P (*iter) != val)((void)(!(((*iter)->base.visited) != val) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2449, __FUNCTION__), 0 : 0))
;
2450 LOOKUP_SEEN_P (*iter)((*iter)->base.visited) = val;
2451 }
2452}
2453
2454/* Add a set of new FNS into a lookup. */
2455
2456tree
2457lookup_add (tree fns, tree lookup)
2458{
2459 if (fns == error_mark_nodeglobal_trees[TI_ERROR_MARK] || lookup == error_mark_nodeglobal_trees[TI_ERROR_MARK])
2460 return error_mark_nodeglobal_trees[TI_ERROR_MARK];
2461
2462 if (lookup || TREE_CODE (fns)((enum tree_code) (fns)->base.code) == TEMPLATE_DECL)
2463 {
2464 lookup = ovl_make (fns, lookup);
2465 OVL_LOOKUP_P (lookup)((tree_not_check2 (((tree_check ((lookup), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2465, __FUNCTION__, (OVERLOAD)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2465, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_4)
= true;
2466 }
2467 else
2468 lookup = fns;
2469
2470 return lookup;
2471}
2472
2473/* FNS is a new overload set, add them to LOOKUP, if they are not
2474 already present there. */
2475
2476tree
2477lookup_maybe_add (tree fns, tree lookup, bool deduping)
2478{
2479 if (deduping)
2480 for (tree next, probe = fns; probe; probe = next)
2481 {
2482 tree fn = probe;
2483 next = NULL_TREE(tree) nullptr;
2484
2485 if (TREE_CODE (probe)((enum tree_code) (probe)->base.code) == OVERLOAD)
2486 {
2487 fn = OVL_FUNCTION (probe)(((struct tree_overload*)(tree_check ((probe), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2487, __FUNCTION__, (OVERLOAD))))->function)
;
2488 next = OVL_CHAIN (probe)(((struct tree_overload*)(tree_check ((probe), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2488, __FUNCTION__, (OVERLOAD))))->common.chain)
;
2489 }
2490
2491 if (!LOOKUP_SEEN_P (fn)((fn)->base.visited))
2492 LOOKUP_SEEN_P (fn)((fn)->base.visited) = true;
2493 else
2494 {
2495 /* This function was already seen. Insert all the
2496 predecessors onto the lookup. */
2497 for (; fns != probe; fns = OVL_CHAIN (fns)(((struct tree_overload*)(tree_check ((fns), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2497, __FUNCTION__, (OVERLOAD))))->common.chain)
)
2498 {
2499 lookup = lookup_add (OVL_FUNCTION (fns)(((struct tree_overload*)(tree_check ((fns), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2499, __FUNCTION__, (OVERLOAD))))->function)
, lookup);
2500 /* Propagate OVL_USING, but OVL_HIDDEN &
2501 OVL_DEDUP_P don't matter. */
2502 if (OVL_USING_P (fns)((tree_not_check2 (((tree_check ((fns), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2502, __FUNCTION__, (OVERLOAD)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2502, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_1)
)
2503 OVL_USING_P (lookup)((tree_not_check2 (((tree_check ((lookup), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2503, __FUNCTION__, (OVERLOAD)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2503, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_1)
= true;
2504 }
2505
2506 /* And now skip this function. */
2507 fns = next;
2508 }
2509 }
2510
2511 if (fns)
2512 /* We ended in a set of new functions. Add them all in one go. */
2513 lookup = lookup_add (fns, lookup);
2514
2515 return lookup;
2516}
2517
2518/* Returns nonzero if X is an expression for a (possibly overloaded)
2519 function. If "f" is a function or function template, "f", "c->f",
2520 "c.f", "C::f", and "f<int>" will all be considered possibly
2521 overloaded functions. Returns 2 if the function is actually
2522 overloaded, i.e., if it is impossible to know the type of the
2523 function without performing overload resolution. */
2524
2525int
2526is_overloaded_fn (tree x)
2527{
2528 STRIP_ANY_LOCATION_WRAPPER (x)(x) = tree_strip_any_location_wrapper ((const_cast<union tree_node
*> (((x)))))
;
2529
2530 /* A baselink is also considered an overloaded function. */
2531 if (TREE_CODE (x)((enum tree_code) (x)->base.code) == OFFSET_REF
2532 || TREE_CODE (x)((enum tree_code) (x)->base.code) == COMPONENT_REF)
2533 x = TREE_OPERAND (x, 1)(*((const_cast<tree*> (tree_operand_check ((x), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2533, __FUNCTION__)))))
;
2534 x = MAYBE_BASELINK_FUNCTIONS (x)((((enum tree_code) (x)->base.code) == BASELINK) ? (((struct
tree_baselink*) (tree_check ((x), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2534, __FUNCTION__, (BASELINK))))->functions) : x)
;
2535 if (TREE_CODE (x)((enum tree_code) (x)->base.code) == TEMPLATE_ID_EXPR)
2536 x = TREE_OPERAND (x, 0)(*((const_cast<tree*> (tree_operand_check ((x), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2536, __FUNCTION__)))))
;
2537
2538 if (DECL_FUNCTION_TEMPLATE_P (OVL_FIRST (x))(((enum tree_code) (ovl_first (x))->base.code) == TEMPLATE_DECL
&& ((struct tree_template_decl *)(const_cast<union
tree_node *> ((((tree_check ((ovl_first (x)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2538, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) nullptr && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((ovl_first
(x)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2538, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->
base.code) == FUNCTION_DECL)
2539 || (TREE_CODE (x)((enum tree_code) (x)->base.code) == OVERLOAD && !OVL_SINGLE_P (x)(((enum tree_code) (x)->base.code) != OVERLOAD || !(((struct
tree_overload*)(tree_check ((x), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2539, __FUNCTION__, (OVERLOAD))))->common.chain))
))
2540 return 2;
2541
2542 return OVL_P (x)(((enum tree_code) (x)->base.code) == FUNCTION_DECL || ((enum
tree_code) (x)->base.code) == OVERLOAD)
;
2543}
2544
2545/* X is the CALL_EXPR_FN of a CALL_EXPR. If X represents a dependent name
2546 (14.6.2), return the IDENTIFIER_NODE for that name. Otherwise, return
2547 NULL_TREE. */
2548
2549tree
2550dependent_name (tree x)
2551{
2552 /* FIXME a dependent name must be unqualified, but this function doesn't
2553 distinguish between qualified and unqualified identifiers. */
2554 if (identifier_p (x))
2555 return x;
2556 if (TREE_CODE (x)((enum tree_code) (x)->base.code) == TEMPLATE_ID_EXPR)
2557 x = TREE_OPERAND (x, 0)(*((const_cast<tree*> (tree_operand_check ((x), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2557, __FUNCTION__)))))
;
2558 if (OVL_P (x)(((enum tree_code) (x)->base.code) == FUNCTION_DECL || ((enum
tree_code) (x)->base.code) == OVERLOAD)
)
2559 return OVL_NAME (x)((contains_struct_check ((ovl_first (x)), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2559, __FUNCTION__))->decl_minimal.name)
;
2560 return NULL_TREE(tree) nullptr;
2561}
2562
2563/* Returns true iff X is an expression for an overloaded function
2564 whose type cannot be known without performing overload
2565 resolution. */
2566
2567bool
2568really_overloaded_fn (tree x)
2569{
2570 return is_overloaded_fn (x) == 2;
2571}
2572
2573/* Get the overload set FROM refers to. Returns NULL if it's not an
2574 overload set. */
2575
2576tree
2577maybe_get_fns (tree from)
2578{
2579 STRIP_ANY_LOCATION_WRAPPER (from)(from) = tree_strip_any_location_wrapper ((const_cast<union
tree_node *> (((from)))))
;
2580
2581 /* A baselink is also considered an overloaded function. */
2582 if (TREE_CODE (from)((enum tree_code) (from)->base.code) == OFFSET_REF
2583 || TREE_CODE (from)((enum tree_code) (from)->base.code) == COMPONENT_REF)
2584 from = TREE_OPERAND (from, 1)(*((const_cast<tree*> (tree_operand_check ((from), (1),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2584, __FUNCTION__)))))
;
2585 if (BASELINK_P (from)(((enum tree_code) (from)->base.code) == BASELINK))
2586 from = BASELINK_FUNCTIONS (from)(((struct tree_baselink*) (tree_check ((from), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2586, __FUNCTION__, (BASELINK))))->functions)
;
2587 if (TREE_CODE (from)((enum tree_code) (from)->base.code) == TEMPLATE_ID_EXPR)
2588 from = TREE_OPERAND (from, 0)(*((const_cast<tree*> (tree_operand_check ((from), (0),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2588, __FUNCTION__)))))
;
2589
2590 if (OVL_P (from)(((enum tree_code) (from)->base.code) == FUNCTION_DECL || (
(enum tree_code) (from)->base.code) == OVERLOAD)
)
2591 return from;
2592
2593 return NULLnullptr;
2594}
2595
2596/* FROM refers to an overload set. Return that set (or die). */
2597
2598tree
2599get_fns (tree from)
2600{
2601 tree res = maybe_get_fns (from);
2602
2603 gcc_assert (res)((void)(!(res) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2603, __FUNCTION__), 0 : 0))
;
2604 return res;
2605}
2606
2607/* Return the first function of the overload set FROM refers to. */
2608
2609tree
2610get_first_fn (tree from)
2611{
2612 return OVL_FIRST (get_fns (from))ovl_first (get_fns (from));
2613}
2614
2615/* Return the scope where the overloaded functions OVL were found. */
2616
2617tree
2618ovl_scope (tree ovl)
2619{
2620 if (TREE_CODE (ovl)((enum tree_code) (ovl)->base.code) == OFFSET_REF
2621 || TREE_CODE (ovl)((enum tree_code) (ovl)->base.code) == COMPONENT_REF)
2622 ovl = TREE_OPERAND (ovl, 1)(*((const_cast<tree*> (tree_operand_check ((ovl), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2622, __FUNCTION__)))))
;
2623 if (TREE_CODE (ovl)((enum tree_code) (ovl)->base.code) == BASELINK)
2624 return BINFO_TYPE (BASELINK_BINFO (ovl))((contains_struct_check (((tree_check (((((struct tree_baselink
*) (tree_check ((ovl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2624, __FUNCTION__, (BASELINK))))->binfo)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2624, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2624, __FUNCTION__))->typed.type)
;
2625 if (TREE_CODE (ovl)((enum tree_code) (ovl)->base.code) == TEMPLATE_ID_EXPR)
2626 ovl = TREE_OPERAND (ovl, 0)(*((const_cast<tree*> (tree_operand_check ((ovl), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2626, __FUNCTION__)))))
;
2627 /* Skip using-declarations. */
2628 lkp_iterator iter (ovl);
2629 do
2630 ovl = *iter;
2631 while (iter.using_p () && ++iter);
2632
2633 return CP_DECL_CONTEXT (ovl)(!(! (((contains_struct_check ((ovl), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2633, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((ovl), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2633, __FUNCTION__))->decl_minimal.context))->base.code
) == TRANSLATION_UNIT_DECL) ? ((contains_struct_check ((ovl),
(TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2633, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL])
;
2634}
2635
2636#define PRINT_RING_SIZE4 4
2637
2638static const char *
2639cxx_printable_name_internal (tree decl, int v, bool translate)
2640{
2641 static unsigned int uid_ring[PRINT_RING_SIZE4];
2642 static char *print_ring[PRINT_RING_SIZE4];
2643 static bool trans_ring[PRINT_RING_SIZE4];
2644 static int ring_counter;
2645 int i;
2646
2647 /* Only cache functions. */
2648 if (v < 2
2649 || TREE_CODE (decl)((enum tree_code) (decl)->base.code) != FUNCTION_DECL
2650 || DECL_LANG_SPECIFIC (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2650, __FUNCTION__))->decl_common.lang_specific)
== 0)
2651 return lang_decl_name (decl, v, translate);
2652
2653 /* See if this print name is lying around. */
2654 for (i = 0; i < PRINT_RING_SIZE4; i++)
2655 if (uid_ring[i] == DECL_UID (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2655, __FUNCTION__))->decl_minimal.uid)
&& translate == trans_ring[i])
2656 /* yes, so return it. */
2657 return print_ring[i];
2658
2659 if (++ring_counter == PRINT_RING_SIZE4)
2660 ring_counter = 0;
2661
2662 if (current_function_decl != NULL_TREE(tree) nullptr)
2663 {
2664 /* There may be both translated and untranslated versions of the
2665 name cached. */
2666 for (i = 0; i < 2; i++)
2667 {
2668 if (uid_ring[ring_counter] == DECL_UID (current_function_decl)((contains_struct_check ((current_function_decl), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2668, __FUNCTION__))->decl_minimal.uid)
)
2669 ring_counter += 1;
2670 if (ring_counter == PRINT_RING_SIZE4)
2671 ring_counter = 0;
2672 }
2673 gcc_assert (uid_ring[ring_counter] != DECL_UID (current_function_decl))((void)(!(uid_ring[ring_counter] != ((contains_struct_check (
(current_function_decl), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2673, __FUNCTION__))->decl_minimal.uid)) ? fancy_abort (
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2673, __FUNCTION__), 0 : 0))
;
2674 }
2675
2676 free (print_ring[ring_counter]);
2677
2678 print_ring[ring_counter] = xstrdup (lang_decl_name (decl, v, translate));
2679 uid_ring[ring_counter] = DECL_UID (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2679, __FUNCTION__))->decl_minimal.uid)
;
2680 trans_ring[ring_counter] = translate;
2681 return print_ring[ring_counter];
2682}
2683
2684const char *
2685cxx_printable_name (tree decl, int v)
2686{
2687 return cxx_printable_name_internal (decl, v, false);
2688}
2689
2690const char *
2691cxx_printable_name_translate (tree decl, int v)
2692{
2693 return cxx_printable_name_internal (decl, v, true);
2694}
2695
2696/* Return the canonical version of exception-specification RAISES for a C++17
2697 function type, for use in type comparison and building TYPE_CANONICAL. */
2698
2699tree
2700canonical_eh_spec (tree raises)
2701{
2702 if (raises == NULL_TREE(tree) nullptr)
2703 return raises;
2704 else if (DEFERRED_NOEXCEPT_SPEC_P (raises)((raises) && (((tree_check ((raises), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2704, __FUNCTION__, (TREE_LIST)))->list.purpose)) &&
(((enum tree_code) (((tree_check ((raises), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2704, __FUNCTION__, (TREE_LIST)))->list.purpose))->base
.code) == DEFERRED_NOEXCEPT))
2705 || UNPARSED_NOEXCEPT_SPEC_P (raises)((raises) && (((tree_check ((raises), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2705, __FUNCTION__, (TREE_LIST)))->list.purpose)) &&
(((enum tree_code) (((tree_check ((raises), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2705, __FUNCTION__, (TREE_LIST)))->list.purpose))->base
.code) == DEFERRED_PARSE))
2706 || uses_template_parms (raises)
2707 || uses_template_parms (TREE_PURPOSE (raises)((tree_check ((raises), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2707, __FUNCTION__, (TREE_LIST)))->list.purpose)
))
2708 /* Keep a dependent or deferred exception specification. */
2709 return raises;
2710 else if (nothrow_spec_p (raises))
2711 /* throw() -> noexcept. */
2712 return noexcept_true_speccp_global_trees[CPTI_NOEXCEPT_TRUE_SPEC];
2713 else
2714 /* For C++17 type matching, anything else -> nothing. */
2715 return NULL_TREE(tree) nullptr;
2716}
2717
2718tree
2719build_cp_fntype_variant (tree type, cp_ref_qualifier rqual,
2720 tree raises, bool late)
2721{
2722 cp_cv_quals type_quals = TYPE_QUALS (type)((int) ((((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2722, __FUNCTION__))->base.readonly_flag) * TYPE_QUAL_CONST
) | (((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2722, __FUNCTION__))->base.volatile_flag) * TYPE_QUAL_VOLATILE
) | (((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2722, __FUNCTION__))->base.u.bits.atomic_flag) * TYPE_QUAL_ATOMIC
) | (((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2722, __FUNCTION__))->type_common.restrict_flag) * TYPE_QUAL_RESTRICT
) | (((((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2722, __FUNCTION__))->base.u.bits.address_space) & 0xFF
) << 8))))
;
2723
2724 if (cp_check_qualified_type (type, type, type_quals, rqual, raises, late))
2725 return type;
2726
2727 tree v = TYPE_MAIN_VARIANT (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2727, __FUNCTION__))->type_common.main_variant)
;
2728 for (; v; v = TYPE_NEXT_VARIANT (v)((tree_class_check ((v), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2728, __FUNCTION__))->type_common.next_variant)
)
2729 if (cp_check_qualified_type (v, type, type_quals, rqual, raises, late))
2730 return v;
2731
2732 /* Need to build a new variant. */
2733 v = build_variant_type_copy (type);
2734 if (!TYPE_DEPENDENT_P (v)((tree_class_check ((v), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2734, __FUNCTION__))->type_common.lang_flag_0)
)
2735 /* We no longer know that it's not type-dependent. */
2736 TYPE_DEPENDENT_P_VALID (v)((tree_class_check ((v), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2736, __FUNCTION__))->type_common.lang_flag_6)
= false;
2737 TYPE_RAISES_EXCEPTIONS (v)((tree_class_check (((tree_check2 ((v), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2737, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2737, __FUNCTION__))->type_non_common.lang_1)
= raises;
2738 TYPE_HAS_LATE_RETURN_TYPE (v)(((tree_class_check (((tree_check2 ((v), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2738, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2738, __FUNCTION__))->type_common.lang_flag_2))
= late;
2739 switch (rqual)
2740 {
2741 case REF_QUAL_RVALUE:
2742 FUNCTION_RVALUE_QUALIFIED (v)((tree_not_check2 (((tree_check2 ((v), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2742, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2742, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_5)
= 1;
2743 FUNCTION_REF_QUALIFIED (v)((tree_not_check2 (((tree_check2 ((v), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2743, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2743, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_4)
= 1;
2744 break;
2745 case REF_QUAL_LVALUE:
2746 FUNCTION_RVALUE_QUALIFIED (v)((tree_not_check2 (((tree_check2 ((v), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2746, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2746, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_5)
= 0;
2747 FUNCTION_REF_QUALIFIED (v)((tree_not_check2 (((tree_check2 ((v), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2747, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2747, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_4)
= 1;
2748 break;
2749 default:
2750 FUNCTION_REF_QUALIFIED (v)((tree_not_check2 (((tree_check2 ((v), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2750, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2750, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_4)
= 0;
2751 break;
2752 }
2753
2754 /* Canonicalize the exception specification. */
2755 tree cr = flag_noexcept_type ? canonical_eh_spec (raises) : NULL_TREE(tree) nullptr;
2756
2757 if (TYPE_STRUCTURAL_EQUALITY_P (type)(((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2757, __FUNCTION__))->type_common.canonical) == (tree) nullptr
)
)
2758 /* Propagate structural equality. */
2759 SET_TYPE_STRUCTURAL_EQUALITY (v)(((tree_class_check ((v), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2759, __FUNCTION__))->type_common.canonical) = (tree) nullptr
)
;
2760 else if (TYPE_CANONICAL (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2760, __FUNCTION__))->type_common.canonical)
!= type || cr != raises || late)
2761 /* Build the underlying canonical type, since it is different
2762 from TYPE. */
2763 TYPE_CANONICAL (v)((tree_class_check ((v), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2763, __FUNCTION__))->type_common.canonical)
= build_cp_fntype_variant (TYPE_CANONICAL (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2763, __FUNCTION__))->type_common.canonical)
,
2764 rqual, cr, false);
2765 else
2766 /* T is its own canonical type. */
2767 TYPE_CANONICAL (v)((tree_class_check ((v), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2767, __FUNCTION__))->type_common.canonical)
= v;
2768
2769 return v;
2770}
2771
2772/* TYPE is a function or method type with a deferred exception
2773 specification that has been parsed to RAISES. Fixup all the type
2774 variants that are affected in place. Via decltype &| noexcept
2775 tricks, the unparsed spec could have escaped into the type system.
2776 The general case is hard to fixup canonical types for. */
2777
2778void
2779fixup_deferred_exception_variants (tree type, tree raises)
2780{
2781 tree original = TYPE_RAISES_EXCEPTIONS (type)((tree_class_check (((tree_check2 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2781, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2781, __FUNCTION__))->type_non_common.lang_1)
;
2782 tree cr = flag_noexcept_type ? canonical_eh_spec (raises) : NULL_TREE(tree) nullptr;
2783
2784 gcc_checking_assert (UNPARSED_NOEXCEPT_SPEC_P (original))((void)(!(((original) && (((tree_check ((original), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2784, __FUNCTION__, (TREE_LIST)))->list.purpose)) &&
(((enum tree_code) (((tree_check ((original), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2784, __FUNCTION__, (TREE_LIST)))->list.purpose))->base
.code) == DEFERRED_PARSE))) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2784, __FUNCTION__), 0 : 0))
;
2785
2786 /* Though sucky, this walk will process the canonical variants
2787 first. */
2788 for (tree variant = TYPE_MAIN_VARIANT (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2788, __FUNCTION__))->type_common.main_variant)
;
2789 variant; variant = TYPE_NEXT_VARIANT (variant)((tree_class_check ((variant), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2789, __FUNCTION__))->type_common.next_variant)
)
2790 if (TYPE_RAISES_EXCEPTIONS (variant)((tree_class_check (((tree_check2 ((variant), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2790, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2790, __FUNCTION__))->type_non_common.lang_1)
== original)
2791 {
2792 gcc_checking_assert (variant != TYPE_MAIN_VARIANT (type))((void)(!(variant != ((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2792, __FUNCTION__))->type_common.main_variant)) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2792, __FUNCTION__), 0 : 0))
;
2793
2794 if (!TYPE_STRUCTURAL_EQUALITY_P (variant)(((tree_class_check ((variant), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2794, __FUNCTION__))->type_common.canonical) == (tree) nullptr
)
)
2795 {
2796 cp_cv_quals var_quals = TYPE_QUALS (variant)((int) ((((tree_class_check ((variant), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2796, __FUNCTION__))->base.readonly_flag) * TYPE_QUAL_CONST
) | (((tree_class_check ((variant), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2796, __FUNCTION__))->base.volatile_flag) * TYPE_QUAL_VOLATILE
) | (((tree_class_check ((variant), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2796, __FUNCTION__))->base.u.bits.atomic_flag) * TYPE_QUAL_ATOMIC
) | (((tree_class_check ((variant), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2796, __FUNCTION__))->type_common.restrict_flag) * TYPE_QUAL_RESTRICT
) | (((((tree_class_check ((variant), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2796, __FUNCTION__))->base.u.bits.address_space) & 0xFF
) << 8))))
;
2797 cp_ref_qualifier rqual = type_memfn_rqual (variant);
2798
2799 tree v = TYPE_MAIN_VARIANT (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2799, __FUNCTION__))->type_common.main_variant)
;
2800 for (; v; v = TYPE_NEXT_VARIANT (v)((tree_class_check ((v), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2800, __FUNCTION__))->type_common.next_variant)
)
2801 if (TYPE_CANONICAL (v)((tree_class_check ((v), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2801, __FUNCTION__))->type_common.canonical)
== v
2802 && cp_check_qualified_type (v, variant, var_quals,
2803 rqual, cr, false))
2804 break;
2805 TYPE_RAISES_EXCEPTIONS (variant)((tree_class_check (((tree_check2 ((variant), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2805, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2805, __FUNCTION__))->type_non_common.lang_1)
= raises;
2806
2807 if (!v)
2808 v = build_cp_fntype_variant (TYPE_CANONICAL (variant)((tree_class_check ((variant), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2808, __FUNCTION__))->type_common.canonical)
,
2809 rqual, cr, false);
2810 TYPE_CANONICAL (variant)((tree_class_check ((variant), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2810, __FUNCTION__))->type_common.canonical)
= v;
2811 }
2812 else
2813 TYPE_RAISES_EXCEPTIONS (variant)((tree_class_check (((tree_check2 ((variant), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2813, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2813, __FUNCTION__))->type_non_common.lang_1)
= raises;
2814 }
2815}
2816
2817/* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
2818 listed in RAISES. */
2819
2820tree
2821build_exception_variant (tree type, tree raises)
2822{
2823 cp_ref_qualifier rqual = type_memfn_rqual (type);
2824 bool late = TYPE_HAS_LATE_RETURN_TYPE (type)(((tree_class_check (((tree_check2 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2824, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2824, __FUNCTION__))->type_common.lang_flag_2))
;
2825 return build_cp_fntype_variant (type, rqual, raises, late);
2826}
2827
2828/* Given a TEMPLATE_TEMPLATE_PARM node T, create a new
2829 BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template
2830 arguments. */
2831
2832tree
2833bind_template_template_parm (tree t, tree newargs)
2834{
2835 tree decl = TYPE_NAME (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2835, __FUNCTION__))->type_common.name)
;
2836 tree t2;
2837
2838 t2 = cxx_make_type (BOUND_TEMPLATE_TEMPLATE_PARM);
2839 decl = build_decl (input_location,
2840 TYPE_DECL, DECL_NAME (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2840, __FUNCTION__))->decl_minimal.name)
, NULL_TREE(tree) nullptr);
2841 SET_DECL_TEMPLATE_PARM_P (decl)(((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2841, __FUNCTION__))->decl_common.lang_flag_0) = 1)
;
2842
2843 /* These nodes have to be created to reflect new TYPE_DECL and template
2844 arguments. */
2845 TEMPLATE_TYPE_PARM_INDEX (t2)(((tree_class_check (((tree_check3 (((t2)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2845, __FUNCTION__, (TEMPLATE_TYPE_PARM), (TEMPLATE_TEMPLATE_PARM
), (BOUND_TEMPLATE_TEMPLATE_PARM)))), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2845, __FUNCTION__))->type_non_common.values))
= copy_node (TEMPLATE_TYPE_PARM_INDEX (t)(((tree_class_check (((tree_check3 (((t)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2845, __FUNCTION__, (TEMPLATE_TYPE_PARM), (TEMPLATE_TEMPLATE_PARM
), (BOUND_TEMPLATE_TEMPLATE_PARM)))), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2845, __FUNCTION__))->type_non_common.values))
);
2846 TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2))(((template_parm_index*)(tree_check (((((tree_class_check (((
tree_check3 (((t2)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2846, __FUNCTION__, (TEMPLATE_TYPE_PARM), (TEMPLATE_TEMPLATE_PARM
), (BOUND_TEMPLATE_TEMPLATE_PARM)))), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2846, __FUNCTION__))->type_non_common.values))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2846, __FUNCTION__, (TEMPLATE_PARM_INDEX))))->decl)
= decl;
2847 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2)(((tree_class_check (((tree_check ((t2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2847, __FUNCTION__, (BOUND_TEMPLATE_TEMPLATE_PARM)))), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2847, __FUNCTION__))->type_non_common.lang_1))
2848 = build_template_info (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t)((((enum tree_code) (t)->base.code) == BOUND_TEMPLATE_TEMPLATE_PARM
) ? (((struct tree_template_info*)(tree_check (((((enum tree_code
) (t)->base.code) == ENUMERAL_TYPE || ((enum tree_code) (t
)->base.code) == BOUND_TEMPLATE_TEMPLATE_PARM || (((enum tree_code
) (t)->base.code) == RECORD_TYPE || ((enum tree_code) (t)->
base.code) == UNION_TYPE || ((enum tree_code) (t)->base.code
) == QUAL_UNION_TYPE) ? ((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2848, __FUNCTION__))->type_non_common.lang_1) : (tree) nullptr
)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2848, __FUNCTION__, (TEMPLATE_INFO))))->tmpl) : ((tree_class_check
((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2848, __FUNCTION__))->type_common.name))
, newargs);
2849
2850 TREE_TYPE (decl)((contains_struct_check ((decl), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2850, __FUNCTION__))->typed.type)
= t2;
2851 TYPE_NAME (t2)((tree_class_check ((t2), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2851, __FUNCTION__))->type_common.name)
= decl;
2852 TYPE_STUB_DECL (t2)(((contains_struct_check (((tree_class_check ((t2), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2852, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2852, __FUNCTION__))->common.chain))
= decl;
2853 TYPE_SIZE (t2)((tree_class_check ((t2), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2853, __FUNCTION__))->type_common.size)
= 0;
2854 SET_TYPE_STRUCTURAL_EQUALITY (t2)(((tree_class_check ((t2), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2854, __FUNCTION__))->type_common.canonical) = (tree) nullptr
)
;
2855
2856 return t2;
2857}
2858
2859/* Called from count_trees via walk_tree. */
2860
2861static tree
2862count_trees_r (tree *tp, int *walk_subtrees, void *data)
2863{
2864 ++*((int *) data);
2865
2866 if (TYPE_P (*tp)(tree_code_type[(int) (((enum tree_code) (*tp)->base.code)
)] == tcc_type)
)
2867 *walk_subtrees = 0;
2868
2869 return NULL_TREE(tree) nullptr;
2870}
2871
2872/* Debugging function for measuring the rough complexity of a tree
2873 representation. */
2874
2875int
2876count_trees (tree t)
2877{
2878 int n_trees = 0;
2879 cp_walk_tree_without_duplicates (&t, count_trees_r, &n_trees)walk_tree_without_duplicates_1 (&t, count_trees_r, &n_trees
, cp_walk_subtrees)
;
2880 return n_trees;
2881}
2882
2883/* Called from verify_stmt_tree via walk_tree. */
2884
2885static tree
2886verify_stmt_tree_r (tree* tp, int * /*walk_subtrees*/, void* data)
2887{
2888 tree t = *tp;
2889 hash_table<nofree_ptr_hash <tree_node> > *statements
2890 = static_cast <hash_table<nofree_ptr_hash <tree_node> > *> (data);
2891 tree_node **slot;
2892
2893 if (!STATEMENT_CODE_P (TREE_CODE (t))statement_code_p[(int) (((enum tree_code) (t)->base.code))
]
)
2894 return NULL_TREE(tree) nullptr;
2895
2896 /* If this statement is already present in the hash table, then
2897 there is a circularity in the statement tree. */
2898 gcc_assert (!statements->find (t))((void)(!(!statements->find (t)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2898, __FUNCTION__), 0 : 0))
;
2899
2900 slot = statements->find_slot (t, INSERT);
2901 *slot = t;
2902
2903 return NULL_TREE(tree) nullptr;
2904}
2905
2906/* Debugging function to check that the statement T has not been
2907 corrupted. For now, this function simply checks that T contains no
2908 circularities. */
2909
2910void
2911verify_stmt_tree (tree t)
2912{
2913 hash_table<nofree_ptr_hash <tree_node> > statements (37);
2914 cp_walk_tree (&t, verify_stmt_tree_r, &statements, NULL)walk_tree_1 (&t, verify_stmt_tree_r, &statements, nullptr
, cp_walk_subtrees)
;
2915}
2916
2917/* Check if the type T depends on a type with no linkage and if so,
2918 return it. If RELAXED_P then do not consider a class type declared
2919 within a vague-linkage function to have no linkage. Remember:
2920 no-linkage is not the same as internal-linkage*/
2921
2922tree
2923no_linkage_check (tree t, bool relaxed_p)
2924{
2925 tree r;
2926
2927 /* Lambda types that don't have mangling scope have no linkage. We
2928 check CLASSTYPE_LAMBDA_EXPR for error_mark_node because
2929 when we get here from pushtag none of the lambda information is
2930 set up yet, so we want to assume that the lambda has linkage and
2931 fix it up later if not. We need to check this even in templates so
2932 that we properly handle a lambda-expression in the signature. */
2933 if (LAMBDA_TYPE_P (t)(((enum tree_code) (t)->base.code) == RECORD_TYPE &&
((((tree_class_check ((((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2933, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2933, __FUNCTION__))->type_common.name) && (tree_code_type
[(int) (((enum tree_code) (((tree_class_check ((((tree_class_check
((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2933, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2933, __FUNCTION__))->type_common.name))->base.code))
] == tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2933, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2933, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2933, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2933, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2933, __FUNCTION__))->type_common.name))) && ((tree_check
((((((tree_class_check ((((tree_class_check ((t), (tcc_type)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2933, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2933, __FUNCTION__))->type_common.name) && (tree_code_type
[(int) (((enum tree_code) (((tree_class_check ((((tree_class_check
((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2933, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2933, __FUNCTION__))->type_common.name))->base.code))
] == tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2933, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2933, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2933, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2933, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2933, __FUNCTION__))->type_common.name)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2933, __FUNCTION__, (IDENTIFIER_NODE)))->base.protected_flag
))
2934 && CLASSTYPE_LAMBDA_EXPR (t)((((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2934, __FUNCTION__))->type_with_lang_specific.lang_specific
))->lambda_expr)
!= error_mark_nodeglobal_trees[TI_ERROR_MARK])
2935 {
2936 tree extra = LAMBDA_TYPE_EXTRA_SCOPE (t)((((struct tree_lambda_expr *)(tree_check ((((((tree_class_check
((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2936, __FUNCTION__))->type_with_lang_specific.lang_specific
))->lambda_expr)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2936, __FUNCTION__, (LAMBDA_EXPR))))->extra_scope))
;
2937 if (!extra)
2938 return t;
2939 }
2940
2941 /* Otherwise there's no point in checking linkage on template functions; we
2942 can't know their complete types. */
2943 if (processing_template_declscope_chain->x_processing_template_decl)
2944 return NULL_TREE(tree) nullptr;
2945
2946 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
2947 {
2948 case RECORD_TYPE:
2949 if (TYPE_PTRMEMFUNC_P (t)(((enum tree_code) (t)->base.code) == RECORD_TYPE &&
(((tree_class_check (((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2949, __FUNCTION__, (RECORD_TYPE)))), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2949, __FUNCTION__))->type_common.lang_flag_2)))
)
2950 goto ptrmem;
2951 /* Fall through. */
2952 case UNION_TYPE:
2953 if (!CLASS_TYPE_P (t)(((((enum tree_code) (t)->base.code)) == RECORD_TYPE || ((
(enum tree_code) (t)->base.code)) == UNION_TYPE) &&
((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2953, __FUNCTION__))->type_common.lang_flag_5))
)
2954 return NULL_TREE(tree) nullptr;
2955 /* Fall through. */
2956 case ENUMERAL_TYPE:
2957 /* Only treat unnamed types as having no linkage if they're at
2958 namespace scope. This is core issue 966. */
2959 if (TYPE_UNNAMED_P (t)((((((tree_class_check ((((tree_class_check ((t), (tcc_type),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2959, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2959, __FUNCTION__))->type_common.name) && (tree_code_type
[(int) (((enum tree_code) (((tree_class_check ((((tree_class_check
((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2959, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2959, __FUNCTION__))->type_common.name))->base.code))
] == tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2959, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2959, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2959, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2959, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2959, __FUNCTION__))->type_common.name))) && ((tree_check
((((((tree_class_check ((((tree_class_check ((t), (tcc_type)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2959, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2959, __FUNCTION__))->type_common.name) && (tree_code_type
[(int) (((enum tree_code) (((tree_class_check ((((tree_class_check
((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2959, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2959, __FUNCTION__))->type_common.name))->base.code))
] == tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2959, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2959, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2959, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2959, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2959, __FUNCTION__))->type_common.name)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2959, __FUNCTION__, (IDENTIFIER_NODE)))->base.private_flag
)) && !((tree_check ((((((tree_class_check ((((tree_class_check
((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2959, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2959, __FUNCTION__))->type_common.name) && (tree_code_type
[(int) (((enum tree_code) (((tree_class_check ((((tree_class_check
((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2959, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2959, __FUNCTION__))->type_common.name))->base.code))
] == tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2959, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2959, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2959, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2959, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2959, __FUNCTION__))->type_common.name)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2959, __FUNCTION__, (IDENTIFIER_NODE)))->base.protected_flag
))
&& TYPE_NAMESPACE_SCOPE_P (t)(((enum tree_code) ((!(! (((tree_class_check ((t), (tcc_type)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2959, __FUNCTION__))->type_common.context)) || ((enum tree_code
) (((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2959, __FUNCTION__))->type_common.context))->base.code
) == TRANSLATION_UNIT_DECL) ? ((tree_class_check ((t), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2959, __FUNCTION__))->type_common.context) : cp_global_trees
[CPTI_GLOBAL]))->base.code) == NAMESPACE_DECL)
)
2960 return t;
2961
2962 for (r = CP_TYPE_CONTEXT (t)(!(! (((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2962, __FUNCTION__))->type_common.context)) || ((enum tree_code
) (((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2962, __FUNCTION__))->type_common.context))->base.code
) == TRANSLATION_UNIT_DECL) ? ((tree_class_check ((t), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2962, __FUNCTION__))->type_common.context) : cp_global_trees
[CPTI_GLOBAL])
; ; )
2963 {
2964 /* If we're a nested type of a !TREE_PUBLIC class, we might not
2965 have linkage, or we might just be in an anonymous namespace.
2966 If we're in a TREE_PUBLIC class, we have linkage. */
2967 if (TYPE_P (r)(tree_code_type[(int) (((enum tree_code) (r)->base.code))]
== tcc_type)
&& !TREE_PUBLIC (TYPE_NAME (r))((((tree_class_check ((r), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2967, __FUNCTION__))->type_common.name))->base.public_flag
)
)
2968 return no_linkage_check (TYPE_CONTEXT (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2968, __FUNCTION__))->type_common.context)
, relaxed_p);
2969 else if (TREE_CODE (r)((enum tree_code) (r)->base.code) == FUNCTION_DECL)
2970 {
2971 if (!relaxed_p || !vague_linkage_p (r))
2972 return t;
2973 else
2974 r = CP_DECL_CONTEXT (r)(!(! (((contains_struct_check ((r), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2974, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((r), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2974, __FUNCTION__))->decl_minimal.context))->base.code
) == TRANSLATION_UNIT_DECL) ? ((contains_struct_check ((r), (
TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2974, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL])
;
2975 }
2976 else
2977 break;
2978 }
2979
2980 return NULL_TREE(tree) nullptr;
2981
2982 case ARRAY_TYPE:
2983 case POINTER_TYPE:
2984 case REFERENCE_TYPE:
2985 case VECTOR_TYPE:
2986 return no_linkage_check (TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2986, __FUNCTION__))->typed.type)
, relaxed_p);
2987
2988 case OFFSET_TYPE:
2989 ptrmem:
2990 r = no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t)((((enum tree_code) (t)->base.code) == OFFSET_TYPE) ? ((contains_struct_check
((t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2990, __FUNCTION__))->typed.type) : ((contains_struct_check
(((cp_build_qualified_type_real ((((contains_struct_check ((
((tree_check3 ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2990, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values)), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2990, __FUNCTION__))->typed.type)), (cp_type_quals (t)),
tf_warning_or_error))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2990, __FUNCTION__))->typed.type))
,
2991 relaxed_p);
2992 if (r)
2993 return r;
2994 return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t)((((enum tree_code) (t)->base.code) == OFFSET_TYPE) ? ((tree_check
((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2994, __FUNCTION__, (OFFSET_TYPE)))->type_non_common.maxval
) : ((tree_check2 ((((contains_struct_check (((cp_build_qualified_type_real
((((contains_struct_check ((((tree_check3 ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2994, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values)), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2994, __FUNCTION__))->typed.type)), (cp_type_quals (t)),
tf_warning_or_error))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2994, __FUNCTION__))->typed.type)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2994, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))->type_non_common
.maxval))
, relaxed_p);
2995
2996 case METHOD_TYPE:
2997 case FUNCTION_TYPE:
2998 {
2999 tree parm = TYPE_ARG_TYPES (t)((tree_check2 ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 2999, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))->type_non_common
.values)
;
3000 if (TREE_CODE (t)((enum tree_code) (t)->base.code) == METHOD_TYPE)
3001 /* The 'this' pointer isn't interesting; a method has the same
3002 linkage (or lack thereof) as its enclosing class. */
3003 parm = TREE_CHAIN (parm)((contains_struct_check ((parm), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3003, __FUNCTION__))->common.chain)
;
3004 for (;
3005 parm && parm != void_list_nodeglobal_trees[TI_VOID_LIST_NODE];
3006 parm = TREE_CHAIN (parm)((contains_struct_check ((parm), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3006, __FUNCTION__))->common.chain)
)
3007 {
3008 r = no_linkage_check (TREE_VALUE (parm)((tree_check ((parm), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3008, __FUNCTION__, (TREE_LIST)))->list.value)
, relaxed_p);
3009 if (r)
3010 return r;
3011 }
3012 return no_linkage_check (TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3012, __FUNCTION__))->typed.type)
, relaxed_p);
3013 }
3014
3015 default:
3016 return NULL_TREE(tree) nullptr;
3017 }
3018}
3019
3020extern int depth_reached;
3021
3022void
3023cxx_print_statistics (void)
3024{
3025 print_template_statistics ();
3026 if (GATHER_STATISTICS0)
3027 fprintf (stderrstderr, "maximum template instantiation depth reached: %d\n",
3028 depth_reached);
3029}
3030
3031/* Return, as an INTEGER_CST node, the number of elements for TYPE
3032 (which is an ARRAY_TYPE). This counts only elements of the top
3033 array. */
3034
3035tree
3036array_type_nelts_top (tree type)
3037{
3038 return fold_build2_loc (input_location,
3039 PLUS_EXPR, sizetypesizetype_tab[(int) stk_sizetype],
3040 array_type_nelts (type),
3041 size_one_nodeglobal_trees[TI_SIZE_ONE]);
3042}
3043
3044/* Return, as an INTEGER_CST node, the number of elements for TYPE
3045 (which is an ARRAY_TYPE). This one is a recursive count of all
3046 ARRAY_TYPEs that are clumped together. */
3047
3048tree
3049array_type_nelts_total (tree type)
3050{
3051 tree sz = array_type_nelts_top (type);
3052 type = TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3052, __FUNCTION__))->typed.type)
;
3053 while (TREE_CODE (type)((enum tree_code) (type)->base.code) == ARRAY_TYPE)
3054 {
3055 tree n = array_type_nelts_top (type);
3056 sz = fold_build2_loc (input_location,
3057 MULT_EXPR, sizetypesizetype_tab[(int) stk_sizetype], sz, n);
3058 type = TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3058, __FUNCTION__))->typed.type)
;
3059 }
3060 return sz;
3061}
3062
3063/* Return true if FNDECL is std::source_location::current () method. */
3064
3065bool
3066source_location_current_p (tree fndecl)
3067{
3068 gcc_checking_assert (TREE_CODE (fndecl) == FUNCTION_DECL((void)(!(((enum tree_code) (fndecl)->base.code) == FUNCTION_DECL
&& (((contains_struct_check (((tree_check (((((enum tree_code
) (fndecl)->base.code) == TEMPLATE_DECL ? ((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((fndecl
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3069, __FUNCTION__, (TEMPLATE_DECL))))))))->result : fndecl
)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3069, __FUNCTION__, (FUNCTION_DECL)))), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3069, __FUNCTION__))->decl_common.lang_specific) ? __extension__
({ struct lang_decl *lt = ((contains_struct_check (((((enum tree_code
) (fndecl)->base.code) == TEMPLATE_DECL ? ((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((fndecl
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3069, __FUNCTION__, (TEMPLATE_DECL))))))))->result : fndecl
)), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3069, __FUNCTION__))->decl_common.lang_specific); if (!(
((enum tree_code) (fndecl)->base.code) == FUNCTION_DECL ||
(((enum tree_code) (fndecl)->base.code) == TEMPLATE_DECL &&
((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((fndecl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3069, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) nullptr && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((fndecl
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3069, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->
base.code) == FUNCTION_DECL)) || lt->u.base.selector != lds_fn
) lang_check_failed ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3069, __FUNCTION__); &lt->u.fn; })->immediate_fn_p
: false)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3069, __FUNCTION__), 0 : 0))
3069 && DECL_IMMEDIATE_FUNCTION_P (fndecl))((void)(!(((enum tree_code) (fndecl)->base.code) == FUNCTION_DECL
&& (((contains_struct_check (((tree_check (((((enum tree_code
) (fndecl)->base.code) == TEMPLATE_DECL ? ((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((fndecl
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3069, __FUNCTION__, (TEMPLATE_DECL))))))))->result : fndecl
)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3069, __FUNCTION__, (FUNCTION_DECL)))), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3069, __FUNCTION__))->decl_common.lang_specific) ? __extension__
({ struct lang_decl *lt = ((contains_struct_check (((((enum tree_code
) (fndecl)->base.code) == TEMPLATE_DECL ? ((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((fndecl
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3069, __FUNCTION__, (TEMPLATE_DECL))))))))->result : fndecl
)), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3069, __FUNCTION__))->decl_common.lang_specific); if (!(
((enum tree_code) (fndecl)->base.code) == FUNCTION_DECL ||
(((enum tree_code) (fndecl)->base.code) == TEMPLATE_DECL &&
((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((fndecl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3069, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) nullptr && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((fndecl
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3069, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->
base.code) == FUNCTION_DECL)) || lt->u.base.selector != lds_fn
) lang_check_failed ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3069, __FUNCTION__); &lt->u.fn; })->immediate_fn_p
: false)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3069, __FUNCTION__), 0 : 0))
;
3070 if (DECL_NAME (fndecl)((contains_struct_check ((fndecl), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3070, __FUNCTION__))->decl_minimal.name)
== NULL_TREE(tree) nullptr
3071 || TREE_CODE (TREE_TYPE (fndecl))((enum tree_code) (((contains_struct_check ((fndecl), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3071, __FUNCTION__))->typed.type))->base.code)
!= FUNCTION_TYPE
3072 || TREE_CODE (TREE_TYPE (TREE_TYPE (fndecl)))((enum tree_code) (((contains_struct_check ((((contains_struct_check
((fndecl), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3072, __FUNCTION__))->typed.type)), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3072, __FUNCTION__))->typed.type))->base.code)
!= RECORD_TYPE
3073 || DECL_CONTEXT (fndecl)((contains_struct_check ((fndecl), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3073, __FUNCTION__))->decl_minimal.context)
!= TREE_TYPE (TREE_TYPE (fndecl))((contains_struct_check ((((contains_struct_check ((fndecl), (
TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3073, __FUNCTION__))->typed.type)), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3073, __FUNCTION__))->typed.type)
3074 || !id_equal (DECL_NAME (fndecl)((contains_struct_check ((fndecl), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3074, __FUNCTION__))->decl_minimal.name)
, "current"))
3075 return false;
3076
3077 tree source_location = DECL_CONTEXT (fndecl)((contains_struct_check ((fndecl), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3077, __FUNCTION__))->decl_minimal.context)
;
3078 if (TYPE_NAME (source_location)((tree_class_check ((source_location), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3078, __FUNCTION__))->type_common.name)
== NULL_TREE(tree) nullptr
3079 || TREE_CODE (TYPE_NAME (source_location))((enum tree_code) (((tree_class_check ((source_location), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3079, __FUNCTION__))->type_common.name))->base.code)
!= TYPE_DECL
3080 || TYPE_IDENTIFIER (source_location)(((tree_class_check ((source_location), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3080, __FUNCTION__))->type_common.name) && (tree_code_type
[(int) (((enum tree_code) (((tree_class_check ((source_location
), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3080, __FUNCTION__))->type_common.name))->base.code))
] == tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((source_location), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3080, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3080, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((source_location), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3080, __FUNCTION__))->type_common.name))
== NULL_TREE(tree) nullptr
3081 || !id_equal (TYPE_IDENTIFIER (source_location)(((tree_class_check ((source_location), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3081, __FUNCTION__))->type_common.name) && (tree_code_type
[(int) (((enum tree_code) (((tree_class_check ((source_location
), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3081, __FUNCTION__))->type_common.name))->base.code))
] == tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((source_location), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3081, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3081, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((source_location), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3081, __FUNCTION__))->type_common.name))
,
3082 "source_location")
3083 || !decl_in_std_namespace_p (TYPE_NAME (source_location)((tree_class_check ((source_location), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3083, __FUNCTION__))->type_common.name)
))
3084 return false;
3085
3086 return true;
3087}
3088
3089struct bot_data
3090{
3091 splay_tree target_remap;
3092 bool clear_location;
3093};
3094
3095/* Called from break_out_target_exprs via mapcar. */
3096
3097static tree
3098bot_manip (tree* tp, int* walk_subtrees, void* data_)
3099{
3100 bot_data &data = *(bot_data*)data_;
3101 splay_tree target_remap = data.target_remap;
3102 tree t = *tp;
3103
3104 if (!TYPE_P (t)(tree_code_type[(int) (((enum tree_code) (t)->base.code))]
== tcc_type)
&& TREE_CONSTANT (t)((non_type_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3104, __FUNCTION__))->base.constant_flag)
&& !TREE_SIDE_EFFECTS (t)((non_type_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3104, __FUNCTION__))->base.side_effects_flag)
)
3105 {
3106 /* There can't be any TARGET_EXPRs or their slot variables below this
3107 point. But we must make a copy, in case subsequent processing
3108 alters any part of it. For example, during gimplification a cast
3109 of the form (T) &X::f (where "f" is a member function) will lead
3110 to replacing the PTRMEM_CST for &X::f with a VAR_DECL. */
3111 *walk_subtrees = 0;
3112 *tp = unshare_expr (t);
3113 return NULL_TREE(tree) nullptr;
3114 }
3115 if (TREE_CODE (t)((enum tree_code) (t)->base.code) == TARGET_EXPR)
3116 {
3117 tree u;
3118
3119 if (TREE_CODE (TREE_OPERAND (t, 1))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
((t), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3119, __FUNCTION__))))))->base.code)
== AGGR_INIT_EXPR)
3120 {
3121 u = build_cplus_new (TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3121, __FUNCTION__))->typed.type)
, TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3121, __FUNCTION__)))))
,
3122 tf_warning_or_error);
3123 if (u == error_mark_nodeglobal_trees[TI_ERROR_MARK])
3124 return u;
3125 if (AGGR_INIT_ZERO_FIRST (TREE_OPERAND (t, 1))((tree_not_check2 (((tree_check (((*((const_cast<tree*>
(tree_operand_check ((t), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3125, __FUNCTION__)))))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3125, __FUNCTION__, (AGGR_INIT_EXPR)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3125, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2)
)
3126 AGGR_INIT_ZERO_FIRST (TREE_OPERAND (u, 1))((tree_not_check2 (((tree_check (((*((const_cast<tree*>
(tree_operand_check ((u), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3126, __FUNCTION__)))))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3126, __FUNCTION__, (AGGR_INIT_EXPR)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3126, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2)
= true;
3127 }
3128 else
3129 u = force_target_expr (TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3129, __FUNCTION__))->typed.type)
, TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3129, __FUNCTION__)))))
,
3130 tf_warning_or_error);
3131
3132 TARGET_EXPR_IMPLICIT_P (u)((tree_not_check2 (((tree_check ((u), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3132, __FUNCTION__, (TARGET_EXPR)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3132, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)
= TARGET_EXPR_IMPLICIT_P (t)((tree_not_check2 (((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3132, __FUNCTION__, (TARGET_EXPR)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3132, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)
;
3133 TARGET_EXPR_LIST_INIT_P (u)((tree_not_check2 (((tree_check ((u), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3133, __FUNCTION__, (TARGET_EXPR)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3133, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_1)
= TARGET_EXPR_LIST_INIT_P (t)((tree_not_check2 (((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3133, __FUNCTION__, (TARGET_EXPR)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3133, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_1)
;
3134 TARGET_EXPR_DIRECT_INIT_P (u)((tree_not_check2 (((tree_check ((u), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3134, __FUNCTION__, (TARGET_EXPR)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3134, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2)
= TARGET_EXPR_DIRECT_INIT_P (t)((tree_not_check2 (((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3134, __FUNCTION__, (TARGET_EXPR)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3134, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2)
;
3135
3136 /* Map the old variable to the new one. */
3137 splay_tree_insert (target_remap,
3138 (splay_tree_key) TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3138, __FUNCTION__)))))
,
3139 (splay_tree_value) TREE_OPERAND (u, 0)(*((const_cast<tree*> (tree_operand_check ((u), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3139, __FUNCTION__)))))
);
3140
3141 TREE_OPERAND (u, 1)(*((const_cast<tree*> (tree_operand_check ((u), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3141, __FUNCTION__)))))
= break_out_target_exprs (TREE_OPERAND (u, 1)(*((const_cast<tree*> (tree_operand_check ((u), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3141, __FUNCTION__)))))
,
3142 data.clear_location);
3143 if (TREE_OPERAND (u, 1)(*((const_cast<tree*> (tree_operand_check ((u), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3143, __FUNCTION__)))))
== error_mark_nodeglobal_trees[TI_ERROR_MARK])
3144 return error_mark_nodeglobal_trees[TI_ERROR_MARK];
3145
3146 /* Replace the old expression with the new version. */
3147 *tp = u;
3148 /* We don't have to go below this point; the recursive call to
3149 break_out_target_exprs will have handled anything below this
3150 point. */
3151 *walk_subtrees = 0;
3152 return NULL_TREE(tree) nullptr;
3153 }
3154 if (TREE_CODE (*tp)((enum tree_code) (*tp)->base.code) == SAVE_EXPR)
3155 {
3156 t = *tp;
3157 splay_tree_node n = splay_tree_lookup (target_remap,
3158 (splay_tree_key) t);
3159 if (n)
3160 {
3161 *tp = (tree)n->value;
3162 *walk_subtrees = 0;
3163 }
3164 else
3165 {
3166 copy_tree_r (tp, walk_subtrees, NULLnullptr);
3167 splay_tree_insert (target_remap,
3168 (splay_tree_key)t,
3169 (splay_tree_value)*tp);
3170 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
3171 splay_tree_insert (target_remap,
3172 (splay_tree_key)*tp,
3173 (splay_tree_value)*tp);
3174 }
3175 return NULL_TREE(tree) nullptr;
3176 }
3177 if (TREE_CODE (*tp)((enum tree_code) (*tp)->base.code) == DECL_EXPR
3178 && VAR_P (DECL_EXPR_DECL (*tp))(((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
(((tree_check ((*tp), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3178, __FUNCTION__, (DECL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3178, __FUNCTION__))))))->base.code) == VAR_DECL)
3179 && DECL_ARTIFICIAL (DECL_EXPR_DECL (*tp))((contains_struct_check (((*((const_cast<tree*> (tree_operand_check
(((tree_check ((*tp), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3179, __FUNCTION__, (DECL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3179, __FUNCTION__)))))), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3179, __FUNCTION__))->decl_common.artificial_flag)
3180 && !TREE_STATIC (DECL_EXPR_DECL (*tp))(((*((const_cast<tree*> (tree_operand_check (((tree_check
((*tp), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3180, __FUNCTION__, (DECL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3180, __FUNCTION__))))))->base.static_flag)
)
3181 {
3182 tree t;
3183 splay_tree_node n
3184 = splay_tree_lookup (target_remap,
3185 (splay_tree_key) DECL_EXPR_DECL (*tp)(*((const_cast<tree*> (tree_operand_check (((tree_check
((*tp), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3185, __FUNCTION__, (DECL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3185, __FUNCTION__)))))
);
3186 if (n)
3187 t = (tree) n->value;
3188 else
3189 {
3190 t = create_temporary_var (TREE_TYPE (DECL_EXPR_DECL (*tp))((contains_struct_check (((*((const_cast<tree*> (tree_operand_check
(((tree_check ((*tp), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3190, __FUNCTION__, (DECL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3190, __FUNCTION__)))))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3190, __FUNCTION__))->typed.type)
);
3191 DECL_INITIAL (t)((contains_struct_check ((t), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3191, __FUNCTION__))->decl_common.initial)
= DECL_INITIAL (DECL_EXPR_DECL (*tp))((contains_struct_check (((*((const_cast<tree*> (tree_operand_check
(((tree_check ((*tp), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3191, __FUNCTION__, (DECL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3191, __FUNCTION__)))))), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3191, __FUNCTION__))->decl_common.initial)
;
3192 splay_tree_insert (target_remap,
3193 (splay_tree_key) DECL_EXPR_DECL (*tp)(*((const_cast<tree*> (tree_operand_check (((tree_check
((*tp), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3193, __FUNCTION__, (DECL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3193, __FUNCTION__)))))
,
3194 (splay_tree_value) t);
3195 }
3196 copy_tree_r (tp, walk_subtrees, NULLnullptr);
3197 DECL_EXPR_DECL (*tp)(*((const_cast<tree*> (tree_operand_check (((tree_check
((*tp), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3197, __FUNCTION__, (DECL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3197, __FUNCTION__)))))
= t;
3198 if (data.clear_location && EXPR_HAS_LOCATION (*tp)(((IS_ADHOC_LOC (((((*tp)) && ((tree_code_type[(int) (
((enum tree_code) ((*tp))->base.code))]) >= tcc_reference
&& (tree_code_type[(int) (((enum tree_code) ((*tp))->
base.code))]) <= tcc_expression)) ? (*tp)->exp.locus : (
(location_t) 0)))) ? get_location_from_adhoc_loc (line_table,
((((*tp)) && ((tree_code_type[(int) (((enum tree_code
) ((*tp))->base.code))]) >= tcc_reference && (tree_code_type
[(int) (((enum tree_code) ((*tp))->base.code))]) <= tcc_expression
)) ? (*tp)->exp.locus : ((location_t) 0))) : (((((*tp)) &&
((tree_code_type[(int) (((enum tree_code) ((*tp))->base.code
))]) >= tcc_reference && (tree_code_type[(int) (((
enum tree_code) ((*tp))->base.code))]) <= tcc_expression
)) ? (*tp)->exp.locus : ((location_t) 0)))) != ((location_t
) 0))
)
3199 SET_EXPR_LOCATION (*tp, input_location)(expr_check (((*tp)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3199, __FUNCTION__))->exp.locus = (input_location)
;
3200 return NULL_TREE(tree) nullptr;
3201 }
3202 if (TREE_CODE (*tp)((enum tree_code) (*tp)->base.code) == BIND_EXPR && BIND_EXPR_VARS (*tp)((*((const_cast<tree*> (tree_operand_check (((tree_check
((*tp), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3202, __FUNCTION__, (BIND_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3202, __FUNCTION__))))))
)
3203 {
3204 copy_tree_r (tp, walk_subtrees, NULLnullptr);
3205 for (tree *p = &BIND_EXPR_VARS (*tp)((*((const_cast<tree*> (tree_operand_check (((tree_check
((*tp), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3205, __FUNCTION__, (BIND_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3205, __FUNCTION__))))))
; *p; p = &DECL_CHAIN (*p)(((contains_struct_check (((contains_struct_check ((*p), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3205, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3205, __FUNCTION__))->common.chain))
)
3206 {
3207 gcc_assert (VAR_P (*p) && DECL_ARTIFICIAL (*p) && !TREE_STATIC (*p))((void)(!((((enum tree_code) (*p)->base.code) == VAR_DECL)
&& ((contains_struct_check ((*p), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3207, __FUNCTION__))->decl_common.artificial_flag) &&
!((*p)->base.static_flag)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3207, __FUNCTION__), 0 : 0))
;
3208 tree t = create_temporary_var (TREE_TYPE (*p)((contains_struct_check ((*p), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3208, __FUNCTION__))->typed.type)
);
3209 DECL_INITIAL (t)((contains_struct_check ((t), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3209, __FUNCTION__))->decl_common.initial)
= DECL_INITIAL (*p)((contains_struct_check ((*p), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3209, __FUNCTION__))->decl_common.initial)
;
3210 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/cp/tree.c"
, 3210, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3210, __FUNCTION__))->common.chain))
= DECL_CHAIN (*p)(((contains_struct_check (((contains_struct_check ((*p), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3210, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3210, __FUNCTION__))->common.chain))
;
3211 splay_tree_insert (target_remap, (splay_tree_key) *p,
3212 (splay_tree_value) t);
3213 *p = t;
3214 }
3215 if (data.clear_location && EXPR_HAS_LOCATION (*tp)(((IS_ADHOC_LOC (((((*tp)) && ((tree_code_type[(int) (
((enum tree_code) ((*tp))->base.code))]) >= tcc_reference
&& (tree_code_type[(int) (((enum tree_code) ((*tp))->
base.code))]) <= tcc_expression)) ? (*tp)->exp.locus : (
(location_t) 0)))) ? get_location_from_adhoc_loc (line_table,
((((*tp)) && ((tree_code_type[(int) (((enum tree_code
) ((*tp))->base.code))]) >= tcc_reference && (tree_code_type
[(int) (((enum tree_code) ((*tp))->base.code))]) <= tcc_expression
)) ? (*tp)->exp.locus : ((location_t) 0))) : (((((*tp)) &&
((tree_code_type[(int) (((enum tree_code) ((*tp))->base.code
))]) >= tcc_reference && (tree_code_type[(int) (((
enum tree_code) ((*tp))->base.code))]) <= tcc_expression
)) ? (*tp)->exp.locus : ((location_t) 0)))) != ((location_t
) 0))
)
3216 SET_EXPR_LOCATION (*tp, input_location)(expr_check (((*tp)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3216, __FUNCTION__))->exp.locus = (input_location)
;
3217 return NULL_TREE(tree) nullptr;
3218 }
3219
3220 /* Make a copy of this node. */
3221 t = copy_tree_r (tp, walk_subtrees, NULLnullptr);
3222 if (TREE_CODE (*tp)((enum tree_code) (*tp)->base.code) == CALL_EXPR || TREE_CODE (*tp)((enum tree_code) (*tp)->base.code) == AGGR_INIT_EXPR)
3223 if (!processing_template_declscope_chain->x_processing_template_decl)
3224 set_flags_from_callee (*tp);
3225 if (data.clear_location && EXPR_HAS_LOCATION (*tp)(((IS_ADHOC_LOC (((((*tp)) && ((tree_code_type[(int) (
((enum tree_code) ((*tp))->base.code))]) >= tcc_reference
&& (tree_code_type[(int) (((enum tree_code) ((*tp))->
base.code))]) <= tcc_expression)) ? (*tp)->exp.locus : (
(location_t) 0)))) ? get_location_from_adhoc_loc (line_table,
((((*tp)) && ((tree_code_type[(int) (((enum tree_code
) ((*tp))->base.code))]) >= tcc_reference && (tree_code_type
[(int) (((enum tree_code) ((*tp))->base.code))]) <= tcc_expression
)) ? (*tp)->exp.locus : ((location_t) 0))) : (((((*tp)) &&
((tree_code_type[(int) (((enum tree_code) ((*tp))->base.code
))]) >= tcc_reference && (tree_code_type[(int) (((
enum tree_code) ((*tp))->base.code))]) <= tcc_expression
)) ? (*tp)->exp.locus : ((location_t) 0)))) != ((location_t
) 0))
)
3226 SET_EXPR_LOCATION (*tp, input_location)(expr_check (((*tp)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3226, __FUNCTION__))->exp.locus = (input_location)
;
3227 return t;
3228}
3229
3230/* Replace all remapped VAR_DECLs in T with their new equivalents.
3231 DATA is really a splay-tree mapping old variables to new
3232 variables. */
3233
3234static tree
3235bot_replace (tree* t, int* /*walk_subtrees*/, void* data_)
3236{
3237 bot_data &data = *(bot_data*)data_;
3238 splay_tree target_remap = data.target_remap;
3239
3240 if (VAR_P (*t)(((enum tree_code) (*t)->base.code) == VAR_DECL))
3241 {
3242 splay_tree_node n = splay_tree_lookup (target_remap,
3243 (splay_tree_key) *t);
3244 if (n)
3245 *t = (tree) n->value;
3246 }
3247 else if (TREE_CODE (*t)((enum tree_code) (*t)->base.code) == PARM_DECL
3248 && DECL_NAME (*t)((contains_struct_check ((*t), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3248, __FUNCTION__))->decl_minimal.name)
== this_identifiercp_global_trees[CPTI_THIS_IDENTIFIER]
3249 && !DECL_CONTEXT (*t)((contains_struct_check ((*t), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3249, __FUNCTION__))->decl_minimal.context)
)
3250 {
3251 /* In an NSDMI we need to replace the 'this' parameter we used for
3252 parsing with the real one for this function. */
3253 *t = current_class_ptr(*((cfun + 0) && ((cfun + 0)->language) ? &((cfun
+ 0)->language)->x_current_class_ptr : &scope_chain
->x_current_class_ptr))
;
3254 }
3255 else if (TREE_CODE (*t)((enum tree_code) (*t)->base.code) == CONVERT_EXPR
3256 && CONVERT_EXPR_VBASE_PATH (*t)((tree_not_check2 (((tree_check ((*t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3256, __FUNCTION__, (CONVERT_EXPR)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3256, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)
)
3257 {
3258 /* In an NSDMI build_base_path defers building conversions to morally
3259 virtual bases, and we handle it here. */
3260 tree basetype = TREE_TYPE (*t)((contains_struct_check ((*t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3260, __FUNCTION__))->typed.type)
;
3261 *t = convert_to_base (TREE_OPERAND (*t, 0)(*((const_cast<tree*> (tree_operand_check ((*t), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3261, __FUNCTION__)))))
, basetype,
3262 /*check_access=*/false, /*nonnull=*/true,
3263 tf_warning_or_error);
3264 }
3265
3266 return NULL_TREE(tree) nullptr;
3267}
3268
3269/* When we parse a default argument expression, we may create
3270 temporary variables via TARGET_EXPRs. When we actually use the
3271 default-argument expression, we make a copy of the expression
3272 and replace the temporaries with appropriate local versions.
3273
3274 If CLEAR_LOCATION is true, override any EXPR_LOCATION with
3275 input_location. */
3276
3277tree
3278break_out_target_exprs (tree t, bool clear_location /* = false */)
3279{
3280 static int target_remap_count;
3281 static splay_tree target_remap;
3282
3283 if (!target_remap_count++)
3284 target_remap = splay_tree_new (splay_tree_compare_pointers,
3285 /*splay_tree_delete_key_fn=*/NULLnullptr,
3286 /*splay_tree_delete_value_fn=*/NULLnullptr);
3287 bot_data data = { target_remap, clear_location };
3288 if (cp_walk_tree (&t, bot_manip, &data, NULL)walk_tree_1 (&t, bot_manip, &data, nullptr, cp_walk_subtrees
)
== error_mark_nodeglobal_trees[TI_ERROR_MARK])
3289 t = error_mark_nodeglobal_trees[TI_ERROR_MARK];
3290 cp_walk_tree (&t, bot_replace, &data, NULL)walk_tree_1 (&t, bot_replace, &data, nullptr, cp_walk_subtrees
)
;
3291
3292 if (!--target_remap_count)
3293 {
3294 splay_tree_delete (target_remap);
3295 target_remap = NULLnullptr;
3296 }
3297
3298 return t;
3299}
3300
3301/* Build an expression for the subobject of OBJ at CONSTRUCTOR index INDEX,
3302 which we expect to have type TYPE. */
3303
3304tree
3305build_ctor_subob_ref (tree index, tree type, tree obj)
3306{
3307 if (index == NULL_TREE(tree) nullptr)
3308 /* Can't refer to a particular member of a vector. */
3309 obj = NULL_TREE(tree) nullptr;
3310 else if (TREE_CODE (index)((enum tree_code) (index)->base.code) == INTEGER_CST)
3311 obj = cp_build_array_ref (input_location, obj, index, tf_none);
3312 else
3313 obj = build_class_member_access_expr (obj, index, NULL_TREE(tree) nullptr,
3314 /*reference*/false, tf_none);
3315 if (obj)
3316 {
3317 tree objtype = TREE_TYPE (obj)((contains_struct_check ((obj), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3317, __FUNCTION__))->typed.type)
;
3318 if (TREE_CODE (objtype)((enum tree_code) (objtype)->base.code) == ARRAY_TYPE && !TYPE_DOMAIN (objtype)((tree_check ((objtype), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3318, __FUNCTION__, (ARRAY_TYPE)))->type_non_common.values
)
)
3319 {
3320 /* When the destination object refers to a flexible array member
3321 verify that it matches the type of the source object except
3322 for its domain and qualifiers. */
3323 gcc_assert (comptypes (TYPE_MAIN_VARIANT (type),((void)(!(comptypes (((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3323, __FUNCTION__))->type_common.main_variant), ((tree_class_check
((objtype), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3324, __FUNCTION__))->type_common.main_variant), 4)) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3325, __FUNCTION__), 0 : 0))
3324 TYPE_MAIN_VARIANT (objtype),((void)(!(comptypes (((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3323, __FUNCTION__))->type_common.main_variant), ((tree_class_check
((objtype), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3324, __FUNCTION__))->type_common.main_variant), 4)) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3325, __FUNCTION__), 0 : 0))
3325 COMPARE_REDECLARATION))((void)(!(comptypes (((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3323, __FUNCTION__))->type_common.main_variant), ((tree_class_check
((objtype), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3324, __FUNCTION__))->type_common.main_variant), 4)) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3325, __FUNCTION__), 0 : 0))
;
3326 }
3327 else
3328 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type, objtype))((void)(!(same_type_ignoring_top_level_qualifiers_p (type, objtype
)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3328, __FUNCTION__), 0 : 0))
;
3329 }
3330
3331 return obj;
3332}
3333
3334struct replace_placeholders_t
3335{
3336 tree obj; /* The object to be substituted for a PLACEHOLDER_EXPR. */
3337 tree exp; /* The outermost exp. */
3338 bool seen; /* Whether we've encountered a PLACEHOLDER_EXPR. */
3339 hash_set<tree> *pset; /* To avoid walking same trees multiple times. */
3340};
3341
3342/* Like substitute_placeholder_in_expr, but handle C++ tree codes and
3343 build up subexpressions as we go deeper. */
3344
3345static tree
3346replace_placeholders_r (tree* t, int* walk_subtrees, void* data_)
3347{
3348 replace_placeholders_t *d = static_cast<replace_placeholders_t*>(data_);
3349 tree obj = d->obj;
3350
3351 if (TYPE_P (*t)(tree_code_type[(int) (((enum tree_code) (*t)->base.code))
] == tcc_type)
|| TREE_CONSTANT (*t)((non_type_check ((*t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3351, __FUNCTION__))->base.constant_flag)
)
3352 {
3353 *walk_subtrees = false;
3354 return NULL_TREE(tree) nullptr;
3355 }
3356
3357 switch (TREE_CODE (*t)((enum tree_code) (*t)->base.code))
3358 {
3359 case PLACEHOLDER_EXPR:
3360 {
3361 tree x = obj;
3362 for (; !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (*t)((contains_struct_check ((*t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3362, __FUNCTION__))->typed.type)
,
3363 TREE_TYPE (x)((contains_struct_check ((x), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3363, __FUNCTION__))->typed.type)
);
3364 x = TREE_OPERAND (x, 0)(*((const_cast<tree*> (tree_operand_check ((x), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3364, __FUNCTION__)))))
)
3365 gcc_assert (handled_component_p (x))((void)(!(handled_component_p (x)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3365, __FUNCTION__), 0 : 0))
;
3366 *t = unshare_expr (x);
3367 *walk_subtrees = false;
3368 d->seen = true;
3369 }
3370 break;
3371
3372 case CONSTRUCTOR:
3373 {
3374 constructor_elt *ce;
3375 vec<constructor_elt,va_gc> *v = CONSTRUCTOR_ELTS (*t)((tree_check ((*t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3375, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts)
;
3376 /* Don't walk into CONSTRUCTOR_PLACEHOLDER_BOUNDARY ctors
3377 other than the d->exp one, those have PLACEHOLDER_EXPRs
3378 related to another object. */
3379 if ((CONSTRUCTOR_PLACEHOLDER_BOUNDARY (*t)(((tree_not_check2 (((tree_check ((*t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3379, __FUNCTION__, (CONSTRUCTOR)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3379, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_5))
3380 && *t != d->exp)
3381 || d->pset->add (*t))
3382 {
3383 *walk_subtrees = false;
3384 return NULL_TREE(tree) nullptr;
3385 }
3386 for (unsigned i = 0; vec_safe_iterate (v, i, &ce); ++i)
3387 {
3388 tree *valp = &ce->value;
3389 tree type = TREE_TYPE (*valp)((contains_struct_check ((*valp), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3389, __FUNCTION__))->typed.type)
;
3390 tree subob = obj;
3391
3392 /* Elements with RANGE_EXPR index shouldn't have any
3393 placeholders in them. */
3394 if (ce->index && TREE_CODE (ce->index)((enum tree_code) (ce->index)->base.code) == RANGE_EXPR)
3395 continue;
3396
3397 if (TREE_CODE (*valp)((enum tree_code) (*valp)->base.code) == CONSTRUCTOR
3398 && 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))
)
3399 {
3400 /* If we're looking at the initializer for OBJ, then build
3401 a sub-object reference. If we're looking at an
3402 initializer for another object, just pass OBJ down. */
3403 if (same_type_ignoring_top_level_qualifiers_p
3404 (TREE_TYPE (*t)((contains_struct_check ((*t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3404, __FUNCTION__))->typed.type)
, TREE_TYPE (obj)((contains_struct_check ((obj), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3404, __FUNCTION__))->typed.type)
))
3405 subob = build_ctor_subob_ref (ce->index, type, obj);
3406 if (TREE_CODE (*valp)((enum tree_code) (*valp)->base.code) == TARGET_EXPR)
3407 valp = &TARGET_EXPR_INITIAL (*valp)(*(tree_operand_check_code ((*valp), (TARGET_EXPR), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3407, __FUNCTION__)))
;
3408 }
3409 d->obj = subob;
3410 cp_walk_tree (valp, replace_placeholders_r, data_, NULL)walk_tree_1 (valp, replace_placeholders_r, data_, nullptr, cp_walk_subtrees
)
;
3411 d->obj = obj;
3412 }
3413 *walk_subtrees = false;
3414 break;
3415 }
3416
3417 default:
3418 if (d->pset->add (*t))
3419 *walk_subtrees = false;
3420 break;
3421 }
3422
3423 return NULL_TREE(tree) nullptr;
3424}
3425
3426/* Replace PLACEHOLDER_EXPRs in EXP with object OBJ. SEEN_P is set if
3427 a PLACEHOLDER_EXPR has been encountered. */
3428
3429tree
3430replace_placeholders (tree exp, tree obj, bool *seen_p /*= NULL*/)
3431{
3432 /* This is only relevant for C++14. */
3433 if (cxx_dialect < cxx14)
3434 return exp;
3435
3436 /* If the object isn't a (member of a) class, do nothing. */
3437 tree op0 = obj;
3438 while (handled_component_p (op0))
3439 op0 = TREE_OPERAND (op0, 0)(*((const_cast<tree*> (tree_operand_check ((op0), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3439, __FUNCTION__)))))
;
3440 if (!CLASS_TYPE_P (strip_array_types (TREE_TYPE (op0)))(((((enum tree_code) (strip_array_types (((contains_struct_check
((op0), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3440, __FUNCTION__))->typed.type)))->base.code)) == RECORD_TYPE
|| (((enum tree_code) (strip_array_types (((contains_struct_check
((op0), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3440, __FUNCTION__))->typed.type)))->base.code)) == UNION_TYPE
) && ((tree_class_check ((strip_array_types (((contains_struct_check
((op0), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3440, __FUNCTION__))->typed.type))), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3440, __FUNCTION__))->type_common.lang_flag_5))
)
3441 return exp;
3442
3443 tree *tp = &exp;
3444 if (TREE_CODE (exp)((enum tree_code) (exp)->base.code) == TARGET_EXPR)
3445 tp = &TARGET_EXPR_INITIAL (exp)(*(tree_operand_check_code ((exp), (TARGET_EXPR), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3445, __FUNCTION__)))
;
3446 hash_set<tree> pset;
3447 replace_placeholders_t data = { obj, *tp, false, &pset };
3448 cp_walk_tree (tp, replace_placeholders_r, &data, NULL)walk_tree_1 (tp, replace_placeholders_r, &data, nullptr, cp_walk_subtrees
)
;
3449 if (seen_p)
3450 *seen_p = data.seen;
3451 return exp;
3452}
3453
3454/* Callback function for find_placeholders. */
3455
3456static tree
3457find_placeholders_r (tree *t, int *walk_subtrees, void *)
3458{
3459 if (TYPE_P (*t)(tree_code_type[(int) (((enum tree_code) (*t)->base.code))
] == tcc_type)
|| TREE_CONSTANT (*t)((non_type_check ((*t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3459, __FUNCTION__))->base.constant_flag)
)
3460 {
3461 *walk_subtrees = false;
3462 return NULL_TREE(tree) nullptr;
3463 }
3464
3465 switch (TREE_CODE (*t)((enum tree_code) (*t)->base.code))
3466 {
3467 case PLACEHOLDER_EXPR:
3468 return *t;
3469
3470 case CONSTRUCTOR:
3471 if (CONSTRUCTOR_PLACEHOLDER_BOUNDARY (*t)(((tree_not_check2 (((tree_check ((*t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3471, __FUNCTION__, (CONSTRUCTOR)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3471, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_5))
)
3472 *walk_subtrees = false;
3473 break;
3474
3475 default:
3476 break;
3477 }
3478
3479 return NULL_TREE(tree) nullptr;
3480}
3481
3482/* Return true if EXP contains a PLACEHOLDER_EXPR. Don't walk into
3483 ctors with CONSTRUCTOR_PLACEHOLDER_BOUNDARY flag set. */
3484
3485bool
3486find_placeholders (tree exp)
3487{
3488 /* This is only relevant for C++14. */
3489 if (cxx_dialect < cxx14)
3490 return false;
3491
3492 return cp_walk_tree_without_duplicates (&exp, find_placeholders_r, NULL)walk_tree_without_duplicates_1 (&exp, find_placeholders_r
, nullptr, cp_walk_subtrees)
;
3493}
3494
3495/* Similar to `build_nt', but for template definitions of dependent
3496 expressions */
3497
3498tree
3499build_min_nt_loc (location_t loc, enum tree_code code, ...)
3500{
3501 tree t;
3502 int length;
3503 int i;
3504 va_list p;
3505
3506 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp)((void)(!(tree_code_type[(int) (code)] != tcc_vl_exp) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3506, __FUNCTION__), 0 : 0))
;
3507
3508 va_start (p, code)__builtin_va_start(p, code);
3509
3510 t = make_node (code);
3511 SET_EXPR_LOCATION (t, loc)(expr_check (((t)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3511, __FUNCTION__))->exp.locus = (loc)
;
3512 length = TREE_CODE_LENGTH (code)tree_code_length[(int) (code)];
3513
3514 for (i = 0; i < length; i++)
3515 TREE_OPERAND (t, i)(*((const_cast<tree*> (tree_operand_check ((t), (i), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3515, __FUNCTION__)))))
= va_arg (p, tree)__builtin_va_arg(p, tree);
3516
3517 va_end (p)__builtin_va_end(p);
3518 return t;
3519}
3520
3521/* Similar to `build', but for template definitions. */
3522
3523tree
3524build_min (enum tree_code code, tree tt, ...)
3525{
3526 tree t;
3527 int length;
3528 int i;
3529 va_list p;
3530
3531 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp)((void)(!(tree_code_type[(int) (code)] != tcc_vl_exp) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3531, __FUNCTION__), 0 : 0))
;
3532
3533 va_start (p, tt)__builtin_va_start(p, tt);
3534
3535 t = make_node (code);
3536 length = TREE_CODE_LENGTH (code)tree_code_length[(int) (code)];
3537 TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3537, __FUNCTION__))->typed.type)
= tt;
3538
3539 for (i = 0; i < length; i++)
3540 {
3541 tree x = va_arg (p, tree)__builtin_va_arg(p, tree);
3542 TREE_OPERAND (t, i)(*((const_cast<tree*> (tree_operand_check ((t), (i), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3542, __FUNCTION__)))))
= x;
3543 if (x && !TYPE_P (x)(tree_code_type[(int) (((enum tree_code) (x)->base.code))]
== tcc_type)
&& TREE_SIDE_EFFECTS (x)((non_type_check ((x), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3543, __FUNCTION__))->base.side_effects_flag)
)
3544 TREE_SIDE_EFFECTS (t)((non_type_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3544, __FUNCTION__))->base.side_effects_flag)
= 1;
3545 }
3546
3547 va_end (p)__builtin_va_end(p);
3548
3549 return t;
3550}
3551
3552/* Similar to `build', but for template definitions of non-dependent
3553 expressions. NON_DEP is the non-dependent expression that has been
3554 built. */
3555
3556tree
3557build_min_non_dep (enum tree_code code, tree non_dep, ...)
3558{
3559 tree t;
3560 int length;
3561 int i;
3562 va_list p;
3563
3564 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp)((void)(!(tree_code_type[(int) (code)] != tcc_vl_exp) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3564, __FUNCTION__), 0 : 0))
;
3565
3566 va_start (p, non_dep)__builtin_va_start(p, non_dep);
3567
3568 if (REFERENCE_REF_P (non_dep)((((enum tree_code) (non_dep)->base.code) == INDIRECT_REF)
&& ((contains_struct_check (((*((const_cast<tree*
> (tree_operand_check ((non_dep), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3568, __FUNCTION__)))))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3568, __FUNCTION__))->typed.type) && (((enum tree_code
) (((contains_struct_check (((*((const_cast<tree*> (tree_operand_check
(((non_dep)), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3568, __FUNCTION__)))))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3568, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
))
)
3569 non_dep = TREE_OPERAND (non_dep, 0)(*((const_cast<tree*> (tree_operand_check ((non_dep), (
0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3569, __FUNCTION__)))))
;
3570
3571 t = make_node (code);
3572 SET_EXPR_LOCATION (t, cp_expr_loc_or_input_loc (non_dep))(expr_check (((t)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3572, __FUNCTION__))->exp.locus = (cp_expr_loc_or_input_loc
(non_dep))
;
3573 length = TREE_CODE_LENGTH (code)tree_code_length[(int) (code)];
3574 TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3574, __FUNCTION__))->typed.type)
= unlowered_expr_type (non_dep);
3575 TREE_SIDE_EFFECTS (t)((non_type_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3575, __FUNCTION__))->base.side_effects_flag)
= TREE_SIDE_EFFECTS (non_dep)((non_type_check ((non_dep), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3575, __FUNCTION__))->base.side_effects_flag)
;
3576
3577 for (i = 0; i < length; i++)
3578 TREE_OPERAND (t, i)(*((const_cast<tree*> (tree_operand_check ((t), (i), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3578, __FUNCTION__)))))
= va_arg (p, tree)__builtin_va_arg(p, tree);
3579
3580 if (code == COMPOUND_EXPR && TREE_CODE (non_dep)((enum tree_code) (non_dep)->base.code) != COMPOUND_EXPR)
3581 /* This should not be considered a COMPOUND_EXPR, because it
3582 resolves to an overload. */
3583 COMPOUND_EXPR_OVERLOADED (t)((tree_not_check2 (((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3583, __FUNCTION__, (COMPOUND_EXPR)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3583, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)
= 1;
3584
3585 va_end (p)__builtin_va_end(p);
3586 return convert_from_reference (t);
3587}
3588
3589/* Similar to build_min_nt, but call expressions */
3590
3591tree
3592build_min_nt_call_vec (tree fn, vec<tree, va_gc> *args)
3593{
3594 tree ret, t;
3595 unsigned int ix;
3596
3597 ret = build_vl_exp (CALL_EXPR, vec_safe_length (args) + 3);
3598 CALL_EXPR_FN (ret)(*((const_cast<tree*> (tree_operand_check (((tree_check
((ret), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3598, __FUNCTION__, (CALL_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3598, __FUNCTION__)))))
= fn;
3599 CALL_EXPR_STATIC_CHAIN (ret)(*((const_cast<tree*> (tree_operand_check (((tree_check
((ret), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3599, __FUNCTION__, (CALL_EXPR)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3599, __FUNCTION__)))))
= NULL_TREE(tree) nullptr;
3600 FOR_EACH_VEC_SAFE_ELT (args, ix, t)for (ix = 0; vec_safe_iterate ((args), (ix), &(t)); ++(ix
))
3601 CALL_EXPR_ARG (ret, ix)(*((const_cast<tree*> (tree_operand_check (((tree_check
((ret), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3601, __FUNCTION__, (CALL_EXPR)))), ((ix) + 3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3601, __FUNCTION__)))))
= t;
3602
3603 return ret;
3604}
3605
3606/* Similar to `build_min_nt_call_vec', but for template definitions of
3607 non-dependent expressions. NON_DEP is the non-dependent expression
3608 that has been built. */
3609
3610tree
3611build_min_non_dep_call_vec (tree non_dep, tree fn, vec<tree, va_gc> *argvec)
3612{
3613 tree t = build_min_nt_call_vec (fn, argvec);
3614 if (REFERENCE_REF_P (non_dep)((((enum tree_code) (non_dep)->base.code) == INDIRECT_REF)
&& ((contains_struct_check (((*((const_cast<tree*
> (tree_operand_check ((non_dep), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3614, __FUNCTION__)))))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3614, __FUNCTION__))->typed.type) && (((enum tree_code
) (((contains_struct_check (((*((const_cast<tree*> (tree_operand_check
(((non_dep)), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3614, __FUNCTION__)))))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3614, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
))
)
3615 non_dep = TREE_OPERAND (non_dep, 0)(*((const_cast<tree*> (tree_operand_check ((non_dep), (
0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3615, __FUNCTION__)))))
;
3616 TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3616, __FUNCTION__))->typed.type)
= TREE_TYPE (non_dep)((contains_struct_check ((non_dep), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3616, __FUNCTION__))->typed.type)
;
3617 TREE_SIDE_EFFECTS (t)((non_type_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3617, __FUNCTION__))->base.side_effects_flag)
= TREE_SIDE_EFFECTS (non_dep)((non_type_check ((non_dep), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3617, __FUNCTION__))->base.side_effects_flag)
;
3618 return convert_from_reference (t);
3619}
3620
3621/* Similar to build_min_non_dep, but for expressions that have been resolved to
3622 a call to an operator overload. OP is the operator that has been
3623 overloaded. NON_DEP is the non-dependent expression that's been built,
3624 which should be a CALL_EXPR or an INDIRECT_REF to a CALL_EXPR. OVERLOAD is
3625 the overload that NON_DEP is calling. */
3626
3627tree
3628build_min_non_dep_op_overload (enum tree_code op,
3629 tree non_dep,
3630 tree overload, ...)
3631{
3632 va_list p;
3633 int nargs, expected_nargs;
3634 tree fn, call;
3635
3636 non_dep = extract_call_expr (non_dep);
3637
3638 nargs = call_expr_nargs (non_dep)(((int)((unsigned long) (*tree_int_cst_elt_check (((tree_class_check
((non_dep), (tcc_vl_exp), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3638, __FUNCTION__))->exp.operands[0]), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3638, __FUNCTION__)))) - 3)
;
3639
3640 expected_nargs = cp_tree_code_length (op);
3641 if ((op == POSTINCREMENT_EXPR
3642 || op == POSTDECREMENT_EXPR)
3643 /* With -fpermissive non_dep could be operator++(). */
3644 && (!flag_permissiveglobal_options.x_flag_permissive || nargs != expected_nargs))
3645 expected_nargs += 1;
3646 gcc_assert (nargs == expected_nargs)((void)(!(nargs == expected_nargs) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3646, __FUNCTION__), 0 : 0))
;
3647
3648 releasing_vec args;
3649 va_start (p, overload)__builtin_va_start(p, overload);
3650
3651 if (TREE_CODE (TREE_TYPE (overload))((enum tree_code) (((contains_struct_check ((overload), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3651, __FUNCTION__))->typed.type))->base.code)
== FUNCTION_TYPE)
3652 {
3653 fn = overload;
3654 for (int i = 0; i < nargs; i++)
3655 {
3656 tree arg = va_arg (p, tree)__builtin_va_arg(p, tree);
3657 vec_safe_push (args, arg);
3658 }
3659 }
3660 else if (TREE_CODE (TREE_TYPE (overload))((enum tree_code) (((contains_struct_check ((overload), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3660, __FUNCTION__))->typed.type))->base.code)
== METHOD_TYPE)
3661 {
3662 tree object = va_arg (p, tree)__builtin_va_arg(p, tree);
3663 tree binfo = TYPE_BINFO (TREE_TYPE (object))((tree_check3 ((((contains_struct_check ((object), (TS_TYPED)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3663, __FUNCTION__))->typed.type)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3663, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.maxval)
;
3664 tree method = build_baselink (binfo, binfo, overload, NULL_TREE(tree) nullptr);
3665 fn = build_min (COMPONENT_REF, TREE_TYPE (overload)((contains_struct_check ((overload), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3665, __FUNCTION__))->typed.type)
,
3666 object, method, NULL_TREE(tree) nullptr);
3667 for (int i = 1; i < nargs; i++)
3668 {
3669 tree arg = va_arg (p, tree)__builtin_va_arg(p, tree);
3670 vec_safe_push (args, arg);
3671 }
3672 }
3673 else
3674 gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3674, __FUNCTION__))
;
3675
3676 va_end (p)__builtin_va_end(p);
3677 call = build_min_non_dep_call_vec (non_dep, fn, args);
3678
3679 tree call_expr = extract_call_expr (call);
3680 KOENIG_LOOKUP_P (call_expr)((tree_not_check2 (((tree_check ((call_expr), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3680, __FUNCTION__, (CALL_EXPR)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3680, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)
= KOENIG_LOOKUP_P (non_dep)((tree_not_check2 (((tree_check ((non_dep), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3680, __FUNCTION__, (CALL_EXPR)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3680, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)
;
3681 CALL_EXPR_OPERATOR_SYNTAX (call_expr)((tree_not_check2 (((tree_check2 (((call_expr)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3681, __FUNCTION__, (CALL_EXPR), (AGGR_INIT_EXPR)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3681, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_6)
= true;
3682 CALL_EXPR_ORDERED_ARGS (call_expr)((tree_not_check2 (((tree_check2 (((call_expr)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3682, __FUNCTION__, (CALL_EXPR), (AGGR_INIT_EXPR)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3682, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_3)
= CALL_EXPR_ORDERED_ARGS (non_dep)((tree_not_check2 (((tree_check2 (((non_dep)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3682, __FUNCTION__, (CALL_EXPR), (AGGR_INIT_EXPR)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3682, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_3)
;
3683 CALL_EXPR_REVERSE_ARGS (call_expr)((tree_not_check2 (((tree_check2 (((call_expr)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3683, __FUNCTION__, (CALL_EXPR), (AGGR_INIT_EXPR)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3683, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_5)
= CALL_EXPR_REVERSE_ARGS (non_dep)((tree_not_check2 (((tree_check2 (((non_dep)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3683, __FUNCTION__, (CALL_EXPR), (AGGR_INIT_EXPR)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3683, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_5)
;
3684
3685 return call;
3686}
3687
3688/* Return a new tree vec copied from VEC, with ELT inserted at index IDX. */
3689
3690vec<tree, va_gc> *
3691vec_copy_and_insert (vec<tree, va_gc> *old_vec, tree elt, unsigned idx)
3692{
3693 unsigned len = vec_safe_length (old_vec);
3694 gcc_assert (idx <= len)((void)(!(idx <= len) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3694, __FUNCTION__), 0 : 0))
;
1
Assuming 'idx' is <= 'len'
2
'?' condition is false
3695
3696 vec<tree, va_gc> *new_vec = NULLnullptr;
3697 vec_alloc (new_vec, len + 1);
3
Calling 'vec_alloc<tree_node *, va_gc>'
11
Returning from 'vec_alloc<tree_node *, va_gc>'
3698
3699 unsigned i;
3700 for (i = 0; i < len; ++i)
12
Loop condition is true. Entering loop body
3701 {
3702 if (i == idx)
13
Assuming 'i' is not equal to 'idx'
14
Taking false branch
3703 new_vec->quick_push (elt);
3704 new_vec->quick_push ((*old_vec)[i]);
15
Called C++ object pointer is null
3705 }
3706 if (i == idx)
3707 new_vec->quick_push (elt);
3708
3709 return new_vec;
3710}
3711
3712tree
3713get_type_decl (tree t)
3714{
3715 if (TREE_CODE (t)((enum tree_code) (t)->base.code) == TYPE_DECL)
3716 return t;
3717 if (TYPE_P (t)(tree_code_type[(int) (((enum tree_code) (t)->base.code))]
== tcc_type)
)
3718 return TYPE_STUB_DECL (t)(((contains_struct_check (((tree_class_check ((t), (tcc_type)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3718, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3718, __FUNCTION__))->common.chain))
;
3719 gcc_assert (t == error_mark_node)((void)(!(t == global_trees[TI_ERROR_MARK]) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3719, __FUNCTION__), 0 : 0))
;
3720 return t;
3721}
3722
3723/* Returns the namespace that contains DECL, whether directly or
3724 indirectly. */
3725
3726tree
3727decl_namespace_context (tree decl)
3728{
3729 while (1)
3730 {
3731 if (TREE_CODE (decl)((enum tree_code) (decl)->base.code) == NAMESPACE_DECL)
3732 return decl;
3733 else if (TYPE_P (decl)(tree_code_type[(int) (((enum tree_code) (decl)->base.code
))] == tcc_type)
)
3734 decl = CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl))(!(! (((contains_struct_check ((((((contains_struct_check (((
tree_class_check ((((tree_class_check ((decl), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3734, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3734, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3734, __FUNCTION__))->common.chain)))), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3734, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((((((contains_struct_check (((tree_class_check
((((tree_class_check ((decl), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3734, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3734, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3734, __FUNCTION__))->common.chain)))), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3734, __FUNCTION__))->decl_minimal.context))->base.code
) == TRANSLATION_UNIT_DECL) ? ((contains_struct_check ((((((contains_struct_check
(((tree_class_check ((((tree_class_check ((decl), (tcc_type)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3734, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3734, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3734, __FUNCTION__))->common.chain)))), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3734, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL])
;
3735 else
3736 decl = CP_DECL_CONTEXT (decl)(!(! (((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3736, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3736, __FUNCTION__))->decl_minimal.context))->base.code
) == TRANSLATION_UNIT_DECL) ? ((contains_struct_check ((decl)
, (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3736, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL])
;
3737 }
3738}
3739
3740/* Returns true if decl is within an anonymous namespace, however deeply
3741 nested, or false otherwise. */
3742
3743bool
3744decl_anon_ns_mem_p (const_tree decl)
3745{
3746 while (TREE_CODE (decl)((enum tree_code) (decl)->base.code) != NAMESPACE_DECL)
3747 {
3748 /* Classes inside anonymous namespaces have TREE_PUBLIC == 0. */
3749 if (TYPE_P (decl)(tree_code_type[(int) (((enum tree_code) (decl)->base.code
))] == tcc_type)
)
3750 return !TREE_PUBLIC (TYPE_MAIN_DECL (decl))((((((contains_struct_check (((tree_class_check ((((tree_class_check
((decl), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3750, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3750, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3750, __FUNCTION__))->common.chain))))->base.public_flag
)
;
3751
3752 decl = CP_DECL_CONTEXT (decl)(!(! (((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3752, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3752, __FUNCTION__))->decl_minimal.context))->base.code
) == TRANSLATION_UNIT_DECL) ? ((contains_struct_check ((decl)
, (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3752, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL])
;
3753 }
3754 return !TREE_PUBLIC (decl)((decl)->base.public_flag);
3755}
3756
3757/* Subroutine of cp_tree_equal: t1 and t2 are the CALL_EXPR_FNs of two
3758 CALL_EXPRS. Return whether they are equivalent. */
3759
3760static bool
3761called_fns_equal (tree t1, tree t2)
3762{
3763 /* Core 1321: dependent names are equivalent even if the overload sets
3764 are different. But do compare explicit template arguments. */
3765 tree name1 = dependent_name (t1);
3766 tree name2 = dependent_name (t2);
3767 if (name1 || name2)
3768 {
3769 tree targs1 = NULL_TREE(tree) nullptr, targs2 = NULL_TREE(tree) nullptr;
3770
3771 if (name1 != name2)
3772 return false;
3773
3774 /* FIXME dependent_name currently returns an unqualified name regardless
3775 of whether the function was named with a qualified- or unqualified-id.
3776 Until that's fixed, check that we aren't looking at overload sets from
3777 different scopes. */
3778 if (is_overloaded_fn (t1) && is_overloaded_fn (t2)
3779 && (DECL_CONTEXT (get_first_fn (t1))((contains_struct_check ((get_first_fn (t1)), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3779, __FUNCTION__))->decl_minimal.context)
3780 != DECL_CONTEXT (get_first_fn (t2))((contains_struct_check ((get_first_fn (t2)), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3780, __FUNCTION__))->decl_minimal.context)
))
3781 return false;
3782
3783 if (TREE_CODE (t1)((enum tree_code) (t1)->base.code) == TEMPLATE_ID_EXPR)
3784 targs1 = TREE_OPERAND (t1, 1)(*((const_cast<tree*> (tree_operand_check ((t1), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3784, __FUNCTION__)))))
;
3785 if (TREE_CODE (t2)((enum tree_code) (t2)->base.code) == TEMPLATE_ID_EXPR)
3786 targs2 = TREE_OPERAND (t2, 1)(*((const_cast<tree*> (tree_operand_check ((t2), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3786, __FUNCTION__)))))
;
3787 return cp_tree_equal (targs1, targs2);
3788 }
3789 else
3790 return cp_tree_equal (t1, t2);
3791}
3792
3793/* Return truthvalue of whether T1 is the same tree structure as T2.
3794 Return 1 if they are the same. Return 0 if they are different. */
3795
3796bool
3797cp_tree_equal (tree t1, tree t2)
3798{
3799 enum tree_code code1, code2;
3800
3801 if (t1 == t2)
3802 return true;
3803 if (!t1 || !t2)
3804 return false;
3805
3806 code1 = TREE_CODE (t1)((enum tree_code) (t1)->base.code);
3807 code2 = TREE_CODE (t2)((enum tree_code) (t2)->base.code);
3808
3809 if (code1 != code2)
3810 return false;
3811
3812 if (CONSTANT_CLASS_P (t1)(tree_code_type[(int) (((enum tree_code) (t1)->base.code))
] == tcc_constant)
3813 && !same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))comptypes ((((contains_struct_check ((t1), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3813, __FUNCTION__))->typed.type)), (((contains_struct_check
((t2), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3813, __FUNCTION__))->typed.type)), 0)
)
3814 return false;
3815
3816 switch (code1)
3817 {
3818 case VOID_CST:
3819 /* There's only a single VOID_CST node, so we should never reach
3820 here. */
3821 gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3821, __FUNCTION__))
;
3822
3823 case INTEGER_CST:
3824 return tree_int_cst_equal (t1, t2);
3825
3826 case REAL_CST:
3827 return real_identical (&TREE_REAL_CST (t1)(*((tree_check ((t1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3827, __FUNCTION__, (REAL_CST)))->real_cst.real_cst_ptr)
)
, &TREE_REAL_CST (t2)(*((tree_check ((t2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3827, __FUNCTION__, (REAL_CST)))->real_cst.real_cst_ptr)
)
);
3828
3829 case STRING_CST:
3830 return TREE_STRING_LENGTH (t1)((tree_check ((t1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3830, __FUNCTION__, (STRING_CST)))->string.length)
== TREE_STRING_LENGTH (t2)((tree_check ((t2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3830, __FUNCTION__, (STRING_CST)))->string.length)
3831 && !memcmp (TREE_STRING_POINTER (t1)((const char *)((tree_check ((t1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3831, __FUNCTION__, (STRING_CST)))->string.str))
, TREE_STRING_POINTER (t2)((const char *)((tree_check ((t2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3831, __FUNCTION__, (STRING_CST)))->string.str))
,
3832 TREE_STRING_LENGTH (t1)((tree_check ((t1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3832, __FUNCTION__, (STRING_CST)))->string.length)
);
3833
3834 case FIXED_CST:
3835 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1),fixed_identical (&((*((tree_check ((t1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3835, __FUNCTION__, (FIXED_CST)))->fixed_cst.fixed_cst_ptr
))), &((*((tree_check ((t2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3836, __FUNCTION__, (FIXED_CST)))->fixed_cst.fixed_cst_ptr
))))
3836 TREE_FIXED_CST (t2))fixed_identical (&((*((tree_check ((t1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3835, __FUNCTION__, (FIXED_CST)))->fixed_cst.fixed_cst_ptr
))), &((*((tree_check ((t2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3836, __FUNCTION__, (FIXED_CST)))->fixed_cst.fixed_cst_ptr
))))
;
3837
3838 case COMPLEX_CST:
3839 return cp_tree_equal (TREE_REALPART (t1)((tree_check ((t1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3839, __FUNCTION__, (COMPLEX_CST)))->complex.real)
, TREE_REALPART (t2)((tree_check ((t2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3839, __FUNCTION__, (COMPLEX_CST)))->complex.real)
)
3840 && cp_tree_equal (TREE_IMAGPART (t1)((tree_check ((t1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3840, __FUNCTION__, (COMPLEX_CST)))->complex.imag)
, TREE_IMAGPART (t2)((tree_check ((t2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3840, __FUNCTION__, (COMPLEX_CST)))->complex.imag)
);
3841
3842 case VECTOR_CST:
3843 return operand_equal_p (t1, t2, OEP_ONLY_CONST);
3844
3845 case CONSTRUCTOR:
3846 /* We need to do this when determining whether or not two
3847 non-type pointer to member function template arguments
3848 are the same. */
3849 if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))comptypes ((((contains_struct_check ((t1), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3849, __FUNCTION__))->typed.type)), (((contains_struct_check
((t2), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3849, __FUNCTION__))->typed.type)), 0)
3850 || CONSTRUCTOR_NELTS (t1)(vec_safe_length (((tree_check ((t1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3850, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts)))
!= CONSTRUCTOR_NELTS (t2)(vec_safe_length (((tree_check ((t2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3850, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts)))
)
3851 return false;
3852 {
3853 tree field, value;
3854 unsigned int i;
3855 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1), i, field, value)for (i = 0; (i >= vec_safe_length (((tree_check ((t1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3855, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts)))
? false : (((void) (value = (*((tree_check ((t1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3855, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts))[
i].value)), (field = (*((tree_check ((t1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3855, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts))[
i].index), true); (i)++)
3856 {
3857 constructor_elt *elt2 = CONSTRUCTOR_ELT (t2, i)(&(*((tree_check ((t2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3857, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts))[
i])
;
3858 if (!cp_tree_equal (field, elt2->index)
3859 || !cp_tree_equal (value, elt2->value))
3860 return false;
3861 }
3862 }
3863 return true;
3864
3865 case TREE_LIST:
3866 if (!cp_tree_equal (TREE_PURPOSE (t1)((tree_check ((t1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3866, __FUNCTION__, (TREE_LIST)))->list.purpose)
, TREE_PURPOSE (t2)((tree_check ((t2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3866, __FUNCTION__, (TREE_LIST)))->list.purpose)
))
3867 return false;
3868 if (!cp_tree_equal (TREE_VALUE (t1)((tree_check ((t1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3868, __FUNCTION__, (TREE_LIST)))->list.value)
, TREE_VALUE (t2)((tree_check ((t2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3868, __FUNCTION__, (TREE_LIST)))->list.value)
))
3869 return false;
3870 return cp_tree_equal (TREE_CHAIN (t1)((contains_struct_check ((t1), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3870, __FUNCTION__))->common.chain)
, TREE_CHAIN (t2)((contains_struct_check ((t2), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3870, __FUNCTION__))->common.chain)
);
3871
3872 case SAVE_EXPR:
3873 return cp_tree_equal (TREE_OPERAND (t1, 0)(*((const_cast<tree*> (tree_operand_check ((t1), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3873, __FUNCTION__)))))
, TREE_OPERAND (t2, 0)(*((const_cast<tree*> (tree_operand_check ((t2), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3873, __FUNCTION__)))))
);
3874
3875 case CALL_EXPR:
3876 {
3877 if (KOENIG_LOOKUP_P (t1)((tree_not_check2 (((tree_check ((t1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3877, __FUNCTION__, (CALL_EXPR)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3877, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)
!= KOENIG_LOOKUP_P (t2)((tree_not_check2 (((tree_check ((t2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3877, __FUNCTION__, (CALL_EXPR)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3877, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)
)
3878 return false;
3879
3880 if (!called_fns_equal (CALL_EXPR_FN (t1)(*((const_cast<tree*> (tree_operand_check (((tree_check
((t1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3880, __FUNCTION__, (CALL_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3880, __FUNCTION__)))))
, CALL_EXPR_FN (t2)(*((const_cast<tree*> (tree_operand_check (((tree_check
((t2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3880, __FUNCTION__, (CALL_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3880, __FUNCTION__)))))
))
3881 return false;
3882
3883 call_expr_arg_iterator iter1, iter2;
3884 init_call_expr_arg_iterator (t1, &iter1);
3885 init_call_expr_arg_iterator (t2, &iter2);
3886 if (iter1.n != iter2.n)
3887 return false;
3888
3889 while (more_call_expr_args_p (&iter1))
3890 {
3891 tree arg1 = next_call_expr_arg (&iter1);
3892 tree arg2 = next_call_expr_arg (&iter2);
3893
3894 gcc_checking_assert (arg1 && arg2)((void)(!(arg1 && arg2) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3894, __FUNCTION__), 0 : 0))
;
3895 if (!cp_tree_equal (arg1, arg2))
3896 return false;
3897 }
3898
3899 return true;
3900 }
3901
3902 case TARGET_EXPR:
3903 {
3904 tree o1 = TREE_OPERAND (t1, 0)(*((const_cast<tree*> (tree_operand_check ((t1), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3904, __FUNCTION__)))))
;
3905 tree o2 = TREE_OPERAND (t2, 0)(*((const_cast<tree*> (tree_operand_check ((t2), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3905, __FUNCTION__)))))
;
3906
3907 /* Special case: if either target is an unallocated VAR_DECL,
3908 it means that it's going to be unified with whatever the
3909 TARGET_EXPR is really supposed to initialize, so treat it
3910 as being equivalent to anything. */
3911 if (VAR_P (o1)(((enum tree_code) (o1)->base.code) == VAR_DECL) && DECL_NAME (o1)((contains_struct_check ((o1), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3911, __FUNCTION__))->decl_minimal.name)
== NULL_TREE(tree) nullptr
3912 && !DECL_RTL_SET_P (o1)(((tree_contains_struct[(((enum tree_code) (o1)->base.code
))][(TS_DECL_WRTL)])) && (contains_struct_check ((o1)
, (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3912, __FUNCTION__))->decl_with_rtl.rtl != nullptr)
)
3913 /*Nop*/;
3914 else if (VAR_P (o2)(((enum tree_code) (o2)->base.code) == VAR_DECL) && DECL_NAME (o2)((contains_struct_check ((o2), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3914, __FUNCTION__))->decl_minimal.name)
== NULL_TREE(tree) nullptr
3915 && !DECL_RTL_SET_P (o2)(((tree_contains_struct[(((enum tree_code) (o2)->base.code
))][(TS_DECL_WRTL)])) && (contains_struct_check ((o2)
, (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3915, __FUNCTION__))->decl_with_rtl.rtl != nullptr)
)
3916 /*Nop*/;
3917 else if (!cp_tree_equal (o1, o2))
3918 return false;
3919
3920 return cp_tree_equal (TREE_OPERAND (t1, 1)(*((const_cast<tree*> (tree_operand_check ((t1), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3920, __FUNCTION__)))))
, TREE_OPERAND (t2, 1)(*((const_cast<tree*> (tree_operand_check ((t2), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3920, __FUNCTION__)))))
);
3921 }
3922
3923 case PARM_DECL:
3924 /* For comparing uses of parameters in late-specified return types
3925 with an out-of-class definition of the function, but can also come
3926 up for expressions that involve 'this' in a member function
3927 template. */
3928
3929 if (comparing_specializations
3930 && DECL_CONTEXT (t1)((contains_struct_check ((t1), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3930, __FUNCTION__))->decl_minimal.context)
!= DECL_CONTEXT (t2)((contains_struct_check ((t2), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3930, __FUNCTION__))->decl_minimal.context)
)
3931 /* When comparing hash table entries, only an exact match is
3932 good enough; we don't want to replace 'this' with the
3933 version from another function. But be more flexible
3934 with parameters with identical contexts. */
3935 return false;
3936
3937 if (same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))comptypes ((((contains_struct_check ((t1), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3937, __FUNCTION__))->typed.type)), (((contains_struct_check
((t2), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3937, __FUNCTION__))->typed.type)), 0)
)
3938 {
3939 if (DECL_ARTIFICIAL (t1)((contains_struct_check ((t1), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3939, __FUNCTION__))->decl_common.artificial_flag)
^ DECL_ARTIFICIAL (t2)((contains_struct_check ((t2), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3939, __FUNCTION__))->decl_common.artificial_flag)
)
3940 return false;
3941 if (CONSTRAINT_VAR_P (t1)((contains_struct_check (((tree_check ((t1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3941, __FUNCTION__, (PARM_DECL)))), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3941, __FUNCTION__))->decl_common.lang_flag_2)
^ CONSTRAINT_VAR_P (t2)((contains_struct_check (((tree_check ((t2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3941, __FUNCTION__, (PARM_DECL)))), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3941, __FUNCTION__))->decl_common.lang_flag_2)
)
3942 return false;
3943 if (DECL_ARTIFICIAL (t1)((contains_struct_check ((t1), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3943, __FUNCTION__))->decl_common.artificial_flag)
3944 || (DECL_PARM_LEVEL (t1)(__extension__ ({ struct lang_decl *lt = ((contains_struct_check
((t1), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3944, __FUNCTION__))->decl_common.lang_specific); if (((
enum tree_code) (t1)->base.code) != PARM_DECL || lt->u.
base.selector != lds_parm) lang_check_failed ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3944, __FUNCTION__); &lt->u.parm; })->level)
== DECL_PARM_LEVEL (t2)(__extension__ ({ struct lang_decl *lt = ((contains_struct_check
((t2), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3944, __FUNCTION__))->decl_common.lang_specific); if (((
enum tree_code) (t2)->base.code) != PARM_DECL || lt->u.
base.selector != lds_parm) lang_check_failed ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3944, __FUNCTION__); &lt->u.parm; })->level)
3945 && DECL_PARM_INDEX (t1)(__extension__ ({ struct lang_decl *lt = ((contains_struct_check
((t1), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3945, __FUNCTION__))->decl_common.lang_specific); if (((
enum tree_code) (t1)->base.code) != PARM_DECL || lt->u.
base.selector != lds_parm) lang_check_failed ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3945, __FUNCTION__); &lt->u.parm; })->index)
== DECL_PARM_INDEX (t2)(__extension__ ({ struct lang_decl *lt = ((contains_struct_check
((t2), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3945, __FUNCTION__))->decl_common.lang_specific); if (((
enum tree_code) (t2)->base.code) != PARM_DECL || lt->u.
base.selector != lds_parm) lang_check_failed ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3945, __FUNCTION__); &lt->u.parm; })->index)
))
3946 return true;
3947 }
3948 return false;
3949
3950 case VAR_DECL:
3951 case CONST_DECL:
3952 case FIELD_DECL:
3953 case FUNCTION_DECL:
3954 case TEMPLATE_DECL:
3955 case IDENTIFIER_NODE:
3956 case SSA_NAME:
3957 case USING_DECL:
3958 case DEFERRED_PARSE:
3959 return false;
3960
3961 case BASELINK:
3962 return (BASELINK_BINFO (t1)(((struct tree_baselink*) (tree_check ((t1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3962, __FUNCTION__, (BASELINK))))->binfo)
== BASELINK_BINFO (t2)(((struct tree_baselink*) (tree_check ((t2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3962, __FUNCTION__, (BASELINK))))->binfo)
3963 && BASELINK_ACCESS_BINFO (t1)(((struct tree_baselink*) (tree_check ((t1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3963, __FUNCTION__, (BASELINK))))->access_binfo)
== BASELINK_ACCESS_BINFO (t2)(((struct tree_baselink*) (tree_check ((t2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3963, __FUNCTION__, (BASELINK))))->access_binfo)
3964 && BASELINK_QUALIFIED_P (t1)((tree_not_check2 (((tree_check ((t1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3964, __FUNCTION__, (BASELINK)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3964, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)
== BASELINK_QUALIFIED_P (t2)((tree_not_check2 (((tree_check ((t2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3964, __FUNCTION__, (BASELINK)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3964, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)
3965 && cp_tree_equal (BASELINK_FUNCTIONS (t1)(((struct tree_baselink*) (tree_check ((t1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3965, __FUNCTION__, (BASELINK))))->functions)
,
3966 BASELINK_FUNCTIONS (t2)(((struct tree_baselink*) (tree_check ((t2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3966, __FUNCTION__, (BASELINK))))->functions)
));
3967
3968 case TEMPLATE_PARM_INDEX:
3969 return (TEMPLATE_PARM_IDX (t1)(((template_parm_index*)(tree_check ((t1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3969, __FUNCTION__, (TEMPLATE_PARM_INDEX))))->index)
== TEMPLATE_PARM_IDX (t2)(((template_parm_index*)(tree_check ((t2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3969, __FUNCTION__, (TEMPLATE_PARM_INDEX))))->index)
3970 && TEMPLATE_PARM_LEVEL (t1)(((template_parm_index*)(tree_check ((t1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3970, __FUNCTION__, (TEMPLATE_PARM_INDEX))))->level)
== TEMPLATE_PARM_LEVEL (t2)(((template_parm_index*)(tree_check ((t2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3970, __FUNCTION__, (TEMPLATE_PARM_INDEX))))->level)
3971 && (TEMPLATE_PARM_PARAMETER_PACK (t1)(((tree_not_check2 (((tree_check ((t1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3971, __FUNCTION__, (TEMPLATE_PARM_INDEX)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3971, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0))
3972 == TEMPLATE_PARM_PARAMETER_PACK (t2)(((tree_not_check2 (((tree_check ((t2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3972, __FUNCTION__, (TEMPLATE_PARM_INDEX)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3972, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0))
)
3973 && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1)),comptypes ((((contains_struct_check (((((template_parm_index*
)(tree_check ((t1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3973, __FUNCTION__, (TEMPLATE_PARM_INDEX))))->decl)), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3973, __FUNCTION__))->typed.type)), (((contains_struct_check
(((((template_parm_index*)(tree_check ((t2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3974, __FUNCTION__, (TEMPLATE_PARM_INDEX))))->decl)), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3974, __FUNCTION__))->typed.type)), 0)
3974 TREE_TYPE (TEMPLATE_PARM_DECL (t2)))comptypes ((((contains_struct_check (((((template_parm_index*
)(tree_check ((t1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3973, __FUNCTION__, (TEMPLATE_PARM_INDEX))))->decl)), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3973, __FUNCTION__))->typed.type)), (((contains_struct_check
(((((template_parm_index*)(tree_check ((t2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3974, __FUNCTION__, (TEMPLATE_PARM_INDEX))))->decl)), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3974, __FUNCTION__))->typed.type)), 0)
);
3975
3976 case TEMPLATE_ID_EXPR:
3977 if (!cp_tree_equal (TREE_OPERAND (t1, 0)(*((const_cast<tree*> (tree_operand_check ((t1), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3977, __FUNCTION__)))))
, TREE_OPERAND (t2, 0)(*((const_cast<tree*> (tree_operand_check ((t2), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3977, __FUNCTION__)))))
))
3978 return false;
3979 if (!comp_template_args (TREE_OPERAND (t1, 1)(*((const_cast<tree*> (tree_operand_check ((t1), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3979, __FUNCTION__)))))
, TREE_OPERAND (t2, 1)(*((const_cast<tree*> (tree_operand_check ((t2), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3979, __FUNCTION__)))))
))
3980 return false;
3981 return true;
3982
3983 case CONSTRAINT_INFO:
3984 return cp_tree_equal (CI_ASSOCIATED_CONSTRAINTS (t1)check_constraint_info (check_nonnull (t1))->associated_constr,
3985 CI_ASSOCIATED_CONSTRAINTS (t2)check_constraint_info (check_nonnull (t2))->associated_constr);
3986
3987 case CHECK_CONSTR:
3988 return (CHECK_CONSTR_CONCEPT (t1)(*((const_cast<tree*> (tree_operand_check (((tree_check
((t1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3988, __FUNCTION__, (CHECK_CONSTR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3988, __FUNCTION__)))))
== CHECK_CONSTR_CONCEPT (t2)(*((const_cast<tree*> (tree_operand_check (((tree_check
((t2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3988, __FUNCTION__, (CHECK_CONSTR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3988, __FUNCTION__)))))
3989 && comp_template_args (CHECK_CONSTR_ARGS (t1)(*((const_cast<tree*> (tree_operand_check (((tree_check
((t1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3989, __FUNCTION__, (CHECK_CONSTR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3989, __FUNCTION__)))))
,
3990 CHECK_CONSTR_ARGS (t2)(*((const_cast<tree*> (tree_operand_check (((tree_check
((t2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3990, __FUNCTION__, (CHECK_CONSTR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 3990, __FUNCTION__)))))
));
3991
3992 case TREE_VEC:
3993 /* These are template args. Really we should be getting the
3994 caller to do this as it knows it to be true. */
3995 if (!comp_template_args (t1, t2, NULLnullptr, NULLnullptr, false))
3996 return false;
3997 return true;
3998
3999 case SIZEOF_EXPR:
4000 case ALIGNOF_EXPR:
4001 {
4002 tree o1 = TREE_OPERAND (t1, 0)(*((const_cast<tree*> (tree_operand_check ((t1), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4002, __FUNCTION__)))))
;
4003 tree o2 = TREE_OPERAND (t2, 0)(*((const_cast<tree*> (tree_operand_check ((t2), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4003, __FUNCTION__)))))
;
4004
4005 if (code1 == SIZEOF_EXPR)
4006 {
4007 if (SIZEOF_EXPR_TYPE_P (t1)((tree_not_check2 (((tree_check ((t1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4007, __FUNCTION__, (SIZEOF_EXPR)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4007, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)
)
4008 o1 = TREE_TYPE (o1)((contains_struct_check ((o1), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4008, __FUNCTION__))->typed.type)
;
4009 if (SIZEOF_EXPR_TYPE_P (t2)((tree_not_check2 (((tree_check ((t2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4009, __FUNCTION__, (SIZEOF_EXPR)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4009, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)
)
4010 o2 = TREE_TYPE (o2)((contains_struct_check ((o2), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4010, __FUNCTION__))->typed.type)
;
4011 }
4012 else if (ALIGNOF_EXPR_STD_P (t1)((tree_not_check2 (((tree_check ((t1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4012, __FUNCTION__, (ALIGNOF_EXPR)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4012, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)
!= ALIGNOF_EXPR_STD_P (t2)((tree_not_check2 (((tree_check ((t2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4012, __FUNCTION__, (ALIGNOF_EXPR)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4012, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)
)
4013 return false;
4014
4015 if (TREE_CODE (o1)((enum tree_code) (o1)->base.code) != TREE_CODE (o2)((enum tree_code) (o2)->base.code))
4016 return false;
4017
4018 if (ARGUMENT_PACK_P (o1)(((enum tree_code) (o1)->base.code) == TYPE_ARGUMENT_PACK ||
((enum tree_code) (o1)->base.code) == NONTYPE_ARGUMENT_PACK
)
)
4019 return template_args_equal (o1, o2);
4020 else if (TYPE_P (o1)(tree_code_type[(int) (((enum tree_code) (o1)->base.code))
] == tcc_type)
)
4021 return same_type_p (o1, o2)comptypes ((o1), (o2), 0);
4022 else
4023 return cp_tree_equal (o1, o2);
4024 }
4025
4026 case MODOP_EXPR:
4027 {
4028 tree t1_op1, t2_op1;
4029
4030 if (!cp_tree_equal (TREE_OPERAND (t1, 0)(*((const_cast<tree*> (tree_operand_check ((t1), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4030, __FUNCTION__)))))
, TREE_OPERAND (t2, 0)(*((const_cast<tree*> (tree_operand_check ((t2), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4030, __FUNCTION__)))))
))
4031 return false;
4032
4033 t1_op1 = TREE_OPERAND (t1, 1)(*((const_cast<tree*> (tree_operand_check ((t1), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4033, __FUNCTION__)))))
;
4034 t2_op1 = TREE_OPERAND (t2, 1)(*((const_cast<tree*> (tree_operand_check ((t2), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4034, __FUNCTION__)))))
;
4035 if (TREE_CODE (t1_op1)((enum tree_code) (t1_op1)->base.code) != TREE_CODE (t2_op1)((enum tree_code) (t2_op1)->base.code))
4036 return false;
4037
4038 return cp_tree_equal (TREE_OPERAND (t1, 2)(*((const_cast<tree*> (tree_operand_check ((t1), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4038, __FUNCTION__)))))
, TREE_OPERAND (t2, 2)(*((const_cast<tree*> (tree_operand_check ((t2), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4038, __FUNCTION__)))))
);
4039 }
4040
4041 case PTRMEM_CST:
4042 /* Two pointer-to-members are the same if they point to the same
4043 field or function in the same class. */
4044 if (PTRMEM_CST_MEMBER (t1)(((ptrmem_cst_t)(tree_check ((t1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4044, __FUNCTION__, (PTRMEM_CST))))->member)
!= PTRMEM_CST_MEMBER (t2)(((ptrmem_cst_t)(tree_check ((t2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4044, __FUNCTION__, (PTRMEM_CST))))->member)
)
4045 return false;
4046
4047 return same_type_p (PTRMEM_CST_CLASS (t1), PTRMEM_CST_CLASS (t2))comptypes ((((((enum tree_code) (((contains_struct_check (((tree_check
((t1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4047, __FUNCTION__, (PTRMEM_CST)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4047, __FUNCTION__))->typed.type))->base.code) == OFFSET_TYPE
) ? ((tree_check ((((contains_struct_check (((tree_check ((t1
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4047, __FUNCTION__, (PTRMEM_CST)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4047, __FUNCTION__))->typed.type)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4047, __FUNCTION__, (OFFSET_TYPE)))->type_non_common.maxval
) : ((tree_check2 ((((contains_struct_check (((cp_build_qualified_type_real
((((contains_struct_check ((((tree_check3 ((((contains_struct_check
(((tree_check ((t1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4047, __FUNCTION__, (PTRMEM_CST)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4047, __FUNCTION__))->typed.type)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4047, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values)), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4047, __FUNCTION__))->typed.type)), (cp_type_quals (((contains_struct_check
(((tree_check ((t1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4047, __FUNCTION__, (PTRMEM_CST)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4047, __FUNCTION__))->typed.type))), tf_warning_or_error
))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4047, __FUNCTION__))->typed.type)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4047, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))->type_non_common
.maxval))), (((((enum tree_code) (((contains_struct_check (((
tree_check ((t2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4047, __FUNCTION__, (PTRMEM_CST)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4047, __FUNCTION__))->typed.type))->base.code) == OFFSET_TYPE
) ? ((tree_check ((((contains_struct_check (((tree_check ((t2
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4047, __FUNCTION__, (PTRMEM_CST)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4047, __FUNCTION__))->typed.type)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4047, __FUNCTION__, (OFFSET_TYPE)))->type_non_common.maxval
) : ((tree_check2 ((((contains_struct_check (((cp_build_qualified_type_real
((((contains_struct_check ((((tree_check3 ((((contains_struct_check
(((tree_check ((t2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4047, __FUNCTION__, (PTRMEM_CST)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4047, __FUNCTION__))->typed.type)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4047, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values)), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4047, __FUNCTION__))->typed.type)), (cp_type_quals (((contains_struct_check
(((tree_check ((t2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4047, __FUNCTION__, (PTRMEM_CST)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4047, __FUNCTION__))->typed.type))), tf_warning_or_error
))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4047, __FUNCTION__))->typed.type)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4047, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))->type_non_common
.maxval))), 0)
;
4048
4049 case OVERLOAD:
4050 {
4051 /* Two overloads. Must be exactly the same set of decls. */
4052 lkp_iterator first (t1);
4053 lkp_iterator second (t2);
4054
4055 for (; first && second; ++first, ++second)
4056 if (*first != *second)
4057 return false;
4058 return !(first || second);
4059 }
4060
4061 case TRAIT_EXPR:
4062 if (TRAIT_EXPR_KIND (t1)(((struct tree_trait_expr *)(tree_check ((t1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4062, __FUNCTION__, (TRAIT_EXPR))))->kind)
!= TRAIT_EXPR_KIND (t2)(((struct tree_trait_expr *)(tree_check ((t2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4062, __FUNCTION__, (TRAIT_EXPR))))->kind)
)
4063 return false;
4064 return same_type_p (TRAIT_EXPR_TYPE1 (t1), TRAIT_EXPR_TYPE1 (t2))comptypes (((((struct tree_trait_expr *)(tree_check ((t1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4064, __FUNCTION__, (TRAIT_EXPR))))->type1)), ((((struct
tree_trait_expr *)(tree_check ((t2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4064, __FUNCTION__, (TRAIT_EXPR))))->type1)), 0)
4065 && cp_tree_equal (TRAIT_EXPR_TYPE2 (t1)(((struct tree_trait_expr *)(tree_check ((t1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4065, __FUNCTION__, (TRAIT_EXPR))))->type2)
, TRAIT_EXPR_TYPE2 (t2)(((struct tree_trait_expr *)(tree_check ((t2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4065, __FUNCTION__, (TRAIT_EXPR))))->type2)
);
4066
4067 case NON_LVALUE_EXPR:
4068 case VIEW_CONVERT_EXPR:
4069 /* Used for location wrappers with possibly NULL types. */
4070 if (!TREE_TYPE (t1)((contains_struct_check ((t1), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4070, __FUNCTION__))->typed.type)
|| !TREE_TYPE (t2)((contains_struct_check ((t2), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4070, __FUNCTION__))->typed.type)
)
4071 {
4072 if (TREE_TYPE (t1)((contains_struct_check ((t1), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4072, __FUNCTION__))->typed.type)
|| TREE_TYPE (t2)((contains_struct_check ((t2), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4072, __FUNCTION__))->typed.type)
)
4073 return false;
4074 break;
4075 }
4076 /* FALLTHROUGH */
4077
4078 case CAST_EXPR:
4079 case STATIC_CAST_EXPR:
4080 case REINTERPRET_CAST_EXPR:
4081 case CONST_CAST_EXPR:
4082 case DYNAMIC_CAST_EXPR:
4083 case IMPLICIT_CONV_EXPR:
4084 case NEW_EXPR:
4085 case BIT_CAST_EXPR:
4086 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
4087 if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))comptypes ((((contains_struct_check ((t1), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4087, __FUNCTION__))->typed.type)), (((contains_struct_check
((t2), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4087, __FUNCTION__))->typed.type)), 0)
)
4088 return false;
4089 /* Now compare operands as usual. */
4090 break;
4091
4092 case DEFERRED_NOEXCEPT:
4093 return (cp_tree_equal (DEFERRED_NOEXCEPT_PATTERN (t1)(((struct tree_deferred_noexcept *)(tree_check ((t1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4093, __FUNCTION__, (DEFERRED_NOEXCEPT))))->pattern)
,
4094 DEFERRED_NOEXCEPT_PATTERN (t2)(((struct tree_deferred_noexcept *)(tree_check ((t2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4094, __FUNCTION__, (DEFERRED_NOEXCEPT))))->pattern)
)
4095 && comp_template_args (DEFERRED_NOEXCEPT_ARGS (t1)(((struct tree_deferred_noexcept *)(tree_check ((t1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4095, __FUNCTION__, (DEFERRED_NOEXCEPT))))->args)
,
4096 DEFERRED_NOEXCEPT_ARGS (t2)(((struct tree_deferred_noexcept *)(tree_check ((t2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4096, __FUNCTION__, (DEFERRED_NOEXCEPT))))->args)
));
4097
4098 case LAMBDA_EXPR:
4099 /* Two lambda-expressions are never considered equivalent. */
4100 return false;
4101
4102 case TYPE_ARGUMENT_PACK:
4103 case NONTYPE_ARGUMENT_PACK:
4104 {
4105 tree p1 = ARGUMENT_PACK_ARGS (t1)(((enum tree_code) (t1)->base.code) == TYPE_ARGUMENT_PACK?
((contains_struct_check ((t1), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4105, __FUNCTION__))->typed.type) : (*((const_cast<tree
*> (tree_operand_check ((t1), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4105, __FUNCTION__))))))
;
4106 tree p2 = ARGUMENT_PACK_ARGS (t2)(((enum tree_code) (t2)->base.code) == TYPE_ARGUMENT_PACK?
((contains_struct_check ((t2), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4106, __FUNCTION__))->typed.type) : (*((const_cast<tree
*> (tree_operand_check ((t2), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4106, __FUNCTION__))))))
;
4107 int len = TREE_VEC_LENGTH (p1)((tree_check ((p1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4107, __FUNCTION__, (TREE_VEC)))->base.u.length)
;
4108 if (TREE_VEC_LENGTH (p2)((tree_check ((p2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4108, __FUNCTION__, (TREE_VEC)))->base.u.length)
!= len)
4109 return false;
4110
4111 for (int ix = 0; ix != len; ix++)
4112 if (!template_args_equal (TREE_VEC_ELT (p1, ix)(*((const_cast<tree *> (tree_vec_elt_check ((p1), (ix),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4112, __FUNCTION__)))))
,
4113 TREE_VEC_ELT (p2, ix)(*((const_cast<tree *> (tree_vec_elt_check ((p2), (ix),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4113, __FUNCTION__)))))
))
4114 return false;
4115 return true;
4116 }
4117
4118 case EXPR_PACK_EXPANSION:
4119 if (!cp_tree_equal (PACK_EXPANSION_PATTERN (t1)(((enum tree_code) (t1)->base.code) == TYPE_PACK_EXPANSION
? ((contains_struct_check ((t1), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4119, __FUNCTION__))->typed.type) : (*((const_cast<tree
*> (tree_operand_check ((t1), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4119, __FUNCTION__))))))
,
4120 PACK_EXPANSION_PATTERN (t2)(((enum tree_code) (t2)->base.code) == TYPE_PACK_EXPANSION
? ((contains_struct_check ((t2), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4120, __FUNCTION__))->typed.type) : (*((const_cast<tree
*> (tree_operand_check ((t2), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4120, __FUNCTION__))))))
))
4121 return false;
4122 if (!comp_template_args (PACK_EXPANSION_EXTRA_ARGS (t1)*(((enum tree_code) (t1)->base.code) == TYPE_PACK_EXPANSION
? &((tree_class_check ((t1), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4122, __FUNCTION__))->type_non_common.maxval) : &(*(
(const_cast<tree*> (tree_operand_check (((t1)), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4122, __FUNCTION__))))))
,
4123 PACK_EXPANSION_EXTRA_ARGS (t2)*(((enum tree_code) (t2)->base.code) == TYPE_PACK_EXPANSION
? &((tree_class_check ((t2), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4123, __FUNCTION__))->type_non_common.maxval) : &(*(
(const_cast<tree*> (tree_operand_check (((t2)), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4123, __FUNCTION__))))))
))
4124 return false;
4125 return true;
4126
4127 default:
4128 break;
4129 }
4130
4131 switch (TREE_CODE_CLASS (code1)tree_code_type[(int) (code1)])
4132 {
4133 case tcc_unary:
4134 case tcc_binary:
4135 case tcc_comparison:
4136 case tcc_expression:
4137 case tcc_vl_exp:
4138 case tcc_reference:
4139 case tcc_statement:
4140 {
4141 int n = cp_tree_operand_length (t1);
4142 if (TREE_CODE_CLASS (code1)tree_code_type[(int) (code1)] == tcc_vl_exp
4143 && n != TREE_OPERAND_LENGTH (t2)tree_operand_length (t2))
4144 return false;
4145
4146 for (int i = 0; i < n; ++i)
4147 if (!cp_tree_equal (TREE_OPERAND (t1, i)(*((const_cast<tree*> (tree_operand_check ((t1), (i), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4147, __FUNCTION__)))))
, TREE_OPERAND (t2, i)(*((const_cast<tree*> (tree_operand_check ((t2), (i), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4147, __FUNCTION__)))))
))
4148 return false;
4149
4150 return true;
4151 }
4152
4153 case tcc_type:
4154 return same_type_p (t1, t2)comptypes ((t1), (t2), 0);
4155
4156 default:
4157 gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4157, __FUNCTION__))
;
4158 }
4159
4160 /* We can get here with --disable-checking. */
4161 return false;
4162}
4163
4164/* The type of ARG when used as an lvalue. */
4165
4166tree
4167lvalue_type (tree arg)
4168{
4169 tree type = TREE_TYPE (arg)((contains_struct_check ((arg), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4169, __FUNCTION__))->typed.type)
;
4170 return type;
4171}
4172
4173/* The type of ARG for printing error messages; denote lvalues with
4174 reference types. */
4175
4176tree
4177error_type (tree arg)
4178{
4179 tree type = TREE_TYPE (arg)((contains_struct_check ((arg), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4179, __FUNCTION__))->typed.type)
;
4180
4181 if (TREE_CODE (type)((enum tree_code) (type)->base.code) == ARRAY_TYPE)
4182 ;
4183 else if (TREE_CODE (type)((enum tree_code) (type)->base.code) == ERROR_MARK)
4184 ;
4185 else if (lvalue_p (arg))
4186 type = build_reference_type (lvalue_type (arg));
4187 else if (MAYBE_CLASS_TYPE_P (type)((((enum tree_code) (type)->base.code) == TEMPLATE_TYPE_PARM
|| ((enum tree_code) (type)->base.code) == TYPENAME_TYPE ||
((enum tree_code) (type)->base.code) == TYPEOF_TYPE || ((
enum tree_code) (type)->base.code) == BOUND_TEMPLATE_TEMPLATE_PARM
|| ((enum tree_code) (type)->base.code) == DECLTYPE_TYPE)
|| (((((enum tree_code) (type)->base.code)) == RECORD_TYPE
|| (((enum tree_code) (type)->base.code)) == UNION_TYPE) &&
((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4187, __FUNCTION__))->type_common.lang_flag_5)))
)
4188 type = lvalue_type (arg);
4189
4190 return type;
4191}
4192
4193/* Does FUNCTION use a variable-length argument list? */
4194
4195int
4196varargs_function_p (const_tree function)
4197{
4198 return stdarg_p (TREE_TYPE (function)((contains_struct_check ((function), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4198, __FUNCTION__))->typed.type)
);
4199}
4200
4201/* Returns 1 if decl is a member of a class. */
4202
4203int
4204member_p (const_tree decl)
4205{
4206 const_tree const ctx = DECL_CONTEXT (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4206, __FUNCTION__))->decl_minimal.context)
;
4207 return (ctx && TYPE_P (ctx)(tree_code_type[(int) (((enum tree_code) (ctx)->base.code)
)] == tcc_type)
);
4208}
4209
4210/* Create a placeholder for member access where we don't actually have an
4211 object that the access is against. For a general declval<T> equivalent,
4212 use build_stub_object instead. */
4213
4214tree
4215build_dummy_object (tree type)
4216{
4217 tree decl = build1 (CONVERT_EXPR, build_pointer_type (type), void_nodeglobal_trees[TI_VOID]);
4218 return cp_build_fold_indirect_ref (decl);
4219}
4220
4221/* We've gotten a reference to a member of TYPE. Return *this if appropriate,
4222 or a dummy object otherwise. If BINFOP is non-0, it is filled with the
4223 binfo path from current_class_type to TYPE, or 0. */
4224
4225tree
4226maybe_dummy_object (tree type, tree* binfop)
4227{
4228 tree decl, context;
4229 tree binfo;
4230 tree current = current_nonlambda_class_type ();
4231
4232 if (current
4233 && (binfo = lookup_base (current, type, ba_any, NULLnullptr,
4234 tf_warning_or_error)))
4235 context = current;
4236 else
4237 {
4238 /* Reference from a nested class member function. */
4239 context = type;
4240 binfo = TYPE_BINFO (type)((tree_check3 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4240, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.maxval)
;
4241 }
4242
4243 if (binfop)
4244 *binfop = binfo;
4245
4246 if (current_class_ref(*((cfun + 0) && ((cfun + 0)->language) ? &((cfun
+ 0)->language)->x_current_class_ref : &scope_chain
->x_current_class_ref))
4247 /* current_class_ref might not correspond to current_class_type if
4248 we're in tsubst_default_argument or a lambda-declarator; in either
4249 case, we want to use current_class_ref if it matches CONTEXT. */
4250 && (same_type_ignoring_top_level_qualifiers_p
4251 (TREE_TYPE (current_class_ref)((contains_struct_check (((*((cfun + 0) && ((cfun + 0
)->language) ? &((cfun + 0)->language)->x_current_class_ref
: &scope_chain->x_current_class_ref))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4251, __FUNCTION__))->typed.type)
, context)))
4252 decl = current_class_ref(*((cfun + 0) && ((cfun + 0)->language) ? &((cfun
+ 0)->language)->x_current_class_ref : &scope_chain
->x_current_class_ref))
;
4253 else
4254 decl = build_dummy_object (context);
4255
4256 return decl;
4257}
4258
4259/* Returns 1 if OB is a placeholder object, or a pointer to one. */
4260
4261bool
4262is_dummy_object (const_tree ob)
4263{
4264 if (INDIRECT_REF_P (ob)(((enum tree_code) (ob)->base.code) == INDIRECT_REF))
4265 ob = TREE_OPERAND (ob, 0)(*((const_cast<tree*> (tree_operand_check ((ob), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4265, __FUNCTION__)))))
;
4266 return (TREE_CODE (ob)((enum tree_code) (ob)->base.code) == CONVERT_EXPR
4267 && TREE_OPERAND (ob, 0)(*((const_cast<tree*> (tree_operand_check ((ob), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4267, __FUNCTION__)))))
== void_nodeglobal_trees[TI_VOID]);
4268}
4269
4270/* Returns true if TYPE is char, unsigned char, or std::byte. */
4271
4272bool
4273is_byte_access_type (tree type)
4274{
4275 type = TYPE_MAIN_VARIANT (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4275, __FUNCTION__))->type_common.main_variant)
;
4276 if (type == char_type_nodeinteger_types[itk_char]
4277 || type == unsigned_char_type_nodeinteger_types[itk_unsigned_char])
4278 return true;
4279
4280 return (TREE_CODE (type)((enum tree_code) (type)->base.code) == ENUMERAL_TYPE
4281 && TYPE_CONTEXT (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4281, __FUNCTION__))->type_common.context)
== std_nodecp_global_trees[CPTI_STD]
4282 && !strcmp ("byte", TYPE_NAME_STRING (type)(((const char *) (tree_check (((((tree_class_check ((type), (
tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4282, __FUNCTION__))->type_common.name) && (tree_code_type
[(int) (((enum tree_code) (((tree_class_check ((type), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4282, __FUNCTION__))->type_common.name))->base.code))
] == tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4282, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4282, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4282, __FUNCTION__))->type_common.name))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4282, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
))
));
4283}
4284
4285/* Returns 1 iff type T is something we want to treat as a scalar type for
4286 the purpose of deciding whether it is trivial/POD/standard-layout. */
4287
4288bool
4289scalarish_type_p (const_tree t)
4290{
4291 if (t == error_mark_nodeglobal_trees[TI_ERROR_MARK])
4292 return 1;
4293
4294 return (SCALAR_TYPE_P (t)((((enum tree_code) (t)->base.code) == OFFSET_TYPE) || ((enum
tree_code) (t)->base.code) == ENUMERAL_TYPE || ((((enum tree_code
) (t)->base.code) == BOOLEAN_TYPE || ((enum tree_code) (t)
->base.code) == INTEGER_TYPE) || ((enum tree_code) (t)->
base.code) == REAL_TYPE || ((enum tree_code) (t)->base.code
) == COMPLEX_TYPE) || (((enum tree_code) (t)->base.code) ==
POINTER_TYPE) || (((enum tree_code) (t)->base.code) == RECORD_TYPE
&& (((tree_class_check (((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4294, __FUNCTION__, (RECORD_TYPE)))), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4294, __FUNCTION__))->type_common.lang_flag_2))) || (((enum
tree_code) (t)->base.code) == NULLPTR_TYPE))
|| VECTOR_TYPE_P (t)(((enum tree_code) (t)->base.code) == VECTOR_TYPE));
4295}
4296
4297/* Returns true iff T requires non-trivial default initialization. */
4298
4299bool
4300type_has_nontrivial_default_init (const_tree t)
4301{
4302 t = strip_array_types (CONST_CAST_TREE (t)(const_cast<union tree_node *> (((t)))));
4303
4304 if (CLASS_TYPE_P (t)(((((enum tree_code) (t)->base.code)) == RECORD_TYPE || ((
(enum tree_code) (t)->base.code)) == UNION_TYPE) &&
((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4304, __FUNCTION__))->type_common.lang_flag_5))
)
4305 return TYPE_HAS_COMPLEX_DFLT (t)((((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4305, __FUNCTION__))->type_with_lang_specific.lang_specific
))->has_complex_dflt)
;
4306 else
4307 return 0;
4308}
4309
4310/* Track classes with only deleted copy/move constructors so that we can warn
4311 if they are used in call/return by value. */
4312
4313static GTY(()) hash_set<tree>* deleted_copy_types;
4314static void
4315remember_deleted_copy (const_tree t)
4316{
4317 if (!deleted_copy_types)
4318 deleted_copy_types = hash_set<tree>::create_ggc(37);
4319 deleted_copy_types->add (CONST_CAST_TREE (t)(const_cast<union tree_node *> (((t)))));
4320}
4321void
4322maybe_warn_parm_abi (tree t, location_t loc)
4323{
4324 if (!deleted_copy_types
4325 || !deleted_copy_types->contains (t))
4326 return;
4327
4328 if ((flag_abi_versionglobal_options.x_flag_abi_version == 12 || warn_abi_version == 12)
4329 && classtype_has_non_deleted_move_ctor (t))
4330 {
4331 bool w;
4332 auto_diagnostic_group d;
4333 if (flag_abi_versionglobal_options.x_flag_abi_version > 12)
4334 w = warning_at (loc, OPT_Wabi, "%<-fabi-version=13%> (GCC 8.2) fixes "
4335 "the calling convention for %qT, which was "
4336 "accidentally changed in 8.1", t);
4337 else
4338 w = warning_at (loc, OPT_Wabi, "%<-fabi-version=12%> (GCC 8.1) accident"
4339 "ally changes the calling convention for %qT", t);
4340 if (w)
4341 inform (location_of (t), " declared here");
4342 return;
4343 }
4344
4345 auto_diagnostic_group d;
4346 if (warning_at (loc, OPT_Wabi, "the calling convention for %qT changes in "
4347 "%<-fabi-version=13%> (GCC 8.2)", t))
4348 inform (location_of (t), " because all of its copy and move "
4349 "constructors are deleted");
4350}
4351
4352/* Returns true iff copying an object of type T (including via move
4353 constructor) is non-trivial. That is, T has no non-trivial copy
4354 constructors and no non-trivial move constructors, and not all copy/move
4355 constructors are deleted. This function implements the ABI notion of
4356 non-trivial copy, which has diverged from the one in the standard. */
4357
4358bool
4359type_has_nontrivial_copy_init (const_tree type)
4360{
4361 tree t = strip_array_types (CONST_CAST_TREE (type)(const_cast<union tree_node *> (((type)))));
4362
4363 if (CLASS_TYPE_P (t)(((((enum tree_code) (t)->base.code)) == RECORD_TYPE || ((
(enum tree_code) (t)->base.code)) == UNION_TYPE) &&
((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4363, __FUNCTION__))->type_common.lang_flag_5))
)
4364 {
4365 gcc_assert (COMPLETE_TYPE_P (t))((void)(!((((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4365, __FUNCTION__))->type_common.size) != (tree) nullptr
)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4365, __FUNCTION__), 0 : 0))
;
4366
4367 if (TYPE_HAS_COMPLEX_COPY_CTOR (t)((((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4367, __FUNCTION__))->type_with_lang_specific.lang_specific
))->has_complex_copy_ctor)
4368 || TYPE_HAS_COMPLEX_MOVE_CTOR (t)((((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4368, __FUNCTION__))->type_with_lang_specific.lang_specific
))->has_complex_move_ctor)
)
4369 /* Nontrivial. */
4370 return true;
4371
4372 if (cxx_dialect < cxx11)
4373 /* No deleted functions before C++11. */
4374 return false;
4375
4376 /* Before ABI v12 we did a bitwise copy of types with only deleted
4377 copy/move constructors. */
4378 if (!abi_version_at_least (12)(global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (12))
4379 && !(warn_abiglobal_options.x_warn_abi && abi_version_crosses (12)((global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (12)) != (warn_abi_version == 0 || warn_abi_version >=
(12)))
))
4380 return false;
4381
4382 bool saw_copy = false;
4383 bool saw_non_deleted = false;
4384 bool saw_non_deleted_move = false;
4385
4386 if (CLASSTYPE_LAZY_MOVE_CTOR (t)((((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4386, __FUNCTION__))->type_with_lang_specific.lang_specific
))->lazy_move_ctor)
)
4387 saw_copy = saw_non_deleted = true;
4388 else if (CLASSTYPE_LAZY_COPY_CTOR (t)((((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4388, __FUNCTION__))->type_with_lang_specific.lang_specific
))->lazy_copy_ctor)
)
4389 {
4390 saw_copy = true;
4391 if (classtype_has_move_assign_or_move_ctor_p (t, true))
4392 /* [class.copy]/8 If the class definition declares a move
4393 constructor or move assignment operator, the implicitly declared
4394 copy constructor is defined as deleted.... */;
4395 else
4396 /* Any other reason the implicitly-declared function would be
4397 deleted would also cause TYPE_HAS_COMPLEX_COPY_CTOR to be
4398 set. */
4399 saw_non_deleted = true;
4400 }
4401
4402 if (!saw_non_deleted)
4403 for (ovl_iterator iter (CLASSTYPE_CONSTRUCTORS (t)(get_class_binding_direct (t, cp_global_trees[CPTI_CTOR_IDENTIFIER
]))
); iter; ++iter)
4404 {
4405 tree fn = *iter;
4406 if (copy_fn_p (fn))
4407 {
4408 saw_copy = true;
4409 if (!DECL_DELETED_FN (fn)(__extension__ ({ struct lang_decl *lt = ((contains_struct_check
(((((enum tree_code) (fn)->base.code) == TEMPLATE_DECL ? (
(struct tree_template_decl *)(const_cast<union tree_node *
> ((((tree_check ((fn), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4409, __FUNCTION__, (TEMPLATE_DECL))))))))->result : fn)
), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4409, __FUNCTION__))->decl_common.lang_specific); if (!(
((enum tree_code) (fn)->base.code) == FUNCTION_DECL || (((
enum tree_code) (fn)->base.code) == TEMPLATE_DECL &&
((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((fn), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4409, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) nullptr && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((fn),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4409, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->
base.code) == FUNCTION_DECL)) || lt->u.base.selector != lds_fn
) lang_check_failed ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4409, __FUNCTION__); &lt->u.fn; })->min.base.threadprivate_or_deleted_p
)
)
4410 {
4411 /* Not deleted, therefore trivial. */
4412 saw_non_deleted = true;
4413 break;
4414 }
4415 }
4416 else if (move_fn_p (fn))
4417 if (!DECL_DELETED_FN (fn)(__extension__ ({ struct lang_decl *lt = ((contains_struct_check
(((((enum tree_code) (fn)->base.code) == TEMPLATE_DECL ? (
(struct tree_template_decl *)(const_cast<union tree_node *
> ((((tree_check ((fn), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4417, __FUNCTION__, (TEMPLATE_DECL))))))))->result : fn)
), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4417, __FUNCTION__))->decl_common.lang_specific); if (!(
((enum tree_code) (fn)->base.code) == FUNCTION_DECL || (((
enum tree_code) (fn)->base.code) == TEMPLATE_DECL &&
((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((fn), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4417, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) nullptr && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((fn),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4417, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->
base.code) == FUNCTION_DECL)) || lt->u.base.selector != lds_fn
) lang_check_failed ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4417, __FUNCTION__); &lt->u.fn; })->min.base.threadprivate_or_deleted_p
)
)
4418 saw_non_deleted_move = true;
4419 }
4420
4421 gcc_assert (saw_copy)((void)(!(saw_copy) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4421, __FUNCTION__), 0 : 0))
;
4422
4423 /* ABI v12 buggily ignored move constructors. */
4424 bool v11nontriv = false;
4425 bool v12nontriv = !saw_non_deleted;
4426 bool v13nontriv = !saw_non_deleted && !saw_non_deleted_move;
4427 bool nontriv = (abi_version_at_least (13)(global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (13))
? v13nontriv
4428 : flag_abi_versionglobal_options.x_flag_abi_version == 12 ? v12nontriv
4429 : v11nontriv);
4430 bool warn_nontriv = (warn_abi_version >= 13 ? v13nontriv
4431 : warn_abi_version == 12 ? v12nontriv
4432 : v11nontriv);
4433 if (nontriv != warn_nontriv)
4434 remember_deleted_copy (t);
4435
4436 return nontriv;
4437 }
4438 else
4439 return 0;
4440}
4441
4442/* Returns 1 iff type T is a trivially copyable type, as defined in
4443 [basic.types] and [class]. */
4444
4445bool
4446trivially_copyable_p (const_tree t)
4447{
4448 t = strip_array_types (CONST_CAST_TREE (t)(const_cast<union tree_node *> (((t)))));
4449
4450 if (CLASS_TYPE_P (t)(((((enum tree_code) (t)->base.code)) == RECORD_TYPE || ((
(enum tree_code) (t)->base.code)) == UNION_TYPE) &&
((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4450, __FUNCTION__))->type_common.lang_flag_5))
)
4451 return ((!TYPE_HAS_COPY_CTOR (t)((((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4451, __FUNCTION__))->type_with_lang_specific.lang_specific
))->has_copy_ctor)
4452 || !TYPE_HAS_COMPLEX_COPY_CTOR (t)((((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4452, __FUNCTION__))->type_with_lang_specific.lang_specific
))->has_complex_copy_ctor)
)
4453 && !TYPE_HAS_COMPLEX_MOVE_CTOR (t)((((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4453, __FUNCTION__))->type_with_lang_specific.lang_specific
))->has_complex_move_ctor)
4454 && (!TYPE_HAS_COPY_ASSIGN (t)((((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4454, __FUNCTION__))->type_with_lang_specific.lang_specific
))->has_copy_assign)
4455 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (t)((((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4455, __FUNCTION__))->type_with_lang_specific.lang_specific
))->has_complex_copy_assign)
)
4456 && !TYPE_HAS_COMPLEX_MOVE_ASSIGN (t)((((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4456, __FUNCTION__))->type_with_lang_specific.lang_specific
))->has_complex_move_assign)
4457 && TYPE_HAS_TRIVIAL_DESTRUCTOR (t)(!(((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4457, __FUNCTION__))->type_common.lang_flag_4)))
);
4458 else
4459 /* CWG 2094 makes volatile-qualified scalars trivially copyable again. */
4460 return scalarish_type_p (t);
4461}
4462
4463/* Returns 1 iff type T is a trivial type, as defined in [basic.types] and
4464 [class]. */
4465
4466bool
4467trivial_type_p (const_tree t)
4468{
4469 t = strip_array_types (CONST_CAST_TREE (t)(const_cast<union tree_node *> (((t)))));
4470
4471 if (CLASS_TYPE_P (t)(((((enum tree_code) (t)->base.code)) == RECORD_TYPE || ((
(enum tree_code) (t)->base.code)) == UNION_TYPE) &&
((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4471, __FUNCTION__))->type_common.lang_flag_5))
)
4472 return (TYPE_HAS_TRIVIAL_DFLT (t)(((((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4472, __FUNCTION__))->type_with_lang_specific.lang_specific
))->has_default_ctor) && ! ((((tree_class_check ((
t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4472, __FUNCTION__))->type_with_lang_specific.lang_specific
))->has_complex_dflt))
4473 && trivially_copyable_p (t));
4474 else
4475 return scalarish_type_p (t);
4476}
4477
4478/* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
4479
4480bool
4481pod_type_p (const_tree t)
4482{
4483 /* This CONST_CAST is okay because strip_array_types returns its
4484 argument unmodified and we assign it to a const_tree. */
4485 t = strip_array_types (CONST_CAST_TREE(t)(const_cast<union tree_node *> (((t)))));
4486
4487 if (!CLASS_TYPE_P (t)(((((enum tree_code) (t)->base.code)) == RECORD_TYPE || ((
(enum tree_code) (t)->base.code)) == UNION_TYPE) &&
((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4487, __FUNCTION__))->type_common.lang_flag_5))
)
4488 return scalarish_type_p (t);
4489 else if (cxx_dialect > cxx98)
4490 /* [class]/10: A POD struct is a class that is both a trivial class and a
4491 standard-layout class, and has no non-static data members of type
4492 non-POD struct, non-POD union (or array of such types).
4493
4494 We don't need to check individual members because if a member is
4495 non-std-layout or non-trivial, the class will be too. */
4496 return (std_layout_type_p (t) && trivial_type_p (t));
4497 else
4498 /* The C++98 definition of POD is different. */
4499 return !CLASSTYPE_NON_LAYOUT_POD_P (t)((((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4499, __FUNCTION__))->type_with_lang_specific.lang_specific
))->non_pod_class)
;
4500}
4501
4502/* Returns true iff T is POD for the purpose of layout, as defined in the
4503 C++ ABI. */
4504
4505bool
4506layout_pod_type_p (const_tree t)
4507{
4508 t = strip_array_types (CONST_CAST_TREE (t)(const_cast<union tree_node *> (((t)))));
4509
4510 if (CLASS_TYPE_P (t)(((((enum tree_code) (t)->base.code)) == RECORD_TYPE || ((
(enum tree_code) (t)->base.code)) == UNION_TYPE) &&
((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4510, __FUNCTION__))->type_common.lang_flag_5))
)
4511 return !CLASSTYPE_NON_LAYOUT_POD_P (t)((((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4511, __FUNCTION__))->type_with_lang_specific.lang_specific
))->non_pod_class)
;
4512 else
4513 return scalarish_type_p (t);
4514}
4515
4516/* Returns true iff T is a standard-layout type, as defined in
4517 [basic.types]. */
4518
4519bool
4520std_layout_type_p (const_tree t)
4521{
4522 t = strip_array_types (CONST_CAST_TREE (t)(const_cast<union tree_node *> (((t)))));
4523
4524 if (CLASS_TYPE_P (t)(((((enum tree_code) (t)->base.code)) == RECORD_TYPE || ((
(enum tree_code) (t)->base.code)) == UNION_TYPE) &&
((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4524, __FUNCTION__))->type_common.lang_flag_5))
)
4525 return !CLASSTYPE_NON_STD_LAYOUT (t)((((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/tree.c"
, 4525, __FUNCTION__))->type_with_lang_specific.lang_specific
))->non_std_layout)
;
4526 else
4527 return scalarish_type_p (t);
4528}
4529
4530static bool record_has_unique_obj_representations (const_tree, const_tree);
4531