1 /* Code to test for "definitive [un]assignment".
2 Copyright (C) 1999, 2000, 2001, 2003 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GCC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING. If not, write to
18 the Free Software Foundation, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA.
21 Java and all Java-based marks are trademarks or registered trademarks
22 of Sun Microsystems, Inc. in the United States and other countries.
23 The Free Software Foundation is independent of Sun Microsystems, Inc. */
25 /* Written by Per Bothner <bothner@cygnus.com>, January 1999. */
29 #include "coretypes.h"
32 #include "flags.h" /* Needed for optimize. */
33 #include "java-tree.h"
34 #include "toplev.h" /* Needed for fatal. */
36 /* The basic idea is that we assign each local variable declaration
37 and each blank final field an index, and then we pass around
38 bitstrings, where the (2*i)'th bit is set if decl whose DECL_BIT_INDEX
39 is i is definitely assigned, and the the (2*i=1)'th bit is set if
40 decl whose DECL_BIT_INDEX is i is definitely unassigned */
42 /* One segment of a bitstring. */
43 typedef unsigned int word
;
45 /* Pointer to a bitstring. */
48 /* Number of locals variables currently active. */
49 static int num_current_locals
= 0;
51 /* The value of num_current_locals when we entered the closest
52 enclosing LOOP_EXPR. */
53 static int loop_current_locals
;
55 /* The index of the first local variable in the current block.
57 The variables whose DECL_BIT_INDEX are in the range from
58 start_current_locals (inclusive) up to num_current_locals (exclusive)
59 are declared in the "current" block. If there is a loop or branch
60 form, we set start_current_locals to num_current_locals to indicate
61 there is no current block.
63 The point is that if a variable in the current block is set,
64 there are no other control paths that we have to worry about.
65 Hence, we can remove it from the set of variables we are
66 checking, making its bit index available for some other variable.
67 For simplicity, we only do that if the variable's bit index
68 is (num_current_locals-1); freeing up its bit index is then
69 just a simple matter of decrementing num_current_locals.
70 The reason this is worth doing is that it is simple, and
71 allows us to use short (usually one-word) bit-strings,
72 even for methods with thousands of local variables, as
73 long as most of them are initialized immediately after or in
75 static int start_current_locals
= 0;
77 static int num_current_words
;
81 #define COPYN(DST, SRC, NWORDS) memcpy (DST, SRC, NWORDS * sizeof(word))
82 #define COPY(DST, SRC) COPYN (DST, SRC, num_current_words)
84 #define SET_ALL(DST) memset (DST, ~0, num_current_words * sizeof(word))
85 #define CLEAR_ALL(DST) memset (DST, 0, num_current_words * sizeof(word))
87 #define INTERSECTN(DST, SRC1, SRC2, N) \
89 while (--n >= 0) DST[n] = SRC1[n] & SRC2[n]; \
92 #define UNION(DST, SRC1, SRC2) \
93 UNIONN (DST, SRC1, SRC2, num_current_words)
95 #define UNIONN(DST, SRC1, SRC2, N) \
97 while (--n >= 0) DST[n] = SRC1[n] | SRC2[n]; \
100 #define INTERSECT(DST, SRC1, SRC2) \
101 INTERSECTN (DST, SRC1, SRC2, num_current_words)
103 #define WORD_SIZE ((unsigned int)(sizeof(word) * BITS_PER_UNIT))
105 static void check_bool_init (tree
, words
, words
, words
);
106 static void check_init (tree
, words
);
107 static void check_cond_init (tree
, tree
, tree
, words
, words
, words
);
108 static void check_bool2_init (enum tree_code
, tree
, tree
, words
, words
, words
);
110 static void done_alternative (words
, struct alternatives
*);
111 static tree
get_variable_decl (tree
);
112 static void final_assign_error (tree
);
113 static void check_final_reassigned (tree
, words
);
115 #define ALLOC_WORDS(NUM) (xmalloc ((NUM) * sizeof (word)))
116 #define FREE_WORDS(PTR) (free (PTR))
118 /* DECLARE_BUFFERS is used to allocate NUMBUFFER bit sets, each of
119 which is an array of length num_current_words number of words.
120 Declares a new local variable BUFFER to hold the result (or rather
121 a pointer to the first of the bit sets). In almost all cases
122 num_current_words will be 1 or at most 2, so we try to stack
123 allocate the arrays in that case, using a stack array
124 named BUFFER##_short. Each DECLARE_BUFFERS must be matched by
125 a corresponding RELEASE_BUFFERS to avoid memory leaks. */
127 #define DECLARE_BUFFERS(BUFFER, NUMBUFFERS) \
128 word BUFFER##_short[2 * NUMBUFFERS]; \
129 words BUFFER = ALLOC_BUFFER(BUFFER##_short, NUMBUFFERS * num_current_words)
131 #define RELEASE_BUFFERS(BUFFER) \
132 FREE_BUFFER(BUFFER, BUFFER##_short)
134 #define ALLOC_BUFFER(SHORTBUFFER, NUMWORDS) \
135 ((NUMWORDS) * sizeof(word) <= sizeof(SHORTBUFFER) ? SHORTBUFFER \
136 : ALLOC_WORDS(NUMWORDS))
138 #define FREE_BUFFER(BUFFER, SHORTBUFFER) \
139 if (BUFFER != SHORTBUFFER) FREE_WORDS(BUFFER)
141 #define SET_P(WORDS, BIT) \
142 (WORDS[(BIT) / WORD_SIZE] & (1 << ((BIT) % WORD_SIZE)))
144 #define CLEAR_BIT(WORDS, BIT) \
145 (WORDS[(BIT) / WORD_SIZE] &= ~ (1 << ((BIT) % WORD_SIZE)))
147 #define SET_BIT(WORDS, BIT) \
148 (WORDS[(BIT) / WORD_SIZE] |= (1 << ((BIT) % WORD_SIZE)))
150 #define WORDS_NEEDED(BITS) (((BITS)+(WORD_SIZE-1))/(WORD_SIZE))
152 #define ASSIGNED_P(WORDS, BIT) SET_P(WORDS, 2 * (BIT))
153 #define UNASSIGNED_P(WORDS, BIT) SET_P(WORDS, 2 * (BIT) + 1)
155 #define SET_ASSIGNED(WORDS, INDEX) SET_BIT (WORDS, 2 * (INDEX))
156 #define SET_UNASSIGNED(WORDS, INDEX) SET_BIT (WORDS, 2 * (INDEX) + 1)
158 #define CLEAR_ASSIGNED(WORDS, INDEX) CLEAR_BIT (WORDS, 2 * (INDEX))
159 #define CLEAR_UNASSIGNED(WORDS, INDEX) CLEAR_BIT (WORDS, 2 * (INDEX) + 1)
161 /* Get the "interesting" declaration from a MODIFY_EXPR or COMPONENT_REF.
162 Return the declaration or NULL_TREE if no interesting declaration. */
165 get_variable_decl (exp
)
168 if (TREE_CODE (exp
) == VAR_DECL
)
170 if (! TREE_STATIC (exp
) || FIELD_FINAL (exp
))
173 /* We only care about final parameters. */
174 else if (TREE_CODE (exp
) == PARM_DECL
)
176 if (DECL_FINAL (exp
))
179 /* See if exp is this.field. */
180 else if (TREE_CODE (exp
) == COMPONENT_REF
)
182 tree op0
= TREE_OPERAND (exp
, 0);
183 tree op1
= TREE_OPERAND (exp
, 1);
184 tree mdecl
= current_function_decl
;
185 if (TREE_CODE (op0
) == INDIRECT_REF
186 && TREE_CODE (op1
) == FIELD_DECL
187 && ! METHOD_STATIC (mdecl
)
188 && FIELD_FINAL (op1
))
190 op0
= TREE_OPERAND (op0
, 0);
191 if (op0
== BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (mdecl
)))
199 final_assign_error (name
)
202 static const char format
[]
203 = "can't reassign a value to the final variable '%s'";
204 parse_error_context (wfl
, format
, IDENTIFIER_POINTER (name
));
208 check_final_reassigned (decl
, before
)
212 int index
= DECL_BIT_INDEX (decl
);
213 /* A final local already assigned or a final parameter
214 assigned must be reported as errors */
215 if (DECL_FINAL (decl
) && index
!= -2
216 && (index
< loop_current_locals
/* I.e. -1, or outside current loop. */
217 || ! UNASSIGNED_P (before
, index
)))
219 final_assign_error (DECL_NAME (decl
));
223 /* Check a conditional form (TEST_EXP ? THEN_EXP : ELSE_EXP) for
224 definite [un]assignment.
225 BEFORE, WHEN_FALSE, and WHEN_TRUE are as in check_bool_init. */
228 check_cond_init (test_exp
, then_exp
, else_exp
,
229 before
, when_false
, when_true
)
230 tree test_exp
, then_exp
, else_exp
;
231 words before
, when_false
, when_true
;
233 int save_start_current_locals
= start_current_locals
;
234 DECLARE_BUFFERS(test_false
, 6);
235 words test_true
= test_false
+ num_current_words
;
236 words then_false
= test_true
+ num_current_words
;
237 words then_true
= then_false
+ num_current_words
;
238 words else_false
= then_true
+ num_current_words
;
239 words else_true
= else_false
+ num_current_words
;
240 start_current_locals
= num_current_locals
;
242 check_bool_init (test_exp
, before
, test_false
, test_true
);
243 check_bool_init (then_exp
, test_true
, then_false
, then_true
);
244 check_bool_init (else_exp
, test_false
, else_false
, else_true
);
245 INTERSECT (when_false
, then_false
, else_false
);
246 INTERSECT (when_true
, then_true
, else_true
);
247 RELEASE_BUFFERS(test_false
);
248 start_current_locals
= save_start_current_locals
;
251 /* Check a boolean binary form CODE (EXP0, EXP1),
252 where CODE is one of EQ_EXPR, BIT_AND_EXPR, or BIT_IOR_EXPR.
253 BEFORE, WHEN_FALSE, and WHEN_TRUE are as in check_bool_init. */
256 check_bool2_init (code
, exp0
, exp1
, before
, when_false
, when_true
)
257 enum tree_code code
; tree exp0
, exp1
;
258 words before
, when_false
, when_true
;
261 words tmp
= num_current_words
<= 2 ? buf
262 : ALLOC_WORDS (4 * num_current_words
);
263 words when_false_0
= tmp
;
264 words when_false_1
= tmp
+num_current_words
;
265 words when_true_0
= tmp
+2*num_current_words
;
266 words when_true_1
= tmp
+3*num_current_words
;
267 check_bool_init (exp0
, before
, when_false_0
, when_true_0
);
268 INTERSECT (before
, when_false_0
, when_true_0
);
269 check_bool_init (exp1
, before
, when_false_1
, when_true_1
);
271 INTERSECT (before
, when_false_1
, when_true_1
);
276 * when_true = (when_false_1 INTERSECTION when_true_1)
277 * UNION (when_true_0 INTERSECTION when_false_1)
278 * UNION (when_false_0 INTERSECTION when_true_1);
279 * using when_false and before as temporary working areas. */
280 INTERSECT (when_true
, when_true_0
, when_false_1
);
281 INTERSECT (when_false
, when_true_0
, when_false_1
);
282 UNION (when_true
, when_true
, when_false
);
283 UNION (when_true
, when_true
, before
);
286 * when_false = (when_false_1 INTERSECTION when_true_1)
287 * UNION (when_true_0 INTERSECTION when_true_1)
288 * UNION (when_false_0 INTERSECTION when_false_1);
289 * using before as a temporary working area. */
290 INTERSECT (when_false
, when_true_0
, when_true_1
);
291 UNION (when_false
, when_false
, before
);
292 INTERSECT (before
, when_false_0
, when_false_1
);
293 UNION (when_false
, when_false
, before
);
295 else if (code
== BIT_AND_EXPR
|| code
== TRUTH_AND_EXPR
)
297 UNION (when_true
, when_true_0
, when_true_1
);
298 INTERSECT (when_false
, when_false_0
, when_false_1
);
299 UNION (when_false
, when_false
, before
);
301 else /* if (code == BIT_IOR_EXPR || code == TRUTH_OR_EXPR) */
303 UNION (when_false
, when_false_0
, when_false_1
);
304 INTERSECT (when_true
, when_true_0
, when_true_1
);
305 UNION (when_true
, when_true
, before
);
312 /* Check a boolean expression EXP for definite [un]assignment.
313 BEFORE is the set of variables definitely [un]assigned before the
314 conditional. (This bitstring may be modified arbitrarily in this function.)
315 On output, WHEN_FALSE is the set of variables [un]definitely assigned after
316 the conditional when the conditional is false.
317 On output, WHEN_TRUE is the set of variables definitely [un]assigned after
318 the conditional when the conditional is true.
319 (WHEN_FALSE and WHEN_TRUE are overwritten with initial values ignored.)
320 (None of BEFORE, WHEN_FALSE, or WHEN_TRUE can overlap, as they may
321 be used as temporary working areas. */
324 check_bool_init (exp
, before
, when_false
, when_true
)
326 words before
, when_false
, when_true
;
328 switch (TREE_CODE (exp
))
331 check_cond_init (TREE_OPERAND (exp
, 0), TREE_OPERAND (exp
, 1),
332 TREE_OPERAND (exp
, 2),
333 before
, when_false
, when_true
);
336 case TRUTH_ANDIF_EXPR
:
337 check_cond_init (TREE_OPERAND (exp
, 0),
338 TREE_OPERAND (exp
, 1), boolean_false_node
,
339 before
, when_false
, when_true
);
341 case TRUTH_ORIF_EXPR
:
342 check_cond_init (TREE_OPERAND (exp
, 0),
343 boolean_true_node
, TREE_OPERAND (exp
, 1),
344 before
, when_false
, when_true
);
347 check_bool_init (TREE_OPERAND (exp
, 0), before
, when_true
, when_false
);
351 tree tmp
= TREE_OPERAND (exp
, 0);
352 if ((tmp
= get_variable_decl (tmp
)) != NULL_TREE
)
355 check_bool_init (TREE_OPERAND (exp
, 1), before
,
356 when_false
, when_true
);
357 check_final_reassigned (tmp
, before
);
358 index
= DECL_BIT_INDEX (tmp
);
361 SET_ASSIGNED (when_false
, index
);
362 SET_ASSIGNED (when_true
, index
);
363 CLEAR_UNASSIGNED (when_false
, index
);
364 CLEAR_UNASSIGNED (when_true
, index
);
376 check_bool2_init (TREE_CODE (exp
),
377 TREE_OPERAND (exp
, 0), TREE_OPERAND (exp
, 1),
378 before
, when_false
, when_true
);
384 /* Just like EQ_EXPR, but switch when_true and when_false. */
385 check_bool2_init (EQ_EXPR
, TREE_OPERAND (exp
, 0), TREE_OPERAND (exp
, 1),
386 before
, when_true
, when_false
);
391 if (integer_zerop (exp
))
394 COPY (when_false
, before
);
398 SET_ALL (when_false
);
399 COPY (when_true
, before
);
404 check_init (exp
, before
);
405 COPY (when_false
, before
);
406 COPY (when_true
, before
);
410 /* Used to keep track of control flow branches. */
414 struct alternatives
*outer
;
416 /* The value of num_current_locals at the start of this compound. */
419 /* The value of the "before" set at the start of the control stucture.
420 Used for SWITCH_EXPR but not set for LABELED_BLOCK_EXPR. */
423 int save_start_current_locals
;
425 /* If num_current_words==1, combined==&one_word, for efficiency. */
428 /* The intersection of the "after" sets from previous branches. */
434 struct alternatives
* alternatives
= NULL
;
436 /* Begin handling a control flow branch.
437 BEFORE is the state of [un]assigned variables on entry.
438 CURRENT is a struct alt to manage the branch alternatives. */
440 #define BEGIN_ALTERNATIVES(before, current) \
442 current.saved = NULL; \
443 current.num_locals = num_current_locals; \
444 current.combined = num_current_words <= 1 ? ¤t.one_word \
445 : ALLOC_WORDS (num_current_words); \
446 SET_ALL (current.combined); \
447 current.outer = alternatives; \
448 alternatives = ¤t; \
449 current.save_start_current_locals = start_current_locals; \
450 start_current_locals = num_current_locals; \
453 /* We have finished with one branch of branching control flow.
454 Store the [un]assigned state, merging (intersecting) it with the state
455 of previous alternative branches. */
458 done_alternative (after
, current
)
460 struct alternatives
*current
;
462 INTERSECTN (current
->combined
, current
->combined
, after
,
463 WORDS_NEEDED (2 * current
->num_locals
));
466 /* Used when we done with a control flow branch and are all merged again.
467 * AFTER is the merged state of [un]assigned variables,
468 CURRENT is a struct alt that was passed to BEGIN_ALTERNATIVES. */
470 #define END_ALTERNATIVES(after, current) \
472 alternatives = current.outer; \
473 COPY (after, current.combined); \
474 if (current.combined != ¤t.one_word) \
475 FREE_WORDS (current.combined); \
476 start_current_locals = current.save_start_current_locals; \
479 /* Check for (un)initialized local variables in EXP. */
482 check_init (exp
, before
)
488 switch (TREE_CODE (exp
))
492 if (! FIELD_STATIC (exp
) && DECL_NAME (exp
) != NULL_TREE
493 && DECL_NAME (exp
) != this_identifier_node
)
495 int index
= DECL_BIT_INDEX (exp
);
496 /* We don't want to report and mark as non initialized class
497 initialization flags. */
498 if (! LOCAL_CLASS_INITIALIZATION_FLAG_P (exp
)
499 && index
>= 0 && ! ASSIGNED_P (before
, index
))
502 (wfl
, "Variable `%s' may not have been initialized",
503 IDENTIFIER_POINTER (DECL_NAME (exp
)));
504 /* Suppress further errors. */
505 DECL_BIT_INDEX (exp
) = -2;
511 check_init (TREE_OPERAND (exp
, 0), before
);
512 if ((tmp
= get_variable_decl (exp
)) != NULL_TREE
)
514 int index
= DECL_BIT_INDEX (tmp
);
515 if (index
>= 0 && ! ASSIGNED_P (before
, index
))
518 (wfl
, "variable '%s' may not have been initialized",
519 IDENTIFIER_POINTER (DECL_NAME (tmp
)));
520 /* Suppress further errors. */
521 DECL_BIT_INDEX (tmp
) = -2;
527 tmp
= TREE_OPERAND (exp
, 0);
528 /* We're interested in variable declaration and parameter
529 declaration when they're declared with the `final' modifier. */
530 if ((tmp
= get_variable_decl (tmp
)) != NULL_TREE
)
533 check_init (TREE_OPERAND (exp
, 1), before
);
534 check_final_reassigned (tmp
, before
);
535 index
= DECL_BIT_INDEX (tmp
);
538 SET_ASSIGNED (before
, index
);
539 CLEAR_UNASSIGNED (before
, index
);
541 /* Minor optimization. See comment for start_current_locals.
542 If we're optimizing for class initialization, we keep
543 this information to check whether the variable is
544 definitely assigned when once we checked the whole
546 if (! STATIC_CLASS_INIT_OPT_P () /* FIXME */
547 && index
>= start_current_locals
548 && index
== num_current_locals
- 1)
550 num_current_locals
--;
551 DECL_BIT_INDEX (tmp
) = -1;
555 else if (TREE_CODE (tmp
= TREE_OPERAND (exp
, 0)) == COMPONENT_REF
)
558 check_init (tmp
, before
);
559 check_init (TREE_OPERAND (exp
, 1), before
);
560 decl
= TREE_OPERAND (tmp
, 1);
561 if (DECL_FINAL (decl
))
562 final_assign_error (DECL_NAME (decl
));
565 else if (TREE_CODE (tmp
) == COMPONENT_REF
&& IS_ARRAY_LENGTH_ACCESS (tmp
))
567 /* We can't emit a more specific message here, because when
568 compiling to bytecodes we don't get here. */
569 final_assign_error (length_identifier_node
);
574 if (BLOCK_EXPR_BODY (exp
))
576 tree decl
= BLOCK_EXPR_DECLS (exp
);
580 int save_start_current_locals
= start_current_locals
;
581 int save_num_current_words
= num_current_words
;
582 start_current_locals
= num_current_locals
;
583 for (; decl
!= NULL_TREE
; decl
= TREE_CHAIN (decl
))
585 DECL_BIT_INDEX (decl
) = num_current_locals
++;
587 words_needed
= WORDS_NEEDED (2 * num_current_locals
);
588 if (words_needed
> num_current_words
)
590 tmp
= ALLOC_WORDS (words_needed
);
592 num_current_words
= words_needed
;
596 for (i
= start_current_locals
; i
< num_current_locals
; i
++)
598 CLEAR_ASSIGNED (tmp
, i
);
599 SET_UNASSIGNED (tmp
, i
);
601 check_init (BLOCK_EXPR_BODY (exp
), tmp
);
603 /* Re-set DECL_BIT_INDEX since it is also DECL_POINTER_ALIAS_SET. */
604 for (decl
= BLOCK_EXPR_DECLS (exp
);
605 decl
!= NULL_TREE
; decl
= TREE_CHAIN (decl
))
607 if (LOCAL_CLASS_INITIALIZATION_FLAG_P (decl
))
609 int index
= DECL_BIT_INDEX (decl
);
610 tree fndecl
= DECL_CONTEXT (decl
);
611 if (fndecl
&& METHOD_STATIC (fndecl
)
612 && (DECL_INITIAL (decl
) == boolean_true_node
613 || (index
>= 0 && ASSIGNED_P (tmp
, index
))))
615 (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (fndecl
),
616 DECL_FUNCTION_INIT_TEST_CLASS (decl
), INSERT
)) =
617 DECL_FUNCTION_INIT_TEST_CLASS (decl
);
619 DECL_BIT_INDEX (decl
) = -1;
622 num_current_locals
= start_current_locals
;
623 start_current_locals
= save_start_current_locals
;
626 num_current_words
= save_num_current_words
;
634 /* The JLS 2nd edition discusses a complication determining
635 definite unassignment of loop statements. They define a
636 "hypothetical" analysis model. We do something much
637 simpler: We just disallow assignments inside loops to final
638 variables declared outside the loop. This means we may
639 disallow some contrived assignments that the JLS, but I
640 can't see how anything except a very contrived testcase (a
641 do-while whose condition is false?) would care. */
643 struct alternatives alt
;
644 int save_loop_current_locals
= loop_current_locals
;
645 int save_start_current_locals
= start_current_locals
;
646 loop_current_locals
= num_current_locals
;
647 start_current_locals
= num_current_locals
;
648 BEGIN_ALTERNATIVES (before
, alt
);
650 check_init (TREE_OPERAND (exp
, 0), before
);
651 END_ALTERNATIVES (before
, alt
);
652 loop_current_locals
= save_loop_current_locals
;
653 start_current_locals
= save_start_current_locals
;
658 struct alternatives
*alt
= alternatives
;
659 DECLARE_BUFFERS(when_true
, 2);
660 words when_false
= when_true
+ num_current_words
;
661 #ifdef ENABLE_JC1_CHECKING
662 if (TREE_CODE (alt
->block
) != LOOP_EXPR
)
665 check_bool_init (TREE_OPERAND (exp
, 0), before
, when_false
, when_true
);
666 done_alternative (when_true
, alt
);
667 COPY (before
, when_false
);
668 RELEASE_BUFFERS(when_true
);
671 case LABELED_BLOCK_EXPR
:
673 struct alternatives alt
;
674 BEGIN_ALTERNATIVES (before
, alt
);
676 if (LABELED_BLOCK_BODY (exp
))
677 check_init (LABELED_BLOCK_BODY (exp
), before
);
678 done_alternative (before
, &alt
);
679 END_ALTERNATIVES (before
, alt
);
682 case EXIT_BLOCK_EXPR
:
684 tree block
= TREE_OPERAND (exp
, 0);
685 struct alternatives
*alt
= alternatives
;
686 while (alt
->block
!= block
)
688 done_alternative (before
, alt
);
694 struct alternatives alt
;
696 check_init (TREE_OPERAND (exp
, 0), before
);
697 BEGIN_ALTERNATIVES (before
, alt
);
698 alt
.saved
= ALLOC_BUFFER(buf
, num_current_words
);
699 COPY (alt
.saved
, before
);
701 check_init (TREE_OPERAND (exp
, 1), before
);
702 done_alternative (before
, &alt
);
703 if (! SWITCH_HAS_DEFAULT (exp
))
704 done_alternative (alt
.saved
, &alt
);
705 FREE_BUFFER(alt
.saved
, buf
);
706 END_ALTERNATIVES (before
, alt
);
713 struct alternatives
*alt
= alternatives
;
714 while (TREE_CODE (alt
->block
) != SWITCH_EXPR
)
716 COPYN (before
, alt
->saved
, WORDS_NEEDED (2 * alt
->num_locals
));
717 for (i
= alt
->num_locals
; i
< num_current_locals
; i
++)
718 CLEAR_ASSIGNED (before
, i
);
724 tree try_clause
= TREE_OPERAND (exp
, 0);
725 tree clause
= TREE_OPERAND (exp
, 1);
727 words tmp
= (num_current_words
<= 2 ? buf
728 : ALLOC_WORDS (2 * num_current_words
));
729 words save
= tmp
+ num_current_words
;
730 struct alternatives alt
;
731 BEGIN_ALTERNATIVES (before
, alt
);
734 check_init (try_clause
, tmp
);
735 done_alternative (tmp
, &alt
);
736 for ( ; clause
!= NULL_TREE
; clause
= TREE_CHAIN (clause
))
738 tree catch_clause
= TREE_OPERAND (clause
, 0);
740 check_init (catch_clause
, tmp
);
741 done_alternative (tmp
, &alt
);
747 END_ALTERNATIVES (before
, alt
);
751 case TRY_FINALLY_EXPR
:
753 DECLARE_BUFFERS(tmp
, 1);
755 check_init (TREE_OPERAND (exp
, 0), before
);
756 check_init (TREE_OPERAND (exp
, 1), tmp
);
757 UNION (before
, before
, tmp
);
758 RELEASE_BUFFERS(tmp
);
764 if (TREE_OPERAND (exp
, 0))
765 check_init (TREE_OPERAND (exp
, 0), before
);
766 goto never_continues
;
774 case TRUTH_ANDIF_EXPR
:
775 case TRUTH_ORIF_EXPR
:
777 DECLARE_BUFFERS(when_true
, 2);
778 words when_false
= when_true
+ num_current_words
;
779 check_bool_init (exp
, before
, when_false
, when_true
);
780 INTERSECT (before
, when_false
, when_true
);
781 RELEASE_BUFFERS(when_true
);
786 if (exp
== empty_stmt_node
)
788 /* ... else fall through ... */
789 case UNARY_PLUS_EXPR
:
802 case NON_LVALUE_EXPR
:
803 case INSTANCEOF_EXPR
:
809 /* Avoid needless recursion. */
810 exp
= TREE_OPERAND (exp
, 0);
813 case PREDECREMENT_EXPR
:
814 case PREINCREMENT_EXPR
:
815 case POSTDECREMENT_EXPR
:
816 case POSTINCREMENT_EXPR
:
817 tmp
= get_variable_decl (TREE_OPERAND (exp
, 0));
818 if (tmp
!= NULL_TREE
&& DECL_FINAL (tmp
))
819 final_assign_error (DECL_NAME (tmp
));
821 /* Avoid needless recursion. */
822 exp
= TREE_OPERAND (exp
, 0);
826 if (IS_INIT_CHECKED (exp
))
828 IS_INIT_CHECKED (exp
) = 1;
829 exp
= TREE_OPERAND (exp
, 0);
864 check_init (TREE_OPERAND (exp
, 0), before
);
865 /* Avoid needless recursion, especially for COMPOUND_EXPR. */
866 exp
= TREE_OPERAND (exp
, 1);
874 case JAVA_EXC_OBJ_EXPR
:
880 tree func
= TREE_OPERAND (exp
, 0);
881 tree x
= TREE_OPERAND (exp
, 1);
882 if (TREE_CODE (func
) == ADDR_EXPR
)
883 func
= TREE_OPERAND (func
, 0);
884 check_init (func
, before
);
886 for ( ; x
!= NULL_TREE
; x
= TREE_CHAIN (x
))
887 check_init (TREE_VALUE (x
), before
);
888 if (func
== throw_node
)
889 goto never_continues
;
895 tree x
= CONSTRUCTOR_ELTS (TREE_OPERAND (exp
, 0));
896 for ( ; x
!= NULL_TREE
; x
= TREE_CHAIN (x
))
897 check_init (TREE_VALUE (x
), before
);
901 case EXPR_WITH_FILE_LOCATION
:
903 const char *saved_input_filename
= input_filename
;
904 tree saved_wfl
= wfl
;
905 tree body
= EXPR_WFL_NODE (exp
);
906 int saved_lineno
= lineno
;
907 if (body
== empty_stmt_node
)
910 input_filename
= EXPR_WFL_FILENAME (exp
);
911 lineno
= EXPR_WFL_LINENO (exp
);
912 check_init (body
, before
);
913 input_filename
= saved_input_filename
;
914 lineno
= saved_lineno
;
921 ("internal error in check-init: tree code not implemented: %s",
922 tree_code_name
[(int) TREE_CODE (exp
)]);
927 check_for_initialization (body
, mdecl
)
933 tree owner
= DECL_CONTEXT (mdecl
);
934 int is_static_method
= METHOD_STATIC (mdecl
);
935 /* We don't need to check final fields of <init> it it calls this(). */
936 int is_finit_method
= DECL_FINIT_P (mdecl
) || DECL_INSTINIT_P (mdecl
);
938 = (is_finit_method
|| DECL_CLINIT_P (mdecl
)
939 || (DECL_INIT_P (mdecl
) && ! DECL_INIT_CALLS_THIS (mdecl
)));
941 start_current_locals
= num_current_locals
= 0;
942 num_current_words
= 2;
947 for (decl
= TYPE_FIELDS (owner
);
948 decl
!= NULL_TREE
; decl
= TREE_CHAIN (decl
))
950 if (DECL_FINAL (decl
) && FIELD_STATIC (decl
) == is_static_method
)
952 if (DECL_FIELD_FINAL_IUD (decl
))
953 DECL_BIT_INDEX (decl
) = -1;
955 DECL_BIT_INDEX (decl
) = num_current_locals
++;
958 words_needed
= WORDS_NEEDED (2 * num_current_locals
);
959 if (words_needed
> 2)
961 num_current_words
= words_needed
;
962 before
= ALLOC_WORDS(words_needed
);
965 for (decl
= TYPE_FIELDS (owner
);
966 decl
!= NULL_TREE
; decl
= TREE_CHAIN (decl
))
968 if (FIELD_FINAL (decl
) && FIELD_STATIC (decl
) == is_static_method
)
970 if (! DECL_FIELD_FINAL_IUD (decl
))
972 CLEAR_ASSIGNED (before
, i
);
973 SET_UNASSIGNED (before
, i
);
981 check_init (body
, before
);
985 for (decl
= TYPE_FIELDS (owner
);
986 decl
!= NULL_TREE
; decl
= TREE_CHAIN (decl
))
988 if (FIELD_FINAL (decl
) && FIELD_STATIC (decl
) == is_static_method
)
990 int index
= DECL_BIT_INDEX (decl
);
991 if (index
>= 0 && ! ASSIGNED_P (before
, index
))
993 if (! is_finit_method
)
994 error_with_decl (decl
, "final field '%s' may not have been initialized");
996 else if (is_finit_method
)
997 DECL_FIELD_FINAL_IUD (decl
) = 1;
999 /* Re-set to initial state, since we later may use the
1000 same bit for DECL_POINTER_ALIAS_SET. */
1001 DECL_BIT_INDEX (decl
) = -1;
1006 start_current_locals
= num_current_locals
= 0;