Bug Summary

File:build/gcc/hard-reg-set.h
Warning:line 214, column 4
The left operand of '&' is a garbage value due to array index out of bounds

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 cfgexpand.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-8QU9Gy.plist -x c++ /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc

/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc

1/* A pass for lowering trees to RTL.
2 Copyright (C) 2004-2023 Free Software Foundation, Inc.
3
4This file is part of GCC.
5
6GCC is free software; you can redistribute it and/or modify
7it under the terms of the GNU General Public License as published by
8the Free Software Foundation; either version 3, or (at your option)
9any later version.
10
11GCC is distributed in the hope that it will be useful,
12but WITHOUT ANY WARRANTY; without even the implied warranty of
13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14GNU General Public License for more details.
15
16You should have received a copy of the GNU General Public License
17along with GCC; see the file COPYING3. If not see
18<http://www.gnu.org/licenses/>. */
19
20#include "config.h"
21#include "system.h"
22#include "coretypes.h"
23#include "backend.h"
24#include "target.h"
25#include "rtl.h"
26#include "tree.h"
27#include "gimple.h"
28#include "cfghooks.h"
29#include "tree-pass.h"
30#include "memmodel.h"
31#include "tm_p.h"
32#include "ssa.h"
33#include "optabs.h"
34#include "regs.h" /* For reg_renumber. */
35#include "emit-rtl.h"
36#include "recog.h"
37#include "cgraph.h"
38#include "diagnostic.h"
39#include "fold-const.h"
40#include "varasm.h"
41#include "stor-layout.h"
42#include "stmt.h"
43#include "print-tree.h"
44#include "cfgrtl.h"
45#include "cfganal.h"
46#include "cfgbuild.h"
47#include "cfgcleanup.h"
48#include "dojump.h"
49#include "explow.h"
50#include "calls.h"
51#include "expr.h"
52#include "internal-fn.h"
53#include "tree-eh.h"
54#include "gimple-iterator.h"
55#include "gimple-expr.h"
56#include "gimple-walk.h"
57#include "tree-cfg.h"
58#include "tree-dfa.h"
59#include "tree-ssa.h"
60#include "except.h"
61#include "gimple-pretty-print.h"
62#include "toplev.h"
63#include "debug.h"
64#include "tree-inline.h"
65#include "value-prof.h"
66#include "tree-ssa-live.h"
67#include "tree-outof-ssa.h"
68#include "cfgloop.h"
69#include "insn-attr.h" /* For INSN_SCHEDULING. */
70#include "stringpool.h"
71#include "attribs.h"
72#include "asan.h"
73#include "tree-ssa-address.h"
74#include "output.h"
75#include "builtins.h"
76#include "opts.h"
77
78/* Some systems use __main in a way incompatible with its use in gcc, in these
79 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
80 give the same symbol without quotes for an alternative entry point. You
81 must define both, or neither. */
82#ifndef NAME__MAIN"__main"
83#define NAME__MAIN"__main" "__main"
84#endif
85
86/* This variable holds information helping the rewriting of SSA trees
87 into RTL. */
88struct ssaexpand SA;
89
90/* This variable holds the currently expanded gimple statement for purposes
91 of comminucating the profile info to the builtin expanders. */
92gimple *currently_expanding_gimple_stmt;
93
94static rtx expand_debug_expr (tree);
95
96static bool defer_stack_allocation (tree, bool);
97
98static void record_alignment_for_reg_var (unsigned int);
99
100/* Return an expression tree corresponding to the RHS of GIMPLE
101 statement STMT. */
102
103tree
104gimple_assign_rhs_to_tree (gimple *stmt)
105{
106 tree t;
107 switch (gimple_assign_rhs_class (stmt))
108 {
109 case GIMPLE_TERNARY_RHS:
110 t = build3 (gimple_assign_rhs_code (stmt),
111 TREE_TYPE (gimple_assign_lhs (stmt))((contains_struct_check ((gimple_assign_lhs (stmt)), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 111, __FUNCTION__))->typed.type)
,
112 gimple_assign_rhs1 (stmt), gimple_assign_rhs2 (stmt),
113 gimple_assign_rhs3 (stmt));
114 break;
115 case GIMPLE_BINARY_RHS:
116 t = build2 (gimple_assign_rhs_code (stmt),
117 TREE_TYPE (gimple_assign_lhs (stmt))((contains_struct_check ((gimple_assign_lhs (stmt)), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 117, __FUNCTION__))->typed.type)
,
118 gimple_assign_rhs1 (stmt), gimple_assign_rhs2 (stmt));
119 break;
120 case GIMPLE_UNARY_RHS:
121 t = build1 (gimple_assign_rhs_code (stmt),
122 TREE_TYPE (gimple_assign_lhs (stmt))((contains_struct_check ((gimple_assign_lhs (stmt)), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 122, __FUNCTION__))->typed.type)
,
123 gimple_assign_rhs1 (stmt));
124 break;
125 case GIMPLE_SINGLE_RHS:
126 {
127 t = gimple_assign_rhs1 (stmt);
128 /* Avoid modifying this tree in place below. */
129 if ((gimple_has_location (stmt) && CAN_HAVE_LOCATION_P (t)((t) && ((tree_code_type_tmpl <0>::tree_code_type
[(int) (((enum tree_code) (t)->base.code))]) >= tcc_reference
&& (tree_code_type_tmpl <0>::tree_code_type[(int
) (((enum tree_code) (t)->base.code))]) <= tcc_expression
))
130 && gimple_location (stmt) != EXPR_LOCATION (t)((((t)) && ((tree_code_type_tmpl <0>::tree_code_type
[(int) (((enum tree_code) ((t))->base.code))]) >= tcc_reference
&& (tree_code_type_tmpl <0>::tree_code_type[(int
) (((enum tree_code) ((t))->base.code))]) <= tcc_expression
)) ? (t)->exp.locus : ((location_t) 0))
)
131 || (gimple_block (stmt) && currently_expanding_to_rtl
132 && EXPR_P (t)((tree_code_type_tmpl <0>::tree_code_type[(int) (((enum
tree_code) (t)->base.code))]) >= tcc_reference &&
(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum
tree_code) (t)->base.code))]) <= tcc_expression)
))
133 t = copy_node (t);
134 break;
135 }
136 default:
137 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 137, __FUNCTION__))
;
138 }
139
140 if (gimple_has_location (stmt) && CAN_HAVE_LOCATION_P (t)((t) && ((tree_code_type_tmpl <0>::tree_code_type
[(int) (((enum tree_code) (t)->base.code))]) >= tcc_reference
&& (tree_code_type_tmpl <0>::tree_code_type[(int
) (((enum tree_code) (t)->base.code))]) <= tcc_expression
))
)
141 SET_EXPR_LOCATION (t, gimple_location (stmt))(expr_check (((t)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 141, __FUNCTION__))->exp.locus = (gimple_location (stmt)
)
;
142
143 return t;
144}
145
146
147#ifndef STACK_ALIGNMENT_NEEDED1
148#define STACK_ALIGNMENT_NEEDED1 1
149#endif
150
151#define SSAVAR(x)(((enum tree_code) (x)->base.code) == SSA_NAME ? ((tree_check
((x), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 151, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((x)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (x)->ssa_name.var) : x
)
(TREE_CODE (x)((enum tree_code) (x)->base.code) == SSA_NAME ? SSA_NAME_VAR (x)((tree_check ((x), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 151, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((x)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (x)->ssa_name.var)
: x)
152
153/* Choose either CUR or NEXT as the leader DECL for a partition.
154 Prefer ignored decls, to simplify debug dumps and reduce ambiguity
155 out of the same user variable being in multiple partitions (this is
156 less likely for compiler-introduced temps). */
157
158static tree
159leader_merge (tree cur, tree next)
160{
161 if (cur == NULLnullptr || cur == next)
162 return next;
163
164 if (DECL_P (cur)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (cur)->base.code))] == tcc_declaration)
&& DECL_IGNORED_P (cur)((contains_struct_check ((cur), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 164, __FUNCTION__))->decl_common.ignored_flag)
)
165 return cur;
166
167 if (DECL_P (next)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (next)->base.code))] == tcc_declaration)
&& DECL_IGNORED_P (next)((contains_struct_check ((next), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 167, __FUNCTION__))->decl_common.ignored_flag)
)
168 return next;
169
170 return cur;
171}
172
173/* Associate declaration T with storage space X. If T is no
174 SSA name this is exactly SET_DECL_RTL, otherwise make the
175 partition of T associated with X. */
176static inline void
177set_rtl (tree t, rtx x)
178{
179 gcc_checking_assert (!x((void)(!(!x || !(((enum tree_code) (t)->base.code) == SSA_NAME
|| is_gimple_reg (t)) || (use_register_for_decl (t) ? ((((enum
rtx_code) (x)->code) == REG) || (((enum rtx_code) (x)->
code) == CONCAT && ((((enum rtx_code) ((((x)->u.fld
[0]).rt_rtx))->code) == REG) || (((enum rtx_code) ((((x)->
u.fld[0]).rt_rtx))->code) == SUBREG)) && ((((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == REG) || (((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == SUBREG))) || (((
enum rtx_code) (x)->code) == PARALLEL && (((enum tree_code
) (t)->base.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 193, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
) && ((enum tree_code) ((((enum tree_code) (t)->base
.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 194, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
))->base.code) == RESULT_DECL && (((machine_mode) (
x)->mode) == ((void) 0, E_BLKmode) || !global_options.x_flag_tree_coalesce_vars
))) : ((((enum rtx_code) (x)->code) == MEM) || x == pc_rtx
|| (((enum rtx_code) (x)->code) == CONCAT && (((enum
rtx_code) ((((x)->u.fld[0]).rt_rtx))->code) == MEM) &&
(((enum rtx_code) ((((x)->u.fld[1]).rt_rtx))->code) ==
MEM))))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 200, __FUNCTION__), 0 : 0))
180 || !(TREE_CODE (t) == SSA_NAME || is_gimple_reg (t))((void)(!(!x || !(((enum tree_code) (t)->base.code) == SSA_NAME
|| is_gimple_reg (t)) || (use_register_for_decl (t) ? ((((enum
rtx_code) (x)->code) == REG) || (((enum rtx_code) (x)->
code) == CONCAT && ((((enum rtx_code) ((((x)->u.fld
[0]).rt_rtx))->code) == REG) || (((enum rtx_code) ((((x)->
u.fld[0]).rt_rtx))->code) == SUBREG)) && ((((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == REG) || (((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == SUBREG))) || (((
enum rtx_code) (x)->code) == PARALLEL && (((enum tree_code
) (t)->base.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 193, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
) && ((enum tree_code) ((((enum tree_code) (t)->base
.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 194, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
))->base.code) == RESULT_DECL && (((machine_mode) (
x)->mode) == ((void) 0, E_BLKmode) || !global_options.x_flag_tree_coalesce_vars
))) : ((((enum rtx_code) (x)->code) == MEM) || x == pc_rtx
|| (((enum rtx_code) (x)->code) == CONCAT && (((enum
rtx_code) ((((x)->u.fld[0]).rt_rtx))->code) == MEM) &&
(((enum rtx_code) ((((x)->u.fld[1]).rt_rtx))->code) ==
MEM))))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 200, __FUNCTION__), 0 : 0))
181 || (use_register_for_decl (t)((void)(!(!x || !(((enum tree_code) (t)->base.code) == SSA_NAME
|| is_gimple_reg (t)) || (use_register_for_decl (t) ? ((((enum
rtx_code) (x)->code) == REG) || (((enum rtx_code) (x)->
code) == CONCAT && ((((enum rtx_code) ((((x)->u.fld
[0]).rt_rtx))->code) == REG) || (((enum rtx_code) ((((x)->
u.fld[0]).rt_rtx))->code) == SUBREG)) && ((((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == REG) || (((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == SUBREG))) || (((
enum rtx_code) (x)->code) == PARALLEL && (((enum tree_code
) (t)->base.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 193, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
) && ((enum tree_code) ((((enum tree_code) (t)->base
.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 194, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
))->base.code) == RESULT_DECL && (((machine_mode) (
x)->mode) == ((void) 0, E_BLKmode) || !global_options.x_flag_tree_coalesce_vars
))) : ((((enum rtx_code) (x)->code) == MEM) || x == pc_rtx
|| (((enum rtx_code) (x)->code) == CONCAT && (((enum
rtx_code) ((((x)->u.fld[0]).rt_rtx))->code) == MEM) &&
(((enum rtx_code) ((((x)->u.fld[1]).rt_rtx))->code) ==
MEM))))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 200, __FUNCTION__), 0 : 0))
182 ? (REG_P (x)((void)(!(!x || !(((enum tree_code) (t)->base.code) == SSA_NAME
|| is_gimple_reg (t)) || (use_register_for_decl (t) ? ((((enum
rtx_code) (x)->code) == REG) || (((enum rtx_code) (x)->
code) == CONCAT && ((((enum rtx_code) ((((x)->u.fld
[0]).rt_rtx))->code) == REG) || (((enum rtx_code) ((((x)->
u.fld[0]).rt_rtx))->code) == SUBREG)) && ((((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == REG) || (((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == SUBREG))) || (((
enum rtx_code) (x)->code) == PARALLEL && (((enum tree_code
) (t)->base.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 193, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
) && ((enum tree_code) ((((enum tree_code) (t)->base
.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 194, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
))->base.code) == RESULT_DECL && (((machine_mode) (
x)->mode) == ((void) 0, E_BLKmode) || !global_options.x_flag_tree_coalesce_vars
))) : ((((enum rtx_code) (x)->code) == MEM) || x == pc_rtx
|| (((enum rtx_code) (x)->code) == CONCAT && (((enum
rtx_code) ((((x)->u.fld[0]).rt_rtx))->code) == MEM) &&
(((enum rtx_code) ((((x)->u.fld[1]).rt_rtx))->code) ==
MEM))))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 200, __FUNCTION__), 0 : 0))
183 || (GET_CODE (x) == CONCAT((void)(!(!x || !(((enum tree_code) (t)->base.code) == SSA_NAME
|| is_gimple_reg (t)) || (use_register_for_decl (t) ? ((((enum
rtx_code) (x)->code) == REG) || (((enum rtx_code) (x)->
code) == CONCAT && ((((enum rtx_code) ((((x)->u.fld
[0]).rt_rtx))->code) == REG) || (((enum rtx_code) ((((x)->
u.fld[0]).rt_rtx))->code) == SUBREG)) && ((((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == REG) || (((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == SUBREG))) || (((
enum rtx_code) (x)->code) == PARALLEL && (((enum tree_code
) (t)->base.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 193, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
) && ((enum tree_code) ((((enum tree_code) (t)->base
.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 194, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
))->base.code) == RESULT_DECL && (((machine_mode) (
x)->mode) == ((void) 0, E_BLKmode) || !global_options.x_flag_tree_coalesce_vars
))) : ((((enum rtx_code) (x)->code) == MEM) || x == pc_rtx
|| (((enum rtx_code) (x)->code) == CONCAT && (((enum
rtx_code) ((((x)->u.fld[0]).rt_rtx))->code) == MEM) &&
(((enum rtx_code) ((((x)->u.fld[1]).rt_rtx))->code) ==
MEM))))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 200, __FUNCTION__), 0 : 0))
184 && (REG_P (XEXP (x, 0))((void)(!(!x || !(((enum tree_code) (t)->base.code) == SSA_NAME
|| is_gimple_reg (t)) || (use_register_for_decl (t) ? ((((enum
rtx_code) (x)->code) == REG) || (((enum rtx_code) (x)->
code) == CONCAT && ((((enum rtx_code) ((((x)->u.fld
[0]).rt_rtx))->code) == REG) || (((enum rtx_code) ((((x)->
u.fld[0]).rt_rtx))->code) == SUBREG)) && ((((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == REG) || (((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == SUBREG))) || (((
enum rtx_code) (x)->code) == PARALLEL && (((enum tree_code
) (t)->base.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 193, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
) && ((enum tree_code) ((((enum tree_code) (t)->base
.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 194, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
))->base.code) == RESULT_DECL && (((machine_mode) (
x)->mode) == ((void) 0, E_BLKmode) || !global_options.x_flag_tree_coalesce_vars
))) : ((((enum rtx_code) (x)->code) == MEM) || x == pc_rtx
|| (((enum rtx_code) (x)->code) == CONCAT && (((enum
rtx_code) ((((x)->u.fld[0]).rt_rtx))->code) == MEM) &&
(((enum rtx_code) ((((x)->u.fld[1]).rt_rtx))->code) ==
MEM))))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 200, __FUNCTION__), 0 : 0))
185 || SUBREG_P (XEXP (x, 0)))((void)(!(!x || !(((enum tree_code) (t)->base.code) == SSA_NAME
|| is_gimple_reg (t)) || (use_register_for_decl (t) ? ((((enum
rtx_code) (x)->code) == REG) || (((enum rtx_code) (x)->
code) == CONCAT && ((((enum rtx_code) ((((x)->u.fld
[0]).rt_rtx))->code) == REG) || (((enum rtx_code) ((((x)->
u.fld[0]).rt_rtx))->code) == SUBREG)) && ((((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == REG) || (((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == SUBREG))) || (((
enum rtx_code) (x)->code) == PARALLEL && (((enum tree_code
) (t)->base.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 193, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
) && ((enum tree_code) ((((enum tree_code) (t)->base
.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 194, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
))->base.code) == RESULT_DECL && (((machine_mode) (
x)->mode) == ((void) 0, E_BLKmode) || !global_options.x_flag_tree_coalesce_vars
))) : ((((enum rtx_code) (x)->code) == MEM) || x == pc_rtx
|| (((enum rtx_code) (x)->code) == CONCAT && (((enum
rtx_code) ((((x)->u.fld[0]).rt_rtx))->code) == MEM) &&
(((enum rtx_code) ((((x)->u.fld[1]).rt_rtx))->code) ==
MEM))))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 200, __FUNCTION__), 0 : 0))
186 && (REG_P (XEXP (x, 1))((void)(!(!x || !(((enum tree_code) (t)->base.code) == SSA_NAME
|| is_gimple_reg (t)) || (use_register_for_decl (t) ? ((((enum
rtx_code) (x)->code) == REG) || (((enum rtx_code) (x)->
code) == CONCAT && ((((enum rtx_code) ((((x)->u.fld
[0]).rt_rtx))->code) == REG) || (((enum rtx_code) ((((x)->
u.fld[0]).rt_rtx))->code) == SUBREG)) && ((((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == REG) || (((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == SUBREG))) || (((
enum rtx_code) (x)->code) == PARALLEL && (((enum tree_code
) (t)->base.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 193, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
) && ((enum tree_code) ((((enum tree_code) (t)->base
.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 194, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
))->base.code) == RESULT_DECL && (((machine_mode) (
x)->mode) == ((void) 0, E_BLKmode) || !global_options.x_flag_tree_coalesce_vars
))) : ((((enum rtx_code) (x)->code) == MEM) || x == pc_rtx
|| (((enum rtx_code) (x)->code) == CONCAT && (((enum
rtx_code) ((((x)->u.fld[0]).rt_rtx))->code) == MEM) &&
(((enum rtx_code) ((((x)->u.fld[1]).rt_rtx))->code) ==
MEM))))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 200, __FUNCTION__), 0 : 0))
187 || SUBREG_P (XEXP (x, 1))))((void)(!(!x || !(((enum tree_code) (t)->base.code) == SSA_NAME
|| is_gimple_reg (t)) || (use_register_for_decl (t) ? ((((enum
rtx_code) (x)->code) == REG) || (((enum rtx_code) (x)->
code) == CONCAT && ((((enum rtx_code) ((((x)->u.fld
[0]).rt_rtx))->code) == REG) || (((enum rtx_code) ((((x)->
u.fld[0]).rt_rtx))->code) == SUBREG)) && ((((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == REG) || (((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == SUBREG))) || (((
enum rtx_code) (x)->code) == PARALLEL && (((enum tree_code
) (t)->base.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 193, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
) && ((enum tree_code) ((((enum tree_code) (t)->base
.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 194, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
))->base.code) == RESULT_DECL && (((machine_mode) (
x)->mode) == ((void) 0, E_BLKmode) || !global_options.x_flag_tree_coalesce_vars
))) : ((((enum rtx_code) (x)->code) == MEM) || x == pc_rtx
|| (((enum rtx_code) (x)->code) == CONCAT && (((enum
rtx_code) ((((x)->u.fld[0]).rt_rtx))->code) == MEM) &&
(((enum rtx_code) ((((x)->u.fld[1]).rt_rtx))->code) ==
MEM))))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 200, __FUNCTION__), 0 : 0))
188 /* We need to accept PARALLELs for RESUT_DECLs((void)(!(!x || !(((enum tree_code) (t)->base.code) == SSA_NAME
|| is_gimple_reg (t)) || (use_register_for_decl (t) ? ((((enum
rtx_code) (x)->code) == REG) || (((enum rtx_code) (x)->
code) == CONCAT && ((((enum rtx_code) ((((x)->u.fld
[0]).rt_rtx))->code) == REG) || (((enum rtx_code) ((((x)->
u.fld[0]).rt_rtx))->code) == SUBREG)) && ((((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == REG) || (((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == SUBREG))) || (((
enum rtx_code) (x)->code) == PARALLEL && (((enum tree_code
) (t)->base.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 193, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
) && ((enum tree_code) ((((enum tree_code) (t)->base
.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 194, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
))->base.code) == RESULT_DECL && (((machine_mode) (
x)->mode) == ((void) 0, E_BLKmode) || !global_options.x_flag_tree_coalesce_vars
))) : ((((enum rtx_code) (x)->code) == MEM) || x == pc_rtx
|| (((enum rtx_code) (x)->code) == CONCAT && (((enum
rtx_code) ((((x)->u.fld[0]).rt_rtx))->code) == MEM) &&
(((enum rtx_code) ((((x)->u.fld[1]).rt_rtx))->code) ==
MEM))))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 200, __FUNCTION__), 0 : 0))
189 because of vector types with BLKmode returned((void)(!(!x || !(((enum tree_code) (t)->base.code) == SSA_NAME
|| is_gimple_reg (t)) || (use_register_for_decl (t) ? ((((enum
rtx_code) (x)->code) == REG) || (((enum rtx_code) (x)->
code) == CONCAT && ((((enum rtx_code) ((((x)->u.fld
[0]).rt_rtx))->code) == REG) || (((enum rtx_code) ((((x)->
u.fld[0]).rt_rtx))->code) == SUBREG)) && ((((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == REG) || (((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == SUBREG))) || (((
enum rtx_code) (x)->code) == PARALLEL && (((enum tree_code
) (t)->base.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 193, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
) && ((enum tree_code) ((((enum tree_code) (t)->base
.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 194, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
))->base.code) == RESULT_DECL && (((machine_mode) (
x)->mode) == ((void) 0, E_BLKmode) || !global_options.x_flag_tree_coalesce_vars
))) : ((((enum rtx_code) (x)->code) == MEM) || x == pc_rtx
|| (((enum rtx_code) (x)->code) == CONCAT && (((enum
rtx_code) ((((x)->u.fld[0]).rt_rtx))->code) == MEM) &&
(((enum rtx_code) ((((x)->u.fld[1]).rt_rtx))->code) ==
MEM))))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 200, __FUNCTION__), 0 : 0))
190 in multiple registers, but they are supposed((void)(!(!x || !(((enum tree_code) (t)->base.code) == SSA_NAME
|| is_gimple_reg (t)) || (use_register_for_decl (t) ? ((((enum
rtx_code) (x)->code) == REG) || (((enum rtx_code) (x)->
code) == CONCAT && ((((enum rtx_code) ((((x)->u.fld
[0]).rt_rtx))->code) == REG) || (((enum rtx_code) ((((x)->
u.fld[0]).rt_rtx))->code) == SUBREG)) && ((((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == REG) || (((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == SUBREG))) || (((
enum rtx_code) (x)->code) == PARALLEL && (((enum tree_code
) (t)->base.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 193, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
) && ((enum tree_code) ((((enum tree_code) (t)->base
.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 194, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
))->base.code) == RESULT_DECL && (((machine_mode) (
x)->mode) == ((void) 0, E_BLKmode) || !global_options.x_flag_tree_coalesce_vars
))) : ((((enum rtx_code) (x)->code) == MEM) || x == pc_rtx
|| (((enum rtx_code) (x)->code) == CONCAT && (((enum
rtx_code) ((((x)->u.fld[0]).rt_rtx))->code) == MEM) &&
(((enum rtx_code) ((((x)->u.fld[1]).rt_rtx))->code) ==
MEM))))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 200, __FUNCTION__), 0 : 0))
191 to be uncoalesced. */((void)(!(!x || !(((enum tree_code) (t)->base.code) == SSA_NAME
|| is_gimple_reg (t)) || (use_register_for_decl (t) ? ((((enum
rtx_code) (x)->code) == REG) || (((enum rtx_code) (x)->
code) == CONCAT && ((((enum rtx_code) ((((x)->u.fld
[0]).rt_rtx))->code) == REG) || (((enum rtx_code) ((((x)->
u.fld[0]).rt_rtx))->code) == SUBREG)) && ((((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == REG) || (((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == SUBREG))) || (((
enum rtx_code) (x)->code) == PARALLEL && (((enum tree_code
) (t)->base.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 193, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
) && ((enum tree_code) ((((enum tree_code) (t)->base
.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 194, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
))->base.code) == RESULT_DECL && (((machine_mode) (
x)->mode) == ((void) 0, E_BLKmode) || !global_options.x_flag_tree_coalesce_vars
))) : ((((enum rtx_code) (x)->code) == MEM) || x == pc_rtx
|| (((enum rtx_code) (x)->code) == CONCAT && (((enum
rtx_code) ((((x)->u.fld[0]).rt_rtx))->code) == MEM) &&
(((enum rtx_code) ((((x)->u.fld[1]).rt_rtx))->code) ==
MEM))))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 200, __FUNCTION__), 0 : 0))
192 || (GET_CODE (x) == PARALLEL((void)(!(!x || !(((enum tree_code) (t)->base.code) == SSA_NAME
|| is_gimple_reg (t)) || (use_register_for_decl (t) ? ((((enum
rtx_code) (x)->code) == REG) || (((enum rtx_code) (x)->
code) == CONCAT && ((((enum rtx_code) ((((x)->u.fld
[0]).rt_rtx))->code) == REG) || (((enum rtx_code) ((((x)->
u.fld[0]).rt_rtx))->code) == SUBREG)) && ((((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == REG) || (((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == SUBREG))) || (((
enum rtx_code) (x)->code) == PARALLEL && (((enum tree_code
) (t)->base.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 193, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
) && ((enum tree_code) ((((enum tree_code) (t)->base
.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 194, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
))->base.code) == RESULT_DECL && (((machine_mode) (
x)->mode) == ((void) 0, E_BLKmode) || !global_options.x_flag_tree_coalesce_vars
))) : ((((enum rtx_code) (x)->code) == MEM) || x == pc_rtx
|| (((enum rtx_code) (x)->code) == CONCAT && (((enum
rtx_code) ((((x)->u.fld[0]).rt_rtx))->code) == MEM) &&
(((enum rtx_code) ((((x)->u.fld[1]).rt_rtx))->code) ==
MEM))))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 200, __FUNCTION__), 0 : 0))
193 && SSAVAR (t)((void)(!(!x || !(((enum tree_code) (t)->base.code) == SSA_NAME
|| is_gimple_reg (t)) || (use_register_for_decl (t) ? ((((enum
rtx_code) (x)->code) == REG) || (((enum rtx_code) (x)->
code) == CONCAT && ((((enum rtx_code) ((((x)->u.fld
[0]).rt_rtx))->code) == REG) || (((enum rtx_code) ((((x)->
u.fld[0]).rt_rtx))->code) == SUBREG)) && ((((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == REG) || (((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == SUBREG))) || (((
enum rtx_code) (x)->code) == PARALLEL && (((enum tree_code
) (t)->base.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 193, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
) && ((enum tree_code) ((((enum tree_code) (t)->base
.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 194, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
))->base.code) == RESULT_DECL && (((machine_mode) (
x)->mode) == ((void) 0, E_BLKmode) || !global_options.x_flag_tree_coalesce_vars
))) : ((((enum rtx_code) (x)->code) == MEM) || x == pc_rtx
|| (((enum rtx_code) (x)->code) == CONCAT && (((enum
rtx_code) ((((x)->u.fld[0]).rt_rtx))->code) == MEM) &&
(((enum rtx_code) ((((x)->u.fld[1]).rt_rtx))->code) ==
MEM))))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 200, __FUNCTION__), 0 : 0))
194 && TREE_CODE (SSAVAR (t)) == RESULT_DECL((void)(!(!x || !(((enum tree_code) (t)->base.code) == SSA_NAME
|| is_gimple_reg (t)) || (use_register_for_decl (t) ? ((((enum
rtx_code) (x)->code) == REG) || (((enum rtx_code) (x)->
code) == CONCAT && ((((enum rtx_code) ((((x)->u.fld
[0]).rt_rtx))->code) == REG) || (((enum rtx_code) ((((x)->
u.fld[0]).rt_rtx))->code) == SUBREG)) && ((((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == REG) || (((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == SUBREG))) || (((
enum rtx_code) (x)->code) == PARALLEL && (((enum tree_code
) (t)->base.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 193, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
) && ((enum tree_code) ((((enum tree_code) (t)->base
.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 194, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
))->base.code) == RESULT_DECL && (((machine_mode) (
x)->mode) == ((void) 0, E_BLKmode) || !global_options.x_flag_tree_coalesce_vars
))) : ((((enum rtx_code) (x)->code) == MEM) || x == pc_rtx
|| (((enum rtx_code) (x)->code) == CONCAT && (((enum
rtx_code) ((((x)->u.fld[0]).rt_rtx))->code) == MEM) &&
(((enum rtx_code) ((((x)->u.fld[1]).rt_rtx))->code) ==
MEM))))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 200, __FUNCTION__), 0 : 0))
195 && (GET_MODE (x) == BLKmode((void)(!(!x || !(((enum tree_code) (t)->base.code) == SSA_NAME
|| is_gimple_reg (t)) || (use_register_for_decl (t) ? ((((enum
rtx_code) (x)->code) == REG) || (((enum rtx_code) (x)->
code) == CONCAT && ((((enum rtx_code) ((((x)->u.fld
[0]).rt_rtx))->code) == REG) || (((enum rtx_code) ((((x)->
u.fld[0]).rt_rtx))->code) == SUBREG)) && ((((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == REG) || (((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == SUBREG))) || (((
enum rtx_code) (x)->code) == PARALLEL && (((enum tree_code
) (t)->base.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 193, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
) && ((enum tree_code) ((((enum tree_code) (t)->base
.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 194, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
))->base.code) == RESULT_DECL && (((machine_mode) (
x)->mode) == ((void) 0, E_BLKmode) || !global_options.x_flag_tree_coalesce_vars
))) : ((((enum rtx_code) (x)->code) == MEM) || x == pc_rtx
|| (((enum rtx_code) (x)->code) == CONCAT && (((enum
rtx_code) ((((x)->u.fld[0]).rt_rtx))->code) == MEM) &&
(((enum rtx_code) ((((x)->u.fld[1]).rt_rtx))->code) ==
MEM))))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 200, __FUNCTION__), 0 : 0))
196 || !flag_tree_coalesce_vars)))((void)(!(!x || !(((enum tree_code) (t)->base.code) == SSA_NAME
|| is_gimple_reg (t)) || (use_register_for_decl (t) ? ((((enum
rtx_code) (x)->code) == REG) || (((enum rtx_code) (x)->
code) == CONCAT && ((((enum rtx_code) ((((x)->u.fld
[0]).rt_rtx))->code) == REG) || (((enum rtx_code) ((((x)->
u.fld[0]).rt_rtx))->code) == SUBREG)) && ((((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == REG) || (((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == SUBREG))) || (((
enum rtx_code) (x)->code) == PARALLEL && (((enum tree_code
) (t)->base.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 193, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
) && ((enum tree_code) ((((enum tree_code) (t)->base
.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 194, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
))->base.code) == RESULT_DECL && (((machine_mode) (
x)->mode) == ((void) 0, E_BLKmode) || !global_options.x_flag_tree_coalesce_vars
))) : ((((enum rtx_code) (x)->code) == MEM) || x == pc_rtx
|| (((enum rtx_code) (x)->code) == CONCAT && (((enum
rtx_code) ((((x)->u.fld[0]).rt_rtx))->code) == MEM) &&
(((enum rtx_code) ((((x)->u.fld[1]).rt_rtx))->code) ==
MEM))))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 200, __FUNCTION__), 0 : 0))
197 : (MEM_P (x) || x == pc_rtx((void)(!(!x || !(((enum tree_code) (t)->base.code) == SSA_NAME
|| is_gimple_reg (t)) || (use_register_for_decl (t) ? ((((enum
rtx_code) (x)->code) == REG) || (((enum rtx_code) (x)->
code) == CONCAT && ((((enum rtx_code) ((((x)->u.fld
[0]).rt_rtx))->code) == REG) || (((enum rtx_code) ((((x)->
u.fld[0]).rt_rtx))->code) == SUBREG)) && ((((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == REG) || (((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == SUBREG))) || (((
enum rtx_code) (x)->code) == PARALLEL && (((enum tree_code
) (t)->base.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 193, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
) && ((enum tree_code) ((((enum tree_code) (t)->base
.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 194, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
))->base.code) == RESULT_DECL && (((machine_mode) (
x)->mode) == ((void) 0, E_BLKmode) || !global_options.x_flag_tree_coalesce_vars
))) : ((((enum rtx_code) (x)->code) == MEM) || x == pc_rtx
|| (((enum rtx_code) (x)->code) == CONCAT && (((enum
rtx_code) ((((x)->u.fld[0]).rt_rtx))->code) == MEM) &&
(((enum rtx_code) ((((x)->u.fld[1]).rt_rtx))->code) ==
MEM))))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 200, __FUNCTION__), 0 : 0))
198 || (GET_CODE (x) == CONCAT((void)(!(!x || !(((enum tree_code) (t)->base.code) == SSA_NAME
|| is_gimple_reg (t)) || (use_register_for_decl (t) ? ((((enum
rtx_code) (x)->code) == REG) || (((enum rtx_code) (x)->
code) == CONCAT && ((((enum rtx_code) ((((x)->u.fld
[0]).rt_rtx))->code) == REG) || (((enum rtx_code) ((((x)->
u.fld[0]).rt_rtx))->code) == SUBREG)) && ((((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == REG) || (((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == SUBREG))) || (((
enum rtx_code) (x)->code) == PARALLEL && (((enum tree_code
) (t)->base.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 193, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
) && ((enum tree_code) ((((enum tree_code) (t)->base
.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 194, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
))->base.code) == RESULT_DECL && (((machine_mode) (
x)->mode) == ((void) 0, E_BLKmode) || !global_options.x_flag_tree_coalesce_vars
))) : ((((enum rtx_code) (x)->code) == MEM) || x == pc_rtx
|| (((enum rtx_code) (x)->code) == CONCAT && (((enum
rtx_code) ((((x)->u.fld[0]).rt_rtx))->code) == MEM) &&
(((enum rtx_code) ((((x)->u.fld[1]).rt_rtx))->code) ==
MEM))))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 200, __FUNCTION__), 0 : 0))
199 && MEM_P (XEXP (x, 0))((void)(!(!x || !(((enum tree_code) (t)->base.code) == SSA_NAME
|| is_gimple_reg (t)) || (use_register_for_decl (t) ? ((((enum
rtx_code) (x)->code) == REG) || (((enum rtx_code) (x)->
code) == CONCAT && ((((enum rtx_code) ((((x)->u.fld
[0]).rt_rtx))->code) == REG) || (((enum rtx_code) ((((x)->
u.fld[0]).rt_rtx))->code) == SUBREG)) && ((((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == REG) || (((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == SUBREG))) || (((
enum rtx_code) (x)->code) == PARALLEL && (((enum tree_code
) (t)->base.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 193, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
) && ((enum tree_code) ((((enum tree_code) (t)->base
.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 194, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
))->base.code) == RESULT_DECL && (((machine_mode) (
x)->mode) == ((void) 0, E_BLKmode) || !global_options.x_flag_tree_coalesce_vars
))) : ((((enum rtx_code) (x)->code) == MEM) || x == pc_rtx
|| (((enum rtx_code) (x)->code) == CONCAT && (((enum
rtx_code) ((((x)->u.fld[0]).rt_rtx))->code) == MEM) &&
(((enum rtx_code) ((((x)->u.fld[1]).rt_rtx))->code) ==
MEM))))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 200, __FUNCTION__), 0 : 0))
200 && MEM_P (XEXP (x, 1))))))((void)(!(!x || !(((enum tree_code) (t)->base.code) == SSA_NAME
|| is_gimple_reg (t)) || (use_register_for_decl (t) ? ((((enum
rtx_code) (x)->code) == REG) || (((enum rtx_code) (x)->
code) == CONCAT && ((((enum rtx_code) ((((x)->u.fld
[0]).rt_rtx))->code) == REG) || (((enum rtx_code) ((((x)->
u.fld[0]).rt_rtx))->code) == SUBREG)) && ((((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == REG) || (((enum rtx_code
) ((((x)->u.fld[1]).rt_rtx))->code) == SUBREG))) || (((
enum rtx_code) (x)->code) == PARALLEL && (((enum tree_code
) (t)->base.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 193, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
) && ((enum tree_code) ((((enum tree_code) (t)->base
.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 194, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
))->base.code) == RESULT_DECL && (((machine_mode) (
x)->mode) == ((void) 0, E_BLKmode) || !global_options.x_flag_tree_coalesce_vars
))) : ((((enum rtx_code) (x)->code) == MEM) || x == pc_rtx
|| (((enum rtx_code) (x)->code) == CONCAT && (((enum
rtx_code) ((((x)->u.fld[0]).rt_rtx))->code) == MEM) &&
(((enum rtx_code) ((((x)->u.fld[1]).rt_rtx))->code) ==
MEM))))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 200, __FUNCTION__), 0 : 0))
;
201 /* Check that the RTL for SSA_NAMEs and gimple-reg PARM_DECLs and
202 RESULT_DECLs has the expected mode. For memory, we accept
203 unpromoted modes, since that's what we're likely to get. For
204 PARM_DECLs and RESULT_DECLs, we'll have been called by
205 set_parm_rtl, which will give us the default def, so we don't
206 have to compute it ourselves. For RESULT_DECLs, we accept mode
207 mismatches too, as long as we have BLKmode or are not coalescing
208 across variables, so that we don't reject BLKmode PARALLELs or
209 unpromoted REGs. */
210 gcc_checking_assert (!x || x == pc_rtx || TREE_CODE (t) != SSA_NAME((void)(!(!x || x == pc_rtx || ((enum tree_code) (t)->base
.code) != SSA_NAME || ((((enum tree_code) (t)->base.code) ==
SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 211, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
) && ((enum tree_code) ((((enum tree_code) (t)->base
.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 212, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
))->base.code) == RESULT_DECL && (promote_ssa_mode
(t, nullptr) == ((void) 0, E_BLKmode) || !global_options.x_flag_tree_coalesce_vars
)) || !use_register_for_decl (t) || ((machine_mode) (x)->mode
) == promote_ssa_mode (t, nullptr)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 216, __FUNCTION__), 0 : 0))
211 || (SSAVAR (t)((void)(!(!x || x == pc_rtx || ((enum tree_code) (t)->base
.code) != SSA_NAME || ((((enum tree_code) (t)->base.code) ==
SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 211, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
) && ((enum tree_code) ((((enum tree_code) (t)->base
.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 212, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
))->base.code) == RESULT_DECL && (promote_ssa_mode
(t, nullptr) == ((void) 0, E_BLKmode) || !global_options.x_flag_tree_coalesce_vars
)) || !use_register_for_decl (t) || ((machine_mode) (x)->mode
) == promote_ssa_mode (t, nullptr)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 216, __FUNCTION__), 0 : 0))
212 && TREE_CODE (SSAVAR (t)) == RESULT_DECL((void)(!(!x || x == pc_rtx || ((enum tree_code) (t)->base
.code) != SSA_NAME || ((((enum tree_code) (t)->base.code) ==
SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 211, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
) && ((enum tree_code) ((((enum tree_code) (t)->base
.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 212, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
))->base.code) == RESULT_DECL && (promote_ssa_mode
(t, nullptr) == ((void) 0, E_BLKmode) || !global_options.x_flag_tree_coalesce_vars
)) || !use_register_for_decl (t) || ((machine_mode) (x)->mode
) == promote_ssa_mode (t, nullptr)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 216, __FUNCTION__), 0 : 0))
213 && (promote_ssa_mode (t, NULL) == BLKmode((void)(!(!x || x == pc_rtx || ((enum tree_code) (t)->base
.code) != SSA_NAME || ((((enum tree_code) (t)->base.code) ==
SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 211, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
) && ((enum tree_code) ((((enum tree_code) (t)->base
.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 212, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
))->base.code) == RESULT_DECL && (promote_ssa_mode
(t, nullptr) == ((void) 0, E_BLKmode) || !global_options.x_flag_tree_coalesce_vars
)) || !use_register_for_decl (t) || ((machine_mode) (x)->mode
) == promote_ssa_mode (t, nullptr)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 216, __FUNCTION__), 0 : 0))
214 || !flag_tree_coalesce_vars))((void)(!(!x || x == pc_rtx || ((enum tree_code) (t)->base
.code) != SSA_NAME || ((((enum tree_code) (t)->base.code) ==
SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 211, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
) && ((enum tree_code) ((((enum tree_code) (t)->base
.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 212, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
))->base.code) == RESULT_DECL && (promote_ssa_mode
(t, nullptr) == ((void) 0, E_BLKmode) || !global_options.x_flag_tree_coalesce_vars
)) || !use_register_for_decl (t) || ((machine_mode) (x)->mode
) == promote_ssa_mode (t, nullptr)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 216, __FUNCTION__), 0 : 0))
215 || !use_register_for_decl (t)((void)(!(!x || x == pc_rtx || ((enum tree_code) (t)->base
.code) != SSA_NAME || ((((enum tree_code) (t)->base.code) ==
SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 211, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
) && ((enum tree_code) ((((enum tree_code) (t)->base
.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 212, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
))->base.code) == RESULT_DECL && (promote_ssa_mode
(t, nullptr) == ((void) 0, E_BLKmode) || !global_options.x_flag_tree_coalesce_vars
)) || !use_register_for_decl (t) || ((machine_mode) (x)->mode
) == promote_ssa_mode (t, nullptr)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 216, __FUNCTION__), 0 : 0))
216 || GET_MODE (x) == promote_ssa_mode (t, NULL))((void)(!(!x || x == pc_rtx || ((enum tree_code) (t)->base
.code) != SSA_NAME || ((((enum tree_code) (t)->base.code) ==
SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 211, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
) && ((enum tree_code) ((((enum tree_code) (t)->base
.code) == SSA_NAME ? ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 212, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
))->base.code) == RESULT_DECL && (promote_ssa_mode
(t, nullptr) == ((void) 0, E_BLKmode) || !global_options.x_flag_tree_coalesce_vars
)) || !use_register_for_decl (t) || ((machine_mode) (x)->mode
) == promote_ssa_mode (t, nullptr)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 216, __FUNCTION__), 0 : 0))
;
217
218 if (x)
219 {
220 bool skip = false;
221 tree cur = NULL_TREE(tree) nullptr;
222 rtx xm = x;
223
224 retry:
225 if (MEM_P (xm)(((enum rtx_code) (xm)->code) == MEM))
226 cur = MEM_EXPR (xm)(get_mem_attrs (xm)->expr);
227 else if (REG_P (xm)(((enum rtx_code) (xm)->code) == REG))
228 cur = REG_EXPR (xm)(((&(xm)->u.reg)->attrs) == 0 ? 0 : ((&(xm)->
u.reg)->attrs)->decl)
;
229 else if (SUBREG_P (xm)(((enum rtx_code) (xm)->code) == SUBREG))
230 {
231 gcc_assert (subreg_lowpart_p (xm))((void)(!(subreg_lowpart_p (xm)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 231, __FUNCTION__), 0 : 0))
;
232 xm = SUBREG_REG (xm)(((xm)->u.fld[0]).rt_rtx);
233 goto retry;
234 }
235 else if (GET_CODE (xm)((enum rtx_code) (xm)->code) == CONCAT)
236 {
237 xm = XEXP (xm, 0)(((xm)->u.fld[0]).rt_rtx);
238 goto retry;
239 }
240 else if (GET_CODE (xm)((enum rtx_code) (xm)->code) == PARALLEL)
241 {
242 xm = XVECEXP (xm, 0, 0)(((((xm)->u.fld[0]).rt_rtvec))->elem[0]);
243 gcc_assert (GET_CODE (xm) == EXPR_LIST)((void)(!(((enum rtx_code) (xm)->code) == EXPR_LIST) ? fancy_abort
("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 243, __FUNCTION__), 0 : 0))
;
244 xm = XEXP (xm, 0)(((xm)->u.fld[0]).rt_rtx);
245 goto retry;
246 }
247 else if (xm == pc_rtx)
248 skip = true;
249 else
250 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 250, __FUNCTION__))
;
251
252 tree next = skip ? cur : leader_merge (cur, SSAVAR (t)(((enum tree_code) (t)->base.code) == SSA_NAME ? ((tree_check
((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 252, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
)
? SSAVAR (t)(((enum tree_code) (t)->base.code) == SSA_NAME ? ((tree_check
((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 252, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var) : t
)
: t);
253
254 if (cur != next)
255 {
256 if (MEM_P (x)(((enum rtx_code) (x)->code) == MEM))
257 set_mem_attributes (x,
258 next && TREE_CODE (next)((enum tree_code) (next)->base.code) == SSA_NAME
259 ? TREE_TYPE (next)((contains_struct_check ((next), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 259, __FUNCTION__))->typed.type)
260 : next, true);
261 else
262 set_reg_attrs_for_decl_rtl (next, x);
263 }
264 }
265
266 if (TREE_CODE (t)((enum tree_code) (t)->base.code) == SSA_NAME)
267 {
268 int part = var_to_partition (SA.map, t);
269 if (part != NO_PARTITION-1)
270 {
271 if (SA.partition_to_pseudo[part])
272 gcc_assert (SA.partition_to_pseudo[part] == x)((void)(!(SA.partition_to_pseudo[part] == x) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 272, __FUNCTION__), 0 : 0))
;
273 else if (x != pc_rtx)
274 SA.partition_to_pseudo[part] = x;
275 }
276 /* For the benefit of debug information at -O0 (where
277 vartracking doesn't run) record the place also in the base
278 DECL. For PARMs and RESULTs, do so only when setting the
279 default def. */
280 if (x && x != pc_rtx && SSA_NAME_VAR (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 280, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var)
281 && (VAR_P (SSA_NAME_VAR (t))(((enum tree_code) (((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 281, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var))->
base.code) == VAR_DECL)
282 || SSA_NAME_IS_DEFAULT_DEF (t)(tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 282, __FUNCTION__, (SSA_NAME)))->base.default_def_flag
))
283 {
284 tree var = SSA_NAME_VAR (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 284, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((t)->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name.var)
;
285 /* If we don't yet have something recorded, just record it now. */
286 if (!DECL_RTL_SET_P (var)(((tree_contains_struct[(((enum tree_code) (var)->base.code
))][(TS_DECL_WRTL)])) && (contains_struct_check ((var
), (TS_DECL_WRTL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 286, __FUNCTION__))->decl_with_rtl.rtl != nullptr)
)
287 SET_DECL_RTL (var, x)set_decl_rtl (var, x);
288 /* If we have it set already to "multiple places" don't
289 change this. */
290 else if (DECL_RTL (var)((contains_struct_check ((var), (TS_DECL_WRTL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 290, __FUNCTION__))->decl_with_rtl.rtl ? (var)->decl_with_rtl
.rtl : (make_decl_rtl (var), (var)->decl_with_rtl.rtl))
== pc_rtx)
291 ;
292 /* If we have something recorded and it's not the same place
293 as we want to record now, we have multiple partitions for the
294 same base variable, with different places. We can't just
295 randomly chose one, hence we have to say that we don't know.
296 This only happens with optimization, and there var-tracking
297 will figure out the right thing. */
298 else if (DECL_RTL (var)((contains_struct_check ((var), (TS_DECL_WRTL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 298, __FUNCTION__))->decl_with_rtl.rtl ? (var)->decl_with_rtl
.rtl : (make_decl_rtl (var), (var)->decl_with_rtl.rtl))
!= x)
299 SET_DECL_RTL (var, pc_rtx)set_decl_rtl (var, pc_rtx);
300 }
301 }
302 else
303 SET_DECL_RTL (t, x)set_decl_rtl (t, x);
304}
305
306/* This structure holds data relevant to one variable that will be
307 placed in a stack slot. */
308class stack_var
309{
310public:
311 /* The Variable. */
312 tree decl;
313
314 /* Initially, the size of the variable. Later, the size of the partition,
315 if this variable becomes it's partition's representative. */
316 poly_uint64 size;
317
318 /* The *byte* alignment required for this variable. Or as, with the
319 size, the alignment for this partition. */
320 unsigned int alignb;
321
322 /* The partition representative. */
323 size_t representative;
324
325 /* The next stack variable in the partition, or EOC. */
326 size_t next;
327
328 /* The numbers of conflicting stack variables. */
329 bitmap conflicts;
330};
331
332#define EOC((size_t)-1) ((size_t)-1)
333
334/* We have an array of such objects while deciding allocation. */
335static class stack_var *stack_vars;
336static size_t stack_vars_alloc;
337static size_t stack_vars_num;
338static hash_map<tree, size_t> *decl_to_stack_part;
339
340/* Conflict bitmaps go on this obstack. This allows us to destroy
341 all of them in one big sweep. */
342static bitmap_obstack stack_var_bitmap_obstack;
343
344/* An array of indices such that stack_vars[stack_vars_sorted[i]].size
345 is non-decreasing. */
346static size_t *stack_vars_sorted;
347
348/* The phase of the stack frame. This is the known misalignment of
349 virtual_stack_vars_rtx from PREFERRED_STACK_BOUNDARY. That is,
350 (frame_offset+frame_phase) % PREFERRED_STACK_BOUNDARY == 0. */
351static int frame_phase;
352
353/* Used during expand_used_vars to remember if we saw any decls for
354 which we'd like to enable stack smashing protection. */
355static bool has_protected_decls;
356
357/* Used during expand_used_vars. Remember if we say a character buffer
358 smaller than our cutoff threshold. Used for -Wstack-protector. */
359static bool has_short_buffer;
360
361/* Compute the byte alignment to use for DECL. Ignore alignment
362 we can't do with expected alignment of the stack boundary. */
363
364static unsigned int
365align_local_variable (tree decl, bool really_expand)
366{
367 unsigned int align;
368
369 if (TREE_CODE (decl)((enum tree_code) (decl)->base.code) == SSA_NAME)
370 {
371 tree type = TREE_TYPE (decl)((contains_struct_check ((decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 371, __FUNCTION__))->typed.type)
;
372 machine_mode mode = TYPE_MODE (type)((((enum tree_code) ((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 372, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(type) : (type)->type_common.mode)
;
373
374 align = TYPE_ALIGN (type)(((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 374, __FUNCTION__))->type_common.align) ? ((unsigned)1) <<
(((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 374, __FUNCTION__))->type_common.align) - 1) : 0)
;
375 if (mode != BLKmode((void) 0, E_BLKmode)
376 && align < GET_MODE_ALIGNMENT (mode)get_mode_alignment (mode))
377 align = GET_MODE_ALIGNMENT (mode)get_mode_alignment (mode);
378 }
379 else
380 align = LOCAL_DECL_ALIGNMENT (decl)ix86_local_alignment ((decl), ((void) 0, E_VOIDmode), (((contains_struct_check
((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 380, __FUNCTION__))->decl_common.align) ? ((unsigned)1) <<
(((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 380, __FUNCTION__))->decl_common.align) - 1) : 0))
;
381
382 if (hwasan_sanitize_stack_p ())
383 align = MAX (align, (unsigned) HWASAN_TAG_GRANULE_SIZE * BITS_PER_UNIT)((align) > ((unsigned) targetm.memtag.granule_size () * (8
)) ? (align) : ((unsigned) targetm.memtag.granule_size () * (
8)))
;
384
385 if (TREE_CODE (decl)((enum tree_code) (decl)->base.code) != SSA_NAME && really_expand)
386 /* Don't change DECL_ALIGN when called from estimated_stack_frame_size.
387 That is done before IPA and could bump alignment based on host
388 backend even for offloaded code which wants different
389 LOCAL_DECL_ALIGNMENT. */
390 SET_DECL_ALIGN (decl, align)(((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 390, __FUNCTION__))->decl_common.align) = ffs_hwi (align
))
;
391
392 return align / BITS_PER_UNIT(8);
393}
394
395/* Align given offset BASE with ALIGN. Truncate up if ALIGN_UP is true,
396 down otherwise. Return truncated BASE value. */
397
398static inline unsigned HOST_WIDE_INTlong
399align_base (HOST_WIDE_INTlong base, unsigned HOST_WIDE_INTlong align, bool align_up)
400{
401 return align_up ? (base + align - 1) & -align : base & -align;
402}
403
404/* Allocate SIZE bytes at byte alignment ALIGN from the stack frame.
405 Return the frame offset. */
406
407static poly_int64
408alloc_stack_frame_space (poly_int64 size, unsigned HOST_WIDE_INTlong align)
409{
410 poly_int64 offset, new_frame_offset;
411
412 if (FRAME_GROWS_DOWNWARD1)
413 {
414 new_frame_offset
415 = aligned_lower_bound (frame_offset((&x_rtl)->x_frame_offset) - frame_phase - size,
416 align) + frame_phase;
417 offset = new_frame_offset;
418 }
419 else
420 {
421 new_frame_offset
422 = aligned_upper_bound (frame_offset((&x_rtl)->x_frame_offset) - frame_phase,
423 align) + frame_phase;
424 offset = new_frame_offset;
425 new_frame_offset += size;
426 }
427 frame_offset((&x_rtl)->x_frame_offset) = new_frame_offset;
428
429 if (frame_offset_overflow (frame_offset((&x_rtl)->x_frame_offset), cfun(cfun + 0)->decl))
430 frame_offset((&x_rtl)->x_frame_offset) = offset = 0;
431
432 return offset;
433}
434
435/* Ensure that the stack is aligned to ALIGN bytes.
436 Return the new frame offset. */
437static poly_int64
438align_frame_offset (unsigned HOST_WIDE_INTlong align)
439{
440 return alloc_stack_frame_space (0, align);
441}
442
443/* Accumulate DECL into STACK_VARS. */
444
445static void
446add_stack_var (tree decl, bool really_expand)
447{
448 class stack_var *v;
449
450 if (stack_vars_num >= stack_vars_alloc)
451 {
452 if (stack_vars_alloc)
453 stack_vars_alloc = stack_vars_alloc * 3 / 2;
454 else
455 stack_vars_alloc = 32;
456 stack_vars
457 = XRESIZEVEC (class stack_var, stack_vars, stack_vars_alloc)((class stack_var *) xrealloc ((void *) (stack_vars), sizeof (
class stack_var) * (stack_vars_alloc)))
;
458 }
459 if (!decl_to_stack_part)
460 decl_to_stack_part = new hash_map<tree, size_t>;
461
462 v = &stack_vars[stack_vars_num];
463 decl_to_stack_part->put (decl, stack_vars_num);
464
465 v->decl = decl;
466 tree size = TREE_CODE (decl)((enum tree_code) (decl)->base.code) == SSA_NAME
467 ? TYPE_SIZE_UNIT (TREE_TYPE (decl))((tree_class_check ((((contains_struct_check ((decl), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 467, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 467, __FUNCTION__))->type_common.size_unit)
468 : DECL_SIZE_UNIT (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 468, __FUNCTION__))->decl_common.size_unit)
;
469 v->size = tree_to_poly_uint64 (size);
470 /* Ensure that all variables have size, so that &a != &b for any two
471 variables that are simultaneously live. */
472 if (known_eq (v->size, 0U)(!maybe_ne (v->size, 0U)))
473 v->size = 1;
474 v->alignb = align_local_variable (decl, really_expand);
475 /* An alignment of zero can mightily confuse us later. */
476 gcc_assert (v->alignb != 0)((void)(!(v->alignb != 0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 476, __FUNCTION__), 0 : 0))
;
477
478 /* All variables are initially in their own partition. */
479 v->representative = stack_vars_num;
480 v->next = EOC((size_t)-1);
481
482 /* All variables initially conflict with no other. */
483 v->conflicts = NULLnullptr;
484
485 /* Ensure that this decl doesn't get put onto the list twice. */
486 set_rtl (decl, pc_rtx);
487
488 stack_vars_num++;
489}
490
491/* Make the decls associated with luid's X and Y conflict. */
492
493static void
494add_stack_var_conflict (size_t x, size_t y)
495{
496 class stack_var *a = &stack_vars[x];
497 class stack_var *b = &stack_vars[y];
498 if (x == y)
499 return;
500 if (!a->conflicts)
501 a->conflicts = BITMAP_ALLOCbitmap_alloc (&stack_var_bitmap_obstack);
502 if (!b->conflicts)
503 b->conflicts = BITMAP_ALLOCbitmap_alloc (&stack_var_bitmap_obstack);
504 bitmap_set_bit (a->conflicts, y);
505 bitmap_set_bit (b->conflicts, x);
506}
507
508/* Check whether the decls associated with luid's X and Y conflict. */
509
510static bool
511stack_var_conflict_p (size_t x, size_t y)
512{
513 class stack_var *a = &stack_vars[x];
514 class stack_var *b = &stack_vars[y];
515 if (x == y)
516 return false;
517 /* Partitions containing an SSA name result from gimple registers
518 with things like unsupported modes. They are top-level and
519 hence conflict with everything else. */
520 if (TREE_CODE (a->decl)((enum tree_code) (a->decl)->base.code) == SSA_NAME || TREE_CODE (b->decl)((enum tree_code) (b->decl)->base.code) == SSA_NAME)
521 return true;
522
523 if (!a->conflicts || !b->conflicts)
524 return false;
525 return bitmap_bit_p (a->conflicts, y);
526}
527
528/* Callback for walk_stmt_ops. If OP is a decl touched by add_stack_var
529 enter its partition number into bitmap DATA. */
530
531static bool
532visit_op (gimple *, tree op, tree, void *data)
533{
534 bitmap active = (bitmap)data;
535 op = get_base_address (op);
536 if (op
537 && DECL_P (op)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (op)->base.code))] == tcc_declaration)
538 && DECL_RTL_IF_SET (op)((((tree_contains_struct[(((enum tree_code) (op)->base.code
))][(TS_DECL_WRTL)])) && (contains_struct_check ((op)
, (TS_DECL_WRTL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 538, __FUNCTION__))->decl_with_rtl.rtl != nullptr) ? ((contains_struct_check
((op), (TS_DECL_WRTL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 538, __FUNCTION__))->decl_with_rtl.rtl ? (op)->decl_with_rtl
.rtl : (make_decl_rtl (op), (op)->decl_with_rtl.rtl)) : nullptr
)
== pc_rtx)
539 {
540 size_t *v = decl_to_stack_part->get (op);
541 if (v)
542 bitmap_set_bit (active, *v);
543 }
544 return false;
545}
546
547/* Callback for walk_stmt_ops. If OP is a decl touched by add_stack_var
548 record conflicts between it and all currently active other partitions
549 from bitmap DATA. */
550
551static bool
552visit_conflict (gimple *, tree op, tree, void *data)
553{
554 bitmap active = (bitmap)data;
555 op = get_base_address (op);
556 if (op
557 && DECL_P (op)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (op)->base.code))] == tcc_declaration)
558 && DECL_RTL_IF_SET (op)((((tree_contains_struct[(((enum tree_code) (op)->base.code
))][(TS_DECL_WRTL)])) && (contains_struct_check ((op)
, (TS_DECL_WRTL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 558, __FUNCTION__))->decl_with_rtl.rtl != nullptr) ? ((contains_struct_check
((op), (TS_DECL_WRTL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 558, __FUNCTION__))->decl_with_rtl.rtl ? (op)->decl_with_rtl
.rtl : (make_decl_rtl (op), (op)->decl_with_rtl.rtl)) : nullptr
)
== pc_rtx)
559 {
560 size_t *v = decl_to_stack_part->get (op);
561 if (v && bitmap_set_bit (active, *v))
562 {
563 size_t num = *v;
564 bitmap_iterator bi;
565 unsigned i;
566 gcc_assert (num < stack_vars_num)((void)(!(num < stack_vars_num) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 566, __FUNCTION__), 0 : 0))
;
567 EXECUTE_IF_SET_IN_BITMAP (active, 0, i, bi)for (bmp_iter_set_init (&(bi), (active), (0), &(i)); bmp_iter_set
(&(bi), &(i)); bmp_iter_next (&(bi), &(i)))
568 add_stack_var_conflict (num, i);
569 }
570 }
571 return false;
572}
573
574/* Helper routine for add_scope_conflicts, calculating the active partitions
575 at the end of BB, leaving the result in WORK. We're called to generate
576 conflicts when FOR_CONFLICT is true, otherwise we're just tracking
577 liveness. */
578
579static void
580add_scope_conflicts_1 (basic_block bb, bitmap work, bool for_conflict)
581{
582 edge e;
583 edge_iterator ei;
584 gimple_stmt_iterator gsi;
585 walk_stmt_load_store_addr_fn visit;
586
587 bitmap_clear (work);
588 FOR_EACH_EDGE (e, ei, bb->preds)for ((ei) = ei_start_1 (&((bb->preds))); ei_cond ((ei)
, &(e)); ei_next (&(ei)))
589 bitmap_ior_into (work, (bitmap)e->src->aux);
590
591 visit = visit_op;
592
593 for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
594 {
595 gimple *stmt = gsi_stmt (gsi);
596 walk_stmt_load_store_addr_ops (stmt, work, NULLnullptr, NULLnullptr, visit);
597 }
598 for (gsi = gsi_after_labels (bb); !gsi_end_p (gsi); gsi_next (&gsi))
599 {
600 gimple *stmt = gsi_stmt (gsi);
601
602 if (gimple_clobber_p (stmt))
603 {
604 tree lhs = gimple_assign_lhs (stmt);
605 size_t *v;
606 /* Nested function lowering might introduce LHSs
607 that are COMPONENT_REFs. */
608 if (!VAR_P (lhs)(((enum tree_code) (lhs)->base.code) == VAR_DECL))
609 continue;
610 if (DECL_RTL_IF_SET (lhs)((((tree_contains_struct[(((enum tree_code) (lhs)->base.code
))][(TS_DECL_WRTL)])) && (contains_struct_check ((lhs
), (TS_DECL_WRTL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 610, __FUNCTION__))->decl_with_rtl.rtl != nullptr) ? ((contains_struct_check
((lhs), (TS_DECL_WRTL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 610, __FUNCTION__))->decl_with_rtl.rtl ? (lhs)->decl_with_rtl
.rtl : (make_decl_rtl (lhs), (lhs)->decl_with_rtl.rtl)) : nullptr
)
== pc_rtx
611 && (v = decl_to_stack_part->get (lhs)))
612 bitmap_clear_bit (work, *v);
613 }
614 else if (!is_gimple_debug (stmt))
615 {
616 if (for_conflict
617 && visit == visit_op)
618 {
619 /* If this is the first real instruction in this BB we need
620 to add conflicts for everything live at this point now.
621 Unlike classical liveness for named objects we can't
622 rely on seeing a def/use of the names we're interested in.
623 There might merely be indirect loads/stores. We'd not add any
624 conflicts for such partitions. */
625 bitmap_iterator bi;
626 unsigned i;
627 EXECUTE_IF_SET_IN_BITMAP (work, 0, i, bi)for (bmp_iter_set_init (&(bi), (work), (0), &(i)); bmp_iter_set
(&(bi), &(i)); bmp_iter_next (&(bi), &(i)))
628 {
629 class stack_var *a = &stack_vars[i];
630 if (!a->conflicts)
631 a->conflicts = BITMAP_ALLOCbitmap_alloc (&stack_var_bitmap_obstack);
632 bitmap_ior_into (a->conflicts, work);
633 }
634 visit = visit_conflict;
635 }
636 walk_stmt_load_store_addr_ops (stmt, work, visit, visit, visit);
637 }
638 }
639}
640
641/* Generate stack partition conflicts between all partitions that are
642 simultaneously live. */
643
644static void
645add_scope_conflicts (void)
646{
647 basic_block bb;
648 bool changed;
649 bitmap work = BITMAP_ALLOCbitmap_alloc (NULLnullptr);
650 int *rpo;
651 int n_bbs;
652
653 /* We approximate the live range of a stack variable by taking the first
654 mention of its name as starting point(s), and by the end-of-scope
655 death clobber added by gimplify as ending point(s) of the range.
656 This overapproximates in the case we for instance moved an address-taken
657 operation upward, without also moving a dereference to it upwards.
658 But it's conservatively correct as a variable never can hold values
659 before its name is mentioned at least once.
660
661 We then do a mostly classical bitmap liveness algorithm. */
662
663 FOR_ALL_BB_FN (bb, cfun)for (bb = (((cfun + 0))->cfg->x_entry_block_ptr); bb; bb
= bb->next_bb)
664 bb->aux = BITMAP_ALLOCbitmap_alloc (&stack_var_bitmap_obstack);
665
666 rpo = XNEWVEC (int, last_basic_block_for_fn (cfun))((int *) xmalloc (sizeof (int) * ((((cfun + 0))->cfg->x_last_basic_block
))))
;
667 n_bbs = pre_and_rev_post_order_compute (NULLnullptr, rpo, false);
668
669 changed = true;
670 while (changed)
671 {
672 int i;
673 changed = false;
674 for (i = 0; i < n_bbs; i++)
675 {
676 bitmap active;
677 bb = BASIC_BLOCK_FOR_FN (cfun, rpo[i])((*(((cfun + 0))->cfg->x_basic_block_info))[(rpo[i])]);
678 active = (bitmap)bb->aux;
679 add_scope_conflicts_1 (bb, work, false);
680 if (bitmap_ior_into (active, work))
681 changed = true;
682 }
683 }
684
685 FOR_EACH_BB_FN (bb, cfun)for (bb = ((cfun + 0))->cfg->x_entry_block_ptr->next_bb
; bb != ((cfun + 0))->cfg->x_exit_block_ptr; bb = bb->
next_bb)
686 add_scope_conflicts_1 (bb, work, true);
687
688 free (rpo);
689 BITMAP_FREE (work)((void) (bitmap_obstack_free ((bitmap) work), (work) = (bitmap
) nullptr))
;
690 FOR_ALL_BB_FN (bb, cfun)for (bb = (((cfun + 0))->cfg->x_entry_block_ptr); bb; bb
= bb->next_bb)
691 BITMAP_FREE (bb->aux)((void) (bitmap_obstack_free ((bitmap) bb->aux), (bb->aux
) = (bitmap) nullptr))
;
692}
693
694/* A subroutine of partition_stack_vars. A comparison function for qsort,
695 sorting an array of indices by the properties of the object. */
696
697static int
698stack_var_cmp (const void *a, const void *b)
699{
700 size_t ia = *(const size_t *)a;
701 size_t ib = *(const size_t *)b;
702 unsigned int aligna = stack_vars[ia].alignb;
703 unsigned int alignb = stack_vars[ib].alignb;
704 poly_int64 sizea = stack_vars[ia].size;
705 poly_int64 sizeb = stack_vars[ib].size;
706 tree decla = stack_vars[ia].decl;
707 tree declb = stack_vars[ib].decl;
708 bool largea, largeb;
709 unsigned int uida, uidb;
710
711 /* Primary compare on "large" alignment. Large comes first. */
712 largea = (aligna * BITS_PER_UNIT(8) > MAX_SUPPORTED_STACK_ALIGNMENT(((unsigned int) 1 << 28) * 8));
713 largeb = (alignb * BITS_PER_UNIT(8) > MAX_SUPPORTED_STACK_ALIGNMENT(((unsigned int) 1 << 28) * 8));
714 if (largea != largeb)
715 return (int)largeb - (int)largea;
716
717 /* Secondary compare on size, decreasing */
718 int diff = compare_sizes_for_sort (sizeb, sizea);
719 if (diff != 0)
720 return diff;
721
722 /* Tertiary compare on true alignment, decreasing. */
723 if (aligna < alignb)
724 return -1;
725 if (aligna > alignb)
726 return 1;
727
728 /* Final compare on ID for sort stability, increasing.
729 Two SSA names are compared by their version, SSA names come before
730 non-SSA names, and two normal decls are compared by their DECL_UID. */
731 if (TREE_CODE (decla)((enum tree_code) (decla)->base.code) == SSA_NAME)
732 {
733 if (TREE_CODE (declb)((enum tree_code) (declb)->base.code) == SSA_NAME)
734 uida = SSA_NAME_VERSION (decla)(tree_check ((decla), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 734, __FUNCTION__, (SSA_NAME)))->base.u.version
, uidb = SSA_NAME_VERSION (declb)(tree_check ((declb), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 734, __FUNCTION__, (SSA_NAME)))->base.u.version
;
735 else
736 return -1;
737 }
738 else if (TREE_CODE (declb)((enum tree_code) (declb)->base.code) == SSA_NAME)
739 return 1;
740 else
741 uida = DECL_UID (decla)((contains_struct_check ((decla), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 741, __FUNCTION__))->decl_minimal.uid)
, uidb = DECL_UID (declb)((contains_struct_check ((declb), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 741, __FUNCTION__))->decl_minimal.uid)
;
742 if (uida < uidb)
743 return 1;
744 if (uida > uidb)
745 return -1;
746 return 0;
747}
748
749struct part_traits : unbounded_int_hashmap_traits <size_t, bitmap> {};
750typedef hash_map<size_t, bitmap, part_traits> part_hashmap;
751
752/* If the points-to solution *PI points to variables that are in a partition
753 together with other variables add all partition members to the pointed-to
754 variables bitmap. */
755
756static void
757add_partitioned_vars_to_ptset (struct pt_solution *pt,
758 part_hashmap *decls_to_partitions,
759 hash_set<bitmap> *visited, bitmap temp)
760{
761 bitmap_iterator bi;
762 unsigned i;
763 bitmap *part;
764
765 if (pt->anything
766 || pt->vars == NULLnullptr
767 /* The pointed-to vars bitmap is shared, it is enough to
768 visit it once. */
769 || visited->add (pt->vars))
770 return;
771
772 bitmap_clear (temp);
773
774 /* By using a temporary bitmap to store all members of the partitions
775 we have to add we make sure to visit each of the partitions only
776 once. */
777 EXECUTE_IF_SET_IN_BITMAP (pt->vars, 0, i, bi)for (bmp_iter_set_init (&(bi), (pt->vars), (0), &(
i)); bmp_iter_set (&(bi), &(i)); bmp_iter_next (&
(bi), &(i)))
778 if ((!temp
779 || !bitmap_bit_p (temp, i))
780 && (part = decls_to_partitions->get (i)))
781 bitmap_ior_into (temp, *part);
782 if (!bitmap_empty_p (temp))
783 bitmap_ior_into (pt->vars, temp);
784}
785
786/* Update points-to sets based on partition info, so we can use them on RTL.
787 The bitmaps representing stack partitions will be saved until expand,
788 where partitioned decls used as bases in memory expressions will be
789 rewritten. */
790
791static void
792update_alias_info_with_stack_vars (void)
793{
794 part_hashmap *decls_to_partitions = NULLnullptr;
795 size_t i, j;
796 tree var = NULL_TREE(tree) nullptr;
797
798 for (i = 0; i < stack_vars_num; i++)
799 {
800 bitmap part = NULLnullptr;
801 tree name;
802 struct ptr_info_def *pi;
803
804 /* Not interested in partitions with single variable. */
805 if (stack_vars[i].representative != i
806 || stack_vars[i].next == EOC((size_t)-1))
807 continue;
808
809 if (!decls_to_partitions)
810 {
811 decls_to_partitions = new part_hashmap;
812 cfun(cfun + 0)->gimple_df->decls_to_pointers = new hash_map<tree, tree>;
813 }
814
815 /* Create an SSA_NAME that points to the partition for use
816 as base during alias-oracle queries on RTL for bases that
817 have been partitioned. */
818 if (var == NULL_TREE(tree) nullptr)
819 var = create_tmp_var (ptr_type_nodeglobal_trees[TI_PTR_TYPE]);
820 name = make_ssa_name (var);
821
822 /* Create bitmaps representing partitions. They will be used for
823 points-to sets later, so use GGC alloc. */
824 part = BITMAP_GGC_ALLOCbitmap_gc_alloc ();
825 for (j = i; j != EOC((size_t)-1); j = stack_vars[j].next)
826 {
827 tree decl = stack_vars[j].decl;
828 unsigned int uid = DECL_PT_UID (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 828, __FUNCTION__))->decl_common.pt_uid == -1u ? (decl)->
decl_minimal.uid : (decl)->decl_common.pt_uid)
;
829 bitmap_set_bit (part, uid);
830 decls_to_partitions->put (uid, part);
831 cfun(cfun + 0)->gimple_df->decls_to_pointers->put (decl, name);
832 if (TREE_ADDRESSABLE (decl)((decl)->base.addressable_flag))
833 TREE_ADDRESSABLE (name)((name)->base.addressable_flag) = 1;
834 }
835
836 /* Make the SSA name point to all partition members. */
837 pi = get_ptr_info (name);
838 pt_solution_set (&pi->pt, part, false);
839 }
840
841 /* Make all points-to sets that contain one member of a partition
842 contain all members of the partition. */
843 if (decls_to_partitions)
844 {
845 unsigned i;
846 tree name;
847 hash_set<bitmap> visited;
848 bitmap temp = BITMAP_ALLOCbitmap_alloc (&stack_var_bitmap_obstack);
849
850 FOR_EACH_SSA_NAME (i, name, cfun)for (i = 1; ((cfun + 0))->gimple_df->ssa_names->iterate
(i, &name); ++i) if (name)
851 {
852 struct ptr_info_def *pi;
853
854 if (POINTER_TYPE_P (TREE_TYPE (name))(((enum tree_code) (((contains_struct_check ((name), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 854, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
|| ((enum tree_code) (((contains_struct_check ((name), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 854, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
)
855 && ((pi = SSA_NAME_PTR_INFO (name)(tree_check ((name), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 855, __FUNCTION__, (SSA_NAME)))->ssa_name.info.ptr_info
) != NULLnullptr))
856 add_partitioned_vars_to_ptset (&pi->pt, decls_to_partitions,
857 &visited, temp);
858 }
859
860 add_partitioned_vars_to_ptset (&cfun(cfun + 0)->gimple_df->escaped,
861 decls_to_partitions, &visited, temp);
862
863 delete decls_to_partitions;
864 BITMAP_FREE (temp)((void) (bitmap_obstack_free ((bitmap) temp), (temp) = (bitmap
) nullptr))
;
865 }
866}
867
868/* A subroutine of partition_stack_vars. The UNION portion of a UNION/FIND
869 partitioning algorithm. Partitions A and B are known to be non-conflicting.
870 Merge them into a single partition A. */
871
872static void
873union_stack_vars (size_t a, size_t b)
874{
875 class stack_var *vb = &stack_vars[b];
876 bitmap_iterator bi;
877 unsigned u;
878
879 gcc_assert (stack_vars[b].next == EOC)((void)(!(stack_vars[b].next == ((size_t)-1)) ? fancy_abort (
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 879, __FUNCTION__), 0 : 0))
;
880 /* Add B to A's partition. */
881 stack_vars[b].next = stack_vars[a].next;
882 stack_vars[b].representative = a;
883 stack_vars[a].next = b;
884
885 /* Make sure A is big enough to hold B. */
886 stack_vars[a].size = upper_bound (stack_vars[a].size, stack_vars[b].size);
887
888 /* Update the required alignment of partition A to account for B. */
889 if (stack_vars[a].alignb < stack_vars[b].alignb)
890 stack_vars[a].alignb = stack_vars[b].alignb;
891
892 /* Update the interference graph and merge the conflicts. */
893 if (vb->conflicts)
894 {
895 EXECUTE_IF_SET_IN_BITMAP (vb->conflicts, 0, u, bi)for (bmp_iter_set_init (&(bi), (vb->conflicts), (0), &
(u)); bmp_iter_set (&(bi), &(u)); bmp_iter_next (&
(bi), &(u)))
896 add_stack_var_conflict (a, stack_vars[u].representative);
897 BITMAP_FREE (vb->conflicts)((void) (bitmap_obstack_free ((bitmap) vb->conflicts), (vb
->conflicts) = (bitmap) nullptr))
;
898 }
899}
900
901/* A subroutine of expand_used_vars. Binpack the variables into
902 partitions constrained by the interference graph. The overall
903 algorithm used is as follows:
904
905 Sort the objects by size in descending order.
906 For each object A {
907 S = size(A)
908 O = 0
909 loop {
910 Look for the largest non-conflicting object B with size <= S.
911 UNION (A, B)
912 }
913 }
914*/
915
916static void
917partition_stack_vars (void)
918{
919 size_t si, sj, n = stack_vars_num;
920
921 stack_vars_sorted = XNEWVEC (size_t, stack_vars_num)((size_t *) xmalloc (sizeof (size_t) * (stack_vars_num)));
922 for (si = 0; si < n; ++si)
923 stack_vars_sorted[si] = si;
924
925 if (n == 1)
926 return;
927
928 qsort (stack_vars_sorted, n, sizeof (size_t), stack_var_cmp)gcc_qsort (stack_vars_sorted, n, sizeof (size_t), stack_var_cmp
)
;
929
930 for (si = 0; si < n; ++si)
931 {
932 size_t i = stack_vars_sorted[si];
933 unsigned int ialign = stack_vars[i].alignb;
934 poly_int64 isize = stack_vars[i].size;
935
936 /* Ignore objects that aren't partition representatives. If we
937 see a var that is not a partition representative, it must
938 have been merged earlier. */
939 if (stack_vars[i].representative != i)
940 continue;
941
942 for (sj = si + 1; sj < n; ++sj)
943 {
944 size_t j = stack_vars_sorted[sj];
945 unsigned int jalign = stack_vars[j].alignb;
946 poly_int64 jsize = stack_vars[j].size;
947
948 /* Ignore objects that aren't partition representatives. */
949 if (stack_vars[j].representative != j)
950 continue;
951
952 /* Do not mix objects of "small" (supported) alignment
953 and "large" (unsupported) alignment. */
954 if ((ialign * BITS_PER_UNIT(8) <= MAX_SUPPORTED_STACK_ALIGNMENT(((unsigned int) 1 << 28) * 8))
955 != (jalign * BITS_PER_UNIT(8) <= MAX_SUPPORTED_STACK_ALIGNMENT(((unsigned int) 1 << 28) * 8)))
956 break;
957
958 /* For Address Sanitizer do not mix objects with different
959 sizes, as the shorter vars wouldn't be adequately protected.
960 Don't do that for "large" (unsupported) alignment objects,
961 those aren't protected anyway. */
962 if (asan_sanitize_stack_p ()
963 && maybe_ne (isize, jsize)
964 && ialign * BITS_PER_UNIT(8) <= MAX_SUPPORTED_STACK_ALIGNMENT(((unsigned int) 1 << 28) * 8))
965 break;
966
967 /* Ignore conflicting objects. */
968 if (stack_var_conflict_p (i, j))
969 continue;
970
971 /* UNION the objects, placing J at OFFSET. */
972 union_stack_vars (i, j);
973 }
974 }
975
976 update_alias_info_with_stack_vars ();
977}
978
979/* A debugging aid for expand_used_vars. Dump the generated partitions. */
980
981static void
982dump_stack_var_partition (void)
983{
984 size_t si, i, j, n = stack_vars_num;
985
986 for (si = 0; si < n; ++si)
987 {
988 i = stack_vars_sorted[si];
989
990 /* Skip variables that aren't partition representatives, for now. */
991 if (stack_vars[i].representative != i)
992 continue;
993
994 fprintf (dump_file, "Partition %lu: size ", (unsigned long) i);
995 print_dec (stack_vars[i].size, dump_file);
996 fprintf (dump_file, " align %u\n", stack_vars[i].alignb);
997
998 for (j = i; j != EOC((size_t)-1); j = stack_vars[j].next)
999 {
1000 fputc ('\t', dump_file);
1001 print_generic_expr (dump_file, stack_vars[j].decl, dump_flags);
1002 }
1003 fputc ('\n', dump_file);
1004 }
1005}
1006
1007/* Assign rtl to DECL at BASE + OFFSET. */
1008
1009static void
1010expand_one_stack_var_at (tree decl, rtx base, unsigned base_align,
1011 poly_int64 offset)
1012{
1013 unsigned align;
1014 rtx x;
1015
1016 /* If this fails, we've overflowed the stack frame. Error nicely? */
1017 gcc_assert (known_eq (offset, trunc_int_for_mode (offset, Pmode)))((void)(!((!maybe_ne (offset, trunc_int_for_mode (offset, (global_options
.x_ix86_pmode == PMODE_DI ? (scalar_int_mode ((scalar_int_mode
::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode::
from_int) E_SImode))))))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1017, __FUNCTION__), 0 : 0))
;
1018
1019 if (hwasan_sanitize_stack_p ())
1020 x = targetm.memtag.add_tag (base, offset,
1021 hwasan_current_frame_tag ());
1022 else
1023 x = plus_constant (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode)))
, base, offset);
1024
1025 x = gen_rtx_MEM (TREE_CODE (decl)((enum tree_code) (decl)->base.code) == SSA_NAME
1026 ? TYPE_MODE (TREE_TYPE (decl))((((enum tree_code) ((tree_class_check ((((contains_struct_check
((decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1026, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1026, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(((contains_struct_check ((decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1026, __FUNCTION__))->typed.type)) : (((contains_struct_check
((decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1026, __FUNCTION__))->typed.type))->type_common.mode)
1027 : DECL_MODE (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1027, __FUNCTION__))->decl_common.mode)
, x);
1028
1029 /* Set alignment we actually gave this decl if it isn't an SSA name.
1030 If it is we generate stack slots only accidentally so it isn't as
1031 important, we'll simply set the alignment directly on the MEM. */
1032
1033 if (stack_vars_base_reg_p (base))
1034 offset -= frame_phase;
1035 align = known_alignment (offset);
1036 align *= BITS_PER_UNIT(8);
1037 if (align == 0 || align > base_align)
1038 align = base_align;
1039
1040 if (TREE_CODE (decl)((enum tree_code) (decl)->base.code) != SSA_NAME)
1041 {
1042 /* One would think that we could assert that we're not decreasing
1043 alignment here, but (at least) the i386 port does exactly this
1044 via the MINIMUM_ALIGNMENT hook. */
1045
1046 SET_DECL_ALIGN (decl, align)(((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1046, __FUNCTION__))->decl_common.align) = ffs_hwi (align
))
;
1047 DECL_USER_ALIGN (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1047, __FUNCTION__))->base.u.bits.user_align)
= 0;
1048 }
1049
1050 set_rtl (decl, x);
1051
1052 set_mem_align (x, align);
1053}
1054
1055class stack_vars_data
1056{
1057public:
1058 /* Vector of offset pairs, always end of some padding followed
1059 by start of the padding that needs Address Sanitizer protection.
1060 The vector is in reversed, highest offset pairs come first. */
1061 auto_vec<HOST_WIDE_INTlong> asan_vec;
1062
1063 /* Vector of partition representative decls in between the paddings. */
1064 auto_vec<tree> asan_decl_vec;
1065
1066 /* Base pseudo register for Address Sanitizer protected automatic vars. */
1067 rtx asan_base;
1068
1069 /* Alignment needed for the Address Sanitizer protected automatic vars. */
1070 unsigned int asan_alignb;
1071};
1072
1073/* A subroutine of expand_used_vars. Give each partition representative
1074 a unique location within the stack frame. Update each partition member
1075 with that location. */
1076static void
1077expand_stack_vars (bool (*pred) (size_t), class stack_vars_data *data)
1078{
1079 size_t si, i, j, n = stack_vars_num;
1080 poly_uint64 large_size = 0, large_alloc = 0;
1081 rtx large_base = NULLnullptr;
1082 rtx large_untagged_base = NULLnullptr;
1083 unsigned large_align = 0;
1084 bool large_allocation_done = false;
1085 tree decl;
1086
1087 /* Determine if there are any variables requiring "large" alignment.
1088 Since these are dynamically allocated, we only process these if
1089 no predicate involved. */
1090 large_align = stack_vars[stack_vars_sorted[0]].alignb * BITS_PER_UNIT(8);
1091 if (pred == NULLnullptr && large_align > MAX_SUPPORTED_STACK_ALIGNMENT(((unsigned int) 1 << 28) * 8))
1092 {
1093 /* Find the total size of these variables. */
1094 for (si = 0; si < n; ++si)
1095 {
1096 unsigned alignb;
1097
1098 i = stack_vars_sorted[si];
1099 alignb = stack_vars[i].alignb;
1100
1101 /* All "large" alignment decls come before all "small" alignment
1102 decls, but "large" alignment decls are not sorted based on
1103 their alignment. Increase large_align to track the largest
1104 required alignment. */
1105 if ((alignb * BITS_PER_UNIT(8)) > large_align)
1106 large_align = alignb * BITS_PER_UNIT(8);
1107
1108 /* Stop when we get to the first decl with "small" alignment. */
1109 if (alignb * BITS_PER_UNIT(8) <= MAX_SUPPORTED_STACK_ALIGNMENT(((unsigned int) 1 << 28) * 8))
1110 break;
1111
1112 /* Skip variables that aren't partition representatives. */
1113 if (stack_vars[i].representative != i)
1114 continue;
1115
1116 /* Skip variables that have already had rtl assigned. See also
1117 add_stack_var where we perpetrate this pc_rtx hack. */
1118 decl = stack_vars[i].decl;
1119 if (TREE_CODE (decl)((enum tree_code) (decl)->base.code) == SSA_NAME
1120 ? SA.partition_to_pseudo[var_to_partition (SA.map, decl)] != NULL_RTX(rtx) 0
1121 : DECL_RTL (decl)((contains_struct_check ((decl), (TS_DECL_WRTL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1121, __FUNCTION__))->decl_with_rtl.rtl ? (decl)->decl_with_rtl
.rtl : (make_decl_rtl (decl), (decl)->decl_with_rtl.rtl))
!= pc_rtx)
1122 continue;
1123
1124 large_size = aligned_upper_bound (large_size, alignb);
1125 large_size += stack_vars[i].size;
1126 }
1127 }
1128
1129 for (si = 0; si < n; ++si)
1130 {
1131 rtx base;
1132 unsigned base_align, alignb;
1133 poly_int64 offset = 0;
1134
1135 i = stack_vars_sorted[si];
1136
1137 /* Skip variables that aren't partition representatives, for now. */
1138 if (stack_vars[i].representative != i)
1139 continue;
1140
1141 /* Skip variables that have already had rtl assigned. See also
1142 add_stack_var where we perpetrate this pc_rtx hack. */
1143 decl = stack_vars[i].decl;
1144 if (TREE_CODE (decl)((enum tree_code) (decl)->base.code) == SSA_NAME
1145 ? SA.partition_to_pseudo[var_to_partition (SA.map, decl)] != NULL_RTX(rtx) 0
1146 : DECL_RTL (decl)((contains_struct_check ((decl), (TS_DECL_WRTL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1146, __FUNCTION__))->decl_with_rtl.rtl ? (decl)->decl_with_rtl
.rtl : (make_decl_rtl (decl), (decl)->decl_with_rtl.rtl))
!= pc_rtx)
1147 continue;
1148
1149 /* Check the predicate to see whether this variable should be
1150 allocated in this pass. */
1151 if (pred && !pred (i))
1152 continue;
1153
1154 base = (hwasan_sanitize_stack_p ()
1155 ? hwasan_frame_base ()
1156 : virtual_stack_vars_rtx((this_target_rtl->x_global_rtl)[GR_VIRTUAL_STACK_ARGS]));
1157 alignb = stack_vars[i].alignb;
1158 if (alignb * BITS_PER_UNIT(8) <= MAX_SUPPORTED_STACK_ALIGNMENT(((unsigned int) 1 << 28) * 8))
1159 {
1160 poly_int64 hwasan_orig_offset;
1161 if (hwasan_sanitize_stack_p ())
1162 {
1163 /* There must be no tag granule "shared" between different
1164 objects. This means that no HWASAN_TAG_GRANULE_SIZE byte
1165 chunk can have more than one object in it.
1166
1167 We ensure this by forcing the end of the last bit of data to
1168 be aligned to HWASAN_TAG_GRANULE_SIZE bytes here, and setting
1169 the start of each variable to be aligned to
1170 HWASAN_TAG_GRANULE_SIZE bytes in `align_local_variable`.
1171
1172 We can't align just one of the start or end, since there are
1173 untagged things stored on the stack which we do not align to
1174 HWASAN_TAG_GRANULE_SIZE bytes. If we only aligned the start
1175 or the end of tagged objects then untagged objects could end
1176 up sharing the first granule of a tagged object or sharing the
1177 last granule of a tagged object respectively. */
1178 hwasan_orig_offset = align_frame_offset (HWASAN_TAG_GRANULE_SIZEtargetm.memtag.granule_size ());
1179 gcc_assert (stack_vars[i].alignb >= HWASAN_TAG_GRANULE_SIZE)((void)(!(stack_vars[i].alignb >= targetm.memtag.granule_size
()) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1179, __FUNCTION__), 0 : 0))
;
1180 }
1181 /* ASAN description strings don't yet have a syntax for expressing
1182 polynomial offsets. */
1183 HOST_WIDE_INTlong prev_offset;
1184 if (asan_sanitize_stack_p ()
1185 && pred
1186 && frame_offset((&x_rtl)->x_frame_offset).is_constant (&prev_offset)
1187 && stack_vars[i].size.is_constant ())
1188 {
1189 if (data->asan_vec.is_empty ())
1190 {
1191 align_frame_offset (ASAN_RED_ZONE_SIZE32);
1192 prev_offset = frame_offset((&x_rtl)->x_frame_offset).to_constant ();
1193 }
1194 prev_offset = align_base (prev_offset,
1195 ASAN_MIN_RED_ZONE_SIZE16,
1196 !FRAME_GROWS_DOWNWARD1);
1197 tree repr_decl = NULL_TREE(tree) nullptr;
1198 unsigned HOST_WIDE_INTlong size
1199 = asan_var_and_redzone_size (stack_vars[i].size.to_constant ());
1200 if (data->asan_vec.is_empty ())
1201 size = MAX (size, ASAN_RED_ZONE_SIZE)((size) > (32) ? (size) : (32));
1202
1203 unsigned HOST_WIDE_INTlong alignment = MAX (alignb,((alignb) > (16) ? (alignb) : (16))
1204 ASAN_MIN_RED_ZONE_SIZE)((alignb) > (16) ? (alignb) : (16));
1205 offset = alloc_stack_frame_space (size, alignment);
1206
1207 data->asan_vec.safe_push (prev_offset);
1208 /* Allocating a constant amount of space from a constant
1209 starting offset must give a constant result. */
1210 data->asan_vec.safe_push ((offset + stack_vars[i].size)
1211 .to_constant ());
1212 /* Find best representative of the partition.
1213 Prefer those with DECL_NAME, even better
1214 satisfying asan_protect_stack_decl predicate. */
1215 for (j = i; j != EOC((size_t)-1); j = stack_vars[j].next)
1216 if (asan_protect_stack_decl (stack_vars[j].decl)
1217 && DECL_NAME (stack_vars[j].decl)((contains_struct_check ((stack_vars[j].decl), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1217, __FUNCTION__))->decl_minimal.name)
)
1218 {
1219 repr_decl = stack_vars[j].decl;
1220 break;
1221 }
1222 else if (repr_decl == NULL_TREE(tree) nullptr
1223 && DECL_P (stack_vars[j].decl)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (stack_vars[j].decl)->base.code))] == tcc_declaration)
1224 && DECL_NAME (stack_vars[j].decl)((contains_struct_check ((stack_vars[j].decl), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1224, __FUNCTION__))->decl_minimal.name)
)
1225 repr_decl = stack_vars[j].decl;
1226 if (repr_decl == NULL_TREE(tree) nullptr)
1227 repr_decl = stack_vars[i].decl;
1228 data->asan_decl_vec.safe_push (repr_decl);
1229
1230 /* Make sure a representative is unpoison if another
1231 variable in the partition is handled by
1232 use-after-scope sanitization. */
1233 if (asan_handled_variables != NULLnullptr
1234 && !asan_handled_variables->contains (repr_decl))
1235 {
1236 for (j = i; j != EOC((size_t)-1); j = stack_vars[j].next)
1237 if (asan_handled_variables->contains (stack_vars[j].decl))
1238 break;
1239 if (j != EOC((size_t)-1))
1240 asan_handled_variables->add (repr_decl);
1241 }
1242
1243 data->asan_alignb = MAX (data->asan_alignb, alignb)((data->asan_alignb) > (alignb) ? (data->asan_alignb
) : (alignb))
;
1244 if (data->asan_base == NULLnullptr)
1245 data->asan_base = gen_reg_rtx (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode)))
);
1246 base = data->asan_base;
1247
1248 if (!STRICT_ALIGNMENT0)
1249 base_align = crtl(&x_rtl)->max_used_stack_slot_alignment;
1250 else
1251 base_align = MAX (crtl->max_used_stack_slot_alignment,(((&x_rtl)->max_used_stack_slot_alignment) > (get_mode_alignment
((scalar_int_mode ((scalar_int_mode::from_int) E_SImode))) <<
3) ? ((&x_rtl)->max_used_stack_slot_alignment) : (get_mode_alignment
((scalar_int_mode ((scalar_int_mode::from_int) E_SImode))) <<
3))
1252 GET_MODE_ALIGNMENT (SImode)(((&x_rtl)->max_used_stack_slot_alignment) > (get_mode_alignment
((scalar_int_mode ((scalar_int_mode::from_int) E_SImode))) <<
3) ? ((&x_rtl)->max_used_stack_slot_alignment) : (get_mode_alignment
((scalar_int_mode ((scalar_int_mode::from_int) E_SImode))) <<
3))
1253 << ASAN_SHADOW_SHIFT)(((&x_rtl)->max_used_stack_slot_alignment) > (get_mode_alignment
((scalar_int_mode ((scalar_int_mode::from_int) E_SImode))) <<
3) ? ((&x_rtl)->max_used_stack_slot_alignment) : (get_mode_alignment
((scalar_int_mode ((scalar_int_mode::from_int) E_SImode))) <<
3))
;
1254 }
1255 else
1256 {
1257 offset = alloc_stack_frame_space (stack_vars[i].size, alignb);
1258 base_align = crtl(&x_rtl)->max_used_stack_slot_alignment;
1259
1260 if (hwasan_sanitize_stack_p ())
1261 {
1262 /* Align again since the point of this alignment is to handle
1263 the "end" of the object (i.e. smallest address after the
1264 stack object). For FRAME_GROWS_DOWNWARD that requires
1265 aligning the stack before allocating, but for a frame that
1266 grows upwards that requires aligning the stack after
1267 allocation.
1268
1269 Use `frame_offset` to record the offset value rather than
1270 `offset` since the `frame_offset` describes the extent
1271 allocated for this particular variable while `offset`
1272 describes the address that this variable starts at. */
1273 align_frame_offset (HWASAN_TAG_GRANULE_SIZEtargetm.memtag.granule_size ());
1274 hwasan_record_stack_var (virtual_stack_vars_rtx((this_target_rtl->x_global_rtl)[GR_VIRTUAL_STACK_ARGS]), base,
1275 hwasan_orig_offset, frame_offset((&x_rtl)->x_frame_offset));
1276 }
1277 }
1278 }
1279 else
1280 {
1281 /* Large alignment is only processed in the last pass. */
1282 if (pred)
1283 continue;
1284
1285 /* If there were any variables requiring "large" alignment, allocate
1286 space. */
1287 if (maybe_ne (large_size, 0U) && ! large_allocation_done)
1288 {
1289 poly_int64 loffset;
1290 rtx large_allocsize;
1291
1292 large_allocsize = gen_int_mode (large_size, Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode)))
);
1293 get_dynamic_stack_size (&large_allocsize, 0, large_align, NULLnullptr);
1294 loffset = alloc_stack_frame_space
1295 (rtx_to_poly_int64 (large_allocsize),
1296 PREFERRED_STACK_BOUNDARYix86_preferred_stack_boundary / BITS_PER_UNIT(8));
1297 large_base = get_dynamic_stack_base (loffset, large_align, base);
1298 large_allocation_done = true;
1299 }
1300
1301 gcc_assert (large_base != NULL)((void)(!(large_base != nullptr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1301, __FUNCTION__), 0 : 0))
;
1302 large_alloc = aligned_upper_bound (large_alloc, alignb);
1303 offset = large_alloc;
1304 large_alloc += stack_vars[i].size;
1305 if (hwasan_sanitize_stack_p ())
1306 {
1307 /* An object with a large alignment requirement means that the
1308 alignment requirement is greater than the required alignment
1309 for tags. */
1310 if (!large_untagged_base)
1311 large_untagged_base
1312 = targetm.memtag.untagged_pointer (large_base, NULL_RTX(rtx) 0);
1313 /* Ensure the end of the variable is also aligned correctly. */
1314 poly_int64 align_again
1315 = aligned_upper_bound (large_alloc, HWASAN_TAG_GRANULE_SIZEtargetm.memtag.granule_size ());
1316 /* For large allocations we always allocate a chunk of space
1317 (which is addressed by large_untagged_base/large_base) and
1318 then use positive offsets from that. Hence the farthest
1319 offset is `align_again` and the nearest offset from the base
1320 is `offset`. */
1321 hwasan_record_stack_var (large_untagged_base, large_base,
1322 offset, align_again);
1323 }
1324
1325 base = large_base;
1326 base_align = large_align;
1327 }
1328
1329 /* Create rtl for each variable based on their location within the
1330 partition. */
1331 for (j = i; j != EOC((size_t)-1); j = stack_vars[j].next)
1332 {
1333 expand_one_stack_var_at (stack_vars[j].decl,
1334 base, base_align, offset);
1335 }
1336 if (hwasan_sanitize_stack_p ())
1337 hwasan_increment_frame_tag ();
1338 }
1339
1340 gcc_assert (known_eq (large_alloc, large_size))((void)(!((!maybe_ne (large_alloc, large_size))) ? fancy_abort
("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1340, __FUNCTION__), 0 : 0))
;
1341}
1342
1343/* Take into account all sizes of partitions and reset DECL_RTLs. */
1344static poly_uint64
1345account_stack_vars (void)
1346{
1347 size_t si, j, i, n = stack_vars_num;
1348 poly_uint64 size = 0;
1349
1350 for (si = 0; si < n; ++si)
1351 {
1352 i = stack_vars_sorted[si];
1353
1354 /* Skip variables that aren't partition representatives, for now. */
1355 if (stack_vars[i].representative != i)
1356 continue;
1357
1358 size += stack_vars[i].size;
1359 for (j = i; j != EOC((size_t)-1); j = stack_vars[j].next)
1360 set_rtl (stack_vars[j].decl, NULLnullptr);
1361 }
1362 return size;
1363}
1364
1365/* Record the RTL assignment X for the default def of PARM. */
1366
1367extern void
1368set_parm_rtl (tree parm, rtx x)
1369{
1370 gcc_assert (TREE_CODE (parm) == PARM_DECL((void)(!(((enum tree_code) (parm)->base.code) == PARM_DECL
|| ((enum tree_code) (parm)->base.code) == RESULT_DECL) ?
fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1371, __FUNCTION__), 0 : 0))
1371 || TREE_CODE (parm) == RESULT_DECL)((void)(!(((enum tree_code) (parm)->base.code) == PARM_DECL
|| ((enum tree_code) (parm)->base.code) == RESULT_DECL) ?
fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1371, __FUNCTION__), 0 : 0))
;
1372
1373 if (x && !MEM_P (x)(((enum rtx_code) (x)->code) == MEM))
1374 {
1375 unsigned int align = MINIMUM_ALIGNMENT (TREE_TYPE (parm),ix86_minimum_alignment ((((contains_struct_check ((parm), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1375, __FUNCTION__))->typed.type)), (((((enum tree_code)
((tree_class_check ((((contains_struct_check ((parm), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1376, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1376, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(((contains_struct_check ((parm), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1376, __FUNCTION__))->typed.type)) : (((contains_struct_check
((parm), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1376, __FUNCTION__))->typed.type))->type_common.mode)
), ((((tree_class_check ((((contains_struct_check ((parm), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1377, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1377, __FUNCTION__))->type_common.align) ? ((unsigned)1)
<< (((tree_class_check ((((contains_struct_check ((parm
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1377, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1377, __FUNCTION__))->type_common.align) - 1) : 0)))
1376 TYPE_MODE (TREE_TYPE (parm)),ix86_minimum_alignment ((((contains_struct_check ((parm), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1375, __FUNCTION__))->typed.type)), (((((enum tree_code)
((tree_class_check ((((contains_struct_check ((parm), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1376, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1376, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(((contains_struct_check ((parm), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1376, __FUNCTION__))->typed.type)) : (((contains_struct_check
((parm), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1376, __FUNCTION__))->typed.type))->type_common.mode)
), ((((tree_class_check ((((contains_struct_check ((parm), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1377, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1377, __FUNCTION__))->type_common.align) ? ((unsigned)1)
<< (((tree_class_check ((((contains_struct_check ((parm
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1377, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1377, __FUNCTION__))->type_common.align) - 1) : 0)))
1377 TYPE_ALIGN (TREE_TYPE (parm)))ix86_minimum_alignment ((((contains_struct_check ((parm), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1375, __FUNCTION__))->typed.type)), (((((enum tree_code)
((tree_class_check ((((contains_struct_check ((parm), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1376, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1376, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(((contains_struct_check ((parm), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1376, __FUNCTION__))->typed.type)) : (((contains_struct_check
((parm), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1376, __FUNCTION__))->typed.type))->type_common.mode)
), ((((tree_class_check ((((contains_struct_check ((parm), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1377, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1377, __FUNCTION__))->type_common.align) ? ((unsigned)1)
<< (((tree_class_check ((((contains_struct_check ((parm
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1377, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1377, __FUNCTION__))->type_common.align) - 1) : 0)))
;
1378
1379 /* If the variable alignment is very large we'll dynamicaly
1380 allocate it, which means that in-frame portion is just a
1381 pointer. ??? We've got a pseudo for sure here, do we
1382 actually dynamically allocate its spilling area if needed?
1383 ??? Isn't it a problem when Pmode alignment also exceeds
1384 MAX_SUPPORTED_STACK_ALIGNMENT, as can happen on cris and lm32? */
1385 if (align > MAX_SUPPORTED_STACK_ALIGNMENT(((unsigned int) 1 << 28) * 8))
1386 align = GET_MODE_ALIGNMENT (Pmode)get_mode_alignment ((global_options.x_ix86_pmode == PMODE_DI ?
(scalar_int_mode ((scalar_int_mode::from_int) E_DImode)) : (
scalar_int_mode ((scalar_int_mode::from_int) E_SImode))))
;
1387
1388 record_alignment_for_reg_var (align);
1389 }
1390
1391 tree ssa = ssa_default_def (cfun(cfun + 0), parm);
1392 if (!ssa)
1393 return set_rtl (parm, x);
1394
1395 int part = var_to_partition (SA.map, ssa);
1396 gcc_assert (part != NO_PARTITION)((void)(!(part != -1) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1396, __FUNCTION__), 0 : 0))
;
1397
1398 bool changed = bitmap_bit_p (SA.partitions_for_parm_default_defs, part);
1399 gcc_assert (changed)((void)(!(changed) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1399, __FUNCTION__), 0 : 0))
;
1400
1401 set_rtl (ssa, x);
1402 gcc_assert (DECL_RTL (parm) == x)((void)(!(((contains_struct_check ((parm), (TS_DECL_WRTL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1402, __FUNCTION__))->decl_with_rtl.rtl ? (parm)->decl_with_rtl
.rtl : (make_decl_rtl (parm), (parm)->decl_with_rtl.rtl)) ==
x) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1402, __FUNCTION__), 0 : 0))
;
1403}
1404
1405/* A subroutine of expand_one_var. Called to immediately assign rtl
1406 to a variable to be allocated in the stack frame. */
1407
1408static void
1409expand_one_stack_var_1 (tree var)
1410{
1411 poly_uint64 size;
1412 poly_int64 offset;
1413 unsigned byte_align;
1414
1415 if (TREE_CODE (var)((enum tree_code) (var)->base.code) == SSA_NAME)
1416 {
1417 tree type = TREE_TYPE (var)((contains_struct_check ((var), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1417, __FUNCTION__))->typed.type)
;
1418 size = tree_to_poly_uint64 (TYPE_SIZE_UNIT (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1418, __FUNCTION__))->type_common.size_unit)
);
1419 }
1420 else
1421 size = tree_to_poly_uint64 (DECL_SIZE_UNIT (var)((contains_struct_check ((var), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1421, __FUNCTION__))->decl_common.size_unit)
);
1422
1423 byte_align = align_local_variable (var, true);
1424
1425 /* We handle highly aligned variables in expand_stack_vars. */
1426 gcc_assert (byte_align * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT)((void)(!(byte_align * (8) <= (((unsigned int) 1 << 28
) * 8)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1426, __FUNCTION__), 0 : 0))
;
1427
1428 rtx base;
1429 if (hwasan_sanitize_stack_p ())
1430 {
1431 /* Allocate zero bytes to align the stack. */
1432 poly_int64 hwasan_orig_offset
1433 = align_frame_offset (HWASAN_TAG_GRANULE_SIZEtargetm.memtag.granule_size ());
1434 offset = alloc_stack_frame_space (size, byte_align);
1435 align_frame_offset (HWASAN_TAG_GRANULE_SIZEtargetm.memtag.granule_size ());
1436 base = hwasan_frame_base ();
1437 /* Use `frame_offset` to automatically account for machines where the
1438 frame grows upwards.
1439
1440 `offset` will always point to the "start" of the stack object, which
1441 will be the smallest address, for ! FRAME_GROWS_DOWNWARD this is *not*
1442 the "furthest" offset from the base delimiting the current stack
1443 object. `frame_offset` will always delimit the extent that the frame.
1444 */
1445 hwasan_record_stack_var (virtual_stack_vars_rtx((this_target_rtl->x_global_rtl)[GR_VIRTUAL_STACK_ARGS]), base,
1446 hwasan_orig_offset, frame_offset((&x_rtl)->x_frame_offset));
1447 }
1448 else
1449 {
1450 offset = alloc_stack_frame_space (size, byte_align);
1451 base = virtual_stack_vars_rtx((this_target_rtl->x_global_rtl)[GR_VIRTUAL_STACK_ARGS]);
1452 }
1453
1454 expand_one_stack_var_at (var, base,
1455 crtl(&x_rtl)->max_used_stack_slot_alignment, offset);
1456
1457 if (hwasan_sanitize_stack_p ())
1458 hwasan_increment_frame_tag ();
1459}
1460
1461/* Wrapper for expand_one_stack_var_1 that checks SSA_NAMEs are
1462 already assigned some MEM. */
1463
1464static void
1465expand_one_stack_var (tree var)
1466{
1467 if (TREE_CODE (var)((enum tree_code) (var)->base.code) == SSA_NAME)
1468 {
1469 int part = var_to_partition (SA.map, var);
1470 if (part != NO_PARTITION-1)
1471 {
1472 rtx x = SA.partition_to_pseudo[part];
1473 gcc_assert (x)((void)(!(x) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1473, __FUNCTION__), 0 : 0))
;
1474 gcc_assert (MEM_P (x))((void)(!((((enum rtx_code) (x)->code) == MEM)) ? fancy_abort
("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1474, __FUNCTION__), 0 : 0))
;
1475 return;
1476 }
1477 }
1478
1479 return expand_one_stack_var_1 (var);
1480}
1481
1482/* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
1483 that will reside in a hard register. */
1484
1485static void
1486expand_one_hard_reg_var (tree var)
1487{
1488 rest_of_decl_compilation (var, 0, 0);
1489}
1490
1491/* Record the alignment requirements of some variable assigned to a
1492 pseudo. */
1493
1494static void
1495record_alignment_for_reg_var (unsigned int align)
1496{
1497 if (SUPPORTS_STACK_ALIGNMENT((((unsigned int) 1 << 28) * 8) > ((((global_options
.x_ix86_isa_flags & (1UL << 1)) != 0) && ix86_cfun_abi
() == MS_ABI) ? 128 : ((8) * (((global_options.x_ix86_isa_flags
& (1UL << 1)) != 0) ? 8 : 4))))
1498 && crtl(&x_rtl)->stack_alignment_estimated < align)
1499 {
1500 /* stack_alignment_estimated shouldn't change after stack
1501 realign decision made */
1502 gcc_assert (!crtl->stack_realign_processed)((void)(!(!(&x_rtl)->stack_realign_processed) ? fancy_abort
("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1502, __FUNCTION__), 0 : 0))
;
1503 crtl(&x_rtl)->stack_alignment_estimated = align;
1504 }
1505
1506 /* stack_alignment_needed > PREFERRED_STACK_BOUNDARY is permitted.
1507 So here we only make sure stack_alignment_needed >= align. */
1508 if (crtl(&x_rtl)->stack_alignment_needed < align)
1509 crtl(&x_rtl)->stack_alignment_needed = align;
1510 if (crtl(&x_rtl)->max_used_stack_slot_alignment < align)
1511 crtl(&x_rtl)->max_used_stack_slot_alignment = align;
1512}
1513
1514/* Create RTL for an SSA partition. */
1515
1516static void
1517expand_one_ssa_partition (tree var)
1518{
1519 int part = var_to_partition (SA.map, var);
1520 gcc_assert (part != NO_PARTITION)((void)(!(part != -1) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1520, __FUNCTION__), 0 : 0))
;
1521
1522 if (SA.partition_to_pseudo[part])
1523 return;
1524
1525 unsigned int align = MINIMUM_ALIGNMENT (TREE_TYPE (var),ix86_minimum_alignment ((((contains_struct_check ((var), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1525, __FUNCTION__))->typed.type)), (((((enum tree_code)
((tree_class_check ((((contains_struct_check ((var), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1526, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1526, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(((contains_struct_check ((var), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1526, __FUNCTION__))->typed.type)) : (((contains_struct_check
((var), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1526, __FUNCTION__))->typed.type))->type_common.mode)
), ((((tree_class_check ((((contains_struct_check ((var), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1527, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1527, __FUNCTION__))->type_common.align) ? ((unsigned)1)
<< (((tree_class_check ((((contains_struct_check ((var
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1527, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1527, __FUNCTION__))->type_common.align) - 1) : 0)))
1526 TYPE_MODE (TREE_TYPE (var)),ix86_minimum_alignment ((((contains_struct_check ((var), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1525, __FUNCTION__))->typed.type)), (((((enum tree_code)
((tree_class_check ((((contains_struct_check ((var), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1526, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1526, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(((contains_struct_check ((var), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1526, __FUNCTION__))->typed.type)) : (((contains_struct_check
((var), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1526, __FUNCTION__))->typed.type))->type_common.mode)
), ((((tree_class_check ((((contains_struct_check ((var), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1527, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1527, __FUNCTION__))->type_common.align) ? ((unsigned)1)
<< (((tree_class_check ((((contains_struct_check ((var
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1527, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1527, __FUNCTION__))->type_common.align) - 1) : 0)))
1527 TYPE_ALIGN (TREE_TYPE (var)))ix86_minimum_alignment ((((contains_struct_check ((var), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1525, __FUNCTION__))->typed.type)), (((((enum tree_code)
((tree_class_check ((((contains_struct_check ((var), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1526, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1526, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(((contains_struct_check ((var), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1526, __FUNCTION__))->typed.type)) : (((contains_struct_check
((var), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1526, __FUNCTION__))->typed.type))->type_common.mode)
), ((((tree_class_check ((((contains_struct_check ((var), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1527, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1527, __FUNCTION__))->type_common.align) ? ((unsigned)1)
<< (((tree_class_check ((((contains_struct_check ((var
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1527, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1527, __FUNCTION__))->type_common.align) - 1) : 0)))
;
1528
1529 /* If the variable alignment is very large we'll dynamicaly allocate
1530 it, which means that in-frame portion is just a pointer. */
1531 if (align > MAX_SUPPORTED_STACK_ALIGNMENT(((unsigned int) 1 << 28) * 8))
1532 align = GET_MODE_ALIGNMENT (Pmode)get_mode_alignment ((global_options.x_ix86_pmode == PMODE_DI ?
(scalar_int_mode ((scalar_int_mode::from_int) E_DImode)) : (
scalar_int_mode ((scalar_int_mode::from_int) E_SImode))))
;
1533
1534 record_alignment_for_reg_var (align);
1535
1536 if (!use_register_for_decl (var))
1537 {
1538 if (defer_stack_allocation (var, true))
1539 add_stack_var (var, true);
1540 else
1541 expand_one_stack_var_1 (var);
1542 return;
1543 }
1544
1545 machine_mode reg_mode = promote_ssa_mode (var, NULLnullptr);
1546 rtx x = gen_reg_rtx (reg_mode);
1547
1548 set_rtl (var, x);
1549
1550 /* For a promoted variable, X will not be used directly but wrapped in a
1551 SUBREG with SUBREG_PROMOTED_VAR_P set, which means that the RTL land
1552 will assume that its upper bits can be inferred from its lower bits.
1553 Therefore, if X isn't initialized on every path from the entry, then
1554 we must do it manually in order to fulfill the above assumption. */
1555 if (reg_mode != TYPE_MODE (TREE_TYPE (var))((((enum tree_code) ((tree_class_check ((((contains_struct_check
((var), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1555, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1555, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(((contains_struct_check ((var), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1555, __FUNCTION__))->typed.type)) : (((contains_struct_check
((var), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1555, __FUNCTION__))->typed.type))->type_common.mode)
1556 && bitmap_bit_p (SA.partitions_for_undefined_values, part))
1557 emit_move_insn (x, CONST0_RTX (reg_mode)(const_tiny_rtx[0][(int) (reg_mode)]));
1558}
1559
1560/* Record the association between the RTL generated for partition PART
1561 and the underlying variable of the SSA_NAME VAR. */
1562
1563static void
1564adjust_one_expanded_partition_var (tree var)
1565{
1566 if (!var)
1567 return;
1568
1569 tree decl = SSA_NAME_VAR (var)((tree_check ((var), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1569, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree)
nullptr || ((enum tree_code) ((var)->ssa_name.var)->base
.code) == IDENTIFIER_NODE ? (tree) nullptr : (var)->ssa_name
.var)
;
1570
1571 int part = var_to_partition (SA.map, var);
1572 if (part == NO_PARTITION-1)
1573 return;
1574
1575 rtx x = SA.partition_to_pseudo[part];
1576
1577 gcc_assert (x)((void)(!(x) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1577, __FUNCTION__), 0 : 0))
;
1578
1579 set_rtl (var, x);
1580
1581 if (!REG_P (x)(((enum rtx_code) (x)->code) == REG))
1582 return;
1583
1584 /* Note if the object is a user variable. */
1585 if (decl && !DECL_ARTIFICIAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1585, __FUNCTION__))->decl_common.artificial_flag)
)
1586 mark_user_reg (x);
1587
1588 if (POINTER_TYPE_P (decl ? TREE_TYPE (decl) : TREE_TYPE (var))(((enum tree_code) (decl ? ((contains_struct_check ((decl), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1588, __FUNCTION__))->typed.type) : ((contains_struct_check
((var), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1588, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
|| ((enum tree_code) (decl ? ((contains_struct_check ((decl)
, (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1588, __FUNCTION__))->typed.type) : ((contains_struct_check
((var), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1588, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
)
)
1589 mark_reg_pointer (x, get_pointer_alignment (var));
1590}
1591
1592/* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
1593 that will reside in a pseudo register. */
1594
1595static void
1596expand_one_register_var (tree var)
1597{
1598 if (TREE_CODE (var)((enum tree_code) (var)->base.code) == SSA_NAME)
1599 {
1600 int part = var_to_partition (SA.map, var);
1601 if (part != NO_PARTITION-1)
1602 {
1603 rtx x = SA.partition_to_pseudo[part];
1604 gcc_assert (x)((void)(!(x) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1604, __FUNCTION__), 0 : 0))
;
1605 gcc_assert (REG_P (x))((void)(!((((enum rtx_code) (x)->code) == REG)) ? fancy_abort
("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1605, __FUNCTION__), 0 : 0))
;
1606 return;
1607 }
1608 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1608, __FUNCTION__))
;
1609 }
1610
1611 tree decl = var;
1612 tree type = TREE_TYPE (decl)((contains_struct_check ((decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1612, __FUNCTION__))->typed.type)
;
1613 machine_mode reg_mode = promote_decl_mode (decl, NULLnullptr);
1614 rtx x = gen_reg_rtx (reg_mode);
1615
1616 set_rtl (var, x);
1617
1618 /* Note if the object is a user variable. */
1619 if (!DECL_ARTIFICIAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1619, __FUNCTION__))->decl_common.artificial_flag)
)
1620 mark_user_reg (x);
1621
1622 if (POINTER_TYPE_P (type)(((enum tree_code) (type)->base.code) == POINTER_TYPE || (
(enum tree_code) (type)->base.code) == REFERENCE_TYPE)
)
1623 mark_reg_pointer (x, get_pointer_alignment (var));
1624}
1625
1626/* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL that
1627 has some associated error, e.g. its type is error-mark. We just need
1628 to pick something that won't crash the rest of the compiler. */
1629
1630static void
1631expand_one_error_var (tree var)
1632{
1633 machine_mode mode = DECL_MODE (var)((contains_struct_check ((var), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1633, __FUNCTION__))->decl_common.mode)
;
1634 rtx x;
1635
1636 if (mode == BLKmode((void) 0, E_BLKmode))
1637 x = gen_rtx_MEM (BLKmode((void) 0, E_BLKmode), const0_rtx(const_int_rtx[64]));
1638 else if (mode == VOIDmode((void) 0, E_VOIDmode))
1639 x = const0_rtx(const_int_rtx[64]);
1640 else
1641 x = gen_reg_rtx (mode);
1642
1643 SET_DECL_RTL (var, x)set_decl_rtl (var, x);
1644}
1645
1646/* A subroutine of expand_one_var. VAR is a variable that will be
1647 allocated to the local stack frame. Return true if we wish to
1648 add VAR to STACK_VARS so that it will be coalesced with other
1649 variables. Return false to allocate VAR immediately.
1650
1651 This function is used to reduce the number of variables considered
1652 for coalescing, which reduces the size of the quadratic problem. */
1653
1654static bool
1655defer_stack_allocation (tree var, bool toplevel)
1656{
1657 tree size_unit = TREE_CODE (var)((enum tree_code) (var)->base.code) == SSA_NAME
1658 ? TYPE_SIZE_UNIT (TREE_TYPE (var))((tree_class_check ((((contains_struct_check ((var), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1658, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1658, __FUNCTION__))->type_common.size_unit)
1659 : DECL_SIZE_UNIT (var)((contains_struct_check ((var), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1659, __FUNCTION__))->decl_common.size_unit)
;
1660 poly_uint64 size;
1661
1662 /* Whether the variable is small enough for immediate allocation not to be
1663 a problem with regard to the frame size. */
1664 bool smallish
1665 = (poly_int_tree_p (size_unit, &size)
1666 && (estimated_poly_value (size)
1667 < param_min_size_for_stack_sharingglobal_options.x_param_min_size_for_stack_sharing));
1668
1669 /* If stack protection is enabled, *all* stack variables must be deferred,
1670 so that we can re-order the strings to the top of the frame.
1671 Similarly for Address Sanitizer. */
1672 if (flag_stack_protectglobal_options.x_flag_stack_protect || asan_sanitize_stack_p ())
1673 return true;
1674
1675 unsigned int align = TREE_CODE (var)((enum tree_code) (var)->base.code) == SSA_NAME
1676 ? TYPE_ALIGN (TREE_TYPE (var))(((tree_class_check ((((contains_struct_check ((var), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1676, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1676, __FUNCTION__))->type_common.align) ? ((unsigned)1)
<< (((tree_class_check ((((contains_struct_check ((var
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1676, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1676, __FUNCTION__))->type_common.align) - 1) : 0)
1677 : DECL_ALIGN (var)(((contains_struct_check ((var), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1677, __FUNCTION__))->decl_common.align) ? ((unsigned)1)
<< (((contains_struct_check ((var), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1677, __FUNCTION__))->decl_common.align) - 1) : 0)
;
1678
1679 /* We handle "large" alignment via dynamic allocation. We want to handle
1680 this extra complication in only one place, so defer them. */
1681 if (align > MAX_SUPPORTED_STACK_ALIGNMENT(((unsigned int) 1 << 28) * 8))
1682 return true;
1683
1684 bool ignored = TREE_CODE (var)((enum tree_code) (var)->base.code) == SSA_NAME
1685 ? !SSAVAR (var)(((enum tree_code) (var)->base.code) == SSA_NAME ? ((tree_check
((var), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1685, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree)
nullptr || ((enum tree_code) ((var)->ssa_name.var)->base
.code) == IDENTIFIER_NODE ? (tree) nullptr : (var)->ssa_name
.var) : var)
|| DECL_IGNORED_P (SSA_NAME_VAR (var))((contains_struct_check ((((tree_check ((var), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1685, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree)
nullptr || ((enum tree_code) ((var)->ssa_name.var)->base
.code) == IDENTIFIER_NODE ? (tree) nullptr : (var)->ssa_name
.var)), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1685, __FUNCTION__))->decl_common.ignored_flag)
1686 : DECL_IGNORED_P (var)((contains_struct_check ((var), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1686, __FUNCTION__))->decl_common.ignored_flag)
;
1687
1688 /* When optimization is enabled, DECL_IGNORED_P variables originally scoped
1689 might be detached from their block and appear at toplevel when we reach
1690 here. We want to coalesce them with variables from other blocks when
1691 the immediate contribution to the frame size would be noticeable. */
1692 if (toplevel && optimizeglobal_options.x_optimize > 0 && ignored && !smallish)
1693 return true;
1694
1695 /* Variables declared in the outermost scope automatically conflict
1696 with every other variable. The only reason to want to defer them
1697 at all is that, after sorting, we can more efficiently pack
1698 small variables in the stack frame. Continue to defer at -O2. */
1699 if (toplevel && optimizeglobal_options.x_optimize < 2)
1700 return false;
1701
1702 /* Without optimization, *most* variables are allocated from the
1703 stack, which makes the quadratic problem large exactly when we
1704 want compilation to proceed as quickly as possible. On the
1705 other hand, we don't want the function's stack frame size to
1706 get completely out of hand. So we avoid adding scalars and
1707 "small" aggregates to the list at all. */
1708 if (optimizeglobal_options.x_optimize == 0 && smallish)
1709 return false;
1710
1711 return true;
1712}
1713
1714/* A subroutine of expand_used_vars. Expand one variable according to
1715 its flavor. Variables to be placed on the stack are not actually
1716 expanded yet, merely recorded.
1717 When REALLY_EXPAND is false, only add stack values to be allocated.
1718 Return stack usage this variable is supposed to take.
1719*/
1720
1721static poly_uint64
1722expand_one_var (tree var, bool toplevel, bool really_expand,
1723 bitmap forced_stack_var = NULLnullptr)
1724{
1725 unsigned int align = BITS_PER_UNIT(8);
1726 tree origvar = var;
1727
1728 var = SSAVAR (var)(((enum tree_code) (var)->base.code) == SSA_NAME ? ((tree_check
((var), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1728, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree)
nullptr || ((enum tree_code) ((var)->ssa_name.var)->base
.code) == IDENTIFIER_NODE ? (tree) nullptr : (var)->ssa_name
.var) : var)
;
1729
1730 if (TREE_TYPE (var)((contains_struct_check ((var), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1730, __FUNCTION__))->typed.type)
!= error_mark_nodeglobal_trees[TI_ERROR_MARK] && VAR_P (var)(((enum tree_code) (var)->base.code) == VAR_DECL))
1731 {
1732 if (is_global_var (var))
1733 return 0;
1734
1735 /* Because we don't know if VAR will be in register or on stack,
1736 we conservatively assume it will be on stack even if VAR is
1737 eventually put into register after RA pass. For non-automatic
1738 variables, which won't be on stack, we collect alignment of
1739 type and ignore user specified alignment. Similarly for
1740 SSA_NAMEs for which use_register_for_decl returns true. */
1741 if (TREE_STATIC (var)((var)->base.static_flag)
1742 || DECL_EXTERNAL (var)((contains_struct_check ((var), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1742, __FUNCTION__))->decl_common.decl_flag_1)
1743 || (TREE_CODE (origvar)((enum tree_code) (origvar)->base.code) == SSA_NAME && use_register_for_decl (var)))
1744 align = MINIMUM_ALIGNMENT (TREE_TYPE (var),ix86_minimum_alignment ((((contains_struct_check ((var), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1744, __FUNCTION__))->typed.type)), (((((enum tree_code)
((tree_class_check ((((contains_struct_check ((var), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1745, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1745, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(((contains_struct_check ((var), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1745, __FUNCTION__))->typed.type)) : (((contains_struct_check
((var), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1745, __FUNCTION__))->typed.type))->type_common.mode)
), ((((tree_class_check ((((contains_struct_check ((var), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1746, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1746, __FUNCTION__))->type_common.align) ? ((unsigned)1)
<< (((tree_class_check ((((contains_struct_check ((var
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1746, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1746, __FUNCTION__))->type_common.align) - 1) : 0)))
1745 TYPE_MODE (TREE_TYPE (var)),ix86_minimum_alignment ((((contains_struct_check ((var), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1744, __FUNCTION__))->typed.type)), (((((enum tree_code)
((tree_class_check ((((contains_struct_check ((var), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1745, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1745, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(((contains_struct_check ((var), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1745, __FUNCTION__))->typed.type)) : (((contains_struct_check
((var), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1745, __FUNCTION__))->typed.type))->type_common.mode)
), ((((tree_class_check ((((contains_struct_check ((var), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1746, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1746, __FUNCTION__))->type_common.align) ? ((unsigned)1)
<< (((tree_class_check ((((contains_struct_check ((var
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1746, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1746, __FUNCTION__))->type_common.align) - 1) : 0)))
1746 TYPE_ALIGN (TREE_TYPE (var)))ix86_minimum_alignment ((((contains_struct_check ((var), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1744, __FUNCTION__))->typed.type)), (((((enum tree_code)
((tree_class_check ((((contains_struct_check ((var), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1745, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1745, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(((contains_struct_check ((var), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1745, __FUNCTION__))->typed.type)) : (((contains_struct_check
((var), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1745, __FUNCTION__))->typed.type))->type_common.mode)
), ((((tree_class_check ((((contains_struct_check ((var), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1746, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1746, __FUNCTION__))->type_common.align) ? ((unsigned)1)
<< (((tree_class_check ((((contains_struct_check ((var
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1746, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1746, __FUNCTION__))->type_common.align) - 1) : 0)))
;
1747 else if (DECL_HAS_VALUE_EXPR_P (var)((tree_check3 ((var), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1747, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL))
) ->decl_common.decl_flag_2)
1748 || (DECL_RTL_SET_P (var)(((tree_contains_struct[(((enum tree_code) (var)->base.code
))][(TS_DECL_WRTL)])) && (contains_struct_check ((var
), (TS_DECL_WRTL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1748, __FUNCTION__))->decl_with_rtl.rtl != nullptr)
&& MEM_P (DECL_RTL (var))(((enum rtx_code) (((contains_struct_check ((var), (TS_DECL_WRTL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1748, __FUNCTION__))->decl_with_rtl.rtl ? (var)->decl_with_rtl
.rtl : (make_decl_rtl (var), (var)->decl_with_rtl.rtl)))->
code) == MEM)
))
1749 /* Don't consider debug only variables with DECL_HAS_VALUE_EXPR_P set
1750 or variables which were assigned a stack slot already by
1751 expand_one_stack_var_at - in the latter case DECL_ALIGN has been
1752 changed from the offset chosen to it. */
1753 align = crtl(&x_rtl)->stack_alignment_estimated;
1754 else
1755 align = MINIMUM_ALIGNMENT (var, DECL_MODE (var), DECL_ALIGN (var))ix86_minimum_alignment ((var), (((contains_struct_check ((var
), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1755, __FUNCTION__))->decl_common.mode)), ((((contains_struct_check
((var), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1755, __FUNCTION__))->decl_common.align) ? ((unsigned)1)
<< (((contains_struct_check ((var), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1755, __FUNCTION__))->decl_common.align) - 1) : 0)))
;
1756
1757 /* If the variable alignment is very large we'll dynamicaly allocate
1758 it, which means that in-frame portion is just a pointer. */
1759 if (align > MAX_SUPPORTED_STACK_ALIGNMENT(((unsigned int) 1 << 28) * 8))
1760 align = GET_MODE_ALIGNMENT (Pmode)get_mode_alignment ((global_options.x_ix86_pmode == PMODE_DI ?
(scalar_int_mode ((scalar_int_mode::from_int) E_DImode)) : (
scalar_int_mode ((scalar_int_mode::from_int) E_SImode))))
;
1761 }
1762
1763 record_alignment_for_reg_var (align);
1764
1765 poly_uint64 size;
1766 if (TREE_CODE (origvar)((enum tree_code) (origvar)->base.code) == SSA_NAME)
1767 {
1768 gcc_assert (!VAR_P (var)((void)(!(!(((enum tree_code) (var)->base.code) == VAR_DECL
) || (!((contains_struct_check ((var), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1769, __FUNCTION__))->decl_common.decl_flag_1) &&
!((tree_check3 ((var), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1770, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL))
) ->decl_common.decl_flag_2) && !((var)->base.static_flag
) && ((contains_struct_check ((var), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1772, __FUNCTION__))->typed.type) != global_trees[TI_ERROR_MARK
] && !((tree_check ((var), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1773, __FUNCTION__, (VAR_DECL)))->decl_with_vis.hard_register
) && really_expand)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1774, __FUNCTION__), 0 : 0))
1769 || (!DECL_EXTERNAL (var)((void)(!(!(((enum tree_code) (var)->base.code) == VAR_DECL
) || (!((contains_struct_check ((var), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1769, __FUNCTION__))->decl_common.decl_flag_1) &&
!((tree_check3 ((var), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1770, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL))
) ->decl_common.decl_flag_2) && !((var)->base.static_flag
) && ((contains_struct_check ((var), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1772, __FUNCTION__))->typed.type) != global_trees[TI_ERROR_MARK
] && !((tree_check ((var), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1773, __FUNCTION__, (VAR_DECL)))->decl_with_vis.hard_register
) && really_expand)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1774, __FUNCTION__), 0 : 0))
1770 && !DECL_HAS_VALUE_EXPR_P (var)((void)(!(!(((enum tree_code) (var)->base.code) == VAR_DECL
) || (!((contains_struct_check ((var), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1769, __FUNCTION__))->decl_common.decl_flag_1) &&
!((tree_check3 ((var), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1770, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL))
) ->decl_common.decl_flag_2) && !((var)->base.static_flag
) && ((contains_struct_check ((var), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1772, __FUNCTION__))->typed.type) != global_trees[TI_ERROR_MARK
] && !((tree_check ((var), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1773, __FUNCTION__, (VAR_DECL)))->decl_with_vis.hard_register
) && really_expand)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1774, __FUNCTION__), 0 : 0))
1771 && !TREE_STATIC (var)((void)(!(!(((enum tree_code) (var)->base.code) == VAR_DECL
) || (!((contains_struct_check ((var), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1769, __FUNCTION__))->decl_common.decl_flag_1) &&
!((tree_check3 ((var), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1770, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL))
) ->decl_common.decl_flag_2) && !((var)->base.static_flag
) && ((contains_struct_check ((var), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1772, __FUNCTION__))->typed.type) != global_trees[TI_ERROR_MARK
] && !((tree_check ((var), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1773, __FUNCTION__, (VAR_DECL)))->decl_with_vis.hard_register
) && really_expand)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1774, __FUNCTION__), 0 : 0))
1772 && TREE_TYPE (var) != error_mark_node((void)(!(!(((enum tree_code) (var)->base.code) == VAR_DECL
) || (!((contains_struct_check ((var), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1769, __FUNCTION__))->decl_common.decl_flag_1) &&
!((tree_check3 ((var), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1770, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL))
) ->decl_common.decl_flag_2) && !((var)->base.static_flag
) && ((contains_struct_check ((var), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1772, __FUNCTION__))->typed.type) != global_trees[TI_ERROR_MARK
] && !((tree_check ((var), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1773, __FUNCTION__, (VAR_DECL)))->decl_with_vis.hard_register
) && really_expand)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1774, __FUNCTION__), 0 : 0))
1773 && !DECL_HARD_REGISTER (var)((void)(!(!(((enum tree_code) (var)->base.code) == VAR_DECL
) || (!((contains_struct_check ((var), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1769, __FUNCTION__))->decl_common.decl_flag_1) &&
!((tree_check3 ((var), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1770, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL))
) ->decl_common.decl_flag_2) && !((var)->base.static_flag
) && ((contains_struct_check ((var), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1772, __FUNCTION__))->typed.type) != global_trees[TI_ERROR_MARK
] && !((tree_check ((var), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1773, __FUNCTION__, (VAR_DECL)))->decl_with_vis.hard_register
) && really_expand)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1774, __FUNCTION__), 0 : 0))
1774 && really_expand))((void)(!(!(((enum tree_code) (var)->base.code) == VAR_DECL
) || (!((contains_struct_check ((var), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1769, __FUNCTION__))->decl_common.decl_flag_1) &&
!((tree_check3 ((var), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1770, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL))
) ->decl_common.decl_flag_2) && !((var)->base.static_flag
) && ((contains_struct_check ((var), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1772, __FUNCTION__))->typed.type) != global_trees[TI_ERROR_MARK
] && !((tree_check ((var), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1773, __FUNCTION__, (VAR_DECL)))->decl_with_vis.hard_register
) && really_expand)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1774, __FUNCTION__), 0 : 0))
;
1775 }
1776 if (!VAR_P (var)(((enum tree_code) (var)->base.code) == VAR_DECL) && TREE_CODE (origvar)((enum tree_code) (origvar)->base.code) != SSA_NAME)
1777 ;
1778 else if (DECL_EXTERNAL (var)((contains_struct_check ((var), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1778, __FUNCTION__))->decl_common.decl_flag_1)
)
1779 ;
1780 else if (DECL_HAS_VALUE_EXPR_P (var)((tree_check3 ((var), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1780, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL))
) ->decl_common.decl_flag_2)
)
1781 ;
1782 else if (TREE_STATIC (var)((var)->base.static_flag))
1783 ;
1784 else if (TREE_CODE (origvar)((enum tree_code) (origvar)->base.code) != SSA_NAME && DECL_RTL_SET_P (var)(((tree_contains_struct[(((enum tree_code) (var)->base.code
))][(TS_DECL_WRTL)])) && (contains_struct_check ((var
), (TS_DECL_WRTL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1784, __FUNCTION__))->decl_with_rtl.rtl != nullptr)
)
1785 ;
1786 else if (TREE_TYPE (var)((contains_struct_check ((var), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1786, __FUNCTION__))->typed.type)
== error_mark_nodeglobal_trees[TI_ERROR_MARK])
1787 {
1788 if (really_expand)
1789 expand_one_error_var (var);
1790 }
1791 else if (VAR_P (var)(((enum tree_code) (var)->base.code) == VAR_DECL) && DECL_HARD_REGISTER (var)((tree_check ((var), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1791, __FUNCTION__, (VAR_DECL)))->decl_with_vis.hard_register
)
)
1792 {
1793 if (really_expand)
1794 {
1795 expand_one_hard_reg_var (var);
1796 if (!DECL_HARD_REGISTER (var)((tree_check ((var), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1796, __FUNCTION__, (VAR_DECL)))->decl_with_vis.hard_register
)
)
1797 /* Invalid register specification. */
1798 expand_one_error_var (var);
1799 }
1800 }
1801 else if (use_register_for_decl (var)
1802 && (!forced_stack_var
1803 || !bitmap_bit_p (forced_stack_var, DECL_UID (var)((contains_struct_check ((var), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1803, __FUNCTION__))->decl_minimal.uid)
)))
1804 {
1805 if (really_expand)
1806 expand_one_register_var (origvar);
1807 }
1808 else if (!poly_int_tree_p (DECL_SIZE_UNIT (var)((contains_struct_check ((var), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1808, __FUNCTION__))->decl_common.size_unit)
, &size)
1809 || !valid_constant_size_p (DECL_SIZE_UNIT (var)((contains_struct_check ((var), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1809, __FUNCTION__))->decl_common.size_unit)
))
1810 {
1811 /* Reject variables which cover more than half of the address-space. */
1812 if (really_expand)
1813 {
1814 if (DECL_NONLOCAL_FRAME (var)((tree_check ((var), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1814, __FUNCTION__, (VAR_DECL)))->base.default_def_flag)
)
1815 error_at (DECL_SOURCE_LOCATION (current_function_decl)((contains_struct_check ((current_function_decl), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1815, __FUNCTION__))->decl_minimal.locus)
,
1816 "total size of local objects is too large");
1817 else
1818 error_at (DECL_SOURCE_LOCATION (var)((contains_struct_check ((var), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1818, __FUNCTION__))->decl_minimal.locus)
,
1819 "size of variable %q+D is too large", var);
1820 expand_one_error_var (var);
1821 }
1822 }
1823 else if (defer_stack_allocation (var, toplevel))
1824 add_stack_var (origvar, really_expand);
1825 else
1826 {
1827 if (really_expand)
1828 {
1829 if (lookup_attribute ("naked",
1830 DECL_ATTRIBUTES (current_function_decl)((contains_struct_check ((current_function_decl), (TS_DECL_COMMON
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1830, __FUNCTION__))->decl_common.attributes)
))
1831 error ("cannot allocate stack for variable %q+D, naked function",
1832 var);
1833
1834 expand_one_stack_var (origvar);
1835 }
1836 return size;
1837 }
1838 return 0;
1839}
1840
1841/* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1842 expanding variables. Those variables that can be put into registers
1843 are allocated pseudos; those that can't are put on the stack.
1844
1845 TOPLEVEL is true if this is the outermost BLOCK. */
1846
1847static void
1848expand_used_vars_for_block (tree block, bool toplevel, bitmap forced_stack_vars)
1849{
1850 tree t;
1851
1852 /* Expand all variables at this level. */
1853 for (t = BLOCK_VARS (block)((tree_check ((block), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1853, __FUNCTION__, (BLOCK)))->block.vars)
; t ; t = DECL_CHAIN (t)(((contains_struct_check (((contains_struct_check ((t), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1853, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1853, __FUNCTION__))->common.chain))
)
1854 if (TREE_USED (t)((t)->base.used_flag)
1855 && ((!VAR_P (t)(((enum tree_code) (t)->base.code) == VAR_DECL) && TREE_CODE (t)((enum tree_code) (t)->base.code) != RESULT_DECL)
1856 || !DECL_NONSHAREABLE (t)((tree_check2 ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1856, __FUNCTION__, (VAR_DECL), (RESULT_DECL)))->decl_common
.decl_nonshareable_flag)
))
1857 expand_one_var (t, toplevel, true, forced_stack_vars);
1858
1859 /* Expand all variables at containing levels. */
1860 for (t = BLOCK_SUBBLOCKS (block)((tree_check ((block), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1860, __FUNCTION__, (BLOCK)))->block.subblocks)
; t ; t = BLOCK_CHAIN (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1860, __FUNCTION__, (BLOCK)))->block.chain)
)
1861 expand_used_vars_for_block (t, false, forced_stack_vars);
1862}
1863
1864/* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1865 and clear TREE_USED on all local variables. */
1866
1867static void
1868clear_tree_used (tree block)
1869{
1870 tree t;
1871
1872 for (t = BLOCK_VARS (block)((tree_check ((block), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1872, __FUNCTION__, (BLOCK)))->block.vars)
; t ; t = DECL_CHAIN (t)(((contains_struct_check (((contains_struct_check ((t), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1872, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1872, __FUNCTION__))->common.chain))
)
1873 /* if (!TREE_STATIC (t) && !DECL_EXTERNAL (t)) */
1874 if ((!VAR_P (t)(((enum tree_code) (t)->base.code) == VAR_DECL) && TREE_CODE (t)((enum tree_code) (t)->base.code) != RESULT_DECL)
1875 || !DECL_NONSHAREABLE (t)((tree_check2 ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1875, __FUNCTION__, (VAR_DECL), (RESULT_DECL)))->decl_common
.decl_nonshareable_flag)
)
1876 TREE_USED (t)((t)->base.used_flag) = 0;
1877
1878 for (t = BLOCK_SUBBLOCKS (block)((tree_check ((block), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1878, __FUNCTION__, (BLOCK)))->block.subblocks)
; t ; t = BLOCK_CHAIN (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1878, __FUNCTION__, (BLOCK)))->block.chain)
)
1879 clear_tree_used (t);
1880}
1881
1882/* Examine TYPE and determine a bit mask of the following features. */
1883
1884#define SPCT_HAS_LARGE_CHAR_ARRAY1 1
1885#define SPCT_HAS_SMALL_CHAR_ARRAY2 2
1886#define SPCT_HAS_ARRAY4 4
1887#define SPCT_HAS_AGGREGATE8 8
1888
1889static unsigned int
1890stack_protect_classify_type (tree type)
1891{
1892 unsigned int ret = 0;
1893 tree t;
1894
1895 switch (TREE_CODE (type)((enum tree_code) (type)->base.code))
1896 {
1897 case ARRAY_TYPE:
1898 t = TYPE_MAIN_VARIANT (TREE_TYPE (type))((tree_class_check ((((contains_struct_check ((type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1898, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1898, __FUNCTION__))->type_common.main_variant)
;
1899 if (t == char_type_nodeinteger_types[itk_char]
1900 || t == signed_char_type_nodeinteger_types[itk_signed_char]
1901 || t == unsigned_char_type_nodeinteger_types[itk_unsigned_char])
1902 {
1903 unsigned HOST_WIDE_INTlong max = param_ssp_buffer_sizeglobal_options.x_param_ssp_buffer_size;
1904 unsigned HOST_WIDE_INTlong len;
1905
1906 if (!TYPE_SIZE_UNIT (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1906, __FUNCTION__))->type_common.size_unit)
1907 || !tree_fits_uhwi_p (TYPE_SIZE_UNIT (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1907, __FUNCTION__))->type_common.size_unit)
))
1908 len = max;
1909 else
1910 len = tree_to_uhwi (TYPE_SIZE_UNIT (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1910, __FUNCTION__))->type_common.size_unit)
);
1911
1912 if (len < max)
1913 ret = SPCT_HAS_SMALL_CHAR_ARRAY2 | SPCT_HAS_ARRAY4;
1914 else
1915 ret = SPCT_HAS_LARGE_CHAR_ARRAY1 | SPCT_HAS_ARRAY4;
1916 }
1917 else
1918 ret = SPCT_HAS_ARRAY4;
1919 break;
1920
1921 case UNION_TYPE:
1922 case QUAL_UNION_TYPE:
1923 case RECORD_TYPE:
1924 ret = SPCT_HAS_AGGREGATE8;
1925 for (t = TYPE_FIELDS (type)((tree_check3 ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1925, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values)
; t ; t = TREE_CHAIN (t)((contains_struct_check ((t), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1925, __FUNCTION__))->common.chain)
)
1926 if (TREE_CODE (t)((enum tree_code) (t)->base.code) == FIELD_DECL)
1927 ret |= stack_protect_classify_type (TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1927, __FUNCTION__))->typed.type)
);
1928 break;
1929
1930 default:
1931 break;
1932 }
1933
1934 return ret;
1935}
1936
1937/* Return nonzero if DECL should be segregated into the "vulnerable" upper
1938 part of the local stack frame. Remember if we ever return nonzero for
1939 any variable in this function. The return value is the phase number in
1940 which the variable should be allocated. */
1941
1942static int
1943stack_protect_decl_phase (tree decl)
1944{
1945 unsigned int bits = stack_protect_classify_type (TREE_TYPE (decl)((contains_struct_check ((decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1945, __FUNCTION__))->typed.type)
);
1946 int ret = 0;
1947
1948 if (bits & SPCT_HAS_SMALL_CHAR_ARRAY2)
1949 has_short_buffer = true;
1950
1951 tree attribs = DECL_ATTRIBUTES (current_function_decl)((contains_struct_check ((current_function_decl), (TS_DECL_COMMON
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 1951, __FUNCTION__))->decl_common.attributes)
;
1952 if (!lookup_attribute ("no_stack_protector", attribs)
1953 && (flag_stack_protectglobal_options.x_flag_stack_protect == SPCT_FLAG_ALL
1954 || flag_stack_protectglobal_options.x_flag_stack_protect == SPCT_FLAG_STRONG
1955 || (flag_stack_protectglobal_options.x_flag_stack_protect == SPCT_FLAG_EXPLICIT
1956 && lookup_attribute ("stack_protect", attribs))))
1957 {
1958 if ((bits & (SPCT_HAS_SMALL_CHAR_ARRAY2 | SPCT_HAS_LARGE_CHAR_ARRAY1))
1959 && !(bits & SPCT_HAS_AGGREGATE8))
1960 ret = 1;
1961 else if (bits & SPCT_HAS_ARRAY4)
1962 ret = 2;
1963 }
1964 else
1965 ret = (bits & SPCT_HAS_LARGE_CHAR_ARRAY1) != 0;
1966
1967 if (ret)
1968 has_protected_decls = true;
1969
1970 return ret;
1971}
1972
1973/* Two helper routines that check for phase 1 and phase 2. These are used
1974 as callbacks for expand_stack_vars. */
1975
1976static bool
1977stack_protect_decl_phase_1 (size_t i)
1978{
1979 return stack_protect_decl_phase (stack_vars[i].decl) == 1;
1980}
1981
1982static bool
1983stack_protect_decl_phase_2 (size_t i)
1984{
1985 return stack_protect_decl_phase (stack_vars[i].decl) == 2;
1986}
1987
1988/* And helper function that checks for asan phase (with stack protector
1989 it is phase 3). This is used as callback for expand_stack_vars.
1990 Returns true if any of the vars in the partition need to be protected. */
1991
1992static bool
1993asan_decl_phase_3 (size_t i)
1994{
1995 while (i != EOC((size_t)-1))
1996 {
1997 if (asan_protect_stack_decl (stack_vars[i].decl))
1998 return true;
1999 i = stack_vars[i].next;
2000 }
2001 return false;
2002}
2003
2004/* Ensure that variables in different stack protection phases conflict
2005 so that they are not merged and share the same stack slot.
2006 Return true if there are any address taken variables. */
2007
2008static bool
2009add_stack_protection_conflicts (void)
2010{
2011 size_t i, j, n = stack_vars_num;
2012 unsigned char *phase;
2013 bool ret = false;
2014
2015 phase = XNEWVEC (unsigned char, n)((unsigned char *) xmalloc (sizeof (unsigned char) * (n)));
2016 for (i = 0; i < n; ++i)
2017 {
2018 phase[i] = stack_protect_decl_phase (stack_vars[i].decl);
2019 if (TREE_ADDRESSABLE (stack_vars[i].decl)((stack_vars[i].decl)->base.addressable_flag))
2020 ret = true;
2021 }
2022
2023 for (i = 0; i < n; ++i)
2024 {
2025 unsigned char ph_i = phase[i];
2026 for (j = i + 1; j < n; ++j)
2027 if (ph_i != phase[j])
2028 add_stack_var_conflict (i, j);
2029 }
2030
2031 XDELETEVEC (phase)free ((void*) (phase));
2032 return ret;
2033}
2034
2035/* Create a decl for the guard at the top of the stack frame. */
2036
2037static void
2038create_stack_guard (void)
2039{
2040 tree guard = build_decl (DECL_SOURCE_LOCATION (current_function_decl)((contains_struct_check ((current_function_decl), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2040, __FUNCTION__))->decl_minimal.locus)
,
2041 VAR_DECL, NULLnullptr, ptr_type_nodeglobal_trees[TI_PTR_TYPE]);
2042 TREE_THIS_VOLATILE (guard)((guard)->base.volatile_flag) = 1;
2043 TREE_USED (guard)((guard)->base.used_flag) = 1;
2044 expand_one_stack_var (guard);
2045 crtl(&x_rtl)->stack_protect_guard = guard;
2046}
2047
2048/* Prepare for expanding variables. */
2049static void
2050init_vars_expansion (void)
2051{
2052 /* Conflict bitmaps, and a few related temporary bitmaps, go here. */
2053 bitmap_obstack_initialize (&stack_var_bitmap_obstack);
2054
2055 /* A map from decl to stack partition. */
2056 decl_to_stack_part = new hash_map<tree, size_t>;
2057
2058 /* Initialize local stack smashing state. */
2059 has_protected_decls = false;
2060 has_short_buffer = false;
2061 if (hwasan_sanitize_stack_p ())
2062 hwasan_record_frame_init ();
2063}
2064
2065/* Free up stack variable graph data. */
2066static void
2067fini_vars_expansion (void)
2068{
2069 bitmap_obstack_release (&stack_var_bitmap_obstack);
2070 if (stack_vars)
2071 XDELETEVEC (stack_vars)free ((void*) (stack_vars));
2072 if (stack_vars_sorted)
2073 XDELETEVEC (stack_vars_sorted)free ((void*) (stack_vars_sorted));
2074 stack_vars = NULLnullptr;
2075 stack_vars_sorted = NULLnullptr;
2076 stack_vars_alloc = stack_vars_num = 0;
2077 delete decl_to_stack_part;
2078 decl_to_stack_part = NULLnullptr;
2079}
2080
2081/* Make a fair guess for the size of the stack frame of the function
2082 in NODE. This doesn't have to be exact, the result is only used in
2083 the inline heuristics. So we don't want to run the full stack var
2084 packing algorithm (which is quadratic in the number of stack vars).
2085 Instead, we calculate the total size of all stack vars. This turns
2086 out to be a pretty fair estimate -- packing of stack vars doesn't
2087 happen very often. */
2088
2089HOST_WIDE_INTlong
2090estimated_stack_frame_size (struct cgraph_node *node)
2091{
2092 poly_int64 size = 0;
2093 size_t i;
2094 tree var;
2095 struct function *fn = DECL_STRUCT_FUNCTION (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2095, __FUNCTION__, (FUNCTION_DECL)))->function_decl.f)
;
2096
2097 push_cfun (fn);
2098
2099 init_vars_expansion ();
2100
2101 FOR_EACH_LOCAL_DECL (fn, i, var)for (i = vec_safe_length ((fn)->local_decls) - 1; vec_safe_iterate
(((fn)->local_decls), (i), &(var)); (i)--)
2102 if (auto_var_in_fn_p (var, fn->decl))
2103 size += expand_one_var (var, true, false);
2104
2105 if (stack_vars_num > 0)
2106 {
2107 /* Fake sorting the stack vars for account_stack_vars (). */
2108 stack_vars_sorted = XNEWVEC (size_t, stack_vars_num)((size_t *) xmalloc (sizeof (size_t) * (stack_vars_num)));
2109 for (i = 0; i < stack_vars_num; ++i)
2110 stack_vars_sorted[i] = i;
2111 size += account_stack_vars ();
2112 }
2113
2114 fini_vars_expansion ();
2115 pop_cfun ();
2116 return estimated_poly_value (size);
2117}
2118
2119/* Check if the current function has calls that use a return slot. */
2120
2121static bool
2122stack_protect_return_slot_p ()
2123{
2124 basic_block bb;
2125
2126 FOR_ALL_BB_FN (bb, cfun)for (bb = (((cfun + 0))->cfg->x_entry_block_ptr); bb; bb
= bb->next_bb)
2127 for (gimple_stmt_iterator gsi = gsi_start_bb (bb);
2128 !gsi_end_p (gsi); gsi_next (&gsi))
2129 {
2130 gimple *stmt = gsi_stmt (gsi);
2131 /* This assumes that calls to internal-only functions never
2132 use a return slot. */
2133 if (is_gimple_call (stmt)
2134 && !gimple_call_internal_p (stmt)
2135 && aggregate_value_p (TREE_TYPE (gimple_call_fntype (stmt))((contains_struct_check ((gimple_call_fntype (stmt)), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2135, __FUNCTION__))->typed.type)
,
2136 gimple_call_fndecl (stmt)))
2137 return true;
2138 }
2139 return false;
2140}
2141
2142/* Expand all variables used in the function. */
2143
2144static rtx_insn *
2145expand_used_vars (bitmap forced_stack_vars)
2146{
2147 tree var, outer_block = DECL_INITIAL (current_function_decl)((contains_struct_check ((current_function_decl), (TS_DECL_COMMON
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2147, __FUNCTION__))->decl_common.initial)
;
2148 auto_vec<tree> maybe_local_decls;
2149 rtx_insn *var_end_seq = NULLnullptr;
2150 unsigned i;
2151 unsigned len;
2152 bool gen_stack_protect_signal = false;
2153
2154 /* Compute the phase of the stack frame for this function. */
2155 {
2156 int align = PREFERRED_STACK_BOUNDARYix86_preferred_stack_boundary / BITS_PER_UNIT(8);
2157 int off = targetm.starting_frame_offset () % align;
2158 frame_phase = off ? align - off : 0;
2159 }
2160
2161 /* Set TREE_USED on all variables in the local_decls. */
2162 FOR_EACH_LOCAL_DECL (cfun, i, var)for (i = vec_safe_length (((cfun + 0))->local_decls) - 1; vec_safe_iterate
((((cfun + 0))->local_decls), (i), &(var)); (i)--)
2163 TREE_USED (var)((var)->base.used_flag) = 1;
2164 /* Clear TREE_USED on all variables associated with a block scope. */
2165 clear_tree_used (DECL_INITIAL (current_function_decl)((contains_struct_check ((current_function_decl), (TS_DECL_COMMON
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2165, __FUNCTION__))->decl_common.initial)
);
2166
2167 init_vars_expansion ();
2168
2169 if (targetm.use_pseudo_pic_reg ())
2170 pic_offset_table_rtx(this_target_rtl->x_pic_offset_table_rtx) = gen_reg_rtx (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode)))
);
2171
2172 for (i = 0; i < SA.map->num_partitions; i++)
2173 {
2174 if (bitmap_bit_p (SA.partitions_for_parm_default_defs, i))
2175 continue;
2176
2177 tree var = partition_to_var (SA.map, i);
2178
2179 gcc_assert (!virtual_operand_p (var))((void)(!(!virtual_operand_p (var)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2179, __FUNCTION__), 0 : 0))
;
2180
2181 expand_one_ssa_partition (var);
2182 }
2183
2184 if (flag_stack_protectglobal_options.x_flag_stack_protect == SPCT_FLAG_STRONG)
2185 gen_stack_protect_signal = stack_protect_return_slot_p ();
2186
2187 /* At this point all variables on the local_decls with TREE_USED
2188 set are not associated with any block scope. Lay them out. */
2189
2190 len = vec_safe_length (cfun(cfun + 0)->local_decls);
2191 FOR_EACH_LOCAL_DECL (cfun, i, var)for (i = vec_safe_length (((cfun + 0))->local_decls) - 1; vec_safe_iterate
((((cfun + 0))->local_decls), (i), &(var)); (i)--)
2192 {
2193 bool expand_now = false;
2194
2195 /* Expanded above already. */
2196 if (is_gimple_reg (var))
2197 {
2198 TREE_USED (var)((var)->base.used_flag) = 0;
2199 goto next;
2200 }
2201 /* We didn't set a block for static or extern because it's hard
2202 to tell the difference between a global variable (re)declared
2203 in a local scope, and one that's really declared there to
2204 begin with. And it doesn't really matter much, since we're
2205 not giving them stack space. Expand them now. */
2206 else if (TREE_STATIC (var)((var)->base.static_flag) || DECL_EXTERNAL (var)((contains_struct_check ((var), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2206, __FUNCTION__))->decl_common.decl_flag_1)
)
2207 expand_now = true;
2208
2209 /* Expand variables not associated with any block now. Those created by
2210 the optimizers could be live anywhere in the function. Those that
2211 could possibly have been scoped originally and detached from their
2212 block will have their allocation deferred so we coalesce them with
2213 others when optimization is enabled. */
2214 else if (TREE_USED (var)((var)->base.used_flag))
2215 expand_now = true;
2216
2217 /* Finally, mark all variables on the list as used. We'll use
2218 this in a moment when we expand those associated with scopes. */
2219 TREE_USED (var)((var)->base.used_flag) = 1;
2220
2221 if (expand_now)
2222 expand_one_var (var, true, true, forced_stack_vars);
2223
2224 next:
2225 if (DECL_ARTIFICIAL (var)((contains_struct_check ((var), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2225, __FUNCTION__))->decl_common.artificial_flag)
&& !DECL_IGNORED_P (var)((contains_struct_check ((var), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2225, __FUNCTION__))->decl_common.ignored_flag)
)
2226 {
2227 rtx rtl = DECL_RTL_IF_SET (var)((((tree_contains_struct[(((enum tree_code) (var)->base.code
))][(TS_DECL_WRTL)])) && (contains_struct_check ((var
), (TS_DECL_WRTL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2227, __FUNCTION__))->decl_with_rtl.rtl != nullptr) ? ((
contains_struct_check ((var), (TS_DECL_WRTL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2227, __FUNCTION__))->decl_with_rtl.rtl ? (var)->decl_with_rtl
.rtl : (make_decl_rtl (var), (var)->decl_with_rtl.rtl)) : nullptr
)
;
2228
2229 /* Keep artificial non-ignored vars in cfun->local_decls
2230 chain until instantiate_decls. */
2231 if (rtl && (MEM_P (rtl)(((enum rtx_code) (rtl)->code) == MEM) || GET_CODE (rtl)((enum rtx_code) (rtl)->code) == CONCAT))
2232 add_local_decl (cfun(cfun + 0), var);
2233 else if (rtl == NULL_RTX(rtx) 0)
2234 /* If rtl isn't set yet, which can happen e.g. with
2235 -fstack-protector, retry before returning from this
2236 function. */
2237 maybe_local_decls.safe_push (var);
2238 }
2239 }
2240
2241 /* We duplicated some of the decls in CFUN->LOCAL_DECLS.
2242
2243 +-----------------+-----------------+
2244 | ...processed... | ...duplicates...|
2245 +-----------------+-----------------+
2246 ^
2247 +-- LEN points here.
2248
2249 We just want the duplicates, as those are the artificial
2250 non-ignored vars that we want to keep until instantiate_decls.
2251 Move them down and truncate the array. */
2252 if (!vec_safe_is_empty (cfun(cfun + 0)->local_decls))
2253 cfun(cfun + 0)->local_decls->block_remove (0, len);
2254
2255 /* At this point, all variables within the block tree with TREE_USED
2256 set are actually used by the optimized function. Lay them out. */
2257 expand_used_vars_for_block (outer_block, true, forced_stack_vars);
2258
2259 tree attribs = DECL_ATTRIBUTES (current_function_decl)((contains_struct_check ((current_function_decl), (TS_DECL_COMMON
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2259, __FUNCTION__))->decl_common.attributes)
;
2260 if (stack_vars_num > 0)
2261 {
2262 bool has_addressable_vars = false;
2263
2264 add_scope_conflicts ();
2265
2266 /* If stack protection is enabled, we don't share space between
2267 vulnerable data and non-vulnerable data. */
2268 if (flag_stack_protectglobal_options.x_flag_stack_protect != 0
2269 && !lookup_attribute ("no_stack_protector", attribs)
2270 && (flag_stack_protectglobal_options.x_flag_stack_protect != SPCT_FLAG_EXPLICIT
2271 || (flag_stack_protectglobal_options.x_flag_stack_protect == SPCT_FLAG_EXPLICIT
2272 && lookup_attribute ("stack_protect", attribs))))
2273 has_addressable_vars = add_stack_protection_conflicts ();
2274
2275 if (flag_stack_protectglobal_options.x_flag_stack_protect == SPCT_FLAG_STRONG && has_addressable_vars)
2276 gen_stack_protect_signal = true;
2277
2278 /* Now that we have collected all stack variables, and have computed a
2279 minimal interference graph, attempt to save some stack space. */
2280 partition_stack_vars ();
2281 if (dump_file)
2282 dump_stack_var_partition ();
2283 }
2284
2285
2286 if (!lookup_attribute ("no_stack_protector", attribs))
2287 switch (flag_stack_protectglobal_options.x_flag_stack_protect)
2288 {
2289 case SPCT_FLAG_ALL:
2290 create_stack_guard ();
2291 break;
2292
2293 case SPCT_FLAG_STRONG:
2294 if (gen_stack_protect_signal
2295 || cfun(cfun + 0)->calls_alloca
2296 || has_protected_decls
2297 || lookup_attribute ("stack_protect", attribs))
2298 create_stack_guard ();
2299 break;
2300
2301 case SPCT_FLAG_DEFAULT:
2302 if (cfun(cfun + 0)->calls_alloca
2303 || has_protected_decls
2304 || lookup_attribute ("stack_protect", attribs))
2305 create_stack_guard ();
2306 break;
2307
2308 case SPCT_FLAG_EXPLICIT:
2309 if (lookup_attribute ("stack_protect", attribs))
2310 create_stack_guard ();
2311 break;
2312
2313 default:
2314 break;
2315 }
2316
2317 /* Assign rtl to each variable based on these partitions. */
2318 if (stack_vars_num > 0)
2319 {
2320 class stack_vars_data data;
2321
2322 data.asan_base = NULL_RTX(rtx) 0;
2323 data.asan_alignb = 0;
2324
2325 /* Reorder decls to be protected by iterating over the variables
2326 array multiple times, and allocating out of each phase in turn. */
2327 /* ??? We could probably integrate this into the qsort we did
2328 earlier, such that we naturally see these variables first,
2329 and thus naturally allocate things in the right order. */
2330 if (has_protected_decls)
2331 {
2332 /* Phase 1 contains only character arrays. */
2333 expand_stack_vars (stack_protect_decl_phase_1, &data);
2334
2335 /* Phase 2 contains other kinds of arrays. */
2336 if (!lookup_attribute ("no_stack_protector", attribs)
2337 && (flag_stack_protectglobal_options.x_flag_stack_protect == SPCT_FLAG_ALL
2338 || flag_stack_protectglobal_options.x_flag_stack_protect == SPCT_FLAG_STRONG
2339 || (flag_stack_protectglobal_options.x_flag_stack_protect == SPCT_FLAG_EXPLICIT
2340 && lookup_attribute ("stack_protect", attribs))))
2341 expand_stack_vars (stack_protect_decl_phase_2, &data);
2342 }
2343
2344 if (asan_sanitize_stack_p ())
2345 /* Phase 3, any partitions that need asan protection
2346 in addition to phase 1 and 2. */
2347 expand_stack_vars (asan_decl_phase_3, &data);
2348
2349 /* ASAN description strings don't yet have a syntax for expressing
2350 polynomial offsets. */
2351 HOST_WIDE_INTlong prev_offset;
2352 if (!data.asan_vec.is_empty ()
2353 && frame_offset((&x_rtl)->x_frame_offset).is_constant (&prev_offset))
2354 {
2355 HOST_WIDE_INTlong offset, sz, redzonesz;
2356 redzonesz = ASAN_RED_ZONE_SIZE32;
2357 sz = data.asan_vec[0] - prev_offset;
2358 if (data.asan_alignb > ASAN_RED_ZONE_SIZE32
2359 && data.asan_alignb <= 4096
2360 && sz + ASAN_RED_ZONE_SIZE32 >= (int) data.asan_alignb)
2361 redzonesz = ((sz + ASAN_RED_ZONE_SIZE32 + data.asan_alignb - 1)
2362 & ~(data.asan_alignb - HOST_WIDE_INT_11L)) - sz;
2363 /* Allocating a constant amount of space from a constant
2364 starting offset must give a constant result. */
2365 offset = (alloc_stack_frame_space (redzonesz, ASAN_RED_ZONE_SIZE32)
2366 .to_constant ());
2367 data.asan_vec.safe_push (prev_offset);
2368 data.asan_vec.safe_push (offset);
2369 /* Leave space for alignment if STRICT_ALIGNMENT. */
2370 if (STRICT_ALIGNMENT0)
2371 alloc_stack_frame_space ((GET_MODE_ALIGNMENT (SImode)get_mode_alignment ((scalar_int_mode ((scalar_int_mode::from_int
) E_SImode)))
2372 << ASAN_SHADOW_SHIFT3)
2373 / BITS_PER_UNIT(8), 1);
2374
2375 var_end_seq
2376 = asan_emit_stack_protection (virtual_stack_vars_rtx((this_target_rtl->x_global_rtl)[GR_VIRTUAL_STACK_ARGS]),
2377 data.asan_base,
2378 data.asan_alignb,
2379 data.asan_vec.address (),
2380 data.asan_decl_vec.address (),
2381 data.asan_vec.length ());
2382 }
2383
2384 expand_stack_vars (NULLnullptr, &data);
2385 }
2386
2387 if (hwasan_sanitize_stack_p ())
2388 hwasan_emit_prologue ();
2389 if (asan_sanitize_allocas_p () && cfun(cfun + 0)->calls_alloca)
2390 var_end_seq = asan_emit_allocas_unpoison (virtual_stack_dynamic_rtx((this_target_rtl->x_global_rtl)[GR_VIRTUAL_STACK_DYNAMIC]
)
,
2391 virtual_stack_vars_rtx((this_target_rtl->x_global_rtl)[GR_VIRTUAL_STACK_ARGS]),
2392 var_end_seq);
2393 else if (hwasan_sanitize_allocas_p () && cfun(cfun + 0)->calls_alloca)
2394 /* When using out-of-line instrumentation we only want to emit one function
2395 call for clearing the tags in a region of shadow stack. When there are
2396 alloca calls in this frame we want to emit a call using the
2397 virtual_stack_dynamic_rtx, but when not we use the hwasan_frame_extent
2398 rtx we created in expand_stack_vars. */
2399 var_end_seq = hwasan_emit_untag_frame (virtual_stack_dynamic_rtx((this_target_rtl->x_global_rtl)[GR_VIRTUAL_STACK_DYNAMIC]
)
,
2400 virtual_stack_vars_rtx((this_target_rtl->x_global_rtl)[GR_VIRTUAL_STACK_ARGS]));
2401 else if (hwasan_sanitize_stack_p ())
2402 /* If no variables were stored on the stack, `hwasan_get_frame_extent`
2403 will return NULL_RTX and hence `hwasan_emit_untag_frame` will return
2404 NULL (i.e. an empty sequence). */
2405 var_end_seq = hwasan_emit_untag_frame (hwasan_get_frame_extent (),
2406 virtual_stack_vars_rtx((this_target_rtl->x_global_rtl)[GR_VIRTUAL_STACK_ARGS]));
2407
2408 fini_vars_expansion ();
2409
2410 /* If there were any artificial non-ignored vars without rtl
2411 found earlier, see if deferred stack allocation hasn't assigned
2412 rtl to them. */
2413 FOR_EACH_VEC_ELT_REVERSE (maybe_local_decls, i, var)for (i = (maybe_local_decls).length () - 1; (maybe_local_decls
).iterate ((i), &(var)); (i)--)
2414 {
2415 rtx rtl = DECL_RTL_IF_SET (var)((((tree_contains_struct[(((enum tree_code) (var)->base.code
))][(TS_DECL_WRTL)])) && (contains_struct_check ((var
), (TS_DECL_WRTL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2415, __FUNCTION__))->decl_with_rtl.rtl != nullptr) ? ((
contains_struct_check ((var), (TS_DECL_WRTL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2415, __FUNCTION__))->decl_with_rtl.rtl ? (var)->decl_with_rtl
.rtl : (make_decl_rtl (var), (var)->decl_with_rtl.rtl)) : nullptr
)
;
2416
2417 /* Keep artificial non-ignored vars in cfun->local_decls
2418 chain until instantiate_decls. */
2419 if (rtl && (MEM_P (rtl)(((enum rtx_code) (rtl)->code) == MEM) || GET_CODE (rtl)((enum rtx_code) (rtl)->code) == CONCAT))
2420 add_local_decl (cfun(cfun + 0), var);
2421 }
2422
2423 /* If the target requires that FRAME_OFFSET be aligned, do it. */
2424 if (STACK_ALIGNMENT_NEEDED1)
2425 {
2426 HOST_WIDE_INTlong align = PREFERRED_STACK_BOUNDARYix86_preferred_stack_boundary / BITS_PER_UNIT(8);
2427 if (FRAME_GROWS_DOWNWARD1)
2428 frame_offset((&x_rtl)->x_frame_offset) = aligned_lower_bound (frame_offset((&x_rtl)->x_frame_offset), align);
2429 else
2430 frame_offset((&x_rtl)->x_frame_offset) = aligned_upper_bound (frame_offset((&x_rtl)->x_frame_offset), align);
2431 }
2432
2433 return var_end_seq;
2434}
2435
2436
2437/* If we need to produce a detailed dump, print the tree representation
2438 for STMT to the dump file. SINCE is the last RTX after which the RTL
2439 generated for STMT should have been appended. */
2440
2441static void
2442maybe_dump_rtl_for_gimple_stmt (gimple *stmt, rtx_insn *since)
2443{
2444 if (dump_file && (dump_flags & TDF_DETAILS))
2445 {
2446 fprintf (dump_file, "\n;; ");
2447 print_gimple_stmt (dump_file, stmt, 0,
2448 TDF_SLIM | (dump_flags & TDF_LINENO));
2449 fprintf (dump_file, "\n");
2450
2451 print_rtl (dump_file, since ? NEXT_INSN (since) : since);
2452 }
2453}
2454
2455/* Maps the blocks that do not contain tree labels to rtx labels. */
2456
2457static hash_map<basic_block, rtx_code_label *> *lab_rtx_for_bb;
2458
2459/* Returns the label_rtx expression for a label starting basic block BB. */
2460
2461static rtx_code_label *
2462label_rtx_for_bb (basic_block bb ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
2463{
2464 if (bb->flags & BB_RTL)
2465 return block_label (bb);
2466
2467 rtx_code_label **elt = lab_rtx_for_bb->get (bb);
2468 if (elt)
2469 return *elt;
2470
2471 /* Find the tree label if it is present. */
2472 gimple_stmt_iterator gsi = gsi_start_bb (bb);
2473 glabel *lab_stmt;
2474 if (!gsi_end_p (gsi)
2475 && (lab_stmt = dyn_cast <glabel *> (gsi_stmt (gsi)))
2476 && !DECL_NONLOCAL (gimple_label_label (lab_stmt))((contains_struct_check ((gimple_label_label (lab_stmt)), (TS_DECL_COMMON
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2476, __FUNCTION__))->decl_common.nonlocal_flag)
)
2477 return jump_target_rtx (gimple_label_label (lab_stmt));
2478
2479 rtx_code_label *l = gen_label_rtx ();
2480 lab_rtx_for_bb->put (bb, l);
2481 return l;
2482}
2483
2484
2485/* A subroutine of expand_gimple_cond. Given E, a fallthrough edge
2486 of a basic block where we just expanded the conditional at the end,
2487 possibly clean up the CFG and instruction sequence. LAST is the
2488 last instruction before the just emitted jump sequence. */
2489
2490static void
2491maybe_cleanup_end_of_block (edge e, rtx_insn *last)
2492{
2493 /* Special case: when jumpif decides that the condition is
2494 trivial it emits an unconditional jump (and the necessary
2495 barrier). But we still have two edges, the fallthru one is
2496 wrong. purge_dead_edges would clean this up later. Unfortunately
2497 we have to insert insns (and split edges) before
2498 find_many_sub_basic_blocks and hence before purge_dead_edges.
2499 But splitting edges might create new blocks which depend on the
2500 fact that if there are two edges there's no barrier. So the
2501 barrier would get lost and verify_flow_info would ICE. Instead
2502 of auditing all edge splitters to care for the barrier (which
2503 normally isn't there in a cleaned CFG), fix it here. */
2504 if (BARRIER_P (get_last_insn ())(((enum rtx_code) (get_last_insn ())->code) == BARRIER))
2505 {
2506 rtx_insn *insn;
2507 remove_edge (e);
2508 /* Now, we have a single successor block, if we have insns to
2509 insert on the remaining edge we potentially will insert
2510 it at the end of this block (if the dest block isn't feasible)
2511 in order to avoid splitting the edge. This insertion will take
2512 place in front of the last jump. But we might have emitted
2513 multiple jumps (conditional and one unconditional) to the
2514 same destination. Inserting in front of the last one then
2515 is a problem. See PR 40021. We fix this by deleting all
2516 jumps except the last unconditional one. */
2517 insn = PREV_INSN (get_last_insn ());
2518 /* Make sure we have an unconditional jump. Otherwise we're
2519 confused. */
2520 gcc_assert (JUMP_P (insn) && !any_condjump_p (insn))((void)(!((((enum rtx_code) (insn)->code) == JUMP_INSN) &&
!any_condjump_p (insn)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2520, __FUNCTION__), 0 : 0))
;
2521 for (insn = PREV_INSN (insn); insn != last;)
2522 {
2523 insn = PREV_INSN (insn);
2524 if (JUMP_P (NEXT_INSN (insn))(((enum rtx_code) (NEXT_INSN (insn))->code) == JUMP_INSN))
2525 {
2526 if (!any_condjump_p (NEXT_INSN (insn)))
2527 {
2528 gcc_assert (BARRIER_P (NEXT_INSN (NEXT_INSN (insn))))((void)(!((((enum rtx_code) (NEXT_INSN (NEXT_INSN (insn)))->
code) == BARRIER)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2528, __FUNCTION__), 0 : 0))
;
2529 delete_insn (NEXT_INSN (NEXT_INSN (insn)));
2530 }
2531 delete_insn (NEXT_INSN (insn));
2532 }
2533 }
2534 }
2535}
2536
2537/* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_COND.
2538 Returns a new basic block if we've terminated the current basic
2539 block and created a new one. */
2540
2541static basic_block
2542expand_gimple_cond (basic_block bb, gcond *stmt)
2543{
2544 basic_block new_bb, dest;
2545 edge true_edge;
2546 edge false_edge;
2547 rtx_insn *last2, *last;
2548 enum tree_code code;
2549 tree op0, op1;
2550
2551 code = gimple_cond_code (stmt);
2552 op0 = gimple_cond_lhs (stmt);
2553 op1 = gimple_cond_rhs (stmt);
2554 /* We're sometimes presented with such code:
2555 D.123_1 = x < y;
2556 if (D.123_1 != 0)
2557 ...
2558 This would expand to two comparisons which then later might
2559 be cleaned up by combine. But some pattern matchers like if-conversion
2560 work better when there's only one compare, so make up for this
2561 here as special exception if TER would have made the same change. */
2562 if (SA.values
2563 && TREE_CODE (op0)((enum tree_code) (op0)->base.code) == SSA_NAME
2564 && TREE_CODE (TREE_TYPE (op0))((enum tree_code) (((contains_struct_check ((op0), (TS_TYPED)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2564, __FUNCTION__))->typed.type))->base.code)
== BOOLEAN_TYPE
2565 && TREE_CODE (op1)((enum tree_code) (op1)->base.code) == INTEGER_CST
2566 && ((gimple_cond_code (stmt) == NE_EXPR
2567 && integer_zerop (op1))
2568 || (gimple_cond_code (stmt) == EQ_EXPR
2569 && integer_onep (op1)))
2570 && bitmap_bit_p (SA.values, SSA_NAME_VERSION (op0)(tree_check ((op0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2570, __FUNCTION__, (SSA_NAME)))->base.u.version
))
2571 {
2572 gimple *second = SSA_NAME_DEF_STMT (op0)(tree_check ((op0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2572, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt
;
2573 if (gimple_code (second) == GIMPLE_ASSIGN)
2574 {
2575 enum tree_code code2 = gimple_assign_rhs_code (second);
2576 if (TREE_CODE_CLASS (code2)tree_code_type_tmpl <0>::tree_code_type[(int) (code2)] == tcc_comparison)
2577 {
2578 code = code2;
2579 op0 = gimple_assign_rhs1 (second);
2580 op1 = gimple_assign_rhs2 (second);
2581 }
2582 /* If jumps are cheap and the target does not support conditional
2583 compare, turn some more codes into jumpy sequences. */
2584 else if (BRANCH_COST (optimize_insn_for_speed_p (), false)(!(optimize_insn_for_speed_p ()) ? 2 : (false) ? 0 : global_options
.x_ix86_branch_cost)
< 4
2585 && targetm.gen_ccmp_first == NULLnullptr)
2586 {
2587 if ((code2 == BIT_AND_EXPR
2588 && TYPE_PRECISION (TREE_TYPE (op0))((tree_class_check ((((contains_struct_check ((op0), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2588, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2588, __FUNCTION__))->type_common.precision)
== 1
2589 && TREE_CODE (gimple_assign_rhs2 (second))((enum tree_code) (gimple_assign_rhs2 (second))->base.code
)
!= INTEGER_CST)
2590 || code2 == TRUTH_AND_EXPR)
2591 {
2592 code = TRUTH_ANDIF_EXPR;
2593 op0 = gimple_assign_rhs1 (second);
2594 op1 = gimple_assign_rhs2 (second);
2595 }
2596 else if (code2 == BIT_IOR_EXPR || code2 == TRUTH_OR_EXPR)
2597 {
2598 code = TRUTH_ORIF_EXPR;
2599 op0 = gimple_assign_rhs1 (second);
2600 op1 = gimple_assign_rhs2 (second);
2601 }
2602 }
2603 }
2604 }
2605
2606 /* Optimize (x % C1) == C2 or (x % C1) != C2 if it is beneficial
2607 into (x - C2) * C3 < C4. */
2608 if ((code == EQ_EXPR || code == NE_EXPR)
2609 && TREE_CODE (op0)((enum tree_code) (op0)->base.code) == SSA_NAME
2610 && TREE_CODE (op1)((enum tree_code) (op1)->base.code) == INTEGER_CST)
2611 code = maybe_optimize_mod_cmp (code, &op0, &op1);
2612
2613 /* Optimize (x - y) < 0 into x < y if x - y has undefined overflow. */
2614 if (!TYPE_UNSIGNED (TREE_TYPE (op0))((tree_class_check ((((contains_struct_check ((op0), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2614, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2614, __FUNCTION__))->base.u.bits.unsigned_flag)
2615 && (code == LT_EXPR || code == LE_EXPR
2616 || code == GT_EXPR || code == GE_EXPR)
2617 && integer_zerop (op1)
2618 && TREE_CODE (op0)((enum tree_code) (op0)->base.code) == SSA_NAME)
2619 maybe_optimize_sub_cmp_0 (code, &op0, &op1);
2620
2621 last2 = last = get_last_insn ();
2622
2623 extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
2624 set_curr_insn_location (gimple_location (stmt));
2625
2626 /* These flags have no purpose in RTL land. */
2627 true_edge->flags &= ~EDGE_TRUE_VALUE;
2628 false_edge->flags &= ~EDGE_FALSE_VALUE;
2629
2630 /* We can either have a pure conditional jump with one fallthru edge or
2631 two-way jump that needs to be decomposed into two basic blocks. */
2632 if (false_edge->dest == bb->next_bb)
2633 {
2634 jumpif_1 (code, op0, op1, label_rtx_for_bb (true_edge->dest),
2635 true_edge->probability);
2636 maybe_dump_rtl_for_gimple_stmt (stmt, last);
2637 if (true_edge->goto_locus != UNKNOWN_LOCATION((location_t) 0))
2638 set_curr_insn_location (true_edge->goto_locus);
2639 false_edge->flags |= EDGE_FALLTHRU;
2640 maybe_cleanup_end_of_block (false_edge, last);
2641 return NULLnullptr;
2642 }
2643 if (true_edge->dest == bb->next_bb)
2644 {
2645 jumpifnot_1 (code, op0, op1, label_rtx_for_bb (false_edge->dest),
2646 false_edge->probability);
2647 maybe_dump_rtl_for_gimple_stmt (stmt, last);
2648 if (false_edge->goto_locus != UNKNOWN_LOCATION((location_t) 0))
2649 set_curr_insn_location (false_edge->goto_locus);
2650 true_edge->flags |= EDGE_FALLTHRU;
2651 maybe_cleanup_end_of_block (true_edge, last);
2652 return NULLnullptr;
2653 }
2654
2655 jumpif_1 (code, op0, op1, label_rtx_for_bb (true_edge->dest),
2656 true_edge->probability);
2657 last = get_last_insn ();
2658 if (false_edge->goto_locus != UNKNOWN_LOCATION((location_t) 0))
2659 set_curr_insn_location (false_edge->goto_locus);
2660 emit_jump (label_rtx_for_bb (false_edge->dest));
2661
2662 BB_END (bb)(bb)->il.x.rtl->end_ = last;
2663 if (BARRIER_P (BB_END (bb))(((enum rtx_code) ((bb)->il.x.rtl->end_)->code) == BARRIER
)
)
2664 BB_END (bb)(bb)->il.x.rtl->end_ = PREV_INSN (BB_END (bb)(bb)->il.x.rtl->end_);
2665 update_bb_for_insn (bb);
2666
2667 new_bb = create_basic_block (NEXT_INSN (last), get_last_insn (), bb);
2668 dest = false_edge->dest;
2669 redirect_edge_succ (false_edge, new_bb);
2670 false_edge->flags |= EDGE_FALLTHRU;
2671 new_bb->count = false_edge->count ();
2672 loop_p loop = find_common_loop (bb->loop_father, dest->loop_father);
2673 add_bb_to_loop (new_bb, loop);
2674 if (loop->latch == bb
2675 && loop->header == dest)
2676 loop->latch = new_bb;
2677 make_single_succ_edge (new_bb, dest, 0);
2678 if (BARRIER_P (BB_END (new_bb))(((enum rtx_code) ((new_bb)->il.x.rtl->end_)->code) ==
BARRIER)
)
2679 BB_END (new_bb)(new_bb)->il.x.rtl->end_ = PREV_INSN (BB_END (new_bb)(new_bb)->il.x.rtl->end_);
2680 update_bb_for_insn (new_bb);
2681
2682 maybe_dump_rtl_for_gimple_stmt (stmt, last2);
2683
2684 if (true_edge->goto_locus != UNKNOWN_LOCATION((location_t) 0))
2685 {
2686 set_curr_insn_location (true_edge->goto_locus);
2687 true_edge->goto_locus = curr_insn_location ();
2688 }
2689
2690 return new_bb;
2691}
2692
2693/* Mark all calls that can have a transaction restart. */
2694
2695static void
2696mark_transaction_restart_calls (gimple *stmt)
2697{
2698 struct tm_restart_node dummy;
2699 tm_restart_node **slot;
2700
2701 if (!cfun(cfun + 0)->gimple_df->tm_restart)
2702 return;
2703
2704 dummy.stmt = stmt;
2705 slot = cfun(cfun + 0)->gimple_df->tm_restart->find_slot (&dummy, NO_INSERT);
2706 if (slot)
2707 {
2708 struct tm_restart_node *n = *slot;
2709 tree list = n->label_or_list;
2710 rtx_insn *insn;
2711
2712 for (insn = next_real_insn (get_last_insn ());
2713 !CALL_P (insn)(((enum rtx_code) (insn)->code) == CALL_INSN);
2714 insn = next_real_insn (insn))
2715 continue;
2716
2717 if (TREE_CODE (list)((enum tree_code) (list)->base.code) == LABEL_DECL)
2718 add_reg_note (insn, REG_TM, label_rtx (list));
2719 else
2720 for (; list ; list = TREE_CHAIN (list)((contains_struct_check ((list), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2720, __FUNCTION__))->common.chain)
)
2721 add_reg_note (insn, REG_TM, label_rtx (TREE_VALUE (list)((tree_check ((list), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2721, __FUNCTION__, (TREE_LIST)))->list.value)
));
2722 }
2723}
2724
2725/* A subroutine of expand_gimple_stmt_1, expanding one GIMPLE_CALL
2726 statement STMT. */
2727
2728static void
2729expand_call_stmt (gcall *stmt)
2730{
2731 tree exp, decl, lhs;
2732 bool builtin_p;
2733 size_t i;
2734
2735 if (gimple_call_internal_p (stmt))
2736 {
2737 expand_internal_call (stmt);
2738 return;
2739 }
2740
2741 /* If this is a call to a built-in function and it has no effect other
2742 than setting the lhs, try to implement it using an internal function
2743 instead. */
2744 decl = gimple_call_fndecl (stmt);
2745 if (gimple_call_lhs (stmt)
2746 && !gimple_has_side_effects (stmt)
2747 && (optimizeglobal_options.x_optimize || (decl && called_as_built_in (decl))))
2748 {
2749 internal_fn ifn = replacement_internal_fn (stmt);
2750 if (ifn != IFN_LAST)
2751 {
2752 expand_internal_call (ifn, stmt);
2753 return;
2754 }
2755 }
2756
2757 exp = build_vl_exp (CALL_EXPR, gimple_call_num_args (stmt) + 3);
2758
2759 CALL_EXPR_FN (exp)(*((const_cast<tree*> (tree_operand_check (((tree_check
((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2759, __FUNCTION__, (CALL_EXPR)))), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2759, __FUNCTION__)))))
= gimple_call_fn (stmt);
2760 builtin_p = decl && fndecl_built_in_p (decl);
2761
2762 /* If this is not a builtin function, the function type through which the
2763 call is made may be different from the type of the function. */
2764 if (!builtin_p)
2765 CALL_EXPR_FN (exp)(*((const_cast<tree*> (tree_operand_check (((tree_check
((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2765, __FUNCTION__, (CALL_EXPR)))), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2765, __FUNCTION__)))))
2766 = fold_convert (build_pointer_type (gimple_call_fntype (stmt)),fold_convert_loc (((location_t) 0), build_pointer_type (gimple_call_fntype
(stmt)), (*((const_cast<tree*> (tree_operand_check (((
tree_check ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2767, __FUNCTION__, (CALL_EXPR)))), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2767, __FUNCTION__))))))
2767 CALL_EXPR_FN (exp))fold_convert_loc (((location_t) 0), build_pointer_type (gimple_call_fntype
(stmt)), (*((const_cast<tree*> (tree_operand_check (((
tree_check ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2767, __FUNCTION__, (CALL_EXPR)))), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2767, __FUNCTION__))))))
;
2768
2769 TREE_TYPE (exp)((contains_struct_check ((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2769, __FUNCTION__))->typed.type)
= gimple_call_return_type (stmt);
2770 CALL_EXPR_STATIC_CHAIN (exp)(*((const_cast<tree*> (tree_operand_check (((tree_check
((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2770, __FUNCTION__, (CALL_EXPR)))), (2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2770, __FUNCTION__)))))
= gimple_call_chain (stmt);
2771
2772 for (i = 0; i < gimple_call_num_args (stmt); i++)
2773 {
2774 tree arg = gimple_call_arg (stmt, i);
2775 gimple *def;
2776 /* TER addresses into arguments of builtin functions so we have a
2777 chance to infer more correct alignment information. See PR39954. */
2778 if (builtin_p
2779 && TREE_CODE (arg)((enum tree_code) (arg)->base.code) == SSA_NAME
2780 && (def = get_gimple_for_ssa_name (arg))
2781 && gimple_assign_rhs_code (def) == ADDR_EXPR)
2782 arg = gimple_assign_rhs1 (def);
2783 CALL_EXPR_ARG (exp, i)(*((const_cast<tree*> (tree_operand_check (((tree_check
((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2783, __FUNCTION__, (CALL_EXPR)))), ((i) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2783, __FUNCTION__)))))
= arg;
2784 }
2785
2786 if (gimple_has_side_effects (stmt)
2787 /* ??? Downstream in expand_expr_real_1 we assume that expressions
2788 w/o side-effects do not throw so work around this here. */
2789 || stmt_could_throw_p (cfun(cfun + 0), stmt))
2790 TREE_SIDE_EFFECTS (exp)((non_type_check ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2790, __FUNCTION__))->base.side_effects_flag)
= 1;
2791
2792 if (gimple_call_nothrow_p (stmt))
2793 TREE_NOTHROW (exp)((exp)->base.nothrow_flag) = 1;
2794
2795 CALL_EXPR_TAILCALL (exp)((tree_check ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2795, __FUNCTION__, (CALL_EXPR)))->base.addressable_flag
)
= gimple_call_tail_p (stmt);
2796 CALL_EXPR_MUST_TAIL_CALL (exp)((tree_check ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2796, __FUNCTION__, (CALL_EXPR)))->base.static_flag)
= gimple_call_must_tail_p (stmt);
2797 CALL_EXPR_RETURN_SLOT_OPT (exp)((tree_check ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2797, __FUNCTION__, (CALL_EXPR)))->base.private_flag)
= gimple_call_return_slot_opt_p (stmt);
2798 if (decl
2799 && fndecl_built_in_p (decl, BUILT_IN_NORMAL)
2800 && ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (decl))((DECL_FUNCTION_CODE (decl)) == BUILT_IN_ALLOCA || (DECL_FUNCTION_CODE
(decl)) == BUILT_IN_ALLOCA_WITH_ALIGN || (DECL_FUNCTION_CODE
(decl)) == BUILT_IN_ALLOCA_WITH_ALIGN_AND_MAX)
)
2801 CALL_ALLOCA_FOR_VAR_P (exp)((tree_check ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2801, __FUNCTION__, (CALL_EXPR)))->base.protected_flag)
= gimple_call_alloca_for_var_p (stmt);
2802 else
2803 CALL_FROM_THUNK_P (exp)((tree_check ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2803, __FUNCTION__, (CALL_EXPR)))->base.protected_flag)
= gimple_call_from_thunk_p (stmt);
2804 CALL_EXPR_VA_ARG_PACK (exp)((tree_check ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2804, __FUNCTION__, (CALL_EXPR)))->base.public_flag)
= gimple_call_va_arg_pack_p (stmt);
2805 CALL_EXPR_BY_DESCRIPTOR (exp)((tree_check ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2805, __FUNCTION__, (CALL_EXPR)))->base.default_def_flag
)
= gimple_call_by_descriptor_p (stmt);
2806 SET_EXPR_LOCATION (exp, gimple_location (stmt))(expr_check (((exp)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2806, __FUNCTION__))->exp.locus = (gimple_location (stmt
))
;
2807
2808 /* Must come after copying location. */
2809 copy_warning (exp, stmt);
2810
2811 /* Ensure RTL is created for debug args. */
2812 if (decl && DECL_HAS_DEBUG_ARGS_P (decl)((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2812, __FUNCTION__, (FUNCTION_DECL)))->function_decl.has_debug_args_flag
)
)
2813 {
2814 vec<tree, va_gc> **debug_args = decl_debug_args_lookup (decl);
2815 unsigned int ix;
2816 tree dtemp;
2817
2818 if (debug_args)
2819 for (ix = 1; (*debug_args)->iterate (ix, &dtemp); ix += 2)
2820 {
2821 gcc_assert (TREE_CODE (dtemp) == DEBUG_EXPR_DECL)((void)(!(((enum tree_code) (dtemp)->base.code) == DEBUG_EXPR_DECL
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2821, __FUNCTION__), 0 : 0))
;
2822 expand_debug_expr (dtemp);
2823 }
2824 }
2825
2826 rtx_insn *before_call = get_last_insn ();
2827 lhs = gimple_call_lhs (stmt);
2828 if (lhs)
2829 expand_assignment (lhs, exp, false);
2830 else
2831 expand_expr (exp, const0_rtx(const_int_rtx[64]), VOIDmode((void) 0, E_VOIDmode), EXPAND_NORMAL);
2832
2833 /* If the gimple call is an indirect call and has 'nocf_check'
2834 attribute find a generated CALL insn to mark it as no
2835 control-flow verification is needed. */
2836 if (gimple_call_nocf_check_p (stmt)
2837 && !gimple_call_fndecl (stmt))
2838 {
2839 rtx_insn *last = get_last_insn ();
2840 while (!CALL_P (last)(((enum rtx_code) (last)->code) == CALL_INSN)
2841 && last != before_call)
2842 last = PREV_INSN (last);
2843
2844 if (last != before_call)
2845 add_reg_note (last, REG_CALL_NOCF_CHECK, const0_rtx(const_int_rtx[64]));
2846 }
2847
2848 mark_transaction_restart_calls (stmt);
2849}
2850
2851
2852/* Generate RTL for an asm statement (explicit assembler code).
2853 STRING is a STRING_CST node containing the assembler code text,
2854 or an ADDR_EXPR containing a STRING_CST. VOL nonzero means the
2855 insn is volatile; don't optimize it. */
2856
2857static void
2858expand_asm_loc (tree string, int vol, location_t locus)
2859{
2860 rtx body;
2861
2862 body = gen_rtx_ASM_INPUT_loc (VOIDmode,gen_rtx_fmt_si_stat ((ASM_INPUT), ((((void) 0, E_VOIDmode))),
((ggc_alloc_string ((((const char *)((tree_check ((string), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2863, __FUNCTION__, (STRING_CST)))->string.str))), -1 ))
), ((locus)) )
2863 ggc_strdup (TREE_STRING_POINTER (string)),gen_rtx_fmt_si_stat ((ASM_INPUT), ((((void) 0, E_VOIDmode))),
((ggc_alloc_string ((((const char *)((tree_check ((string), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2863, __FUNCTION__, (STRING_CST)))->string.str))), -1 ))
), ((locus)) )
2864 locus)gen_rtx_fmt_si_stat ((ASM_INPUT), ((((void) 0, E_VOIDmode))),
((ggc_alloc_string ((((const char *)((tree_check ((string), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2863, __FUNCTION__, (STRING_CST)))->string.str))), -1 ))
), ((locus)) )
;
2865
2866 MEM_VOLATILE_P (body)(__extension__ ({ __typeof ((body)) const _rtx = ((body)); if
(((enum rtx_code) (_rtx)->code) != MEM && ((enum rtx_code
) (_rtx)->code) != ASM_OPERANDS && ((enum rtx_code
) (_rtx)->code) != ASM_INPUT) rtl_check_failed_flag ("MEM_VOLATILE_P"
, _rtx, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2866, __FUNCTION__); _rtx; })->volatil)
= vol;
2867
2868 /* Non-empty basic ASM implicitly clobbers memory. */
2869 if (TREE_STRING_LENGTH (string)((tree_check ((string), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2869, __FUNCTION__, (STRING_CST)))->string.length)
!= 0)
2870 {
2871 rtx asm_op, clob;
2872 unsigned i, nclobbers;
2873 auto_vec<rtx> input_rvec, output_rvec;
2874 auto_vec<machine_mode> input_mode;
2875 auto_vec<const char *> constraints;
2876 auto_vec<rtx> clobber_rvec;
2877 HARD_REG_SET clobbered_regs;
2878 CLEAR_HARD_REG_SET (clobbered_regs);
2879
2880 clob = gen_rtx_MEM (BLKmode((void) 0, E_BLKmode), gen_rtx_SCRATCH (VOIDmode)gen_rtx_fmt__stat ((SCRATCH), ((((void) 0, E_VOIDmode))) ));
2881 clobber_rvec.safe_push (clob);
2882
2883 if (targetm.md_asm_adjust)
2884 targetm.md_asm_adjust (output_rvec, input_rvec, input_mode,
2885 constraints, clobber_rvec, clobbered_regs,
2886 locus);
2887
2888 asm_op = body;
2889 nclobbers = clobber_rvec.length ();
2890 body = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (1 + nclobbers))gen_rtx_fmt_E_stat ((PARALLEL), ((((void) 0, E_VOIDmode))), (
(rtvec_alloc (1 + nclobbers))) )
;
2891
2892 XVECEXP (body, 0, 0)(((((body)->u.fld[0]).rt_rtvec))->elem[0]) = asm_op;
2893 for (i = 0; i < nclobbers; i++)
2894 XVECEXP (body, 0, i + 1)(((((body)->u.fld[0]).rt_rtvec))->elem[i + 1]) = gen_rtx_CLOBBER (VOIDmode, clobber_rvec[i])gen_rtx_fmt_e_stat ((CLOBBER), ((((void) 0, E_VOIDmode))), ((
clobber_rvec[i])) )
;
2895 }
2896
2897 emit_insn (body);
2898}
2899
2900/* Return the number of times character C occurs in string S. */
2901static int
2902n_occurrences (int c, const char *s)
2903{
2904 int n = 0;
2905 while (*s)
2906 n += (*s++ == c);
2907 return n;
2908}
2909
2910/* A subroutine of expand_asm_operands. Check that all operands have
2911 the same number of alternatives. Return true if so. */
2912
2913static bool
2914check_operand_nalternatives (const vec<const char *> &constraints)
2915{
2916 unsigned len = constraints.length();
2917 if (len > 0)
2918 {
2919 int nalternatives = n_occurrences (',', constraints[0]);
2920
2921 if (nalternatives + 1 > MAX_RECOG_ALTERNATIVES35)
2922 {
2923 error ("too many alternatives in %<asm%>");
2924 return false;
2925 }
2926
2927 for (unsigned i = 1; i < len; ++i)
2928 if (n_occurrences (',', constraints[i]) != nalternatives)
2929 {
2930 error ("operand constraints for %<asm%> differ "
2931 "in number of alternatives");
2932 return false;
2933 }
2934 }
2935 return true;
2936}
2937
2938/* Check for overlap between registers marked in CLOBBERED_REGS and
2939 anything inappropriate in T. Emit error and return the register
2940 variable definition for error, NULL_TREE for ok. */
2941
2942static bool
2943tree_conflicts_with_clobbers_p (tree t, HARD_REG_SET *clobbered_regs,
2944 location_t loc)
2945{
2946 /* Conflicts between asm-declared register variables and the clobber
2947 list are not allowed. */
2948 tree overlap = tree_overlaps_hard_reg_set (t, clobbered_regs);
2949
2950 if (overlap)
2951 {
2952 error_at (loc, "%<asm%> specifier for variable %qE conflicts with "
2953 "%<asm%> clobber list", DECL_NAME (overlap)((contains_struct_check ((overlap), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2953, __FUNCTION__))->decl_minimal.name)
);
2954
2955 /* Reset registerness to stop multiple errors emitted for a single
2956 variable. */
2957 DECL_REGISTER (overlap)((contains_struct_check ((overlap), (TS_DECL_WRTL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 2957, __FUNCTION__))->decl_common.decl_flag_0)
= 0;
2958 return true;
2959 }
2960
2961 return false;
2962}
2963
2964/* Check that the given REGNO spanning NREGS is a valid
2965 asm clobber operand. Some HW registers cannot be
2966 saved/restored, hence they should not be clobbered by
2967 asm statements. */
2968static bool
2969asm_clobber_reg_is_valid (int regno, int nregs, const char *regname)
2970{
2971 bool is_valid = true;
2972 HARD_REG_SET regset;
2973
2974 CLEAR_HARD_REG_SET (regset);
18
Calling 'CLEAR_HARD_REG_SET'
22
Returning from 'CLEAR_HARD_REG_SET'
2975
2976 add_range_to_hard_reg_set (&regset, regno, nregs);
23
Calling 'add_range_to_hard_reg_set'
26
Returning from 'add_range_to_hard_reg_set'
2977
2978 /* Clobbering the PIC register is an error. */
2979 if (PIC_OFFSET_TABLE_REGNUM(ix86_use_pseudo_pic_reg () ? ((this_target_rtl->x_pic_offset_table_rtx
) ? (~(unsigned int) 0) : (((global_options.x_ix86_isa_flags &
(1UL << 1)) != 0) ? 43 : 3)) : (~(unsigned int) 0))
!= INVALID_REGNUM(~(unsigned int) 0)
27
Assuming the condition is true
28
'?' condition is true
29
Assuming field 'x_pic_offset_table_rtx' is null
30
Assuming the condition is false
31
'?' condition is false
2980 && overlaps_hard_reg_set_p (regset, Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode)))
, PIC_OFFSET_TABLE_REGNUM(ix86_use_pseudo_pic_reg () ? ((this_target_rtl->x_pic_offset_table_rtx
) ? (~(unsigned int) 0) : (((global_options.x_ix86_isa_flags &
(1UL << 1)) != 0) ? 43 : 3)) : (~(unsigned int) 0))
)
)
32
Assuming field 'x_ix86_pmode' is not equal to PMODE_DI
33
'?' condition is false
34
Assuming the condition is false
35
'?' condition is false
36
Calling 'overlaps_hard_reg_set_p'
2981 {
2982 /* ??? Diagnose during gimplification? */
2983 error ("PIC register clobbered by %qs in %<asm%>", regname);
2984 is_valid = false;
2985 }
2986 else if (!in_hard_reg_set_p
2987 (accessible_reg_set(this_target_hard_regs->x_accessible_reg_set), reg_raw_mode(this_target_regs->x_reg_raw_mode)[regno], regno))
2988 {
2989 /* ??? Diagnose during gimplification? */
2990 error ("the register %qs cannot be clobbered in %<asm%>"
2991 " for the current target", regname);
2992 is_valid = false;
2993 }
2994
2995 /* Clobbering the stack pointer register is deprecated. GCC expects
2996 the value of the stack pointer after an asm statement to be the same
2997 as it was before, so no asm can validly clobber the stack pointer in
2998 the usual sense. Adding the stack pointer to the clobber list has
2999 traditionally had some undocumented and somewhat obscure side-effects. */
3000 if (overlaps_hard_reg_set_p (regset, Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode)))
, STACK_POINTER_REGNUM7))
3001 {
3002 crtl(&x_rtl)->sp_is_clobbered_by_asm = true;
3003 if (warning (OPT_Wdeprecated, "listing the stack pointer register"
3004 " %qs in a clobber list is deprecated", regname))
3005 inform (input_location, "the value of the stack pointer after"
3006 " an %<asm%> statement must be the same as it was before"
3007 " the statement");
3008 }
3009
3010 return is_valid;
3011}
3012
3013/* Generate RTL for an asm statement with arguments.
3014 STRING is the instruction template.
3015 OUTPUTS is a list of output arguments (lvalues); INPUTS a list of inputs.
3016 Each output or input has an expression in the TREE_VALUE and
3017 a tree list in TREE_PURPOSE which in turn contains a constraint
3018 name in TREE_VALUE (or NULL_TREE) and a constraint string
3019 in TREE_PURPOSE.
3020 CLOBBERS is a list of STRING_CST nodes each naming a hard register
3021 that is clobbered by this insn.
3022
3023 LABELS is a list of labels, and if LABELS is non-NULL, FALLTHRU_BB
3024 should be the fallthru basic block of the asm goto.
3025
3026 Not all kinds of lvalue that may appear in OUTPUTS can be stored directly.
3027 Some elements of OUTPUTS may be replaced with trees representing temporary
3028 values. The caller should copy those temporary values to the originally
3029 specified lvalues.
3030
3031 VOL nonzero means the insn is volatile; don't optimize it. */
3032
3033static void
3034expand_asm_stmt (gasm *stmt)
3035{
3036 class save_input_location
3037 {
3038 location_t old;
3039
3040 public:
3041 explicit save_input_location(location_t where)
3042 {
3043 old = input_location;
3044 input_location = where;
3045 }
3046
3047 ~save_input_location()
3048 {
3049 input_location = old;
3050 }
3051 };
3052
3053 location_t locus = gimple_location (stmt);
3054
3055 if (gimple_asm_input_p (stmt))
1
Taking false branch
3056 {
3057 const char *s = gimple_asm_string (stmt);
3058 tree string = build_string (strlen (s), s);
3059 expand_asm_loc (string, gimple_asm_volatile_p (stmt), locus);
3060 return;
3061 }
3062
3063 /* There are some legacy diagnostics in here. */
3064 save_input_location s_i_l(locus);
3065
3066 unsigned noutputs = gimple_asm_noutputs (stmt);
3067 unsigned ninputs = gimple_asm_ninputs (stmt);
3068 unsigned nlabels = gimple_asm_nlabels (stmt);
3069 unsigned i;
3070 bool error_seen = false;
3071
3072 /* ??? Diagnose during gimplification? */
3073 if (ninputs + noutputs + nlabels > MAX_RECOG_OPERANDS30)
2
Assuming the condition is false
3
Taking false branch
3074 {
3075 error_at (locus, "more than %d operands in %<asm%>", MAX_RECOG_OPERANDS30);
3076 return;
3077 }
3078
3079 auto_vec<tree, MAX_RECOG_OPERANDS30> output_tvec;
3080 auto_vec<tree, MAX_RECOG_OPERANDS30> input_tvec;
3081 auto_vec<const char *, MAX_RECOG_OPERANDS30> constraints;
3082
3083 /* Copy the gimple vectors into new vectors that we can manipulate. */
3084
3085 output_tvec.safe_grow (noutputs, true);
3086 input_tvec.safe_grow (ninputs, true);
3087 constraints.safe_grow (noutputs + ninputs, true);
3088
3089 for (i = 0; i < noutputs; ++i)
4
Assuming 'i' is >= 'noutputs'
5
Loop condition is false. Execution continues on line 3095
3090 {
3091 tree t = gimple_asm_output_op (stmt, i);
3092 output_tvec[i] = TREE_VALUE (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3092, __FUNCTION__, (TREE_LIST)))->list.value)
;
3093 constraints[i] = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t)))((const char *)((tree_check ((((tree_check ((((tree_check ((t
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3093, __FUNCTION__, (TREE_LIST)))->list.purpose)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3093, __FUNCTION__, (TREE_LIST)))->list.value)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3093, __FUNCTION__, (STRING_CST)))->string.str))
;
3094 }
3095 for (i = 0; i < ninputs; i++)
6
Assuming 'i' is >= 'ninputs'
7
Loop condition is false. Execution continues on line 3104
3096 {
3097 tree t = gimple_asm_input_op (stmt, i);
3098 input_tvec[i] = TREE_VALUE (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3098, __FUNCTION__, (TREE_LIST)))->list.value)
;
3099 constraints[i + noutputs]
3100 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t)))((const char *)((tree_check ((((tree_check ((((tree_check ((t
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3100, __FUNCTION__, (TREE_LIST)))->list.purpose)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3100, __FUNCTION__, (TREE_LIST)))->list.value)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3100, __FUNCTION__, (STRING_CST)))->string.str))
;
3101 }
3102
3103 /* ??? Diagnose during gimplification? */
3104 if (! check_operand_nalternatives (constraints))
8
Assuming the condition is false
9
Taking false branch
3105 return;
3106
3107 /* Count the number of meaningful clobbered registers, ignoring what
3108 we would ignore later. */
3109 auto_vec<rtx> clobber_rvec;
3110 HARD_REG_SET clobbered_regs;
3111 CLEAR_HARD_REG_SET (clobbered_regs);
3112
3113 if (unsigned n = gimple_asm_nclobbers (stmt))
10
Assuming 'n' is not equal to 0
11
Taking true branch
3114 {
3115 clobber_rvec.reserve (n);
3116 for (i = 0; i
11.1
'i' is < 'n'
11.1
'i' is < 'n'
11.1
'i' is < 'n'
< n; i++)
12
Loop condition is true. Entering loop body
3117 {
3118 tree t = gimple_asm_clobber_op (stmt, i);
3119 const char *regname = TREE_STRING_POINTER (TREE_VALUE (t))((const char *)((tree_check ((((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3119, __FUNCTION__, (TREE_LIST)))->list.value)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3119, __FUNCTION__, (STRING_CST)))->string.str))
;
3120 int nregs, j;
3121
3122 j = decode_reg_name_and_count (regname, &nregs);
3123 if (j < 0)
13
Assuming 'j' is >= 0
14
Taking false branch
3124 {
3125 if (j == -2)
3126 {
3127 /* ??? Diagnose during gimplification? */
3128 error_at (locus, "unknown register name %qs in %<asm%>",
3129 regname);
3130 error_seen = true;
3131 }
3132 else if (j == -4)
3133 {
3134 rtx x = gen_rtx_MEM (BLKmode((void) 0, E_BLKmode), gen_rtx_SCRATCH (VOIDmode)gen_rtx_fmt__stat ((SCRATCH), ((((void) 0, E_VOIDmode))) ));
3135 clobber_rvec.safe_push (x);
3136 }
3137 else
3138 {
3139 /* Otherwise we should have -1 == empty string
3140 or -3 == cc, which is not a register. */
3141 gcc_assert (j == -1 || j == -3)((void)(!(j == -1 || j == -3) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3141, __FUNCTION__), 0 : 0))
;
3142 }
3143 }
3144 else
3145 for (int reg = j; reg < j + nregs; reg++)
15
Assuming the condition is true
16
Loop condition is true. Entering loop body
3146 {
3147 if (!asm_clobber_reg_is_valid (reg, nregs, regname))
17
Calling 'asm_clobber_reg_is_valid'
3148 return;
3149
3150 SET_HARD_REG_BIT (clobbered_regs, reg);
3151 rtx x = gen_rtx_REG (reg_raw_mode(this_target_regs->x_reg_raw_mode)[reg], reg);
3152 clobber_rvec.safe_push (x);
3153 }
3154 }
3155 }
3156
3157 /* First pass over inputs and outputs checks validity and sets
3158 mark_addressable if needed. */
3159 /* ??? Diagnose during gimplification? */
3160
3161 for (i = 0; i < noutputs; ++i)
3162 {
3163 tree val = output_tvec[i];
3164 tree type = TREE_TYPE (val)((contains_struct_check ((val), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3164, __FUNCTION__))->typed.type)
;
3165 const char *constraint;
3166 bool is_inout;
3167 bool allows_reg;
3168 bool allows_mem;
3169
3170 /* Try to parse the output constraint. If that fails, there's
3171 no point in going further. */
3172 constraint = constraints[i];
3173 if (!parse_output_constraint (&constraint, i, ninputs, noutputs,
3174 &allows_mem, &allows_reg, &is_inout))
3175 return;
3176
3177 /* If the output is a hard register, verify it doesn't conflict with
3178 any other operand's possible hard register use. */
3179 if (DECL_P (val)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (val)->base.code))] == tcc_declaration)
3180 && REG_P (DECL_RTL (val))(((enum rtx_code) (((contains_struct_check ((val), (TS_DECL_WRTL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3180, __FUNCTION__))->decl_with_rtl.rtl ? (val)->decl_with_rtl
.rtl : (make_decl_rtl (val), (val)->decl_with_rtl.rtl)))->
code) == REG)
3181 && HARD_REGISTER_P (DECL_RTL (val))((((rhs_regno(((contains_struct_check ((val), (TS_DECL_WRTL),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3181, __FUNCTION__))->decl_with_rtl.rtl ? (val)->decl_with_rtl
.rtl : (make_decl_rtl (val), (val)->decl_with_rtl.rtl)))))
< 76))
)
3182 {
3183 unsigned j, output_hregno = REGNO (DECL_RTL (val))(rhs_regno(((contains_struct_check ((val), (TS_DECL_WRTL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3183, __FUNCTION__))->decl_with_rtl.rtl ? (val)->decl_with_rtl
.rtl : (make_decl_rtl (val), (val)->decl_with_rtl.rtl))))
;
3184 bool early_clobber_p = strchr (constraints[i], '&') != NULLnullptr;
3185 unsigned long match;
3186
3187 /* Verify the other outputs do not use the same hard register. */
3188 for (j = i + 1; j < noutputs; ++j)
3189 if (DECL_P (output_tvec[j])(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (output_tvec[j])->base.code))] == tcc_declaration)
3190 && REG_P (DECL_RTL (output_tvec[j]))(((enum rtx_code) (((contains_struct_check ((output_tvec[j]),
(TS_DECL_WRTL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3190, __FUNCTION__))->decl_with_rtl.rtl ? (output_tvec[j
])->decl_with_rtl.rtl : (make_decl_rtl (output_tvec[j]), (
output_tvec[j])->decl_with_rtl.rtl)))->code) == REG)
3191 && HARD_REGISTER_P (DECL_RTL (output_tvec[j]))((((rhs_regno(((contains_struct_check ((output_tvec[j]), (TS_DECL_WRTL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3191, __FUNCTION__))->decl_with_rtl.rtl ? (output_tvec[j
])->decl_with_rtl.rtl : (make_decl_rtl (output_tvec[j]), (
output_tvec[j])->decl_with_rtl.rtl))))) < 76))
3192 && output_hregno == REGNO (DECL_RTL (output_tvec[j]))(rhs_regno(((contains_struct_check ((output_tvec[j]), (TS_DECL_WRTL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3192, __FUNCTION__))->decl_with_rtl.rtl ? (output_tvec[j
])->decl_with_rtl.rtl : (make_decl_rtl (output_tvec[j]), (
output_tvec[j])->decl_with_rtl.rtl))))
)
3193 {
3194 error_at (locus, "invalid hard register usage between output "
3195 "operands");
3196 error_seen = true;
3197 }
3198
3199 /* Verify matching constraint operands use the same hard register
3200 and that the non-matching constraint operands do not use the same
3201 hard register if the output is an early clobber operand. */
3202 for (j = 0; j < ninputs; ++j)
3203 if (DECL_P (input_tvec[j])(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (input_tvec[j])->base.code))] == tcc_declaration)
3204 && REG_P (DECL_RTL (input_tvec[j]))(((enum rtx_code) (((contains_struct_check ((input_tvec[j]), (
TS_DECL_WRTL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3204, __FUNCTION__))->decl_with_rtl.rtl ? (input_tvec[j]
)->decl_with_rtl.rtl : (make_decl_rtl (input_tvec[j]), (input_tvec
[j])->decl_with_rtl.rtl)))->code) == REG)
3205 && HARD_REGISTER_P (DECL_RTL (input_tvec[j]))((((rhs_regno(((contains_struct_check ((input_tvec[j]), (TS_DECL_WRTL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3205, __FUNCTION__))->decl_with_rtl.rtl ? (input_tvec[j]
)->decl_with_rtl.rtl : (make_decl_rtl (input_tvec[j]), (input_tvec
[j])->decl_with_rtl.rtl))))) < 76))
)
3206 {
3207 unsigned input_hregno = REGNO (DECL_RTL (input_tvec[j]))(rhs_regno(((contains_struct_check ((input_tvec[j]), (TS_DECL_WRTL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3207, __FUNCTION__))->decl_with_rtl.rtl ? (input_tvec[j]
)->decl_with_rtl.rtl : (make_decl_rtl (input_tvec[j]), (input_tvec
[j])->decl_with_rtl.rtl))))
;
3208 switch (*constraints[j + noutputs])
3209 {
3210 case '0': case '1': case '2': case '3': case '4':
3211 case '5': case '6': case '7': case '8': case '9':
3212 match = strtoul (constraints[j + noutputs], NULLnullptr, 10);
3213 break;
3214 default:
3215 match = ULONG_MAX(9223372036854775807L *2UL+1UL);
3216 break;
3217 }
3218 if (i == match
3219 && output_hregno != input_hregno)
3220 {
3221 error_at (locus, "invalid hard register usage between "
3222 "output operand and matching constraint operand");
3223 error_seen = true;
3224 }
3225 else if (early_clobber_p
3226 && i != match
3227 && output_hregno == input_hregno)
3228 {
3229 error_at (locus, "invalid hard register usage between "
3230 "earlyclobber operand and input operand");
3231 error_seen = true;
3232 }
3233 }
3234 }
3235
3236 if (! allows_reg
3237 && (allows_mem
3238 || is_inout
3239 || (DECL_P (val)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (val)->base.code))] == tcc_declaration)
3240 && REG_P (DECL_RTL (val))(((enum rtx_code) (((contains_struct_check ((val), (TS_DECL_WRTL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3240, __FUNCTION__))->decl_with_rtl.rtl ? (val)->decl_with_rtl
.rtl : (make_decl_rtl (val), (val)->decl_with_rtl.rtl)))->
code) == REG)
3241 && GET_MODE (DECL_RTL (val))((machine_mode) (((contains_struct_check ((val), (TS_DECL_WRTL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3241, __FUNCTION__))->decl_with_rtl.rtl ? (val)->decl_with_rtl
.rtl : (make_decl_rtl (val), (val)->decl_with_rtl.rtl)))->
mode)
!= TYPE_MODE (type)((((enum tree_code) ((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3241, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(type) : (type)->type_common.mode)
)))
3242 mark_addressable (val);
3243 }
3244
3245 for (i = 0; i < ninputs; ++i)
3246 {
3247 bool allows_reg, allows_mem;
3248 const char *constraint;
3249
3250 constraint = constraints[i + noutputs];
3251 if (! parse_input_constraint (&constraint, i, ninputs, noutputs, 0,
3252 constraints.address (),
3253 &allows_mem, &allows_reg))
3254 return;
3255
3256 if (! allows_reg && allows_mem)
3257 mark_addressable (input_tvec[i]);
3258 }
3259
3260 /* Second pass evaluates arguments. */
3261
3262 /* Make sure stack is consistent for asm goto. */
3263 if (nlabels > 0)
3264 do_pending_stack_adjust ();
3265 int old_generating_concat_p = generating_concat_p;
3266
3267 /* Vector of RTX's of evaluated output operands. */
3268 auto_vec<rtx, MAX_RECOG_OPERANDS30> output_rvec;
3269 auto_vec<int, MAX_RECOG_OPERANDS30> inout_opnum;
3270 rtx_insn *after_rtl_seq = NULLnullptr, *after_rtl_end = NULLnullptr;
3271
3272 output_rvec.safe_grow (noutputs, true);
3273
3274 for (i = 0; i < noutputs; ++i)
3275 {
3276 tree val = output_tvec[i];
3277 tree type = TREE_TYPE (val)((contains_struct_check ((val), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3277, __FUNCTION__))->typed.type)
;
3278 bool is_inout, allows_reg, allows_mem, ok;
3279 rtx op;
3280
3281 ok = parse_output_constraint (&constraints[i], i, ninputs,
3282 noutputs, &allows_mem, &allows_reg,
3283 &is_inout);
3284 gcc_assert (ok)((void)(!(ok) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3284, __FUNCTION__), 0 : 0))
;
3285
3286 /* If an output operand is not a decl or indirect ref and our constraint
3287 allows a register, make a temporary to act as an intermediate.
3288 Make the asm insn write into that, then we will copy it to
3289 the real output operand. Likewise for promoted variables. */
3290
3291 generating_concat_p = 0;
3292
3293 gcc_assert (TREE_CODE (val) != INDIRECT_REF)((void)(!(((enum tree_code) (val)->base.code) != INDIRECT_REF
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3293, __FUNCTION__), 0 : 0))
;
3294 if (((TREE_CODE (val)((enum tree_code) (val)->base.code) == MEM_REF
3295 && TREE_CODE (TREE_OPERAND (val, 0))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
((val), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3295, __FUNCTION__))))))->base.code)
!= ADDR_EXPR)
3296 && allows_mem)
3297 || (DECL_P (val)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (val)->base.code))] == tcc_declaration)
3298 && (allows_mem || REG_P (DECL_RTL (val))(((enum rtx_code) (((contains_struct_check ((val), (TS_DECL_WRTL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3298, __FUNCTION__))->decl_with_rtl.rtl ? (val)->decl_with_rtl
.rtl : (make_decl_rtl (val), (val)->decl_with_rtl.rtl)))->
code) == REG)
)
3299 && ! (REG_P (DECL_RTL (val))(((enum rtx_code) (((contains_struct_check ((val), (TS_DECL_WRTL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3299, __FUNCTION__))->decl_with_rtl.rtl ? (val)->decl_with_rtl
.rtl : (make_decl_rtl (val), (val)->decl_with_rtl.rtl)))->
code) == REG)
3300 && GET_MODE (DECL_RTL (val))((machine_mode) (((contains_struct_check ((val), (TS_DECL_WRTL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3300, __FUNCTION__))->decl_with_rtl.rtl ? (val)->decl_with_rtl
.rtl : (make_decl_rtl (val), (val)->decl_with_rtl.rtl)))->
mode)
!= TYPE_MODE (type)((((enum tree_code) ((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3300, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(type) : (type)->type_common.mode)
))
3301 || ! allows_reg
3302 || is_inout
3303 || TREE_ADDRESSABLE (type)((type)->base.addressable_flag)
3304 || (!tree_fits_poly_int64_p (TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3304, __FUNCTION__))->type_common.size)
)
3305 && !known_size_p (max_int_size_in_bytes (type))))
3306 {
3307 op = expand_expr (val, NULL_RTX(rtx) 0, VOIDmode((void) 0, E_VOIDmode),
3308 !allows_reg ? EXPAND_MEMORY : EXPAND_WRITE);
3309 if (MEM_P (op)(((enum rtx_code) (op)->code) == MEM))
3310 op = validize_mem (op);
3311
3312 if (! allows_reg && !MEM_P (op)(((enum rtx_code) (op)->code) == MEM))
3313 {
3314 error_at (locus, "output number %d not directly addressable", i);
3315 error_seen = true;
3316 }
3317 if ((! allows_mem && MEM_P (op)(((enum rtx_code) (op)->code) == MEM) && GET_MODE (op)((machine_mode) (op)->mode) != BLKmode((void) 0, E_BLKmode))
3318 || GET_CODE (op)((enum rtx_code) (op)->code) == CONCAT)
3319 {
3320 rtx old_op = op;
3321 op = gen_reg_rtx (GET_MODE (op)((machine_mode) (op)->mode));
3322
3323 generating_concat_p = old_generating_concat_p;
3324
3325 if (is_inout)
3326 emit_move_insn (op, old_op);
3327
3328 push_to_sequence2 (after_rtl_seq, after_rtl_end);
3329 emit_move_insn (old_op, op);
3330 after_rtl_seq = get_insns ();
3331 after_rtl_end = get_last_insn ();
3332 end_sequence ();
3333 }
3334 }
3335 else
3336 {
3337 op = assign_temp (type, 0, 1);
3338 op = validize_mem (op);
3339 if (!MEM_P (op)(((enum rtx_code) (op)->code) == MEM) && TREE_CODE (val)((enum tree_code) (val)->base.code) == SSA_NAME)
3340 set_reg_attrs_for_decl_rtl (SSA_NAME_VAR (val)((tree_check ((val), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3340, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree)
nullptr || ((enum tree_code) ((val)->ssa_name.var)->base
.code) == IDENTIFIER_NODE ? (tree) nullptr : (val)->ssa_name
.var)
, op);
3341
3342 generating_concat_p = old_generating_concat_p;
3343
3344 push_to_sequence2 (after_rtl_seq, after_rtl_end);
3345 expand_assignment (val, make_tree (type, op), false);
3346 after_rtl_seq = get_insns ();
3347 after_rtl_end = get_last_insn ();
3348 end_sequence ();
3349 }
3350 output_rvec[i] = op;
3351
3352 if (is_inout)
3353 inout_opnum.safe_push (i);
3354 }
3355
3356 const char *str = gimple_asm_string (stmt);
3357 if (error_seen)
3358 {
3359 ninputs = 0;
3360 noutputs = 0;
3361 inout_opnum.truncate (0);
3362 output_rvec.truncate (0);
3363 clobber_rvec.truncate (0);
3364 constraints.truncate (0);
3365 CLEAR_HARD_REG_SET (clobbered_regs);
3366 str = "";
3367 }
3368
3369 auto_vec<rtx, MAX_RECOG_OPERANDS30> input_rvec;
3370 auto_vec<machine_mode, MAX_RECOG_OPERANDS30> input_mode;
3371
3372 input_rvec.safe_grow (ninputs, true);
3373 input_mode.safe_grow (ninputs, true);
3374
3375 generating_concat_p = 0;
3376
3377 for (i = 0; i < ninputs; ++i)
3378 {
3379 tree val = input_tvec[i];
3380 tree type = TREE_TYPE (val)((contains_struct_check ((val), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3380, __FUNCTION__))->typed.type)
;
3381 bool allows_reg, allows_mem, ok;
3382 const char *constraint;
3383 rtx op;
3384
3385 constraint = constraints[i + noutputs];
3386 ok = parse_input_constraint (&constraint, i, ninputs, noutputs, 0,
3387 constraints.address (),
3388 &allows_mem, &allows_reg);
3389 gcc_assert (ok)((void)(!(ok) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3389, __FUNCTION__), 0 : 0))
;
3390
3391 /* EXPAND_INITIALIZER will not generate code for valid initializer
3392 constants, but will still generate code for other types of operand.
3393 This is the behavior we want for constant constraints. */
3394 op = expand_expr (val, NULL_RTX(rtx) 0, VOIDmode((void) 0, E_VOIDmode),
3395 allows_reg ? EXPAND_NORMAL
3396 : allows_mem ? EXPAND_MEMORY
3397 : EXPAND_INITIALIZER);
3398
3399 /* Never pass a CONCAT to an ASM. */
3400 if (GET_CODE (op)((enum rtx_code) (op)->code) == CONCAT)
3401 op = force_reg (GET_MODE (op)((machine_mode) (op)->mode), op);
3402 else if (MEM_P (op)(((enum rtx_code) (op)->code) == MEM))
3403 op = validize_mem (op);
3404
3405 if (asm_operand_ok (op, constraint, NULLnullptr) <= 0)
3406 {
3407 if (allows_reg && TYPE_MODE (type)((((enum tree_code) ((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3407, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(type) : (type)->type_common.mode)
!= BLKmode((void) 0, E_BLKmode))
3408 op = force_reg (TYPE_MODE (type)((((enum tree_code) ((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3408, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(type) : (type)->type_common.mode)
, op);
3409 else if (!allows_mem)
3410 warning_at (locus, 0, "%<asm%> operand %d probably does not match "
3411 "constraints", i + noutputs);
3412 else if (MEM_P (op)(((enum rtx_code) (op)->code) == MEM))
3413 {
3414 /* We won't recognize either volatile memory or memory
3415 with a queued address as available a memory_operand
3416 at this point. Ignore it: clearly this *is* a memory. */
3417 }
3418 else
3419 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3419, __FUNCTION__))
;
3420 }
3421 input_rvec[i] = op;
3422 input_mode[i] = TYPE_MODE (type)((((enum tree_code) ((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3422, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(type) : (type)->type_common.mode)
;
3423 }
3424
3425 /* For in-out operands, copy output rtx to input rtx. */
3426 unsigned ninout = inout_opnum.length ();
3427 for (i = 0; i < ninout; i++)
3428 {
3429 int j = inout_opnum[i];
3430 rtx o = output_rvec[j];
3431
3432 input_rvec.safe_push (o);
3433 input_mode.safe_push (GET_MODE (o)((machine_mode) (o)->mode));
3434
3435 char buffer[16];
3436 sprintf (buffer, "%d", j);
3437 constraints.safe_push (ggc_strdup (buffer)ggc_alloc_string ((buffer), -1 ));
3438 }
3439 ninputs += ninout;
3440
3441 /* Sometimes we wish to automatically clobber registers across an asm.
3442 Case in point is when the i386 backend moved from cc0 to a hard reg --
3443 maintaining source-level compatibility means automatically clobbering
3444 the flags register. */
3445 rtx_insn *after_md_seq = NULLnullptr;
3446 if (targetm.md_asm_adjust)
3447 after_md_seq
3448 = targetm.md_asm_adjust (output_rvec, input_rvec, input_mode,
3449 constraints, clobber_rvec, clobbered_regs,
3450 locus);
3451
3452 /* Do not allow the hook to change the output and input count,
3453 lest it mess up the operand numbering. */
3454 gcc_assert (output_rvec.length() == noutputs)((void)(!(output_rvec.length() == noutputs) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3454, __FUNCTION__), 0 : 0))
;
3455 gcc_assert (input_rvec.length() == ninputs)((void)(!(input_rvec.length() == ninputs) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3455, __FUNCTION__), 0 : 0))
;
3456 gcc_assert (constraints.length() == noutputs + ninputs)((void)(!(constraints.length() == noutputs + ninputs) ? fancy_abort
("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3456, __FUNCTION__), 0 : 0))
;
3457
3458 /* But it certainly can adjust the clobbers. */
3459 unsigned nclobbers = clobber_rvec.length ();
3460
3461 /* Third pass checks for easy conflicts. */
3462 /* ??? Why are we doing this on trees instead of rtx. */
3463
3464 bool clobber_conflict_found = 0;
3465 for (i = 0; i < noutputs; ++i)
3466 if (tree_conflicts_with_clobbers_p (output_tvec[i], &clobbered_regs, locus))
3467 clobber_conflict_found = 1;
3468 for (i = 0; i < ninputs - ninout; ++i)
3469 if (tree_conflicts_with_clobbers_p (input_tvec[i], &clobbered_regs, locus))
3470 clobber_conflict_found = 1;
3471
3472 /* Make vectors for the expression-rtx, constraint strings,
3473 and named operands. */
3474
3475 rtvec argvec = rtvec_alloc (ninputs);
3476 rtvec constraintvec = rtvec_alloc (ninputs);
3477 rtvec labelvec = rtvec_alloc (nlabels);
3478
3479 rtx body = gen_rtx_ASM_OPERANDS ((noutputs == 0 ? VOIDmodegen_rtx_fmt_ssiEEEi_stat ((ASM_OPERANDS), (((noutputs == 0 ? (
(void) 0, E_VOIDmode) : ((machine_mode) (output_rvec[0])->
mode)))), ((ggc_alloc_string ((str), -1 ))), (("")), ((0)), (
(argvec)), ((constraintvec)), ((labelvec)), ((locus)) )
3480 : GET_MODE (output_rvec[0])),gen_rtx_fmt_ssiEEEi_stat ((ASM_OPERANDS), (((noutputs == 0 ? (
(void) 0, E_VOIDmode) : ((machine_mode) (output_rvec[0])->
mode)))), ((ggc_alloc_string ((str), -1 ))), (("")), ((0)), (
(argvec)), ((constraintvec)), ((labelvec)), ((locus)) )
3481 ggc_strdup (str),gen_rtx_fmt_ssiEEEi_stat ((ASM_OPERANDS), (((noutputs == 0 ? (
(void) 0, E_VOIDmode) : ((machine_mode) (output_rvec[0])->
mode)))), ((ggc_alloc_string ((str), -1 ))), (("")), ((0)), (
(argvec)), ((constraintvec)), ((labelvec)), ((locus)) )
3482 "", 0, argvec, constraintvec,gen_rtx_fmt_ssiEEEi_stat ((ASM_OPERANDS), (((noutputs == 0 ? (
(void) 0, E_VOIDmode) : ((machine_mode) (output_rvec[0])->
mode)))), ((ggc_alloc_string ((str), -1 ))), (("")), ((0)), (
(argvec)), ((constraintvec)), ((labelvec)), ((locus)) )
3483 labelvec, locus)gen_rtx_fmt_ssiEEEi_stat ((ASM_OPERANDS), (((noutputs == 0 ? (
(void) 0, E_VOIDmode) : ((machine_mode) (output_rvec[0])->
mode)))), ((ggc_alloc_string ((str), -1 ))), (("")), ((0)), (
(argvec)), ((constraintvec)), ((labelvec)), ((locus)) )
;
3484 MEM_VOLATILE_P (body)(__extension__ ({ __typeof ((body)) const _rtx = ((body)); if
(((enum rtx_code) (_rtx)->code) != MEM && ((enum rtx_code
) (_rtx)->code) != ASM_OPERANDS && ((enum rtx_code
) (_rtx)->code) != ASM_INPUT) rtl_check_failed_flag ("MEM_VOLATILE_P"
, _rtx, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3484, __FUNCTION__); _rtx; })->volatil)
= gimple_asm_volatile_p (stmt);
3485
3486 for (i = 0; i < ninputs; ++i)
3487 {
3488 ASM_OPERANDS_INPUT (body, i)(((((body)->u.fld[3]).rt_rtvec))->elem[i]) = input_rvec[i];
3489 ASM_OPERANDS_INPUT_CONSTRAINT_EXP (body, i)(((((body)->u.fld[4]).rt_rtvec))->elem[i])
3490 = gen_rtx_ASM_INPUT_loc (input_mode[i],gen_rtx_fmt_si_stat ((ASM_INPUT), ((input_mode[i])), ((constraints
[i + noutputs])), ((locus)) )
3491 constraints[i + noutputs],gen_rtx_fmt_si_stat ((ASM_INPUT), ((input_mode[i])), ((constraints
[i + noutputs])), ((locus)) )
3492 locus)gen_rtx_fmt_si_stat ((ASM_INPUT), ((input_mode[i])), ((constraints
[i + noutputs])), ((locus)) )
;
3493 }
3494
3495 /* Copy labels to the vector. */
3496 rtx_code_label *fallthru_label = NULLnullptr;
3497 if (nlabels > 0)
3498 {
3499 basic_block fallthru_bb = NULLnullptr;
3500 edge fallthru = find_fallthru_edge (gimple_bb (stmt)->succs);
3501 if (fallthru)
3502 fallthru_bb = fallthru->dest;
3503
3504 for (i = 0; i < nlabels; ++i)
3505 {
3506 tree label = TREE_VALUE (gimple_asm_label_op (stmt, i))((tree_check ((gimple_asm_label_op (stmt, i)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3506, __FUNCTION__, (TREE_LIST)))->list.value)
;
3507 rtx_insn *r;
3508 /* If asm goto has any labels in the fallthru basic block, use
3509 a label that we emit immediately after the asm goto. Expansion
3510 may insert further instructions into the same basic block after
3511 asm goto and if we don't do this, insertion of instructions on
3512 the fallthru edge might misbehave. See PR58670. */
3513 if (fallthru_bb && label_to_block (cfun(cfun + 0), label) == fallthru_bb)
3514 {
3515 if (fallthru_label == NULL_RTX(rtx) 0)
3516 fallthru_label = gen_label_rtx ();
3517 r = fallthru_label;
3518 }
3519 else
3520 r = label_rtx (label);
3521 ASM_OPERANDS_LABEL (body, i)(((((body)->u.fld[5]).rt_rtvec))->elem[i]) = gen_rtx_LABEL_REF (Pmode, r)gen_rtx_fmt_u_stat ((LABEL_REF), (((global_options.x_ix86_pmode
== PMODE_DI ? (scalar_int_mode ((scalar_int_mode::from_int) E_DImode
)) : (scalar_int_mode ((scalar_int_mode::from_int) E_SImode))
))), ((r)) )
;
3522 }
3523 }
3524
3525 /* Now, for each output, construct an rtx
3526 (set OUTPUT (asm_operands INSN OUTPUTCONSTRAINT OUTPUTNUMBER
3527 ARGVEC CONSTRAINTS OPNAMES))
3528 If there is more than one, put them inside a PARALLEL. */
3529
3530 if (noutputs == 0 && nclobbers == 0)
3531 {
3532 /* No output operands: put in a raw ASM_OPERANDS rtx. */
3533 if (nlabels > 0)
3534 emit_jump_insn (body);
3535 else
3536 emit_insn (body);
3537 }
3538 else if (noutputs == 1 && nclobbers == 0)
3539 {
3540 ASM_OPERANDS_OUTPUT_CONSTRAINT (body)(((body)->u.fld[1]).rt_str) = constraints[0];
3541 if (nlabels > 0)
3542 emit_jump_insn (gen_rtx_SET (output_rvec[0], body)gen_rtx_fmt_ee_stat ((SET), (((void) 0, E_VOIDmode)), ((output_rvec
[0])), ((body)) )
);
3543 else
3544 emit_insn (gen_rtx_SET (output_rvec[0], body)gen_rtx_fmt_ee_stat ((SET), (((void) 0, E_VOIDmode)), ((output_rvec
[0])), ((body)) )
);
3545 }
3546 else
3547 {
3548 rtx obody = body;
3549 int num = noutputs;
3550
3551 if (num == 0)
3552 num = 1;
3553
3554 body = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (num + nclobbers))gen_rtx_fmt_E_stat ((PARALLEL), ((((void) 0, E_VOIDmode))), (
(rtvec_alloc (num + nclobbers))) )
;
3555
3556 /* For each output operand, store a SET. */
3557 for (i = 0; i < noutputs; ++i)
3558 {
3559 rtx src, o = output_rvec[i];
3560 if (i == 0)
3561 {
3562 ASM_OPERANDS_OUTPUT_CONSTRAINT (obody)(((obody)->u.fld[1]).rt_str) = constraints[0];
3563 src = obody;
3564 }
3565 else
3566 {
3567 src = gen_rtx_ASM_OPERANDS (GET_MODE (o),gen_rtx_fmt_ssiEEEi_stat ((ASM_OPERANDS), ((((machine_mode) (
o)->mode))), (((((obody)->u.fld[0]).rt_str))), ((constraints
[i])), ((i)), ((argvec)), ((constraintvec)), ((labelvec)), ((
locus)) )
3568 ASM_OPERANDS_TEMPLATE (obody),gen_rtx_fmt_ssiEEEi_stat ((ASM_OPERANDS), ((((machine_mode) (
o)->mode))), (((((obody)->u.fld[0]).rt_str))), ((constraints
[i])), ((i)), ((argvec)), ((constraintvec)), ((labelvec)), ((
locus)) )
3569 constraints[i], i, argvec,gen_rtx_fmt_ssiEEEi_stat ((ASM_OPERANDS), ((((machine_mode) (
o)->mode))), (((((obody)->u.fld[0]).rt_str))), ((constraints
[i])), ((i)), ((argvec)), ((constraintvec)), ((labelvec)), ((
locus)) )
3570 constraintvec, labelvec, locus)gen_rtx_fmt_ssiEEEi_stat ((ASM_OPERANDS), ((((machine_mode) (
o)->mode))), (((((obody)->u.fld[0]).rt_str))), ((constraints
[i])), ((i)), ((argvec)), ((constraintvec)), ((labelvec)), ((
locus)) )
;
3571 MEM_VOLATILE_P (src)(__extension__ ({ __typeof ((src)) const _rtx = ((src)); if (
((enum rtx_code) (_rtx)->code) != MEM && ((enum rtx_code
) (_rtx)->code) != ASM_OPERANDS && ((enum rtx_code
) (_rtx)->code) != ASM_INPUT) rtl_check_failed_flag ("MEM_VOLATILE_P"
, _rtx, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3571, __FUNCTION__); _rtx; })->volatil)
= gimple_asm_volatile_p (stmt);
3572 }
3573 XVECEXP (body, 0, i)(((((body)->u.fld[0]).rt_rtvec))->elem[i]) = gen_rtx_SET (o, src)gen_rtx_fmt_ee_stat ((SET), (((void) 0, E_VOIDmode)), ((o)), (
(src)) )
;
3574 }
3575
3576 /* If there are no outputs (but there are some clobbers)
3577 store the bare ASM_OPERANDS into the PARALLEL. */
3578 if (i == 0)
3579 XVECEXP (body, 0, i++)(((((body)->u.fld[0]).rt_rtvec))->elem[i++]) = obody;
3580
3581 /* Store (clobber REG) for each clobbered register specified. */
3582 for (unsigned j = 0; j < nclobbers; ++j)
3583 {
3584 rtx clobbered_reg = clobber_rvec[j];
3585
3586 /* Do sanity check for overlap between clobbers and respectively
3587 input and outputs that hasn't been handled. Such overlap
3588 should have been detected and reported above. */
3589 if (!clobber_conflict_found && REG_P (clobbered_reg)(((enum rtx_code) (clobbered_reg)->code) == REG))
3590 {
3591 /* We test the old body (obody) contents to avoid
3592 tripping over the under-construction body. */
3593 for (unsigned k = 0; k < noutputs; ++k)
3594 if (reg_overlap_mentioned_p (clobbered_reg, output_rvec[k]))
3595 internal_error ("%<asm%> clobber conflict with "
3596 "output operand");
3597
3598 for (unsigned k = 0; k < ninputs - ninout; ++k)
3599 if (reg_overlap_mentioned_p (clobbered_reg, input_rvec[k]))
3600 internal_error ("%<asm%> clobber conflict with "
3601 "input operand");
3602 }
3603
3604 XVECEXP (body, 0, i++)(((((body)->u.fld[0]).rt_rtvec))->elem[i++]) = gen_rtx_CLOBBER (VOIDmode, clobbered_reg)gen_rtx_fmt_e_stat ((CLOBBER), ((((void) 0, E_VOIDmode))), ((
clobbered_reg)) )
;
3605 }
3606
3607 if (nlabels > 0)
3608 emit_jump_insn (body);
3609 else
3610 emit_insn (body);
3611 }
3612
3613 generating_concat_p = old_generating_concat_p;
3614
3615 if (fallthru_label)
3616 emit_label (fallthru_label);
3617
3618 if (after_md_seq)
3619 emit_insn (after_md_seq);
3620 if (after_rtl_seq)
3621 {
3622 if (nlabels == 0)
3623 emit_insn (after_rtl_seq);
3624 else
3625 {
3626 edge e;
3627 edge_iterator ei;
3628
3629 FOR_EACH_EDGE (e, ei, gimple_bb (stmt)->succs)for ((ei) = ei_start_1 (&((gimple_bb (stmt)->succs)));
ei_cond ((ei), &(e)); ei_next (&(ei)))
3630 {
3631 start_sequence ();
3632 for (rtx_insn *curr = after_rtl_seq;
3633 curr != NULL_RTX(rtx) 0;
3634 curr = NEXT_INSN (curr))
3635 emit_insn (copy_insn (PATTERN (curr)));
3636 rtx_insn *copy = get_insns ();
3637 end_sequence ();
3638 insert_insn_on_edge (copy, e);
3639 }
3640 }
3641 }
3642
3643 free_temp_slots ();
3644 crtl(&x_rtl)->has_asm_statement = 1;
3645}
3646
3647/* Emit code to jump to the address
3648 specified by the pointer expression EXP. */
3649
3650static void
3651expand_computed_goto (tree exp)
3652{
3653 rtx x = expand_normal (exp);
3654
3655 do_pending_stack_adjust ();
3656 emit_indirect_jump (x);
3657}
3658
3659/* Generate RTL code for a `goto' statement with target label LABEL.
3660 LABEL should be a LABEL_DECL tree node that was or will later be
3661 defined with `expand_label'. */
3662
3663static void
3664expand_goto (tree label)
3665{
3666 if (flag_checkingglobal_options.x_flag_checking)
3667 {
3668 /* Check for a nonlocal goto to a containing function. Should have
3669 gotten translated to __builtin_nonlocal_goto. */
3670 tree context = decl_function_context (label);
3671 gcc_assert (!context || context == current_function_decl)((void)(!(!context || context == current_function_decl) ? fancy_abort
("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3671, __FUNCTION__), 0 : 0))
;
3672 }
3673
3674 emit_jump (jump_target_rtx (label));
3675}
3676
3677/* Output a return with no value. */
3678
3679static void
3680expand_null_return_1 (void)
3681{
3682 clear_pending_stack_adjust ();
3683 do_pending_stack_adjust ();
3684 emit_jump (return_label((&x_rtl)->x_return_label));
3685}
3686
3687/* Generate RTL to return from the current function, with no value.
3688 (That is, we do not do anything about returning any value.) */
3689
3690void
3691expand_null_return (void)
3692{
3693 /* If this function was declared to return a value, but we
3694 didn't, clobber the return registers so that they are not
3695 propagated live to the rest of the function. */
3696 clobber_return_register ();
3697
3698 expand_null_return_1 ();
3699}
3700
3701/* Generate RTL to return from the current function, with value VAL. */
3702
3703static void
3704expand_value_return (rtx val)
3705{
3706 /* Copy the value to the return location unless it's already there. */
3707
3708 tree decl = DECL_RESULT (current_function_decl)((tree_check ((current_function_decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3708, __FUNCTION__, (FUNCTION_DECL)))->decl_non_common.result
)
;
3709 rtx return_reg = DECL_RTL (decl)((contains_struct_check ((decl), (TS_DECL_WRTL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3709, __FUNCTION__))->decl_with_rtl.rtl ? (decl)->decl_with_rtl
.rtl : (make_decl_rtl (decl), (decl)->decl_with_rtl.rtl))
;
3710 if (return_reg != val)
3711 {
3712 tree funtype = TREE_TYPE (current_function_decl)((contains_struct_check ((current_function_decl), (TS_TYPED),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3712, __FUNCTION__))->typed.type)
;
3713 tree type = TREE_TYPE (decl)((contains_struct_check ((decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3713, __FUNCTION__))->typed.type)
;
3714 int unsignedp = TYPE_UNSIGNED (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3714, __FUNCTION__))->base.u.bits.unsigned_flag)
;
3715 machine_mode old_mode = DECL_MODE (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3715, __FUNCTION__))->decl_common.mode)
;
3716 machine_mode mode;
3717 if (DECL_BY_REFERENCE (decl)((tree_check3 ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3717, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL))
)->decl_common.decl_by_reference_flag)
)
3718 mode = promote_function_mode (type, old_mode, &unsignedp, funtype, 2);
3719 else
3720 mode = promote_function_mode (type, old_mode, &unsignedp, funtype, 1);
3721
3722 if (mode != old_mode)
3723 {
3724 /* Some ABIs require scalar floating point modes to be returned
3725 in a wider scalar integer mode. We need to explicitly
3726 reinterpret to an integer mode of the correct precision
3727 before extending to the desired result. */
3728 if (SCALAR_INT_MODE_P (mode)(((enum mode_class) mode_class[mode]) == MODE_INT || ((enum mode_class
) mode_class[mode]) == MODE_PARTIAL_INT)
3729 && SCALAR_FLOAT_MODE_P (old_mode)(((enum mode_class) mode_class[old_mode]) == MODE_FLOAT || ((
enum mode_class) mode_class[old_mode]) == MODE_DECIMAL_FLOAT)
3730 && known_gt (GET_MODE_SIZE (mode), GET_MODE_SIZE (old_mode))(!maybe_le (GET_MODE_SIZE (mode), GET_MODE_SIZE (old_mode))))
3731 val = convert_float_to_wider_int (mode, old_mode, val);
3732 else
3733 val = convert_modes (mode, old_mode, val, unsignedp);
3734 }
3735
3736 if (GET_CODE (return_reg)((enum rtx_code) (return_reg)->code) == PARALLEL)
3737 emit_group_load (return_reg, val, type, int_size_in_bytes (type));
3738 else
3739 emit_move_insn (return_reg, val);
3740 }
3741
3742 expand_null_return_1 ();
3743}
3744
3745/* Generate RTL to evaluate the expression RETVAL and return it
3746 from the current function. */
3747
3748static void
3749expand_return (tree retval)
3750{
3751 rtx result_rtl;
3752 rtx val = 0;
3753 tree retval_rhs;
3754
3755 /* If function wants no value, give it none. */
3756 if (TREE_CODE (TREE_TYPE (TREE_TYPE (current_function_decl)))((enum tree_code) (((contains_struct_check ((((contains_struct_check
((current_function_decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3756, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3756, __FUNCTION__))->typed.type))->base.code)
== VOID_TYPE)
3757 {
3758 expand_normal (retval);
3759 expand_null_return ();
3760 return;
3761 }
3762
3763 if (retval == error_mark_nodeglobal_trees[TI_ERROR_MARK])
3764 {
3765 /* Treat this like a return of no value from a function that
3766 returns a value. */
3767 expand_null_return ();
3768 return;
3769 }
3770 else if ((TREE_CODE (retval)((enum tree_code) (retval)->base.code) == MODIFY_EXPR
3771 || TREE_CODE (retval)((enum tree_code) (retval)->base.code) == INIT_EXPR)
3772 && TREE_CODE (TREE_OPERAND (retval, 0))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
((retval), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3772, __FUNCTION__))))))->base.code)
== RESULT_DECL)
3773 retval_rhs = TREE_OPERAND (retval, 1)(*((const_cast<tree*> (tree_operand_check ((retval), (1
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3773, __FUNCTION__)))))
;
3774 else
3775 retval_rhs = retval;
3776
3777 result_rtl = DECL_RTL (DECL_RESULT (current_function_decl))((contains_struct_check ((((tree_check ((current_function_decl
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3777, __FUNCTION__, (FUNCTION_DECL)))->decl_non_common.result
)), (TS_DECL_WRTL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3777, __FUNCTION__))->decl_with_rtl.rtl ? (((tree_check (
(current_function_decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3777, __FUNCTION__, (FUNCTION_DECL)))->decl_non_common.result
))->decl_with_rtl.rtl : (make_decl_rtl (((tree_check ((current_function_decl
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3777, __FUNCTION__, (FUNCTION_DECL)))->decl_non_common.result
)), (((tree_check ((current_function_decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3777, __FUNCTION__, (FUNCTION_DECL)))->decl_non_common.result
))->decl_with_rtl.rtl))
;
3778
3779 /* If we are returning the RESULT_DECL, then the value has already
3780 been stored into it, so we don't have to do anything special. */
3781 if (TREE_CODE (retval_rhs)((enum tree_code) (retval_rhs)->base.code) == RESULT_DECL)
3782 expand_value_return (result_rtl);
3783
3784 /* If the result is an aggregate that is being returned in one (or more)
3785 registers, load the registers here. */
3786
3787 else if (retval_rhs != 0
3788 && TYPE_MODE (TREE_TYPE (retval_rhs))((((enum tree_code) ((tree_class_check ((((contains_struct_check
((retval_rhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3788, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3788, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(((contains_struct_check ((retval_rhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3788, __FUNCTION__))->typed.type)) : (((contains_struct_check
((retval_rhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3788, __FUNCTION__))->typed.type))->type_common.mode)
== BLKmode((void) 0, E_BLKmode)
3789 && REG_P (result_rtl)(((enum rtx_code) (result_rtl)->code) == REG))
3790 {
3791 val = copy_blkmode_to_reg (GET_MODE (result_rtl)((machine_mode) (result_rtl)->mode), retval_rhs);
3792 if (val)
3793 {
3794 /* Use the mode of the result value on the return register. */
3795 PUT_MODE (result_rtl, GET_MODE (val)((machine_mode) (val)->mode));
3796 expand_value_return (val);
3797 }
3798 else
3799 expand_null_return ();
3800 }
3801 else if (retval_rhs != 0
3802 && !VOID_TYPE_P (TREE_TYPE (retval_rhs))(((enum tree_code) (((contains_struct_check ((retval_rhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3802, __FUNCTION__))->typed.type))->base.code) == VOID_TYPE
)
3803 && (REG_P (result_rtl)(((enum rtx_code) (result_rtl)->code) == REG)
3804 || (GET_CODE (result_rtl)((enum rtx_code) (result_rtl)->code) == PARALLEL)))
3805 {
3806 /* Compute the return value into a temporary (usually a pseudo reg). */
3807 val
3808 = assign_temp (TREE_TYPE (DECL_RESULT (current_function_decl))((contains_struct_check ((((tree_check ((current_function_decl
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3808, __FUNCTION__, (FUNCTION_DECL)))->decl_non_common.result
)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3808, __FUNCTION__))->typed.type)
, 0, 1);
3809 val = expand_expr (retval_rhs, val, GET_MODE (val)((machine_mode) (val)->mode), EXPAND_NORMAL);
3810 val = force_not_mem (val);
3811 expand_value_return (val);
3812 }
3813 else
3814 {
3815 /* No hard reg used; calculate value into hard return reg. */
3816 expand_expr (retval, const0_rtx(const_int_rtx[64]), VOIDmode((void) 0, E_VOIDmode), EXPAND_NORMAL);
3817 expand_value_return (result_rtl);
3818 }
3819}
3820
3821/* Expand a clobber of LHS. If LHS is stored it in a multi-part
3822 register, tell the rtl optimizers that its value is no longer
3823 needed. */
3824
3825static void
3826expand_clobber (tree lhs)
3827{
3828 if (DECL_P (lhs)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (lhs)->base.code))] == tcc_declaration)
)
3829 {
3830 rtx decl_rtl = DECL_RTL_IF_SET (lhs)((((tree_contains_struct[(((enum tree_code) (lhs)->base.code
))][(TS_DECL_WRTL)])) && (contains_struct_check ((lhs
), (TS_DECL_WRTL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3830, __FUNCTION__))->decl_with_rtl.rtl != nullptr) ? ((
contains_struct_check ((lhs), (TS_DECL_WRTL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3830, __FUNCTION__))->decl_with_rtl.rtl ? (lhs)->decl_with_rtl
.rtl : (make_decl_rtl (lhs), (lhs)->decl_with_rtl.rtl)) : nullptr
)
;
3831 if (decl_rtl && REG_P (decl_rtl)(((enum rtx_code) (decl_rtl)->code) == REG))
3832 {
3833 machine_mode decl_mode = GET_MODE (decl_rtl)((machine_mode) (decl_rtl)->mode);
3834 if (maybe_gt (GET_MODE_SIZE (decl_mode),maybe_lt (ix86_regmode_natural_size (decl_mode), GET_MODE_SIZE
(decl_mode))
3835 REGMODE_NATURAL_SIZE (decl_mode))maybe_lt (ix86_regmode_natural_size (decl_mode), GET_MODE_SIZE
(decl_mode))
)
3836 emit_clobber (decl_rtl);
3837 }
3838 }
3839}
3840
3841/* A subroutine of expand_gimple_stmt, expanding one gimple statement
3842 STMT that doesn't require special handling for outgoing edges. That
3843 is no tailcalls and no GIMPLE_COND. */
3844
3845static void
3846expand_gimple_stmt_1 (gimple *stmt)
3847{
3848 tree op0;
3849
3850 set_curr_insn_location (gimple_location (stmt));
3851
3852 switch (gimple_code (stmt))
3853 {
3854 case GIMPLE_GOTO:
3855 op0 = gimple_goto_dest (stmt);
3856 if (TREE_CODE (op0)((enum tree_code) (op0)->base.code) == LABEL_DECL)
3857 expand_goto (op0);
3858 else
3859 expand_computed_goto (op0);
3860 break;
3861 case GIMPLE_LABEL:
3862 expand_label (gimple_label_label (as_a <glabel *> (stmt)));
3863 break;
3864 case GIMPLE_NOP:
3865 case GIMPLE_PREDICT:
3866 break;
3867 case GIMPLE_SWITCH:
3868 {
3869 gswitch *swtch = as_a <gswitch *> (stmt);
3870 if (gimple_switch_num_labels (swtch) == 1)
3871 expand_goto (CASE_LABEL (gimple_switch_default_label (swtch))(*((const_cast<tree*> (tree_operand_check (((tree_check
((gimple_switch_default_label (swtch)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3871, __FUNCTION__, (CASE_LABEL_EXPR)))), (2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3871, __FUNCTION__)))))
);
3872 else
3873 expand_case (swtch);
3874 }
3875 break;
3876 case GIMPLE_ASM:
3877 expand_asm_stmt (as_a <gasm *> (stmt));
3878 break;
3879 case GIMPLE_CALL:
3880 expand_call_stmt (as_a <gcall *> (stmt));
3881 break;
3882
3883 case GIMPLE_RETURN:
3884 {
3885 op0 = gimple_return_retval (as_a <greturn *> (stmt));
3886
3887 /* If a return doesn't have a location, it very likely represents
3888 multiple user returns so we cannot let it inherit the location
3889 of the last statement of the previous basic block in RTL. */
3890 if (!gimple_has_location (stmt))
3891 set_curr_insn_location (cfun(cfun + 0)->function_end_locus);
3892
3893 if (op0 && op0 != error_mark_nodeglobal_trees[TI_ERROR_MARK])
3894 {
3895 tree result = DECL_RESULT (current_function_decl)((tree_check ((current_function_decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3895, __FUNCTION__, (FUNCTION_DECL)))->decl_non_common.result
)
;
3896
3897 /* If we are not returning the current function's RESULT_DECL,
3898 build an assignment to it. */
3899 if (op0 != result)
3900 {
3901 /* I believe that a function's RESULT_DECL is unique. */
3902 gcc_assert (TREE_CODE (op0) != RESULT_DECL)((void)(!(((enum tree_code) (op0)->base.code) != RESULT_DECL
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3902, __FUNCTION__), 0 : 0))
;
3903
3904 /* ??? We'd like to use simply expand_assignment here,
3905 but this fails if the value is of BLKmode but the return
3906 decl is a register. expand_return has special handling
3907 for this combination, which eventually should move
3908 to common code. See comments there. Until then, let's
3909 build a modify expression :-/ */
3910 op0 = build2 (MODIFY_EXPR, TREE_TYPE (result)((contains_struct_check ((result), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3910, __FUNCTION__))->typed.type)
,
3911 result, op0);
3912 }
3913 }
3914
3915 if (!op0)
3916 expand_null_return ();
3917 else
3918 expand_return (op0);
3919 }
3920 break;
3921
3922 case GIMPLE_ASSIGN:
3923 {
3924 gassign *assign_stmt = as_a <gassign *> (stmt);
3925 tree lhs = gimple_assign_lhs (assign_stmt);
3926
3927 /* Tree expand used to fiddle with |= and &= of two bitfield
3928 COMPONENT_REFs here. This can't happen with gimple, the LHS
3929 of binary assigns must be a gimple reg. */
3930
3931 if (TREE_CODE (lhs)((enum tree_code) (lhs)->base.code) != SSA_NAME
3932 || gimple_assign_rhs_class (assign_stmt) == GIMPLE_SINGLE_RHS)
3933 {
3934 tree rhs = gimple_assign_rhs1 (assign_stmt);
3935 gcc_assert (gimple_assign_rhs_class (assign_stmt)((void)(!(gimple_assign_rhs_class (assign_stmt) == GIMPLE_SINGLE_RHS
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3936, __FUNCTION__), 0 : 0))
3936 == GIMPLE_SINGLE_RHS)((void)(!(gimple_assign_rhs_class (assign_stmt) == GIMPLE_SINGLE_RHS
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3936, __FUNCTION__), 0 : 0))
;
3937 if (gimple_has_location (stmt) && CAN_HAVE_LOCATION_P (rhs)((rhs) && ((tree_code_type_tmpl <0>::tree_code_type
[(int) (((enum tree_code) (rhs)->base.code))]) >= tcc_reference
&& (tree_code_type_tmpl <0>::tree_code_type[(int
) (((enum tree_code) (rhs)->base.code))]) <= tcc_expression
))
3938 /* Do not put locations on possibly shared trees. */
3939 && !is_gimple_min_invariant (rhs))
3940 SET_EXPR_LOCATION (rhs, gimple_location (stmt))(expr_check (((rhs)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3940, __FUNCTION__))->exp.locus = (gimple_location (stmt
))
;
3941 if (TREE_CLOBBER_P (rhs)(((enum tree_code) (rhs)->base.code) == CONSTRUCTOR &&
((rhs)->base.volatile_flag))
)
3942 /* This is a clobber to mark the going out of scope for
3943 this LHS. */
3944 expand_clobber (lhs);
3945 else
3946 expand_assignment (lhs, rhs,
3947 gimple_assign_nontemporal_move_p (
3948 assign_stmt));
3949 }
3950 else
3951 {
3952 rtx target, temp;
3953 bool nontemporal = gimple_assign_nontemporal_move_p (assign_stmt);
3954 struct separate_ops ops;
3955 bool promoted = false;
3956
3957 target = expand_expr (lhs, NULL_RTX(rtx) 0, VOIDmode((void) 0, E_VOIDmode), EXPAND_WRITE);
3958 if (GET_CODE (target)((enum rtx_code) (target)->code) == SUBREG && SUBREG_PROMOTED_VAR_P (target)(__extension__ ({ __typeof ((target)) const _rtx = ((target))
; if (((enum rtx_code) (_rtx)->code) != SUBREG) rtl_check_failed_flag
("SUBREG_PROMOTED", _rtx, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3958, __FUNCTION__); _rtx; })->in_struct)
)
3959 promoted = true;
3960
3961 ops.code = gimple_assign_rhs_code (assign_stmt);
3962 ops.type = TREE_TYPE (lhs)((contains_struct_check ((lhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3962, __FUNCTION__))->typed.type)
;
3963 switch (get_gimple_rhs_class (ops.code))
3964 {
3965 case GIMPLE_TERNARY_RHS:
3966 ops.op2 = gimple_assign_rhs3 (assign_stmt);
3967 /* Fallthru */
3968 case GIMPLE_BINARY_RHS:
3969 ops.op1 = gimple_assign_rhs2 (assign_stmt);
3970 /* Fallthru */
3971 case GIMPLE_UNARY_RHS:
3972 ops.op0 = gimple_assign_rhs1 (assign_stmt);
3973 break;
3974 default:
3975 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3975, __FUNCTION__))
;
3976 }
3977 ops.location = gimple_location (stmt);
3978
3979 /* If we want to use a nontemporal store, force the value to
3980 register first. If we store into a promoted register,
3981 don't directly expand to target. */
3982 temp = nontemporal || promoted ? NULL_RTX(rtx) 0 : target;
3983 temp = expand_expr_real_2 (&ops, temp, GET_MODE (target)((machine_mode) (target)->mode),
3984 EXPAND_NORMAL);
3985
3986 if (temp == target)
3987 ;
3988 else if (promoted)
3989 {
3990 int unsignedp = SUBREG_PROMOTED_SIGN (target)((__extension__ ({ __typeof ((target)) const _rtx = ((target)
); if (((enum rtx_code) (_rtx)->code) != SUBREG) rtl_check_failed_flag
("SUBREG_PROMOTED_SIGN", _rtx, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3990, __FUNCTION__); _rtx; })->volatil) ? 1 : (target)->
unchanging - 1)
;
3991 /* If TEMP is a VOIDmode constant, use convert_modes to make
3992 sure that we properly convert it. */
3993 if (CONSTANT_P (temp)((rtx_class[(int) (((enum rtx_code) (temp)->code))]) == RTX_CONST_OBJ
)
&& GET_MODE (temp)((machine_mode) (temp)->mode) == VOIDmode((void) 0, E_VOIDmode))
3994 {
3995 temp = convert_modes (GET_MODE (target)((machine_mode) (target)->mode),
3996 TYPE_MODE (ops.type)((((enum tree_code) ((tree_class_check ((ops.type), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 3996, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(ops.type) : (ops.type)->type_common.mode)
,
3997 temp, unsignedp);
3998 temp = convert_modes (GET_MODE (SUBREG_REG (target))((machine_mode) ((((target)->u.fld[0]).rt_rtx))->mode),
3999 GET_MODE (target)((machine_mode) (target)->mode), temp, unsignedp);
4000 }
4001
4002 convert_move (SUBREG_REG (target)(((target)->u.fld[0]).rt_rtx), temp, unsignedp);
4003 }
4004 else if (nontemporal && emit_storent_insn (target, temp))
4005 ;
4006 else
4007 {
4008 temp = force_operand (temp, target);
4009 if (temp != target)
4010 emit_move_insn (target, temp);
4011 }
4012 }
4013 }
4014 break;
4015
4016 default:
4017 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4017, __FUNCTION__))
;
4018 }
4019}
4020
4021/* Expand one gimple statement STMT and return the last RTL instruction
4022 before any of the newly generated ones.
4023
4024 In addition to generating the necessary RTL instructions this also
4025 sets REG_EH_REGION notes if necessary and sets the current source
4026 location for diagnostics. */
4027
4028static rtx_insn *
4029expand_gimple_stmt (gimple *stmt)
4030{
4031 location_t saved_location = input_location;
4032 rtx_insn *last = get_last_insn ();
4033 int lp_nr;
4034
4035 gcc_assert (cfun)((void)(!((cfun + 0)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4035, __FUNCTION__), 0 : 0))
;
4036
4037 /* We need to save and restore the current source location so that errors
4038 discovered during expansion are emitted with the right location. But
4039 it would be better if the diagnostic routines used the source location
4040 embedded in the tree nodes rather than globals. */
4041 if (gimple_has_location (stmt))
4042 input_location = gimple_location (stmt);
4043
4044 expand_gimple_stmt_1 (stmt);
4045
4046 /* Free any temporaries used to evaluate this statement. */
4047 free_temp_slots ();
4048
4049 input_location = saved_location;
4050
4051 /* Mark all insns that may trap. */
4052 lp_nr = lookup_stmt_eh_lp (stmt);
4053 if (lp_nr)
4054 {
4055 rtx_insn *insn;
4056 for (insn = next_real_insn (last); insn;
4057 insn = next_real_insn (insn))
4058 {
4059 if (! find_reg_note (insn, REG_EH_REGION, NULL_RTX(rtx) 0)
4060 /* If we want exceptions for non-call insns, any
4061 may_trap_p instruction may throw. */
4062 && GET_CODE (PATTERN (insn))((enum rtx_code) (PATTERN (insn))->code) != CLOBBER
4063 && GET_CODE (PATTERN (insn))((enum rtx_code) (PATTERN (insn))->code) != USE
4064 && insn_could_throw_p (insn))
4065 make_reg_eh_region_note (insn, 0, lp_nr);
4066 }
4067 }
4068
4069 return last;
4070}
4071
4072/* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_CALL
4073 that has CALL_EXPR_TAILCALL set. Returns non-null if we actually
4074 generated a tail call (something that might be denied by the ABI
4075 rules governing the call; see calls.cc).
4076
4077 Sets CAN_FALLTHRU if we generated a *conditional* tail call, and
4078 can still reach the rest of BB. The case here is __builtin_sqrt,
4079 where the NaN result goes through the external function (with a
4080 tailcall) and the normal result happens via a sqrt instruction. */
4081
4082static basic_block
4083expand_gimple_tailcall (basic_block bb, gcall *stmt, bool *can_fallthru)
4084{
4085 rtx_insn *last2, *last;
4086 edge e;
4087 edge_iterator ei;
4088 profile_probability probability;
4089
4090 last2 = last = expand_gimple_stmt (stmt);
4091
4092 for (last = NEXT_INSN (last); last; last = NEXT_INSN (last))
4093 if (CALL_P (last)(((enum rtx_code) (last)->code) == CALL_INSN) && SIBLING_CALL_P (last)(__extension__ ({ __typeof ((last)) const _rtx = ((last)); if
(((enum rtx_code) (_rtx)->code) != CALL_INSN) rtl_check_failed_flag
("SIBLING_CALL_P", _rtx, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4093, __FUNCTION__); _rtx; })->jump)
)
4094 goto found;
4095
4096 maybe_dump_rtl_for_gimple_stmt (stmt, last2);
4097
4098 *can_fallthru = true;
4099 return NULLnullptr;
4100
4101 found:
4102 /* ??? Wouldn't it be better to just reset any pending stack adjust?
4103 Any instructions emitted here are about to be deleted. */
4104 do_pending_stack_adjust ();
4105
4106 /* Remove any non-eh, non-abnormal edges that don't go to exit. */
4107 /* ??? I.e. the fallthrough edge. HOWEVER! If there were to be
4108 EH or abnormal edges, we shouldn't have created a tail call in
4109 the first place. So it seems to me we should just be removing
4110 all edges here, or redirecting the existing fallthru edge to
4111 the exit block. */
4112
4113 probability = profile_probability::never ();
4114
4115 for (ei = ei_start (bb->succs)ei_start_1 (&(bb->succs)); (e = ei_safe_edge (ei)); )
4116 {
4117 if (!(e->flags & (EDGE_ABNORMAL | EDGE_EH)))
4118 {
4119 if (e->dest != EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr))
4120 e->dest->count -= e->count ();
4121 probability += e->probability;
4122 remove_edge (e);
4123 }
4124 else
4125 ei_next (&ei);
4126 }
4127
4128 /* This is somewhat ugly: the call_expr expander often emits instructions
4129 after the sibcall (to perform the function return). These confuse the
4130 find_many_sub_basic_blocks code, so we need to get rid of these. */
4131 last = NEXT_INSN (last);
4132 gcc_assert (BARRIER_P (last))((void)(!((((enum rtx_code) (last)->code) == BARRIER)) ? fancy_abort
("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4132, __FUNCTION__), 0 : 0))
;
4133
4134 *can_fallthru = false;
4135 while (NEXT_INSN (last))
4136 {
4137 /* For instance an sqrt builtin expander expands if with
4138 sibcall in the then and label for `else`. */
4139 if (LABEL_P (NEXT_INSN (last))(((enum rtx_code) (NEXT_INSN (last))->code) == CODE_LABEL))
4140 {
4141 *can_fallthru = true;
4142 break;
4143 }
4144 delete_insn (NEXT_INSN (last));
4145 }
4146
4147 e = make_edge (bb, EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr), EDGE_ABNORMAL
4148 | EDGE_SIBCALL);
4149 e->probability = probability;
4150 BB_END (bb)(bb)->il.x.rtl->end_ = last;
4151 update_bb_for_insn (bb);
4152
4153 if (NEXT_INSN (last))
4154 {
4155 bb = create_basic_block (NEXT_INSN (last), get_last_insn (), bb);
4156
4157 last = BB_END (bb)(bb)->il.x.rtl->end_;
4158 if (BARRIER_P (last)(((enum rtx_code) (last)->code) == BARRIER))
4159 BB_END (bb)(bb)->il.x.rtl->end_ = PREV_INSN (last);
4160 }
4161
4162 maybe_dump_rtl_for_gimple_stmt (stmt, last2);
4163
4164 return bb;
4165}
4166
4167/* Return the difference between the floor and the truncated result of
4168 a signed division by OP1 with remainder MOD. */
4169static rtx
4170floor_sdiv_adjust (machine_mode mode, rtx mod, rtx op1)
4171{
4172 /* (mod != 0 ? (op1 / mod < 0 ? -1 : 0) : 0) */
4173 return gen_rtx_IF_THEN_ELSEgen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat
((NE), (((scalar_int_mode ((scalar_int_mode::from_int) E_BImode
)))), ((mod)), (((const_int_rtx[64]))) ))), ((gen_rtx_fmt_eee_stat
((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat ((LT), (((scalar_int_mode
((scalar_int_mode::from_int) E_BImode)))), ((gen_rtx_fmt_ee_stat
((DIV), ((mode)), ((op1)), ((mod)) ))), (((const_int_rtx[64]
))) ))), (((const_int_rtx[64 -1]))), (((const_int_rtx[64]))) )
)), (((const_int_rtx[64]))) )
4174 (mode, gen_rtx_NE (BImode, mod, const0_rtx),gen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat
((NE), (((scalar_int_mode ((scalar_int_mode::from_int) E_BImode
)))), ((mod)), (((const_int_rtx[64]))) ))), ((gen_rtx_fmt_eee_stat
((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat ((LT), (((scalar_int_mode
((scalar_int_mode::from_int) E_BImode)))), ((gen_rtx_fmt_ee_stat
((DIV), ((mode)), ((op1)), ((mod)) ))), (((const_int_rtx[64]
))) ))), (((const_int_rtx[64 -1]))), (((const_int_rtx[64]))) )
)), (((const_int_rtx[64]))) )
4175 gen_rtx_IF_THEN_ELSEgen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat
((NE), (((scalar_int_mode ((scalar_int_mode::from_int) E_BImode
)))), ((mod)), (((const_int_rtx[64]))) ))), ((gen_rtx_fmt_eee_stat
((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat ((LT), (((scalar_int_mode
((scalar_int_mode::from_int) E_BImode)))), ((gen_rtx_fmt_ee_stat
((DIV), ((mode)), ((op1)), ((mod)) ))), (((const_int_rtx[64]
))) ))), (((const_int_rtx[64 -1]))), (((const_int_rtx[64]))) )
)), (((const_int_rtx[64]))) )
4176 (mode, gen_rtx_LT (BImode,gen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat
((NE), (((scalar_int_mode ((scalar_int_mode::from_int) E_BImode
)))), ((mod)), (((const_int_rtx[64]))) ))), ((gen_rtx_fmt_eee_stat
((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat ((LT), (((scalar_int_mode
((scalar_int_mode::from_int) E_BImode)))), ((gen_rtx_fmt_ee_stat
((DIV), ((mode)), ((op1)), ((mod)) ))), (((const_int_rtx[64]
))) ))), (((const_int_rtx[64 -1]))), (((const_int_rtx[64]))) )
)), (((const_int_rtx[64]))) )
4177 gen_rtx_DIV (mode, op1, mod),gen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat
((NE), (((scalar_int_mode ((scalar_int_mode::from_int) E_BImode
)))), ((mod)), (((const_int_rtx[64]))) ))), ((gen_rtx_fmt_eee_stat
((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat ((LT), (((scalar_int_mode
((scalar_int_mode::from_int) E_BImode)))), ((gen_rtx_fmt_ee_stat
((DIV), ((mode)), ((op1)), ((mod)) ))), (((const_int_rtx[64]
))) ))), (((const_int_rtx[64 -1]))), (((const_int_rtx[64]))) )
)), (((const_int_rtx[64]))) )
4178 const0_rtx),gen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat
((NE), (((scalar_int_mode ((scalar_int_mode::from_int) E_BImode
)))), ((mod)), (((const_int_rtx[64]))) ))), ((gen_rtx_fmt_eee_stat
((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat ((LT), (((scalar_int_mode
((scalar_int_mode::from_int) E_BImode)))), ((gen_rtx_fmt_ee_stat
((DIV), ((mode)), ((op1)), ((mod)) ))), (((const_int_rtx[64]
))) ))), (((const_int_rtx[64 -1]))), (((const_int_rtx[64]))) )
)), (((const_int_rtx[64]))) )
4179 constm1_rtx, const0_rtx),gen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat
((NE), (((scalar_int_mode ((scalar_int_mode::from_int) E_BImode
)))), ((mod)), (((const_int_rtx[64]))) ))), ((gen_rtx_fmt_eee_stat
((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat ((LT), (((scalar_int_mode
((scalar_int_mode::from_int) E_BImode)))), ((gen_rtx_fmt_ee_stat
((DIV), ((mode)), ((op1)), ((mod)) ))), (((const_int_rtx[64]
))) ))), (((const_int_rtx[64 -1]))), (((const_int_rtx[64]))) )
)), (((const_int_rtx[64]))) )
4180 const0_rtx)gen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat
((NE), (((scalar_int_mode ((scalar_int_mode::from_int) E_BImode
)))), ((mod)), (((const_int_rtx[64]))) ))), ((gen_rtx_fmt_eee_stat
((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat ((LT), (((scalar_int_mode
((scalar_int_mode::from_int) E_BImode)))), ((gen_rtx_fmt_ee_stat
((DIV), ((mode)), ((op1)), ((mod)) ))), (((const_int_rtx[64]
))) ))), (((const_int_rtx[64 -1]))), (((const_int_rtx[64]))) )
)), (((const_int_rtx[64]))) )
;
4181}
4182
4183/* Return the difference between the ceil and the truncated result of
4184 a signed division by OP1 with remainder MOD. */
4185static rtx
4186ceil_sdiv_adjust (machine_mode mode, rtx mod, rtx op1)
4187{
4188 /* (mod != 0 ? (op1 / mod > 0 ? 1 : 0) : 0) */
4189 return gen_rtx_IF_THEN_ELSEgen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat
((NE), (((scalar_int_mode ((scalar_int_mode::from_int) E_BImode
)))), ((mod)), (((const_int_rtx[64]))) ))), ((gen_rtx_fmt_eee_stat
((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat ((GT), (((scalar_int_mode
((scalar_int_mode::from_int) E_BImode)))), ((gen_rtx_fmt_ee_stat
((DIV), ((mode)), ((op1)), ((mod)) ))), (((const_int_rtx[64]
))) ))), (((const_int_rtx[64 +1]))), (((const_int_rtx[64]))) )
)), (((const_int_rtx[64]))) )
4190 (mode, gen_rtx_NE (BImode, mod, const0_rtx),gen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat
((NE), (((scalar_int_mode ((scalar_int_mode::from_int) E_BImode
)))), ((mod)), (((const_int_rtx[64]))) ))), ((gen_rtx_fmt_eee_stat
((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat ((GT), (((scalar_int_mode
((scalar_int_mode::from_int) E_BImode)))), ((gen_rtx_fmt_ee_stat
((DIV), ((mode)), ((op1)), ((mod)) ))), (((const_int_rtx[64]
))) ))), (((const_int_rtx[64 +1]))), (((const_int_rtx[64]))) )
)), (((const_int_rtx[64]))) )
4191 gen_rtx_IF_THEN_ELSEgen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat
((NE), (((scalar_int_mode ((scalar_int_mode::from_int) E_BImode
)))), ((mod)), (((const_int_rtx[64]))) ))), ((gen_rtx_fmt_eee_stat
((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat ((GT), (((scalar_int_mode
((scalar_int_mode::from_int) E_BImode)))), ((gen_rtx_fmt_ee_stat
((DIV), ((mode)), ((op1)), ((mod)) ))), (((const_int_rtx[64]
))) ))), (((const_int_rtx[64 +1]))), (((const_int_rtx[64]))) )
)), (((const_int_rtx[64]))) )
4192 (mode, gen_rtx_GT (BImode,gen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat
((NE), (((scalar_int_mode ((scalar_int_mode::from_int) E_BImode
)))), ((mod)), (((const_int_rtx[64]))) ))), ((gen_rtx_fmt_eee_stat
((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat ((GT), (((scalar_int_mode
((scalar_int_mode::from_int) E_BImode)))), ((gen_rtx_fmt_ee_stat
((DIV), ((mode)), ((op1)), ((mod)) ))), (((const_int_rtx[64]
))) ))), (((const_int_rtx[64 +1]))), (((const_int_rtx[64]))) )
)), (((const_int_rtx[64]))) )
4193 gen_rtx_DIV (mode, op1, mod),gen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat
((NE), (((scalar_int_mode ((scalar_int_mode::from_int) E_BImode
)))), ((mod)), (((const_int_rtx[64]))) ))), ((gen_rtx_fmt_eee_stat
((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat ((GT), (((scalar_int_mode
((scalar_int_mode::from_int) E_BImode)))), ((gen_rtx_fmt_ee_stat
((DIV), ((mode)), ((op1)), ((mod)) ))), (((const_int_rtx[64]
))) ))), (((const_int_rtx[64 +1]))), (((const_int_rtx[64]))) )
)), (((const_int_rtx[64]))) )
4194 const0_rtx),gen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat
((NE), (((scalar_int_mode ((scalar_int_mode::from_int) E_BImode
)))), ((mod)), (((const_int_rtx[64]))) ))), ((gen_rtx_fmt_eee_stat
((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat ((GT), (((scalar_int_mode
((scalar_int_mode::from_int) E_BImode)))), ((gen_rtx_fmt_ee_stat
((DIV), ((mode)), ((op1)), ((mod)) ))), (((const_int_rtx[64]
))) ))), (((const_int_rtx[64 +1]))), (((const_int_rtx[64]))) )
)), (((const_int_rtx[64]))) )
4195 const1_rtx, const0_rtx),gen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat
((NE), (((scalar_int_mode ((scalar_int_mode::from_int) E_BImode
)))), ((mod)), (((const_int_rtx[64]))) ))), ((gen_rtx_fmt_eee_stat
((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat ((GT), (((scalar_int_mode
((scalar_int_mode::from_int) E_BImode)))), ((gen_rtx_fmt_ee_stat
((DIV), ((mode)), ((op1)), ((mod)) ))), (((const_int_rtx[64]
))) ))), (((const_int_rtx[64 +1]))), (((const_int_rtx[64]))) )
)), (((const_int_rtx[64]))) )
4196 const0_rtx)gen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat
((NE), (((scalar_int_mode ((scalar_int_mode::from_int) E_BImode
)))), ((mod)), (((const_int_rtx[64]))) ))), ((gen_rtx_fmt_eee_stat
((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat ((GT), (((scalar_int_mode
((scalar_int_mode::from_int) E_BImode)))), ((gen_rtx_fmt_ee_stat
((DIV), ((mode)), ((op1)), ((mod)) ))), (((const_int_rtx[64]
))) ))), (((const_int_rtx[64 +1]))), (((const_int_rtx[64]))) )
)), (((const_int_rtx[64]))) )
;
4197}
4198
4199/* Return the difference between the ceil and the truncated result of
4200 an unsigned division by OP1 with remainder MOD. */
4201static rtx
4202ceil_udiv_adjust (machine_mode mode, rtx mod, rtx op1 ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
4203{
4204 /* (mod != 0 ? 1 : 0) */
4205 return gen_rtx_IF_THEN_ELSEgen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat
((NE), (((scalar_int_mode ((scalar_int_mode::from_int) E_BImode
)))), ((mod)), (((const_int_rtx[64]))) ))), (((const_int_rtx[
64 +1]))), (((const_int_rtx[64]))) )
4206 (mode, gen_rtx_NE (BImode, mod, const0_rtx),gen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat
((NE), (((scalar_int_mode ((scalar_int_mode::from_int) E_BImode
)))), ((mod)), (((const_int_rtx[64]))) ))), (((const_int_rtx[
64 +1]))), (((const_int_rtx[64]))) )
4207 const1_rtx, const0_rtx)gen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat
((NE), (((scalar_int_mode ((scalar_int_mode::from_int) E_BImode
)))), ((mod)), (((const_int_rtx[64]))) ))), (((const_int_rtx[
64 +1]))), (((const_int_rtx[64]))) )
;
4208}
4209
4210/* Return the difference between the rounded and the truncated result
4211 of a signed division by OP1 with remainder MOD. Halfway cases are
4212 rounded away from zero, rather than to the nearest even number. */
4213static rtx
4214round_sdiv_adjust (machine_mode mode, rtx mod, rtx op1)
4215{
4216 /* (abs (mod) >= abs (op1) - abs (mod)
4217 ? (op1 / mod > 0 ? 1 : -1)
4218 : 0) */
4219 return gen_rtx_IF_THEN_ELSEgen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat
((GE), (((scalar_int_mode ((scalar_int_mode::from_int) E_BImode
)))), ((gen_rtx_fmt_e_stat ((ABS), ((mode)), ((mod)) ))), ((gen_rtx_fmt_ee_stat
((MINUS), ((mode)), ((gen_rtx_fmt_e_stat ((ABS), ((mode)), (
(op1)) ))), ((gen_rtx_fmt_e_stat ((ABS), ((mode)), ((mod)) ))
) ))) ))), ((gen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), (
(gen_rtx_fmt_ee_stat ((GT), (((scalar_int_mode ((scalar_int_mode
::from_int) E_BImode)))), ((gen_rtx_fmt_ee_stat ((DIV), ((mode
)), ((op1)), ((mod)) ))), (((const_int_rtx[64]))) ))), (((const_int_rtx
[64 +1]))), (((const_int_rtx[64 -1]))) ))), (((const_int_rtx[
64]))) )
4220 (mode, gen_rtx_GE (BImode, gen_rtx_ABS (mode, mod),gen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat
((GE), (((scalar_int_mode ((scalar_int_mode::from_int) E_BImode
)))), ((gen_rtx_fmt_e_stat ((ABS), ((mode)), ((mod)) ))), ((gen_rtx_fmt_ee_stat
((MINUS), ((mode)), ((gen_rtx_fmt_e_stat ((ABS), ((mode)), (
(op1)) ))), ((gen_rtx_fmt_e_stat ((ABS), ((mode)), ((mod)) ))
) ))) ))), ((gen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), (
(gen_rtx_fmt_ee_stat ((GT), (((scalar_int_mode ((scalar_int_mode
::from_int) E_BImode)))), ((gen_rtx_fmt_ee_stat ((DIV), ((mode
)), ((op1)), ((mod)) ))), (((const_int_rtx[64]))) ))), (((const_int_rtx
[64 +1]))), (((const_int_rtx[64 -1]))) ))), (((const_int_rtx[
64]))) )
4221 gen_rtx_MINUS (mode,gen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat
((GE), (((scalar_int_mode ((scalar_int_mode::from_int) E_BImode
)))), ((gen_rtx_fmt_e_stat ((ABS), ((mode)), ((mod)) ))), ((gen_rtx_fmt_ee_stat
((MINUS), ((mode)), ((gen_rtx_fmt_e_stat ((ABS), ((mode)), (
(op1)) ))), ((gen_rtx_fmt_e_stat ((ABS), ((mode)), ((mod)) ))
) ))) ))), ((gen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), (
(gen_rtx_fmt_ee_stat ((GT), (((scalar_int_mode ((scalar_int_mode
::from_int) E_BImode)))), ((gen_rtx_fmt_ee_stat ((DIV), ((mode
)), ((op1)), ((mod)) ))), (((const_int_rtx[64]))) ))), (((const_int_rtx
[64 +1]))), (((const_int_rtx[64 -1]))) ))), (((const_int_rtx[
64]))) )
4222 gen_rtx_ABS (mode, op1),gen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat
((GE), (((scalar_int_mode ((scalar_int_mode::from_int) E_BImode
)))), ((gen_rtx_fmt_e_stat ((ABS), ((mode)), ((mod)) ))), ((gen_rtx_fmt_ee_stat
((MINUS), ((mode)), ((gen_rtx_fmt_e_stat ((ABS), ((mode)), (
(op1)) ))), ((gen_rtx_fmt_e_stat ((ABS), ((mode)), ((mod)) ))
) ))) ))), ((gen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), (
(gen_rtx_fmt_ee_stat ((GT), (((scalar_int_mode ((scalar_int_mode
::from_int) E_BImode)))), ((gen_rtx_fmt_ee_stat ((DIV), ((mode
)), ((op1)), ((mod)) ))), (((const_int_rtx[64]))) ))), (((const_int_rtx
[64 +1]))), (((const_int_rtx[64 -1]))) ))), (((const_int_rtx[
64]))) )
4223 gen_rtx_ABS (mode, mod))),gen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat
((GE), (((scalar_int_mode ((scalar_int_mode::from_int) E_BImode
)))), ((gen_rtx_fmt_e_stat ((ABS), ((mode)), ((mod)) ))), ((gen_rtx_fmt_ee_stat
((MINUS), ((mode)), ((gen_rtx_fmt_e_stat ((ABS), ((mode)), (
(op1)) ))), ((gen_rtx_fmt_e_stat ((ABS), ((mode)), ((mod)) ))
) ))) ))), ((gen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), (
(gen_rtx_fmt_ee_stat ((GT), (((scalar_int_mode ((scalar_int_mode
::from_int) E_BImode)))), ((gen_rtx_fmt_ee_stat ((DIV), ((mode
)), ((op1)), ((mod)) ))), (((const_int_rtx[64]))) ))), (((const_int_rtx
[64 +1]))), (((const_int_rtx[64 -1]))) ))), (((const_int_rtx[
64]))) )
4224 gen_rtx_IF_THEN_ELSEgen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat
((GE), (((scalar_int_mode ((scalar_int_mode::from_int) E_BImode
)))), ((gen_rtx_fmt_e_stat ((ABS), ((mode)), ((mod)) ))), ((gen_rtx_fmt_ee_stat
((MINUS), ((mode)), ((gen_rtx_fmt_e_stat ((ABS), ((mode)), (
(op1)) ))), ((gen_rtx_fmt_e_stat ((ABS), ((mode)), ((mod)) ))
) ))) ))), ((gen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), (
(gen_rtx_fmt_ee_stat ((GT), (((scalar_int_mode ((scalar_int_mode
::from_int) E_BImode)))), ((gen_rtx_fmt_ee_stat ((DIV), ((mode
)), ((op1)), ((mod)) ))), (((const_int_rtx[64]))) ))), (((const_int_rtx
[64 +1]))), (((const_int_rtx[64 -1]))) ))), (((const_int_rtx[
64]))) )
4225 (mode, gen_rtx_GT (BImode,gen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat
((GE), (((scalar_int_mode ((scalar_int_mode::from_int) E_BImode
)))), ((gen_rtx_fmt_e_stat ((ABS), ((mode)), ((mod)) ))), ((gen_rtx_fmt_ee_stat
((MINUS), ((mode)), ((gen_rtx_fmt_e_stat ((ABS), ((mode)), (
(op1)) ))), ((gen_rtx_fmt_e_stat ((ABS), ((mode)), ((mod)) ))
) ))) ))), ((gen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), (
(gen_rtx_fmt_ee_stat ((GT), (((scalar_int_mode ((scalar_int_mode
::from_int) E_BImode)))), ((gen_rtx_fmt_ee_stat ((DIV), ((mode
)), ((op1)), ((mod)) ))), (((const_int_rtx[64]))) ))), (((const_int_rtx
[64 +1]))), (((const_int_rtx[64 -1]))) ))), (((const_int_rtx[
64]))) )
4226 gen_rtx_DIV (mode, op1, mod),gen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat
((GE), (((scalar_int_mode ((scalar_int_mode::from_int) E_BImode
)))), ((gen_rtx_fmt_e_stat ((ABS), ((mode)), ((mod)) ))), ((gen_rtx_fmt_ee_stat
((MINUS), ((mode)), ((gen_rtx_fmt_e_stat ((ABS), ((mode)), (
(op1)) ))), ((gen_rtx_fmt_e_stat ((ABS), ((mode)), ((mod)) ))
) ))) ))), ((gen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), (
(gen_rtx_fmt_ee_stat ((GT), (((scalar_int_mode ((scalar_int_mode
::from_int) E_BImode)))), ((gen_rtx_fmt_ee_stat ((DIV), ((mode
)), ((op1)), ((mod)) ))), (((const_int_rtx[64]))) ))), (((const_int_rtx
[64 +1]))), (((const_int_rtx[64 -1]))) ))), (((const_int_rtx[
64]))) )
4227 const0_rtx),gen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat
((GE), (((scalar_int_mode ((scalar_int_mode::from_int) E_BImode
)))), ((gen_rtx_fmt_e_stat ((ABS), ((mode)), ((mod)) ))), ((gen_rtx_fmt_ee_stat
((MINUS), ((mode)), ((gen_rtx_fmt_e_stat ((ABS), ((mode)), (
(op1)) ))), ((gen_rtx_fmt_e_stat ((ABS), ((mode)), ((mod)) ))
) ))) ))), ((gen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), (
(gen_rtx_fmt_ee_stat ((GT), (((scalar_int_mode ((scalar_int_mode
::from_int) E_BImode)))), ((gen_rtx_fmt_ee_stat ((DIV), ((mode
)), ((op1)), ((mod)) ))), (((const_int_rtx[64]))) ))), (((const_int_rtx
[64 +1]))), (((const_int_rtx[64 -1]))) ))), (((const_int_rtx[
64]))) )
4228 const1_rtx, constm1_rtx),gen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat
((GE), (((scalar_int_mode ((scalar_int_mode::from_int) E_BImode
)))), ((gen_rtx_fmt_e_stat ((ABS), ((mode)), ((mod)) ))), ((gen_rtx_fmt_ee_stat
((MINUS), ((mode)), ((gen_rtx_fmt_e_stat ((ABS), ((mode)), (
(op1)) ))), ((gen_rtx_fmt_e_stat ((ABS), ((mode)), ((mod)) ))
) ))) ))), ((gen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), (
(gen_rtx_fmt_ee_stat ((GT), (((scalar_int_mode ((scalar_int_mode
::from_int) E_BImode)))), ((gen_rtx_fmt_ee_stat ((DIV), ((mode
)), ((op1)), ((mod)) ))), (((const_int_rtx[64]))) ))), (((const_int_rtx
[64 +1]))), (((const_int_rtx[64 -1]))) ))), (((const_int_rtx[
64]))) )
4229 const0_rtx)gen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat
((GE), (((scalar_int_mode ((scalar_int_mode::from_int) E_BImode
)))), ((gen_rtx_fmt_e_stat ((ABS), ((mode)), ((mod)) ))), ((gen_rtx_fmt_ee_stat
((MINUS), ((mode)), ((gen_rtx_fmt_e_stat ((ABS), ((mode)), (
(op1)) ))), ((gen_rtx_fmt_e_stat ((ABS), ((mode)), ((mod)) ))
) ))) ))), ((gen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), (
(gen_rtx_fmt_ee_stat ((GT), (((scalar_int_mode ((scalar_int_mode
::from_int) E_BImode)))), ((gen_rtx_fmt_ee_stat ((DIV), ((mode
)), ((op1)), ((mod)) ))), (((const_int_rtx[64]))) ))), (((const_int_rtx
[64 +1]))), (((const_int_rtx[64 -1]))) ))), (((const_int_rtx[
64]))) )
;
4230}
4231
4232/* Return the difference between the rounded and the truncated result
4233 of a unsigned division by OP1 with remainder MOD. Halfway cases
4234 are rounded away from zero, rather than to the nearest even
4235 number. */
4236static rtx
4237round_udiv_adjust (machine_mode mode, rtx mod, rtx op1)
4238{
4239 /* (mod >= op1 - mod ? 1 : 0) */
4240 return gen_rtx_IF_THEN_ELSEgen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat
((GE), (((scalar_int_mode ((scalar_int_mode::from_int) E_BImode
)))), ((mod)), ((gen_rtx_fmt_ee_stat ((MINUS), ((mode)), ((op1
)), ((mod)) ))) ))), (((const_int_rtx[64 +1]))), (((const_int_rtx
[64]))) )
4241 (mode, gen_rtx_GE (BImode, mod,gen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat
((GE), (((scalar_int_mode ((scalar_int_mode::from_int) E_BImode
)))), ((mod)), ((gen_rtx_fmt_ee_stat ((MINUS), ((mode)), ((op1
)), ((mod)) ))) ))), (((const_int_rtx[64 +1]))), (((const_int_rtx
[64]))) )
4242 gen_rtx_MINUS (mode, op1, mod)),gen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat
((GE), (((scalar_int_mode ((scalar_int_mode::from_int) E_BImode
)))), ((mod)), ((gen_rtx_fmt_ee_stat ((MINUS), ((mode)), ((op1
)), ((mod)) ))) ))), (((const_int_rtx[64 +1]))), (((const_int_rtx
[64]))) )
4243 const1_rtx, const0_rtx)gen_rtx_fmt_eee_stat ((IF_THEN_ELSE), ((mode)), ((gen_rtx_fmt_ee_stat
((GE), (((scalar_int_mode ((scalar_int_mode::from_int) E_BImode
)))), ((mod)), ((gen_rtx_fmt_ee_stat ((MINUS), ((mode)), ((op1
)), ((mod)) ))) ))), (((const_int_rtx[64 +1]))), (((const_int_rtx
[64]))) )
;
4244}
4245
4246/* Convert X to MODE, that must be Pmode or ptr_mode, without emitting
4247 any rtl. */
4248
4249static rtx
4250convert_debug_memory_address (scalar_int_mode mode, rtx x,
4251 addr_space_t as)
4252{
4253#ifndef POINTERS_EXTEND_UNSIGNED1
4254 gcc_assert (mode == Pmode((void)(!(mode == (global_options.x_ix86_pmode == PMODE_DI ? (
scalar_int_mode ((scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode
((scalar_int_mode::from_int) E_SImode))) || mode == targetm.
addr_space.address_mode (as)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4255, __FUNCTION__), 0 : 0))
4255 || mode == targetm.addr_space.address_mode (as))((void)(!(mode == (global_options.x_ix86_pmode == PMODE_DI ? (
scalar_int_mode ((scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode
((scalar_int_mode::from_int) E_SImode))) || mode == targetm.
addr_space.address_mode (as)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4255, __FUNCTION__), 0 : 0))
;
4256 gcc_assert (GET_MODE (x) == mode || GET_MODE (x) == VOIDmode)((void)(!(((machine_mode) (x)->mode) == mode || ((machine_mode
) (x)->mode) == ((void) 0, E_VOIDmode)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4256, __FUNCTION__), 0 : 0))
;
4257#else
4258 rtx temp;
4259
4260 gcc_assert (targetm.addr_space.valid_pointer_mode (mode, as))((void)(!(targetm.addr_space.valid_pointer_mode (mode, as)) ?
fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4260, __FUNCTION__), 0 : 0))
;
4261
4262 if (GET_MODE (x)((machine_mode) (x)->mode) == mode || GET_MODE (x)((machine_mode) (x)->mode) == VOIDmode((void) 0, E_VOIDmode))
4263 return x;
4264
4265 /* X must have some form of address mode already. */
4266 scalar_int_mode xmode = as_a <scalar_int_mode> (GET_MODE (x)((machine_mode) (x)->mode));
4267 if (GET_MODE_PRECISION (mode) < GET_MODE_PRECISION (xmode))
4268 x = lowpart_subreg (mode, x, xmode);
4269 else if (POINTERS_EXTEND_UNSIGNED1 > 0)
4270 x = gen_rtx_ZERO_EXTEND (mode, x)gen_rtx_fmt_e_stat ((ZERO_EXTEND), ((mode)), ((x)) );
4271 else if (!POINTERS_EXTEND_UNSIGNED1)
4272 x = gen_rtx_SIGN_EXTEND (mode, x)gen_rtx_fmt_e_stat ((SIGN_EXTEND), ((mode)), ((x)) );
4273 else
4274 {
4275 switch (GET_CODE (x)((enum rtx_code) (x)->code))
4276 {
4277 case SUBREG:
4278 if ((SUBREG_PROMOTED_VAR_P (x)(__extension__ ({ __typeof ((x)) const _rtx = ((x)); if (((enum
rtx_code) (_rtx)->code) != SUBREG) rtl_check_failed_flag (
"SUBREG_PROMOTED", _rtx, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4278, __FUNCTION__); _rtx; })->in_struct)
4279 || (REG_P (SUBREG_REG (x))(((enum rtx_code) ((((x)->u.fld[0]).rt_rtx))->code) == REG
)
&& REG_POINTER (SUBREG_REG (x))(__extension__ ({ __typeof (((((x)->u.fld[0]).rt_rtx))) const
_rtx = (((((x)->u.fld[0]).rt_rtx))); if (((enum rtx_code)
(_rtx)->code) != REG) rtl_check_failed_flag ("REG_POINTER"
, _rtx, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4279, __FUNCTION__); _rtx; })->frame_related)
)
4280 || (GET_CODE (SUBREG_REG (x))((enum rtx_code) ((((x)->u.fld[0]).rt_rtx))->code) == PLUS
4281 && REG_P (XEXP (SUBREG_REG (x), 0))(((enum rtx_code) (((((((x)->u.fld[0]).rt_rtx))->u.fld[
0]).rt_rtx))->code) == REG)
4282 && REG_POINTER (XEXP (SUBREG_REG (x), 0))(__extension__ ({ __typeof ((((((((x)->u.fld[0]).rt_rtx))->
u.fld[0]).rt_rtx))) const _rtx = ((((((((x)->u.fld[0]).rt_rtx
))->u.fld[0]).rt_rtx))); if (((enum rtx_code) (_rtx)->code
) != REG) rtl_check_failed_flag ("REG_POINTER", _rtx, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4282, __FUNCTION__); _rtx; })->frame_related)
4283 && CONST_INT_P (XEXP (SUBREG_REG (x), 1))(((enum rtx_code) (((((((x)->u.fld[0]).rt_rtx))->u.fld[
1]).rt_rtx))->code) == CONST_INT)
))
4284 && GET_MODE (SUBREG_REG (x))((machine_mode) ((((x)->u.fld[0]).rt_rtx))->mode) == mode)
4285 return SUBREG_REG (x)(((x)->u.fld[0]).rt_rtx);
4286 break;
4287 case LABEL_REF:
4288 temp = gen_rtx_LABEL_REF (mode, label_ref_label (x))gen_rtx_fmt_u_stat ((LABEL_REF), ((mode)), ((label_ref_label (
x))) )
;
4289 LABEL_REF_NONLOCAL_P (temp)(__extension__ ({ __typeof ((temp)) const _rtx = ((temp)); if
(((enum rtx_code) (_rtx)->code) != LABEL_REF) rtl_check_failed_flag
("LABEL_REF_NONLOCAL_P", _rtx, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4289, __FUNCTION__); _rtx; })->volatil)
= LABEL_REF_NONLOCAL_P (x)(__extension__ ({ __typeof ((x)) const _rtx = ((x)); if (((enum
rtx_code) (_rtx)->code) != LABEL_REF) rtl_check_failed_flag
("LABEL_REF_NONLOCAL_P", _rtx, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4289, __FUNCTION__); _rtx; })->volatil)
;
4290 return temp;
4291 case SYMBOL_REF:
4292 temp = shallow_copy_rtx (x);
4293 PUT_MODE (temp, mode);
4294 return temp;
4295 case CONST:
4296 temp = convert_debug_memory_address (mode, XEXP (x, 0)(((x)->u.fld[0]).rt_rtx), as);
4297 if (temp)
4298 temp = gen_rtx_CONST (mode, temp)gen_rtx_fmt_e_stat ((CONST), ((mode)), ((temp)) );
4299 return temp;
4300 case PLUS:
4301 case MINUS:
4302 if (CONST_INT_P (XEXP (x, 1))(((enum rtx_code) ((((x)->u.fld[1]).rt_rtx))->code) == CONST_INT
)
)
4303 {
4304 temp = convert_debug_memory_address (mode, XEXP (x, 0)(((x)->u.fld[0]).rt_rtx), as);
4305 if (temp)
4306 return gen_rtx_fmt_ee (GET_CODE (x), mode, temp, XEXP (x, 1))gen_rtx_fmt_ee_stat ((((enum rtx_code) (x)->code)), (mode)
, (temp), ((((x)->u.fld[1]).rt_rtx)) )
;
4307 }
4308 break;
4309 default:
4310 break;
4311 }
4312 /* Don't know how to express ptr_extend as operation in debug info. */
4313 return NULLnullptr;
4314 }
4315#endif /* POINTERS_EXTEND_UNSIGNED */
4316
4317 return x;
4318}
4319
4320/* Map from SSA_NAMEs to corresponding DEBUG_EXPR_DECLs created
4321 by avoid_deep_ter_for_debug. */
4322
4323static hash_map<tree, tree> *deep_ter_debug_map;
4324
4325/* Split too deep TER chains for debug stmts using debug temporaries. */
4326
4327static void
4328avoid_deep_ter_for_debug (gimple *stmt, int depth)
4329{
4330 use_operand_p use_p;
4331 ssa_op_iter iter;
4332 FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE)for (use_p = op_iter_init_use (&(iter), stmt, 0x01); !op_iter_done
(&(iter)); use_p = op_iter_next_use (&(iter)))
4333 {
4334 tree use = USE_FROM_PTR (use_p)get_use_from_ptr (use_p);
4335 if (TREE_CODE (use)((enum tree_code) (use)->base.code) != SSA_NAME || SSA_NAME_IS_DEFAULT_DEF (use)(tree_check ((use), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4335, __FUNCTION__, (SSA_NAME)))->base.default_def_flag
)
4336 continue;
4337 gimple *g = get_gimple_for_ssa_name (use);
4338 if (g == NULLnullptr)
4339 continue;
4340 if (depth > 6 && !stmt_ends_bb_p (g))
4341 {
4342 if (deep_ter_debug_map == NULLnullptr)
4343 deep_ter_debug_map = new hash_map<tree, tree>;
4344
4345 tree &vexpr = deep_ter_debug_map->get_or_insert (use);
4346 if (vexpr != NULLnullptr)
4347 continue;
4348 vexpr = build_debug_expr_decl (TREE_TYPE (use)((contains_struct_check ((use), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4348, __FUNCTION__))->typed.type)
);
4349 gimple *def_temp = gimple_build_debug_bind (vexpr, use, g);
4350 gimple_stmt_iterator gsi = gsi_for_stmt (g);
4351 gsi_insert_after (&gsi, def_temp, GSI_NEW_STMT);
4352 avoid_deep_ter_for_debug (def_temp, 0);
4353 }
4354 else
4355 avoid_deep_ter_for_debug (g, depth + 1);
4356 }
4357}
4358
4359/* Return an RTX equivalent to the value of the parameter DECL. */
4360
4361static rtx
4362expand_debug_parm_decl (tree decl)
4363{
4364 rtx incoming = DECL_INCOMING_RTL (decl)((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4364, __FUNCTION__, (PARM_DECL)))->parm_decl.incoming_rtl
)
;
4365
4366 if (incoming
4367 && GET_MODE (incoming)((machine_mode) (incoming)->mode) != BLKmode((void) 0, E_BLKmode)
4368 && ((REG_P (incoming)(((enum rtx_code) (incoming)->code) == REG) && HARD_REGISTER_P (incoming)((((rhs_regno(incoming))) < 76)))
4369 || (MEM_P (incoming)(((enum rtx_code) (incoming)->code) == MEM)
4370 && REG_P (XEXP (incoming, 0))(((enum rtx_code) ((((incoming)->u.fld[0]).rt_rtx))->code
) == REG)
4371 && HARD_REGISTER_P (XEXP (incoming, 0))((((rhs_regno((((incoming)->u.fld[0]).rt_rtx)))) < 76)))))
4372 {
4373 rtx rtl = gen_rtx_ENTRY_VALUE (GET_MODE (incoming))gen_rtx_fmt_0_stat ((ENTRY_VALUE), ((((machine_mode) (incoming
)->mode))) )
;
4374
4375#ifdef HAVE_window_save
4376 /* DECL_INCOMING_RTL uses the INCOMING_REGNO of parameter registers.
4377 If the target machine has an explicit window save instruction, the
4378 actual entry value is the corresponding OUTGOING_REGNO instead. */
4379 if (REG_P (incoming)(((enum rtx_code) (incoming)->code) == REG)
4380 && OUTGOING_REGNO (REGNO (incoming))((rhs_regno(incoming))) != REGNO (incoming)(rhs_regno(incoming)))
4381 incoming
4382 = gen_rtx_REG_offset (incoming, GET_MODE (incoming)((machine_mode) (incoming)->mode),
4383 OUTGOING_REGNO (REGNO (incoming))((rhs_regno(incoming))), 0);
4384 else if (MEM_P (incoming)(((enum rtx_code) (incoming)->code) == MEM))
4385 {
4386 rtx reg = XEXP (incoming, 0)(((incoming)->u.fld[0]).rt_rtx);
4387 if (OUTGOING_REGNO (REGNO (reg))((rhs_regno(reg))) != REGNO (reg)(rhs_regno(reg)))
4388 {
4389 reg = gen_raw_REG (GET_MODE (reg)((machine_mode) (reg)->mode), OUTGOING_REGNO (REGNO (reg))((rhs_regno(reg))));
4390 incoming = replace_equiv_address_nv (incoming, reg);
4391 }
4392 else
4393 incoming = copy_rtx (incoming);
4394 }
4395#endif
4396
4397 ENTRY_VALUE_EXP (rtl)(((rtl)->u.fld[0]).rt_rtx) = incoming;
4398 return rtl;
4399 }
4400
4401 if (incoming
4402 && GET_MODE (incoming)((machine_mode) (incoming)->mode) != BLKmode((void) 0, E_BLKmode)
4403 && !TREE_ADDRESSABLE (decl)((decl)->base.addressable_flag)
4404 && MEM_P (incoming)(((enum rtx_code) (incoming)->code) == MEM)
4405 && (XEXP (incoming, 0)(((incoming)->u.fld[0]).rt_rtx) == virtual_incoming_args_rtx((this_target_rtl->x_global_rtl)[GR_VIRTUAL_INCOMING_ARGS]
)
4406 || (GET_CODE (XEXP (incoming, 0))((enum rtx_code) ((((incoming)->u.fld[0]).rt_rtx))->code
)
== PLUS
4407 && XEXP (XEXP (incoming, 0), 0)((((((incoming)->u.fld[0]).rt_rtx))->u.fld[0]).rt_rtx) == virtual_incoming_args_rtx((this_target_rtl->x_global_rtl)[GR_VIRTUAL_INCOMING_ARGS]
)
4408 && CONST_INT_P (XEXP (XEXP (incoming, 0), 1))(((enum rtx_code) (((((((incoming)->u.fld[0]).rt_rtx))->
u.fld[1]).rt_rtx))->code) == CONST_INT)
)))
4409 return copy_rtx (incoming);
4410
4411 return NULL_RTX(rtx) 0;
4412}
4413
4414/* Return an RTX equivalent to the value of the tree expression EXP. */
4415
4416static rtx
4417expand_debug_expr (tree exp)
4418{
4419 rtx op0 = NULL_RTX(rtx) 0, op1 = NULL_RTX(rtx) 0, op2 = NULL_RTX(rtx) 0;
4420 machine_mode mode = TYPE_MODE (TREE_TYPE (exp))((((enum tree_code) ((tree_class_check ((((contains_struct_check
((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4420, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4420, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(((contains_struct_check ((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4420, __FUNCTION__))->typed.type)) : (((contains_struct_check
((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4420, __FUNCTION__))->typed.type))->type_common.mode)
;
4421 machine_mode inner_mode = VOIDmode((void) 0, E_VOIDmode);
4422 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (exp))((tree_class_check ((((contains_struct_check ((exp), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4422, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4422, __FUNCTION__))->base.u.bits.unsigned_flag)
;
4423 addr_space_t as;
4424 scalar_int_mode op0_mode, op1_mode, addr_mode;
4425
4426 switch (TREE_CODE_CLASS (TREE_CODE (exp))tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (exp)->base.code))]
)
4427 {
4428 case tcc_expression:
4429 switch (TREE_CODE (exp)((enum tree_code) (exp)->base.code))
4430 {
4431 case COND_EXPR:
4432 case DOT_PROD_EXPR:
4433 case SAD_EXPR:
4434 case WIDEN_MULT_PLUS_EXPR:
4435 case WIDEN_MULT_MINUS_EXPR:
4436 goto ternary;
4437
4438 case TRUTH_ANDIF_EXPR:
4439 case TRUTH_ORIF_EXPR:
4440 case TRUTH_AND_EXPR:
4441 case TRUTH_OR_EXPR:
4442 case TRUTH_XOR_EXPR:
4443 goto binary;
4444
4445 case TRUTH_NOT_EXPR:
4446 goto unary;
4447
4448 default:
4449 break;
4450 }
4451 break;
4452
4453 ternary:
4454 op2 = expand_debug_expr (TREE_OPERAND (exp, 2)(*((const_cast<tree*> (tree_operand_check ((exp), (2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4454, __FUNCTION__)))))
);
4455 if (!op2)
4456 return NULL_RTX(rtx) 0;
4457 /* Fall through. */
4458
4459 binary:
4460 case tcc_binary:
4461 if (mode == BLKmode((void) 0, E_BLKmode))
4462 return NULL_RTX(rtx) 0;
4463 op1 = expand_debug_expr (TREE_OPERAND (exp, 1)(*((const_cast<tree*> (tree_operand_check ((exp), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4463, __FUNCTION__)))))
);
4464 if (!op1)
4465 return NULL_RTX(rtx) 0;
4466 switch (TREE_CODE (exp)((enum tree_code) (exp)->base.code))
4467 {
4468 case LSHIFT_EXPR:
4469 case RSHIFT_EXPR:
4470 case LROTATE_EXPR:
4471 case RROTATE_EXPR:
4472 case WIDEN_LSHIFT_EXPR:
4473 /* Ensure second operand isn't wider than the first one. */
4474 inner_mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 1)))((((enum tree_code) ((tree_class_check ((((contains_struct_check
(((*((const_cast<tree*> (tree_operand_check ((exp), (1
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4474, __FUNCTION__)))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4474, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4474, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(((contains_struct_check (((*((const_cast<tree*> (tree_operand_check
((exp), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4474, __FUNCTION__)))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4474, __FUNCTION__))->typed.type)) : (((contains_struct_check
(((*((const_cast<tree*> (tree_operand_check ((exp), (1
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4474, __FUNCTION__)))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4474, __FUNCTION__))->typed.type))->type_common.mode)
;
4475 if (is_a <scalar_int_mode> (inner_mode, &op1_mode)
4476 && (GET_MODE_UNIT_PRECISION (mode)(mode_to_unit_precision (mode))
4477 < GET_MODE_PRECISION (op1_mode)))
4478 op1 = lowpart_subreg (GET_MODE_INNER (mode)(mode_to_inner (mode)), op1, op1_mode);
4479 break;
4480 default:
4481 break;
4482 }
4483 /* Fall through. */
4484
4485 unary:
4486 case tcc_unary:
4487 if (mode == BLKmode((void) 0, E_BLKmode))
4488 return NULL_RTX(rtx) 0;
4489 inner_mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))((((enum tree_code) ((tree_class_check ((((contains_struct_check
(((*((const_cast<tree*> (tree_operand_check ((exp), (0
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4489, __FUNCTION__)))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4489, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4489, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(((contains_struct_check (((*((const_cast<tree*> (tree_operand_check
((exp), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4489, __FUNCTION__)))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4489, __FUNCTION__))->typed.type)) : (((contains_struct_check
(((*((const_cast<tree*> (tree_operand_check ((exp), (0
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4489, __FUNCTION__)))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4489, __FUNCTION__))->typed.type))->type_common.mode)
;
4490 op0 = expand_debug_expr (TREE_OPERAND (exp, 0)(*((const_cast<tree*> (tree_operand_check ((exp), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4490, __FUNCTION__)))))
);
4491 if (!op0)
4492 return NULL_RTX(rtx) 0;
4493 break;
4494
4495 case tcc_comparison:
4496 unsignedp = TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0)))((tree_class_check ((((contains_struct_check (((*((const_cast
<tree*> (tree_operand_check ((exp), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4496, __FUNCTION__)))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4496, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4496, __FUNCTION__))->base.u.bits.unsigned_flag)
;
4497 goto binary;
4498
4499 case tcc_type:
4500 case tcc_statement:
4501 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4501, __FUNCTION__))
;
4502
4503 case tcc_constant:
4504 case tcc_exceptional:
4505 case tcc_declaration:
4506 case tcc_reference:
4507 case tcc_vl_exp:
4508 break;
4509 }
4510
4511 switch (TREE_CODE (exp)((enum tree_code) (exp)->base.code))
4512 {
4513 case STRING_CST:
4514 if (!lookup_constant_def (exp))
4515 {
4516 if (strlen (TREE_STRING_POINTER (exp)((const char *)((tree_check ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4516, __FUNCTION__, (STRING_CST)))->string.str))
) + 1
4517 != (size_t) TREE_STRING_LENGTH (exp)((tree_check ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4517, __FUNCTION__, (STRING_CST)))->string.length)
)
4518 return NULL_RTX(rtx) 0;
4519 op0 = gen_rtx_CONST_STRING (Pmode, TREE_STRING_POINTER (exp))gen_rtx_fmt_s_stat ((CONST_STRING), (((global_options.x_ix86_pmode
== PMODE_DI ? (scalar_int_mode ((scalar_int_mode::from_int) E_DImode
)) : (scalar_int_mode ((scalar_int_mode::from_int) E_SImode))
))), ((((const char *)((tree_check ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4519, __FUNCTION__, (STRING_CST)))->string.str)))) )
;
4520 op0 = gen_rtx_MEM (BLKmode((void) 0, E_BLKmode), op0);
4521 set_mem_attributes (op0, exp, 0);
4522 return op0;
4523 }
4524 /* Fall through. */
4525
4526 case INTEGER_CST:
4527 case REAL_CST:
4528 case FIXED_CST:
4529 op0 = expand_expr (exp, NULL_RTX(rtx) 0, mode, EXPAND_INITIALIZER);
4530 return op0;
4531
4532 case POLY_INT_CST:
4533 return immed_wide_int_const (poly_int_cst_value (exp), mode);
4534
4535 case COMPLEX_CST:
4536 gcc_assert (COMPLEX_MODE_P (mode))((void)(!((((enum mode_class) mode_class[mode]) == MODE_COMPLEX_INT
|| ((enum mode_class) mode_class[mode]) == MODE_COMPLEX_FLOAT
)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4536, __FUNCTION__), 0 : 0))
;
4537 op0 = expand_debug_expr (TREE_REALPART (exp)((tree_check ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4537, __FUNCTION__, (COMPLEX_CST)))->complex.real)
);
4538 op1 = expand_debug_expr (TREE_IMAGPART (exp)((tree_check ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4538, __FUNCTION__, (COMPLEX_CST)))->complex.imag)
);
4539 return gen_rtx_CONCAT (mode, op0, op1)gen_rtx_fmt_ee_stat ((CONCAT), ((mode)), ((op0)), ((op1)) );
4540
4541 case DEBUG_EXPR_DECL:
4542 op0 = DECL_RTL_IF_SET (exp)((((tree_contains_struct[(((enum tree_code) (exp)->base.code
))][(TS_DECL_WRTL)])) && (contains_struct_check ((exp
), (TS_DECL_WRTL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4542, __FUNCTION__))->decl_with_rtl.rtl != nullptr) ? ((
contains_struct_check ((exp), (TS_DECL_WRTL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4542, __FUNCTION__))->decl_with_rtl.rtl ? (exp)->decl_with_rtl
.rtl : (make_decl_rtl (exp), (exp)->decl_with_rtl.rtl)) : nullptr
)
;
4543
4544 if (op0)
4545 {
4546 if (GET_MODE (op0)((machine_mode) (op0)->mode) != mode)
4547 gcc_assert (VECTOR_TYPE_P (TREE_TYPE (exp)))((void)(!((((enum tree_code) (((contains_struct_check ((exp),
(TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4547, __FUNCTION__))->typed.type))->base.code) == VECTOR_TYPE
)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4547, __FUNCTION__), 0 : 0))
;
4548 else
4549 return op0;
4550 }
4551
4552 op0 = gen_rtx_DEBUG_EXPR (mode)gen_rtx_fmt_0_stat ((DEBUG_EXPR), ((mode)) );
4553 DEBUG_EXPR_TREE_DECL (op0)(((op0)->u.fld[0]).rt_tree) = exp;
4554 SET_DECL_RTL (exp, op0)set_decl_rtl (exp, op0);
4555
4556 return op0;
4557
4558 case VAR_DECL:
4559 case PARM_DECL:
4560 case FUNCTION_DECL:
4561 case LABEL_DECL:
4562 case CONST_DECL:
4563 case RESULT_DECL:
4564 op0 = DECL_RTL_IF_SET (exp)((((tree_contains_struct[(((enum tree_code) (exp)->base.code
))][(TS_DECL_WRTL)])) && (contains_struct_check ((exp
), (TS_DECL_WRTL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4564, __FUNCTION__))->decl_with_rtl.rtl != nullptr) ? ((
contains_struct_check ((exp), (TS_DECL_WRTL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4564, __FUNCTION__))->decl_with_rtl.rtl ? (exp)->decl_with_rtl
.rtl : (make_decl_rtl (exp), (exp)->decl_with_rtl.rtl)) : nullptr
)
;
4565
4566 /* This decl was probably optimized away. */
4567 if (!op0
4568 /* At least label RTXen are sometimes replaced by
4569 NOTE_INSN_DELETED_LABEL. Any notes here are not
4570 handled by copy_rtx. */
4571 || NOTE_P (op0)(((enum rtx_code) (op0)->code) == NOTE))
4572 {
4573 if (!VAR_P (exp)(((enum tree_code) (exp)->base.code) == VAR_DECL)
4574 || DECL_EXTERNAL (exp)((contains_struct_check ((exp), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4574, __FUNCTION__))->decl_common.decl_flag_1)
4575 || !TREE_STATIC (exp)((exp)->base.static_flag)
4576 || !DECL_NAME (exp)((contains_struct_check ((exp), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4576, __FUNCTION__))->decl_minimal.name)
4577 || DECL_HARD_REGISTER (exp)((tree_check ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4577, __FUNCTION__, (VAR_DECL)))->decl_with_vis.hard_register
)
4578 || DECL_IN_CONSTANT_POOL (exp)((tree_check ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4578, __FUNCTION__, (VAR_DECL)))->decl_with_vis.in_constant_pool
)
4579 || mode == VOIDmode((void) 0, E_VOIDmode)
4580 || symtab_node::get (exp) == NULLnullptr)
4581 return NULLnullptr;
4582
4583 op0 = make_decl_rtl_for_debug (exp);
4584 if (!MEM_P (op0)(((enum rtx_code) (op0)->code) == MEM)
4585 || GET_CODE (XEXP (op0, 0))((enum rtx_code) ((((op0)->u.fld[0]).rt_rtx))->code) != SYMBOL_REF
4586 || SYMBOL_REF_DECL (XEXP (op0, 0))((__extension__ ({ __typeof (((((op0)->u.fld[0]).rt_rtx)))
const _rtx = (((((op0)->u.fld[0]).rt_rtx))); if (((enum rtx_code
) (_rtx)->code) != SYMBOL_REF) rtl_check_failed_flag ("CONSTANT_POOL_ADDRESS_P"
, _rtx, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4586, __FUNCTION__); _rtx; })->unchanging) ? nullptr : (
((((((op0)->u.fld[0]).rt_rtx)))->u.fld[1]).rt_tree))
!= exp)
4587 return NULLnullptr;
4588 }
4589 else if (VAR_P (exp)(((enum tree_code) (exp)->base.code) == VAR_DECL)
4590 && is_global_var (exp)
4591 && symtab_node::get (exp) == NULLnullptr)
4592 return NULLnullptr;
4593 else
4594 op0 = copy_rtx (op0);
4595
4596 if (GET_MODE (op0)((machine_mode) (op0)->mode) == BLKmode((void) 0, E_BLKmode)
4597 /* If op0 is not BLKmode, but mode is, adjust_mode
4598 below would ICE. While it is likely a FE bug,
4599 try to be robust here. See PR43166. */
4600 || mode == BLKmode((void) 0, E_BLKmode)
4601 || (mode == VOIDmode((void) 0, E_VOIDmode) && GET_MODE (op0)((machine_mode) (op0)->mode) != VOIDmode((void) 0, E_VOIDmode)))
4602 {
4603 gcc_assert (MEM_P (op0))((void)(!((((enum rtx_code) (op0)->code) == MEM)) ? fancy_abort
("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4603, __FUNCTION__), 0 : 0))
;
4604 op0 = adjust_address_nv (op0, mode, 0)adjust_address_1 (op0, mode, 0, 0, 1, 0, 0);
4605 return op0;
4606 }
4607
4608 /* Fall through. */
4609
4610 adjust_mode:
4611 case PAREN_EXPR:
4612 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
4613 {
4614 inner_mode = GET_MODE (op0)((machine_mode) (op0)->mode);
4615
4616 if (mode == inner_mode)
4617 return op0;
4618
4619 if (inner_mode == VOIDmode((void) 0, E_VOIDmode))
4620 {
4621 if (TREE_CODE (exp)((enum tree_code) (exp)->base.code) == SSA_NAME)
4622 inner_mode = TYPE_MODE (TREE_TYPE (exp))((((enum tree_code) ((tree_class_check ((((contains_struct_check
((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4622, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4622, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(((contains_struct_check ((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4622, __FUNCTION__))->typed.type)) : (((contains_struct_check
((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4622, __FUNCTION__))->typed.type))->type_common.mode)
;
4623 else
4624 inner_mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))((((enum tree_code) ((tree_class_check ((((contains_struct_check
(((*((const_cast<tree*> (tree_operand_check ((exp), (0
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4624, __FUNCTION__)))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4624, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4624, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(((contains_struct_check (((*((const_cast<tree*> (tree_operand_check
((exp), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4624, __FUNCTION__)))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4624, __FUNCTION__))->typed.type)) : (((contains_struct_check
(((*((const_cast<tree*> (tree_operand_check ((exp), (0
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4624, __FUNCTION__)))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4624, __FUNCTION__))->typed.type))->type_common.mode)
;
4625 if (mode == inner_mode)
4626 return op0;
4627 }
4628
4629 if (FLOAT_MODE_P (mode)(((enum mode_class) mode_class[mode]) == MODE_FLOAT || ((enum
mode_class) mode_class[mode]) == MODE_DECIMAL_FLOAT || ((enum
mode_class) mode_class[mode]) == MODE_COMPLEX_FLOAT || ((enum
mode_class) mode_class[mode]) == MODE_VECTOR_FLOAT)
&& FLOAT_MODE_P (inner_mode)(((enum mode_class) mode_class[inner_mode]) == MODE_FLOAT || (
(enum mode_class) mode_class[inner_mode]) == MODE_DECIMAL_FLOAT
|| ((enum mode_class) mode_class[inner_mode]) == MODE_COMPLEX_FLOAT
|| ((enum mode_class) mode_class[inner_mode]) == MODE_VECTOR_FLOAT
)
)
4630 {
4631 if (GET_MODE_UNIT_BITSIZE (mode)((unsigned short) (mode_to_unit_size (mode) * (8)))
4632 == GET_MODE_UNIT_BITSIZE (inner_mode)((unsigned short) (mode_to_unit_size (inner_mode) * (8))))
4633 op0 = simplify_gen_subreg (mode, op0, inner_mode, 0);
4634 else if (GET_MODE_UNIT_BITSIZE (mode)((unsigned short) (mode_to_unit_size (mode) * (8)))
4635 < GET_MODE_UNIT_BITSIZE (inner_mode)((unsigned short) (mode_to_unit_size (inner_mode) * (8))))
4636 op0 = simplify_gen_unary (FLOAT_TRUNCATE, mode, op0, inner_mode);
4637 else
4638 op0 = simplify_gen_unary (FLOAT_EXTEND, mode, op0, inner_mode);
4639 }
4640 else if (FLOAT_MODE_P (mode)(((enum mode_class) mode_class[mode]) == MODE_FLOAT || ((enum
mode_class) mode_class[mode]) == MODE_DECIMAL_FLOAT || ((enum
mode_class) mode_class[mode]) == MODE_COMPLEX_FLOAT || ((enum
mode_class) mode_class[mode]) == MODE_VECTOR_FLOAT)
)
4641 {
4642 gcc_assert (TREE_CODE (exp) != SSA_NAME)((void)(!(((enum tree_code) (exp)->base.code) != SSA_NAME)
? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4642, __FUNCTION__), 0 : 0))
;
4643 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0)))((tree_class_check ((((contains_struct_check (((*((const_cast
<tree*> (tree_operand_check ((exp), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4643, __FUNCTION__)))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4643, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4643, __FUNCTION__))->base.u.bits.unsigned_flag)
)
4644 op0 = simplify_gen_unary (UNSIGNED_FLOAT, mode, op0, inner_mode);
4645 else
4646 op0 = simplify_gen_unary (FLOAT, mode, op0, inner_mode);
4647 }
4648 else if (FLOAT_MODE_P (inner_mode)(((enum mode_class) mode_class[inner_mode]) == MODE_FLOAT || (
(enum mode_class) mode_class[inner_mode]) == MODE_DECIMAL_FLOAT
|| ((enum mode_class) mode_class[inner_mode]) == MODE_COMPLEX_FLOAT
|| ((enum mode_class) mode_class[inner_mode]) == MODE_VECTOR_FLOAT
)
)
4649 {
4650 if (unsignedp)
4651 op0 = simplify_gen_unary (UNSIGNED_FIX, mode, op0, inner_mode);
4652 else
4653 op0 = simplify_gen_unary (FIX, mode, op0, inner_mode);
4654 }
4655 else if (GET_MODE_UNIT_PRECISION (mode)(mode_to_unit_precision (mode))
4656 == GET_MODE_UNIT_PRECISION (inner_mode)(mode_to_unit_precision (inner_mode)))
4657 op0 = lowpart_subreg (mode, op0, inner_mode);
4658 else if (GET_MODE_UNIT_PRECISION (mode)(mode_to_unit_precision (mode))
4659 < GET_MODE_UNIT_PRECISION (inner_mode)(mode_to_unit_precision (inner_mode)))
4660 op0 = simplify_gen_unary (TRUNCATE, mode, op0, inner_mode);
4661 else if (UNARY_CLASS_P (exp)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (exp)->base.code))] == tcc_unary)
4662 ? TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0)))((tree_class_check ((((contains_struct_check (((*((const_cast
<tree*> (tree_operand_check ((exp), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4662, __FUNCTION__)))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4662, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4662, __FUNCTION__))->base.u.bits.unsigned_flag)
4663 : unsignedp)
4664 op0 = simplify_gen_unary (ZERO_EXTEND, mode, op0, inner_mode);
4665 else
4666 op0 = simplify_gen_unary (SIGN_EXTEND, mode, op0, inner_mode);
4667
4668 return op0;
4669 }
4670
4671 case MEM_REF:
4672 if (!is_gimple_mem_ref_addr (TREE_OPERAND (exp, 0)(*((const_cast<tree*> (tree_operand_check ((exp), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4672, __FUNCTION__)))))
))
4673 {
4674 tree newexp = fold_binary (MEM_REF, TREE_TYPE (exp),fold_binary_loc (((location_t) 0), MEM_REF, ((contains_struct_check
((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4674, __FUNCTION__))->typed.type), (*((const_cast<tree
*> (tree_operand_check ((exp), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4675, __FUNCTION__))))), (*((const_cast<tree*> (tree_operand_check
((exp), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4676, __FUNCTION__))))))
4675 TREE_OPERAND (exp, 0),fold_binary_loc (((location_t) 0), MEM_REF, ((contains_struct_check
((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4674, __FUNCTION__))->typed.type), (*((const_cast<tree
*> (tree_operand_check ((exp), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4675, __FUNCTION__))))), (*((const_cast<tree*> (tree_operand_check
((exp), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4676, __FUNCTION__))))))
4676 TREE_OPERAND (exp, 1))fold_binary_loc (((location_t) 0), MEM_REF, ((contains_struct_check
((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4674, __FUNCTION__))->typed.type), (*((const_cast<tree
*> (tree_operand_check ((exp), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4675, __FUNCTION__))))), (*((const_cast<tree*> (tree_operand_check
((exp), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4676, __FUNCTION__))))))
;
4677 if (newexp)
4678 return expand_debug_expr (newexp);
4679 }
4680 /* FALLTHROUGH */
4681 case INDIRECT_REF:
4682 inner_mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))((((enum tree_code) ((tree_class_check ((((contains_struct_check
(((*((const_cast<tree*> (tree_operand_check ((exp), (0
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4682, __FUNCTION__)))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4682, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4682, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(((contains_struct_check (((*((const_cast<tree*> (tree_operand_check
((exp), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4682, __FUNCTION__)))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4682, __FUNCTION__))->typed.type)) : (((contains_struct_check
(((*((const_cast<tree*> (tree_operand_check ((exp), (0
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4682, __FUNCTION__)))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4682, __FUNCTION__))->typed.type))->type_common.mode)
;
4683 op0 = expand_debug_expr (TREE_OPERAND (exp, 0)(*((const_cast<tree*> (tree_operand_check ((exp), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4683, __FUNCTION__)))))
);
4684 if (!op0)
4685 return NULLnullptr;
4686
4687 if (TREE_CODE (exp)((enum tree_code) (exp)->base.code) == MEM_REF)
4688 {
4689 if (GET_CODE (op0)((enum rtx_code) (op0)->code) == DEBUG_IMPLICIT_PTR
4690 || (GET_CODE (op0)((enum rtx_code) (op0)->code) == PLUS
4691 && GET_CODE (XEXP (op0, 0))((enum rtx_code) ((((op0)->u.fld[0]).rt_rtx))->code) == DEBUG_IMPLICIT_PTR))
4692 /* (mem (debug_implicit_ptr)) might confuse aliasing.
4693 Instead just use get_inner_reference. */
4694 goto component_ref;
4695
4696 op1 = expand_debug_expr (TREE_OPERAND (exp, 1)(*((const_cast<tree*> (tree_operand_check ((exp), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4696, __FUNCTION__)))))
);
4697 poly_int64 offset;
4698 if (!op1 || !poly_int_rtx_p (op1, &offset))
4699 return NULLnullptr;
4700
4701 op0 = plus_constant (inner_mode, op0, offset);
4702 }
4703
4704 as = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 0))))((tree_class_check ((((contains_struct_check ((((contains_struct_check
(((*((const_cast<tree*> (tree_operand_check ((exp), (0
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4704, __FUNCTION__)))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4704, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4704, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4704, __FUNCTION__))->base.u.bits.address_space)
;
4705
4706 op0 = convert_debug_memory_address (targetm.addr_space.address_mode (as),
4707 op0, as);
4708 if (op0 == NULL_RTX(rtx) 0)
4709 return NULLnullptr;
4710
4711 op0 = gen_rtx_MEM (mode, op0);
4712 set_mem_attributes (op0, exp, 0);
4713 if (TREE_CODE (exp)((enum tree_code) (exp)->base.code) == MEM_REF
4714 && !is_gimple_mem_ref_addr (TREE_OPERAND (exp, 0)(*((const_cast<tree*> (tree_operand_check ((exp), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4714, __FUNCTION__)))))
))
4715 set_mem_expr (op0, NULL_TREE(tree) nullptr);
4716 set_mem_addr_space (op0, as);
4717
4718 return op0;
4719
4720 case TARGET_MEM_REF:
4721 if (TREE_CODE (TMR_BASE (exp))((enum tree_code) (((*((const_cast<tree*> (tree_operand_check
(((tree_check ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4721, __FUNCTION__, (TARGET_MEM_REF)))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4721, __FUNCTION__)))))))->base.code)
== ADDR_EXPR
4722 && !DECL_RTL_SET_P (TREE_OPERAND (TMR_BASE (exp), 0))(((tree_contains_struct[(((enum tree_code) ((*((const_cast<
tree*> (tree_operand_check ((((*((const_cast<tree*> (
tree_operand_check (((tree_check ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4722, __FUNCTION__, (TARGET_MEM_REF)))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4722, __FUNCTION__))))))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4722, __FUNCTION__))))))->base.code))][(TS_DECL_WRTL)]))
&& (contains_struct_check (((*((const_cast<tree*>
(tree_operand_check ((((*((const_cast<tree*> (tree_operand_check
(((tree_check ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4722, __FUNCTION__, (TARGET_MEM_REF)))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4722, __FUNCTION__))))))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4722, __FUNCTION__)))))), (TS_DECL_WRTL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4722, __FUNCTION__))->decl_with_rtl.rtl != nullptr)
)
4723 return NULLnullptr;
4724
4725 op0 = expand_debug_expr
4726 (tree_mem_ref_addr (build_pointer_type (TREE_TYPE (exp)((contains_struct_check ((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4726, __FUNCTION__))->typed.type)
), exp));
4727 if (!op0)
4728 return NULLnullptr;
4729
4730 as = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 0))))((tree_class_check ((((contains_struct_check ((((contains_struct_check
(((*((const_cast<tree*> (tree_operand_check ((exp), (0
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4730, __FUNCTION__)))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4730, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4730, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4730, __FUNCTION__))->base.u.bits.address_space)
;
4731 op0 = convert_debug_memory_address (targetm.addr_space.address_mode (as),
4732 op0, as);
4733 if (op0 == NULL_RTX(rtx) 0)
4734 return NULLnullptr;
4735
4736 op0 = gen_rtx_MEM (mode, op0);
4737
4738 set_mem_attributes (op0, exp, 0);
4739 set_mem_addr_space (op0, as);
4740
4741 return op0;
4742
4743 component_ref:
4744 case ARRAY_REF:
4745 case ARRAY_RANGE_REF:
4746 case COMPONENT_REF:
4747 case BIT_FIELD_REF:
4748 case REALPART_EXPR:
4749 case IMAGPART_EXPR:
4750 case VIEW_CONVERT_EXPR:
4751 {
4752 machine_mode mode1;
4753 poly_int64 bitsize, bitpos;
4754 tree offset;
4755 int reversep, volatilep = 0;
4756 tree tem
4757 = get_inner_reference (exp, &bitsize, &bitpos, &offset, &mode1,
4758 &unsignedp, &reversep, &volatilep);
4759 rtx orig_op0;
4760
4761 if (known_eq (bitsize, 0)(!maybe_ne (bitsize, 0)))
4762 return NULLnullptr;
4763
4764 orig_op0 = op0 = expand_debug_expr (tem);
4765
4766 if (!op0)
4767 return NULLnullptr;
4768
4769 if (offset)
4770 {
4771 machine_mode addrmode, offmode;
4772
4773 if (!MEM_P (op0)(((enum rtx_code) (op0)->code) == MEM))
4774 return NULLnullptr;
4775
4776 op0 = XEXP (op0, 0)(((op0)->u.fld[0]).rt_rtx);
4777 addrmode = GET_MODE (op0)((machine_mode) (op0)->mode);
4778 if (addrmode == VOIDmode((void) 0, E_VOIDmode))
4779 addrmode = Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode)))
;
4780
4781 op1 = expand_debug_expr (offset);
4782 if (!op1)
4783 return NULLnullptr;
4784
4785 offmode = GET_MODE (op1)((machine_mode) (op1)->mode);
4786 if (offmode == VOIDmode((void) 0, E_VOIDmode))
4787 offmode = TYPE_MODE (TREE_TYPE (offset))((((enum tree_code) ((tree_class_check ((((contains_struct_check
((offset), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4787, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4787, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(((contains_struct_check ((offset), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4787, __FUNCTION__))->typed.type)) : (((contains_struct_check
((offset), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgexpand.cc"
, 4787, __FUNCTION__))->typed.type))->type_common.mode)
;
4788
4789 if (addrmode != offmode)
4790 op1 = lowpart_subreg (addrmode, op1, offmode);
4791
4792 /* Don't use offset_address here, we don't need a
4793 recognizable address, and we don't want to generate
4794 code. */
4795 op0 = gen_rtx_MEM (mode, simplify_gen_binary (PLUS, addrmode,
4796 op0, op1));
4797 }
4798
4799 if (MEM_P (op0)(((enum rtx_code) (op0)->code) == MEM))
4800 {
4801 if (mode1 == VOIDmode((void) 0, E_VOIDmode))
4802 {
4803 if (maybe_gt (bitsize, MAX_BITSIZE_MODE_ANY_INT)maybe_lt ((64*(8)), bitsize))
4804 return NULLnullptr;
4805 /* Bitfield. */
4806 mode1 = smallest_int_mode_for_size (bitsize);
4807 }
4808 poly_int64 bytepos = bits_to_bytes_round_down (bitpos)force_align_down_and_div (bitpos, (8));
4809 if (maybe_ne (bytepos, 0))
4810 {
4811 op0 = adjust_address_nv (op0, mode1, bytepos)adjust_address_1 (op0, mode1, bytepos, 0, 1, 0, 0);
4812 bitpos = num_trailing_bits (bitpos)force_get_misalignment (bitpos, (8));
4813 }
4814 else if (known_eq (bitpos, 0)(!maybe_ne (bitpos, 0))
4815 && known_eq (bitsize, GET_MODE_BITSIZE (mode))(!maybe_ne (bitsize, GET_MODE_BITSIZE (mode))))
4816 op0 = adjust_address_nv (op0, mode, 0)adjust_address_1 (op0, mode, 0, 0, 1, 0, 0);
4817 else if (GET_MODE (op0)((machine_mode) (op0)->mode) != mode1)
4818 op0 = adjust_address_nv (op0, mode1, 0)adjust_address_1 (op0, mode1, 0, 0, 1, 0, 0);
4819 else
4820 op0 = copy_rtx (op0);
4821 if (op0 == orig_op0)
4822 op0 = shallow_copy_rtx (op0);
4823 if (TREE_CODE (tem)((enum tree_code) (tem)->base.code) != SSA_NAME)
4824 set_mem_attributes (op0, exp, 0);
4825 }
4826
4827 if (known_eq (bitpos, 0)(!maybe_ne (bitpos, 0)) && mode == GET_MODE (op0)((machine_mode) (op0)->mode))
4828 return op0;
4829
4830 if (maybe_lt (bitpos, 0))
4831 return NULLnullptr;
4832
4833 if (GET_MODE (op0)((machine_mode) (op0)->mode) == BLKmode((void) 0, E_BLKmode) || mode == BLKmode((void) 0, E_BLKmode))
4834 return NULL