Bug Summary

File:build/gcc/varpool.cc
Warning:line 451, column 4
Value stored to 'decl' is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-suse-linux -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name varpool.cc -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 -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/gcc -resource-dir /usr/lib64/clang/15.0.7 -D IN_GCC -D HAVE_CONFIG_H -I . -I . -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/. -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../include -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcpp/include -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcody -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber/bid -I ../libdecnumber -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libbacktrace -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13 -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13/x86_64-suse-linux -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13/backward -internal-isystem /usr/lib64/clang/15.0.7/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../x86_64-suse-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-narrowing -Wwrite-strings -Wno-long-long -Wno-variadic-macros -Wno-overlength-strings -fdeprecated-macro -fdebug-compilation-dir=/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 /buildworker/marxinbox-gcc-clang-static-analyzer/objdir/clang-static-analyzer/2023-03-27-141847-20772-1/report-cwCHwg.plist -x c++ /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc
1/* Callgraph handling code.
2 Copyright (C) 2003-2023 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka
4
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify it under
8the terms of the GNU General Public License as published by the Free
9Software Foundation; either version 3, or (at your option) any later
10version.
11
12GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13WARRANTY; without even the implied warranty of MERCHANTABILITY or
14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15for 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 "backend.h"
25#include "target.h"
26#include "tree.h"
27#include "gimple.h"
28#include "timevar.h"
29#include "cgraph.h"
30#include "lto-streamer.h"
31#include "varasm.h"
32#include "debug.h"
33#include "output.h"
34#include "omp-offload.h"
35#include "context.h"
36#include "stringpool.h"
37#include "attribs.h"
38#include "tree-pass.h"
39
40const char * const tls_model_names[]={"none", "emulated",
41 "global-dynamic", "local-dynamic",
42 "initial-exec", "local-exec"};
43
44/* List of hooks triggered on varpool_node events. */
45struct varpool_node_hook_list {
46 varpool_node_hook hook;
47 void *data;
48 struct varpool_node_hook_list *next;
49};
50
51/* Register HOOK to be called with DATA on each removed node. */
52varpool_node_hook_list *
53symbol_table::add_varpool_removal_hook (varpool_node_hook hook, void *data)
54{
55 varpool_node_hook_list *entry;
56 varpool_node_hook_list **ptr = &m_first_varpool_removal_hook;
57
58 entry = (varpool_node_hook_list *) xmalloc (sizeof (*entry));
59 entry->hook = hook;
60 entry->data = data;
61 entry->next = NULLnullptr;
62 while (*ptr)
63 ptr = &(*ptr)->next;
64 *ptr = entry;
65 return entry;
66}
67
68/* Remove ENTRY from the list of hooks called on removing nodes. */
69void
70symbol_table::remove_varpool_removal_hook (varpool_node_hook_list *entry)
71{
72 varpool_node_hook_list **ptr = &m_first_varpool_removal_hook;
73
74 while (*ptr != entry)
75 ptr = &(*ptr)->next;
76 *ptr = entry->next;
77 free (entry);
78}
79
80/* Call all node removal hooks. */
81void
82symbol_table::call_varpool_removal_hooks (varpool_node *node)
83{
84 varpool_node_hook_list *entry = m_first_varpool_removal_hook;
85 while (entry)
86 {
87 entry->hook (node, entry->data);
88 entry = entry->next;
89 }
90}
91
92/* Register HOOK to be called with DATA on each inserted node. */
93varpool_node_hook_list *
94symbol_table::add_varpool_insertion_hook (varpool_node_hook hook, void *data)
95{
96 varpool_node_hook_list *entry;
97 varpool_node_hook_list **ptr = &m_first_varpool_insertion_hook;
98
99 entry = (varpool_node_hook_list *) xmalloc (sizeof (*entry));
100 entry->hook = hook;
101 entry->data = data;
102 entry->next = NULLnullptr;
103 while (*ptr)
104 ptr = &(*ptr)->next;
105 *ptr = entry;
106 return entry;
107}
108
109/* Remove ENTRY from the list of hooks called on inserted nodes. */
110void
111symbol_table::remove_varpool_insertion_hook (varpool_node_hook_list *entry)
112{
113 varpool_node_hook_list **ptr = &m_first_varpool_insertion_hook;
114
115 while (*ptr != entry)
116 ptr = &(*ptr)->next;
117 *ptr = entry->next;
118 free (entry);
119}
120
121/* Call all node insertion hooks. */
122void
123symbol_table::call_varpool_insertion_hooks (varpool_node *node)
124{
125 varpool_node_hook_list *entry = m_first_varpool_insertion_hook;
126 while (entry)
127 {
128 entry->hook (node, entry->data);
129 entry = entry->next;
130 }
131}
132
133/* Allocate new callgraph node and insert it into basic data structures. */
134
135varpool_node *
136varpool_node::create_empty (void)
137{
138 return new (ggc_alloc<varpool_node> ()) varpool_node ();
139}
140
141/* Return varpool node assigned to DECL. Create new one when needed. */
142varpool_node *
143varpool_node::get_create (tree decl)
144{
145 varpool_node *node = varpool_node::get (decl);
146 gcc_checking_assert (VAR_P (decl))((void)(!((((enum tree_code) (decl)->base.code) == VAR_DECL
)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 146, __FUNCTION__), 0 : 0));
147 if (node)
148 return node;
149
150 node = varpool_node::create_empty ();
151 node->decl = decl;
152
153 if ((flag_openaccglobal_options.x_flag_openacc || flag_openmpglobal_options.x_flag_openmp)
154 && lookup_attribute ("omp declare target", DECL_ATTRIBUTES (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 154, __FUNCTION__))->decl_common.attributes)))
155 {
156 node->offloadable = 1;
157 if (ENABLE_OFFLOADING0 && !DECL_EXTERNAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 157, __FUNCTION__))->decl_common.decl_flag_1))
158 {
159 g->have_offload = true;
160 if (!in_lto_pglobal_options.x_in_lto_p)
161 vec_safe_push (offload_vars, decl);
162 }
163 }
164
165 node->register_symbol ();
166 return node;
167}
168
169/* Remove variable from symbol table. */
170
171void
172varpool_node::remove (void)
173{
174 symtab->call_varpool_removal_hooks (this);
175 if (lto_file_data)
176 {
177 lto_free_function_in_decl_state_for_node (this);
178 lto_file_data = NULLnullptr;
179 }
180
181 /* When streaming we can have multiple nodes associated with decl. */
182 if (symtab->state == LTO_STREAMING)
183 ;
184 /* Keep constructor when it may be used for folding. We remove
185 references to external variables before final compilation. */
186 else if (DECL_INITIAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 186, __FUNCTION__))->decl_common.initial) && DECL_INITIAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 186, __FUNCTION__))->decl_common.initial) != error_mark_nodeglobal_trees[TI_ERROR_MARK]
187 && !ctor_useable_for_folding_p ())
188 remove_initializer ();
189
190 unregister (NULLnullptr);
191 ggc_free (this);
192}
193
194/* Remove node initializer when it is no longer needed. */
195void
196varpool_node::remove_initializer (void)
197{
198 if (DECL_INITIAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 198, __FUNCTION__))->decl_common.initial)
199 && !DECL_IN_CONSTANT_POOL (decl)((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 199, __FUNCTION__, (VAR_DECL)))->decl_with_vis.in_constant_pool
)
200 /* Keep vtables for BINFO folding. */
201 && !DECL_VIRTUAL_P (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 201, __FUNCTION__))->decl_common.virtual_flag)
202 /* FIXME: http://gcc.gnu.org/PR55395 */
203 && debug_info_levelglobal_options.x_debug_info_level == DINFO_LEVEL_NONE
204 /* When doing declaration merging we have duplicate
205 entries for given decl. Do not attempt to remove
206 the bodies, or we will end up removing
207 wrong one. */
208 && symtab->state != LTO_STREAMING)
209 DECL_INITIAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 209, __FUNCTION__))->decl_common.initial) = error_mark_nodeglobal_trees[TI_ERROR_MARK];
210}
211
212/* Dump given varpool node to F. */
213void
214varpool_node::dump (FILE *f)
215{
216 dump_base (f);
217 fprintf (f, " Availability: %s\n",
218 symtab->function_flags_ready
219 ? cgraph_availability_names[get_availability ()]
220 : "not-ready");
221 fprintf (f, " Varpool flags:");
222 if (DECL_INITIAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 222, __FUNCTION__))->decl_common.initial))
223 fprintf (f, " initialized");
224 if (output)
225 fprintf (f, " output");
226 if (used_by_single_function)
227 fprintf (f, " used-by-single-function");
228 if (TREE_READONLY (decl)((non_type_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 228, __FUNCTION__))->base.readonly_flag))
229 fprintf (f, " read-only");
230 if (ctor_useable_for_folding_p ())
231 fprintf (f, " const-value-known");
232 if (writeonly)
233 fprintf (f, " write-only");
234 if (tls_model)
235 fprintf (f, " tls-%s", tls_model_names [tls_model]);
236 fprintf (f, "\n");
237}
238
239
240/* Dump given varpool node to stderr. */
241void varpool_node::debug (void)
242{
243 varpool_node::dump (stderrstderr);
244}
245
246/* Dump the variable pool to F. */
247void
248varpool_node::dump_varpool (FILE *f)
249{
250 varpool_node *node;
251
252 fprintf (f, "variable pool:\n\n");
253 FOR_EACH_VARIABLE (node)for ((node) = symtab->first_variable (); (node); (node) = symtab
->next_variable ((node)))
254 node->dump (f);
255}
256
257/* Dump the variable pool to stderr. */
258
259DEBUG_FUNCTION__attribute__ ((__used__)) void
260varpool_node::debug_varpool (void)
261{
262 dump_varpool (stderrstderr);
263}
264
265/* Given an assembler name, lookup node. */
266varpool_node *
267varpool_node::get_for_asmname (tree asmname)
268{
269 if (symtab_node *node = symtab_node::get_for_asmname (asmname))
270 return dyn_cast <varpool_node *> (node);
271 else
272 return NULLnullptr;
273}
274
275/* When doing LTO, read variable's constructor from disk if
276 it is not already present. */
277
278tree
279varpool_node::get_constructor (void)
280{
281 lto_file_decl_data *file_data;
282 const char *data, *name;
283 size_t len;
284
285 if (DECL_INITIAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 285, __FUNCTION__))->decl_common.initial) != error_mark_nodeglobal_trees[TI_ERROR_MARK]
286 || !in_lto_pglobal_options.x_in_lto_p
287 || !lto_file_data)
288 return DECL_INITIAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 288, __FUNCTION__))->decl_common.initial);
289
290 timevar_push (TV_IPA_LTO_CTORS_IN);
291
292 file_data = lto_file_data;
293 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))((const char *) (tree_check ((decl_assembler_name (decl)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 293, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
);
294
295 /* We may have renamed the declaration, e.g., a static function. */
296 name = lto_get_decl_name_mapping (file_data, name);
297 struct lto_in_decl_state *decl_state
298 = lto_get_function_in_decl_state (file_data, decl);
299
300 data = lto_get_section_data (file_data, LTO_section_function_body,
301 name, order - file_data->order_base,
302 &len, decl_state->compressed);
303 if (!data)
304 fatal_error (input_location, "%s: section %s.%d is missing",
305 file_data->file_name,
306 name, order - file_data->order_base);
307
308 if (!quiet_flagglobal_options.x_quiet_flag)
309 fprintf (stderrstderr, " in:%s", IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))((const char *) (tree_check ((decl_assembler_name (decl)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 309, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
));
310 lto_input_variable_constructor (file_data, this, data);
311 gcc_assert (DECL_INITIAL (decl) != error_mark_node)((void)(!(((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 311, __FUNCTION__))->decl_common.initial) != global_trees
[TI_ERROR_MARK]) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 311, __FUNCTION__), 0 : 0));
312 lto_stats.num_function_bodies++;
313 lto_free_section_data (file_data, LTO_section_function_body, name,
314 data, len, decl_state->compressed);
315 lto_free_function_in_decl_state_for_node (this);
316 timevar_pop (TV_IPA_LTO_CTORS_IN);
317 return DECL_INITIAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 317, __FUNCTION__))->decl_common.initial);
318}
319
320/* Return true if variable has constructor that can be used for folding. */
321
322bool
323varpool_node::ctor_useable_for_folding_p (void)
324{
325 varpool_node *real_node = this;
326
327 if (real_node->alias && real_node->definition)
328 real_node = ultimate_alias_target ();
329
330 if (TREE_CODE (decl)((enum tree_code) (decl)->base.code) == CONST_DECL
331 || DECL_IN_CONSTANT_POOL (decl)((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 331, __FUNCTION__, (VAR_DECL)))->decl_with_vis.in_constant_pool
))
332 return true;
333 if (TREE_THIS_VOLATILE (decl)((decl)->base.volatile_flag))
334 return false;
335
336 /* Avoid attempts to load constructors that was not streamed. */
337 if (in_lto_pglobal_options.x_in_lto_p && DECL_INITIAL (real_node->decl)((contains_struct_check ((real_node->decl), (TS_DECL_COMMON
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 337, __FUNCTION__))->decl_common.initial) == error_mark_nodeglobal_trees[TI_ERROR_MARK]
338 && real_node->body_removed)
339 return false;
340
341 /* If we do not have a constructor, we can't use it. */
342 if (DECL_INITIAL (real_node->decl)((contains_struct_check ((real_node->decl), (TS_DECL_COMMON
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 342, __FUNCTION__))->decl_common.initial) == error_mark_nodeglobal_trees[TI_ERROR_MARK]
343 && !real_node->lto_file_data)
344 return false;
345
346 /* Vtables are defined by their types and must match no matter of interposition
347 rules. */
348 if (DECL_VIRTUAL_P (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 348, __FUNCTION__))->decl_common.virtual_flag))
349 {
350 /* The C++ front end creates VAR_DECLs for vtables of typeinfo
351 classes not defined in the current TU so that it can refer
352 to them from typeinfo objects. Avoid returning NULL_TREE. */
353 return DECL_INITIAL (real_node->decl)((contains_struct_check ((real_node->decl), (TS_DECL_COMMON
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 353, __FUNCTION__))->decl_common.initial) != NULLnullptr;
354 }
355
356 /* An alias of a read-only variable is also read-only, since the variable
357 is stored in read-only memory. We also accept read-only aliases of
358 non-read-only locations assuming that the user knows what he is asking
359 for. */
360 if (!TREE_READONLY (decl)((non_type_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 360, __FUNCTION__))->base.readonly_flag) && !TREE_READONLY (real_node->decl)((non_type_check ((real_node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 360, __FUNCTION__))->base.readonly_flag))
361 return false;
362
363 /* Variables declared 'const' without an initializer
364 have zero as the initializer if they may not be
365 overridden at link or run time.
366
367 It is actually requirement for C++ compiler to optimize const variables
368 consistently. As a GNU extension, do not enforce this rule for user defined
369 weak variables, so we support interposition on:
370 static const int dummy = 0;
371 extern const int foo __attribute__((__weak__, __alias__("dummy")));
372 */
373 if ((!DECL_INITIAL (real_node->decl)((contains_struct_check ((real_node->decl), (TS_DECL_COMMON
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 373, __FUNCTION__))->decl_common.initial)
374 || (DECL_WEAK (decl)((contains_struct_check ((decl), (TS_DECL_WITH_VIS), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 374, __FUNCTION__))->decl_with_vis.weak_flag) && !DECL_COMDAT (decl)((contains_struct_check ((decl), (TS_DECL_WITH_VIS), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 374, __FUNCTION__))->decl_with_vis.comdat_flag)))
375 && ((DECL_EXTERNAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 375, __FUNCTION__))->decl_common.decl_flag_1) && !in_other_partition)
376 || decl_replaceable_p (decl, semantic_interposition)))
377 return false;
378
379 /* Variables declared `const' with an initializer are considered
380 to not be overwritable with different initializer by default.
381
382 ??? Previously we behaved so for scalar variables but not for array
383 accesses. */
384 return true;
385}
386
387/* If DECLARATION is constant variable and its initial value is known
388 (so we can do constant folding), return its constructor (DECL_INITIAL).
389 This may be an expression or NULL when DECL is initialized to 0.
390 Return ERROR_MARK_NODE otherwise.
391
392 In LTO this may actually trigger reading the constructor from disk.
393 For this reason varpool_ctor_useable_for_folding_p should be used when
394 the actual constructor value is not needed. */
395
396tree
397ctor_for_folding (tree decl)
398{
399 varpool_node *node, *real_node;
400 tree real_decl;
401
402 if (!VAR_P (decl)(((enum tree_code) (decl)->base.code) == VAR_DECL) && TREE_CODE (decl)((enum tree_code) (decl)->base.code) != CONST_DECL)
403 return error_mark_nodeglobal_trees[TI_ERROR_MARK];
404
405 if (TREE_CODE (decl)((enum tree_code) (decl)->base.code) == CONST_DECL
406 || DECL_IN_CONSTANT_POOL (decl)((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 406, __FUNCTION__, (VAR_DECL)))->decl_with_vis.in_constant_pool
))
407 return DECL_INITIAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 407, __FUNCTION__))->decl_common.initial);
408
409 if (TREE_THIS_VOLATILE (decl)((decl)->base.volatile_flag))
410 return error_mark_nodeglobal_trees[TI_ERROR_MARK];
411
412 /* Do not care about automatic variables. Those are never initialized
413 anyway, because gimplifier expands the code. */
414 if (!TREE_STATIC (decl)((decl)->base.static_flag) && !DECL_EXTERNAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 414, __FUNCTION__))->decl_common.decl_flag_1))
415 {
416 gcc_assert (!TREE_PUBLIC (decl))((void)(!(!((decl)->base.public_flag)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 416, __FUNCTION__), 0 : 0));
417 /* Unless this is called during FE folding. */
418 if (cfun(cfun + 0)
419 && (cfun(cfun + 0)->curr_properties & (PROP_gimple((1 << 0) | (1 << 1) | (1 << 2) | (1 <<
8)) | PROP_rtl(1 << 7))) == 0
420 && TREE_READONLY (decl)((non_type_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 420, __FUNCTION__))->base.readonly_flag)
421 && !TREE_SIDE_EFFECTS (decl)((non_type_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 421, __FUNCTION__))->base.side_effects_flag)
422 && DECL_INITIAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 422, __FUNCTION__))->decl_common.initial))
423 return DECL_INITIAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 423, __FUNCTION__))->decl_common.initial);
424 return error_mark_nodeglobal_trees[TI_ERROR_MARK];
425 }
426
427 gcc_assert (VAR_P (decl))((void)(!((((enum tree_code) (decl)->base.code) == VAR_DECL
)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 427, __FUNCTION__), 0 : 0));
428
429 real_node = node = varpool_node::get (decl);
430 if (node)
431 {
432 real_node = node->ultimate_alias_target ();
433 real_decl = real_node->decl;
434 }
435 else
436 real_decl = decl;
437
438 /* See if we are dealing with alias.
439 In most cases alias is just alternative symbol pointing to a given
440 constructor. This allows us to use interposition rules of DECL
441 constructor of REAL_NODE. However weakrefs are special by being just
442 alternative name of their target (if defined). */
443 if (decl != real_decl)
444 {
445 gcc_assert (!DECL_INITIAL (decl)((void)(!(!((contains_struct_check ((decl), (TS_DECL_COMMON),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 445, __FUNCTION__))->decl_common.initial) || (node->alias
&& node->get_alias_target () == real_node) || ((contains_struct_check
((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 447, __FUNCTION__))->decl_common.initial) == global_trees
[TI_ERROR_MARK]) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 447, __FUNCTION__), 0 : 0))
446 || (node->alias && node->get_alias_target () == real_node)((void)(!(!((contains_struct_check ((decl), (TS_DECL_COMMON),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 445, __FUNCTION__))->decl_common.initial) || (node->alias
&& node->get_alias_target () == real_node) || ((contains_struct_check
((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 447, __FUNCTION__))->decl_common.initial) == global_trees
[TI_ERROR_MARK]) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 447, __FUNCTION__), 0 : 0))
447 || DECL_INITIAL (decl) == error_mark_node)((void)(!(!((contains_struct_check ((decl), (TS_DECL_COMMON),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 445, __FUNCTION__))->decl_common.initial) || (node->alias
&& node->get_alias_target () == real_node) || ((contains_struct_check
((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 447, __FUNCTION__))->decl_common.initial) == global_trees
[TI_ERROR_MARK]) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 447, __FUNCTION__), 0 : 0));
448 while (node->transparent_alias && node->analyzed)
449 {
450 node = node->get_alias_target ();
451 decl = node->decl;
Value stored to 'decl' is never read
452 }
453 }
454
455 if ((!DECL_VIRTUAL_P (real_decl)((contains_struct_check ((real_decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 455, __FUNCTION__))->decl_common.virtual_flag)
456 || DECL_INITIAL (real_decl)((contains_struct_check ((real_decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 456, __FUNCTION__))->decl_common.initial) == error_mark_nodeglobal_trees[TI_ERROR_MARK]
457 || !DECL_INITIAL (real_decl)((contains_struct_check ((real_decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 457, __FUNCTION__))->decl_common.initial))
458 && (!node || !node->ctor_useable_for_folding_p ()))
459 return error_mark_nodeglobal_trees[TI_ERROR_MARK];
460
461 /* OK, we can return constructor. See if we need to fetch it from disk
462 in LTO mode. */
463 if (DECL_INITIAL (real_decl)((contains_struct_check ((real_decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 463, __FUNCTION__))->decl_common.initial) != error_mark_nodeglobal_trees[TI_ERROR_MARK]
464 || !in_lto_pglobal_options.x_in_lto_p)
465 return DECL_INITIAL (real_decl)((contains_struct_check ((real_decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 465, __FUNCTION__))->decl_common.initial);
466 return real_node->get_constructor ();
467}
468
469/* Add the variable DECL to the varpool.
470 Unlike finalize_decl function is intended to be used
471 by middle end and allows insertion of new variable at arbitrary point
472 of compilation. */
473void
474varpool_node::add (tree decl)
475{
476 varpool_node *node;
477 varpool_node::finalize_decl (decl);
478 node = varpool_node::get_create (decl);
479 symtab->call_varpool_insertion_hooks (node);
480 if (node->externally_visible_p ())
481 node->externally_visible = true;
482 if (lookup_attribute ("no_reorder", DECL_ATTRIBUTES (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 482, __FUNCTION__))->decl_common.attributes)))
483 node->no_reorder = 1;
484}
485
486/* Return variable availability. See cgraph.h for description of individual
487 return values. */
488enum availability
489varpool_node::get_availability (symtab_node *ref)
490{
491 if (!definition && !in_other_partition)
492 return AVAIL_NOT_AVAILABLE;
493 if (!TREE_PUBLIC (decl)((decl)->base.public_flag))
494 return AVAIL_AVAILABLE;
495 if (DECL_IN_CONSTANT_POOL (decl)((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 495, __FUNCTION__, (VAR_DECL)))->decl_with_vis.in_constant_pool
)
496 || DECL_VIRTUAL_P (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 496, __FUNCTION__))->decl_common.virtual_flag))
497 return AVAIL_AVAILABLE;
498 if (transparent_alias && definition)
499 {
500 enum availability avail;
501
502 ultimate_alias_target (&avail, ref);
503 return avail;
504 }
505 /* If this is a reference from symbol itself and there are no aliases, we
506 may be sure that the symbol was not interposed by something else because
507 the symbol itself would be unreachable otherwise. */
508 if ((this == ref && !has_aliases_p ())
509 || (ref && get_comdat_group ()
510 && get_comdat_group () == ref->get_comdat_group ()))
511 return AVAIL_AVAILABLE;
512 /* If the variable can be overwritten, return OVERWRITABLE. Takes
513 care of at least one notable extension - the COMDAT variables
514 used to share template instantiations in C++. */
515 if (decl_replaceable_p (decl, semantic_interposition)
516 || (DECL_EXTERNAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 516, __FUNCTION__))->decl_common.decl_flag_1) && !in_other_partition))
517 return AVAIL_INTERPOSABLE;
518 return AVAIL_AVAILABLE;
519}
520
521void
522varpool_node::analyze (void)
523{
524 /* When reading back varpool at LTO time, we re-construct the queue in order
525 to have "needed" list right by inserting all needed nodes into varpool.
526 We however don't want to re-analyze already analyzed nodes. */
527 if (!analyzed)
528 {
529 gcc_assert (!in_lto_p || symtab->function_flags_ready)((void)(!(!global_options.x_in_lto_p || symtab->function_flags_ready
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 529, __FUNCTION__), 0 : 0));
530 /* Compute the alignment early so function body expanders are
531 already informed about increased alignment. */
532 align_variable (decl, 0);
533 }
534 if (alias)
535 resolve_alias (varpool_node::get (alias_target));
536 else if (DECL_INITIAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 536, __FUNCTION__))->decl_common.initial))
537 record_references_in_initializer (decl, analyzed);
538 analyzed = true;
539}
540
541/* Assemble thunks and aliases associated to varpool node. */
542
543void
544varpool_node::assemble_aliases (void)
545{
546 ipa_ref *ref;
547
548 FOR_EACH_ALIAS (this, ref)for (unsigned ref_iter_ = 0; (this)->iterate_direct_aliases
(ref_iter_, ref); ref_iter_++)
549 {
550 varpool_node *alias = dyn_cast <varpool_node *> (ref->referring);
551 if (alias->symver)
552 do_assemble_symver (alias->decl,
553 DECL_ASSEMBLER_NAME (decl)decl_assembler_name (decl));
554 else if (!alias->transparent_alias)
555 do_assemble_alias (alias->decl,
556 DECL_ASSEMBLER_NAME (decl)decl_assembler_name (decl));
557 alias->assemble_aliases ();
558 }
559}
560
561/* Output one variable, if necessary. Return whether we output it. */
562
563bool
564varpool_node::assemble_decl (void)
565{
566 /* Aliases are output when their target is produced or by
567 output_weakrefs. */
568 if (alias)
569 return false;
570
571 /* Constant pool is output from RTL land when the reference
572 survive till this level. */
573 if (DECL_IN_CONSTANT_POOL (decl)((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 573, __FUNCTION__, (VAR_DECL)))->decl_with_vis.in_constant_pool
) && TREE_ASM_WRITTEN (decl)((decl)->base.asm_written_flag))
574 return false;
575
576 /* Decls with VALUE_EXPR should not be in the varpool at all. They
577 are not real variables, but just info for debugging and codegen.
578 Unfortunately at the moment emutls is not updating varpool correctly
579 after turning real vars into value_expr vars. */
580 if (DECL_HAS_VALUE_EXPR_P (decl)((tree_check3 ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 580, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL)))
->decl_common.decl_flag_2)
581 && !targetm.have_tls)
582 return false;
583
584 /* Hard register vars do not need to be output. */
585 if (DECL_HARD_REGISTER (decl)((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 585, __FUNCTION__, (VAR_DECL)))->decl_with_vis.hard_register
))
586 return false;
587
588 gcc_checking_assert (!TREE_ASM_WRITTEN (decl)((void)(!(!((decl)->base.asm_written_flag) && (((enum
tree_code) (decl)->base.code) == VAR_DECL) && !((
tree_check3 ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 590, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL)))
->decl_common.decl_flag_2)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 590, __FUNCTION__), 0 : 0))
589 && VAR_P (decl)((void)(!(!((decl)->base.asm_written_flag) && (((enum
tree_code) (decl)->base.code) == VAR_DECL) && !((
tree_check3 ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 590, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL)))
->decl_common.decl_flag_2)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 590, __FUNCTION__), 0 : 0))
590 && !DECL_HAS_VALUE_EXPR_P (decl))((void)(!(!((decl)->base.asm_written_flag) && (((enum
tree_code) (decl)->base.code) == VAR_DECL) && !((
tree_check3 ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 590, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL)))
->decl_common.decl_flag_2)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 590, __FUNCTION__), 0 : 0));
591
592 if (!in_other_partition
593 && !DECL_EXTERNAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 593, __FUNCTION__))->decl_common.decl_flag_1))
594 {
595 get_constructor ();
596 assemble_variable (decl, 0, 1, 0);
597 gcc_assert (TREE_ASM_WRITTEN (decl))((void)(!(((decl)->base.asm_written_flag)) ? fancy_abort (
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 597, __FUNCTION__), 0 : 0));
598 gcc_assert (definition)((void)(!(definition) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 598, __FUNCTION__), 0 : 0));
599 assemble_aliases ();
600 /* After the parser has generated debugging information, augment
601 this information with any new location/etc information that may
602 have become available after the compilation proper. */
603 debug_hooks->late_global_decl (decl);
604 return true;
605 }
606
607 return false;
608}
609
610/* Add NODE to queue starting at FIRST.
611 The queue is linked via AUX pointers and terminated by pointer to 1. */
612
613static void
614enqueue_node (varpool_node *node, varpool_node **first)
615{
616 if (node->aux)
617 return;
618 gcc_checking_assert (*first)((void)(!(*first) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 618, __FUNCTION__), 0 : 0));
619 node->aux = *first;
620 *first = node;
621}
622
623/* Optimization of function bodies might've rendered some variables as
624 unnecessary so we want to avoid these from being compiled. Re-do
625 reachability starting from variables that are either externally visible
626 or was referred from the asm output routines. */
627
628void
629symbol_table::remove_unreferenced_decls (void)
630{
631 varpool_node *next, *node;
632 varpool_node *first = (varpool_node *)(void *)1;
633 int i;
634 ipa_ref *ref = NULLnullptr;
635 hash_set<varpool_node *> referenced;
636
637 if (seen_error ())
638 return;
639
640 if (dump_file)
641 fprintf (dump_file, "Trivially needed variables:");
642 FOR_EACH_DEFINED_VARIABLE (node)for ((node) = symtab->first_defined_variable (); (node); (
node) = symtab->next_defined_variable (node))
643 {
644 if (node->analyzed
645 && (!node->can_remove_if_no_refs_p ()
646 /* We just expanded all function bodies. See if any of
647 them needed the variable. */
648 || DECL_RTL_SET_P (node->decl)(((tree_contains_struct[(((enum tree_code) (node->decl)->
base.code))][(TS_DECL_WRTL)])) && (contains_struct_check
((node->decl), (TS_DECL_WRTL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 648, __FUNCTION__))->decl_with_rtl.rtl != nullptr)))
649 {
650 enqueue_node (node, &first);
651 if (dump_file)
652 fprintf (dump_file, " %s", node->dump_asm_name ());
653 }
654 }
655 while (first != (varpool_node *)(void *)1)
656 {
657 node = first;
658 first = (varpool_node *)first->aux;
659
660 if (node->same_comdat_group)
661 {
662 symtab_node *next;
663 for (next = node->same_comdat_group;
664 next != node;
665 next = next->same_comdat_group)
666 {
667 varpool_node *vnext = dyn_cast <varpool_node *> (next);
668 if (vnext && vnext->analyzed && !next->comdat_local_p ())
669 enqueue_node (vnext, &first);
670 }
671 }
672 for (i = 0; node->iterate_reference (i, ref); i++)
673 {
674 varpool_node *vnode = dyn_cast <varpool_node *> (ref->referred);
675 if (vnode
676 && !vnode->in_other_partition
677 && (!DECL_EXTERNAL (ref->referred->decl)((contains_struct_check ((ref->referred->decl), (TS_DECL_COMMON
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 677, __FUNCTION__))->decl_common.decl_flag_1)
678 || vnode->alias)
679 && vnode->analyzed)
680 enqueue_node (vnode, &first);
681 else
682 {
683 if (vnode)
684 referenced.add (vnode);
685 while (vnode && vnode->alias && vnode->definition)
686 {
687 vnode = vnode->get_alias_target ();
688 gcc_checking_assert (vnode)((void)(!(vnode) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 688, __FUNCTION__), 0 : 0));
689 referenced.add (vnode);
690 }
691 }
692 }
693 }
694 if (dump_file)
695 fprintf (dump_file, "\nRemoving variables:");
696 for (node = first_defined_variable (); node; node = next)
697 {
698 next = next_defined_variable (node);
699 if (!node->aux && !node->no_reorder)
700 {
701 if (dump_file)
702 fprintf (dump_file, " %s", node->dump_asm_name ());
703 if (referenced.contains(node))
704 node->remove_initializer ();
705 else
706 node->remove ();
707 }
708 }
709
710 if (dump_file)
711 fprintf (dump_file, "\n");
712}
713
714/* For variables in named sections make sure get_variable_section
715 is called before we switch to those sections. Then section
716 conflicts between read-only and read-only requiring relocations
717 sections can be resolved. */
718void
719varpool_node::finalize_named_section_flags (void)
720{
721 if (!TREE_ASM_WRITTEN (decl)((decl)->base.asm_written_flag)
722 && !alias
723 && !in_other_partition
724 && !DECL_EXTERNAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 724, __FUNCTION__))->decl_common.decl_flag_1)
725 && VAR_P (decl)(((enum tree_code) (decl)->base.code) == VAR_DECL)
726 && !DECL_HAS_VALUE_EXPR_P (decl)((tree_check3 ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 726, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL)))
->decl_common.decl_flag_2)
727 && get_section ())
728 get_variable_section (decl, false);
729}
730
731/* Output all variables enqueued to be assembled. */
732bool
733symbol_table::output_variables (void)
734{
735 bool changed = false;
736 varpool_node *node;
737
738 if (seen_error ())
739 return false;
740
741 remove_unreferenced_decls ();
742
743 timevar_push (TV_VAROUT);
744
745 FOR_EACH_DEFINED_VARIABLE (node)for ((node) = symtab->first_defined_variable (); (node); (
node) = symtab->next_defined_variable (node))
746 {
747 /* Handled in output_in_order. */
748 if (node->no_reorder)
749 continue;
750
751 node->finalize_named_section_flags ();
752 }
753
754 /* There is a similar loop in output_in_order. Please keep them in sync. */
755 FOR_EACH_VARIABLE (node)for ((node) = symtab->first_variable (); (node); (node) = symtab
->next_variable ((node)))
756 {
757 /* Handled in output_in_order. */
758 if (node->no_reorder)
759 continue;
760 if (DECL_HARD_REGISTER (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 760, __FUNCTION__, (VAR_DECL)))->decl_with_vis.hard_register
)
761 || DECL_HAS_VALUE_EXPR_P (node->decl)((tree_check3 ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 761, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL)))
->decl_common.decl_flag_2))
762 continue;
763 if (node->definition)
764 changed |= node->assemble_decl ();
765 else
766 assemble_undefined_decl (node->decl);
767 }
768 timevar_pop (TV_VAROUT);
769 return changed;
770}
771
772/* Attempt to mark ALIAS as an alias to DECL. Return TRUE if successful.
773 Extra name aliases are output whenever DECL is output. */
774
775varpool_node *
776varpool_node::create_alias (tree alias, tree decl)
777{
778 varpool_node *alias_node;
779
780 gcc_assert (VAR_P (decl))((void)(!((((enum tree_code) (decl)->base.code) == VAR_DECL
)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 780, __FUNCTION__), 0 : 0));
781 gcc_assert (VAR_P (alias))((void)(!((((enum tree_code) (alias)->base.code) == VAR_DECL
)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 781, __FUNCTION__), 0 : 0));
782 alias_node = varpool_node::get_create (alias);
783 alias_node->alias = true;
784 alias_node->definition = true;
785 alias_node->semantic_interposition = flag_semantic_interpositionglobal_options.x_flag_semantic_interposition;
786 alias_node->alias_target = decl;
787 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (alias)((contains_struct_check ((alias), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/varpool.cc"
, 787, __FUNCTION__))->decl_common.attributes)) != NULLnullptr)
788 alias_node->weakref = alias_node->transparent_alias = true;
789 return alias_node;
790}
791
792/* Attempt to mark ALIAS as an alias to DECL. Return TRUE if successful.
793 Extra name aliases are output whenever DECL is output. */
794
795varpool_node *
796varpool_node::create_extra_name_alias (tree alias, tree decl)
797{
798 varpool_node *alias_node;
799
800 /* If aliases aren't supported by the assembler, fail. */
801 if (!TARGET_SUPPORTS_ALIASES1)
802 return NULLnullptr;
803
804 alias_node = varpool_node::create_alias (alias, decl);
805 alias_node->cpp_implicit_alias = true;
806
807 /* Extra name alias mechanism creates aliases really late
808 via DECL_ASSEMBLER_NAME mechanism.
809 This is unfortunate because they are not going through the
810 standard channels. Ensure they get output. */
811 if (symtab->cpp_implicit_aliases_done)
812 alias_node->resolve_alias (varpool_node::get_create (decl));
813 return alias_node;
814}
815
816/* Worker for call_for_symbol_and_aliases. */
817
818bool
819varpool_node::call_for_symbol_and_aliases_1 (bool (*callback) (varpool_node *,
820 void *),
821 void *data,
822 bool include_overwritable)
823{
824 ipa_ref *ref;
825
826 FOR_EACH_ALIAS (this, ref)for (unsigned ref_iter_ = 0; (this)->iterate_direct_aliases
(ref_iter_, ref); ref_iter_++)
827 {
828 varpool_node *alias = dyn_cast <varpool_node *> (ref->referring);
829 if (include_overwritable
830 || alias->get_availability () > AVAIL_INTERPOSABLE)
831 if (alias->call_for_symbol_and_aliases (callback, data,
832 include_overwritable))
833 return true;
834 }
835 return false;
836}