Merge branch 'vendor/GCC50' - gcc 5.0 snapshot 1 FEB 2015
[dragonfly.git] / contrib / gcc-5.0 / gcc / init-regs.c
1 /* Initialization of uninitialized regs.
2    Copyright (C) 2007-2015 Free Software Foundation, Inc.
3
4 This file is part of GCC.
5
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
9 version.
10
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14 for more details.
15
16 You should have received a copy of the GNU General Public License
17 along 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 "tm.h"
24 #include "hash-set.h"
25 #include "machmode.h"
26 #include "vec.h"
27 #include "double-int.h"
28 #include "input.h"
29 #include "alias.h"
30 #include "symtab.h"
31 #include "wide-int.h"
32 #include "inchash.h"
33 #include "tree.h"
34 #include "rtl.h"
35 #include "regs.h"
36 #include "hashtab.h"
37 #include "hard-reg-set.h"
38 #include "function.h"
39 #include "flags.h"
40 #include "statistics.h"
41 #include "real.h"
42 #include "fixed-value.h"
43 #include "insn-config.h"
44 #include "expmed.h"
45 #include "dojump.h"
46 #include "explow.h"
47 #include "calls.h"
48 #include "emit-rtl.h"
49 #include "varasm.h"
50 #include "stmt.h"
51 #include "expr.h"
52 #include "tree-pass.h"
53 #include "predict.h"
54 #include "dominance.h"
55 #include "cfg.h"
56 #include "basic-block.h"
57 #include "df.h"
58
59 /* Check all of the uses of pseudo variables.  If any use that is MUST
60    uninitialized, add a store of 0 immediately before it.  For
61    subregs, this makes combine happy.  For full word regs, this makes
62    other optimizations, like the register allocator and the reg-stack
63    happy as well as papers over some problems on the arm and other
64    processors where certain isa constraints cannot be handled by gcc.
65    These are of the form where two operands to an insn my not be the
66    same.  The ra will only make them the same if they do not
67    interfere, and this can only happen if one is not initialized.
68
69    There is also the unfortunate consequence that this may mask some
70    buggy programs where people forget to initialize stack variable.
71    Any programmer with half a brain would look at the uninitialized
72    variable warnings.  */
73
74 static void
75 initialize_uninitialized_regs (void)
76 {
77   basic_block bb;
78   bitmap already_genned = BITMAP_ALLOC (NULL);
79
80   if (optimize == 1)
81     {
82       df_live_add_problem ();
83       df_live_set_all_dirty ();
84     }
85
86   df_analyze ();
87
88   FOR_EACH_BB_FN (bb, cfun)
89     {
90       rtx_insn *insn;
91       bitmap lr = DF_LR_IN (bb);
92       bitmap ur = DF_LIVE_IN (bb);
93       bitmap_clear (already_genned);
94
95       FOR_BB_INSNS (bb, insn)
96         {
97           df_ref use;
98           if (!NONDEBUG_INSN_P (insn))
99             continue;
100
101           FOR_EACH_INSN_USE (use, insn)
102             {
103               unsigned int regno = DF_REF_REGNO (use);
104
105               /* Only do this for the pseudos.  */
106               if (regno < FIRST_PSEUDO_REGISTER)
107                 continue;
108
109               /* Ignore pseudo PIC register.  */
110               if (pic_offset_table_rtx
111                   && regno == REGNO (pic_offset_table_rtx))
112                 continue;
113
114               /* Do not generate multiple moves for the same regno.
115                  This is common for sequences of subreg operations.
116                  They would be deleted during combine but there is no
117                  reason to churn the system.  */
118               if (bitmap_bit_p (already_genned, regno))
119                 continue;
120
121               /* A use is MUST uninitialized if it reaches the top of
122                  the block from the inside of the block (the lr test)
123                  and no def for it reaches the top of the block from
124                  outside of the block (the ur test).  */
125               if (bitmap_bit_p (lr, regno)
126                   && (!bitmap_bit_p (ur, regno)))
127                 {
128                   rtx_insn *move_insn;
129                   rtx reg = DF_REF_REAL_REG (use);
130
131                   bitmap_set_bit (already_genned, regno);
132
133                   start_sequence ();
134                   emit_move_insn (reg, CONST0_RTX (GET_MODE (reg)));
135                   move_insn = get_insns ();
136                   end_sequence ();
137                   emit_insn_before (move_insn, insn);
138                   if (dump_file)
139                     fprintf (dump_file,
140                              "adding initialization in %s of reg %d at in block %d for insn %d.\n",
141                              current_function_name (), regno, bb->index,
142                              INSN_UID (insn));
143                 }
144             }
145         }
146     }
147
148   if (optimize == 1)
149     {
150       if (dump_file)
151         df_dump (dump_file);
152       df_remove_problem (df_live);
153     }
154
155   BITMAP_FREE (already_genned);
156 }
157
158 namespace {
159
160 const pass_data pass_data_initialize_regs =
161 {
162   RTL_PASS, /* type */
163   "init-regs", /* name */
164   OPTGROUP_NONE, /* optinfo_flags */
165   TV_NONE, /* tv_id */
166   0, /* properties_required */
167   0, /* properties_provided */
168   0, /* properties_destroyed */
169   0, /* todo_flags_start */
170   TODO_df_finish, /* todo_flags_finish */
171 };
172
173 class pass_initialize_regs : public rtl_opt_pass
174 {
175 public:
176   pass_initialize_regs (gcc::context *ctxt)
177     : rtl_opt_pass (pass_data_initialize_regs, ctxt)
178   {}
179
180   /* opt_pass methods: */
181   virtual bool gate (function *) { return optimize > 0; }
182   virtual unsigned int execute (function *)
183     {
184       initialize_uninitialized_regs ();
185       return 0;
186     }
187
188 }; // class pass_initialize_regs
189
190 } // anon namespace
191
192 rtl_opt_pass *
193 make_pass_initialize_regs (gcc::context *ctxt)
194 {
195   return new pass_initialize_regs (ctxt);
196 }