1 /* Code to test for "definitive [un]assignment".
2 Copyright (C) 1999, 2000, 2001, 2003, 2004 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 (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 local 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 (tree exp
)
167 if (TREE_CODE (exp
) == VAR_DECL
)
169 if (! TREE_STATIC (exp
) || FIELD_FINAL (exp
))
172 /* We only care about final parameters. */
173 else if (TREE_CODE (exp
) == PARM_DECL
)
175 if (DECL_FINAL (exp
))
178 /* See if exp is this.field. */
179 else if (TREE_CODE (exp
) == COMPONENT_REF
)
181 tree op0
= TREE_OPERAND (exp
, 0);
182 tree op1
= TREE_OPERAND (exp
, 1);
183 tree mdecl
= current_function_decl
;
184 if (TREE_CODE (op0
) == INDIRECT_REF
185 && TREE_CODE (op1
) == FIELD_DECL
186 && ! METHOD_STATIC (mdecl
)
187 && FIELD_FINAL (op1
))
189 op0
= TREE_OPERAND (op0
, 0);
190 if (op0
== BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (mdecl
)))
198 final_assign_error (tree name
)
200 static const char format
[]
201 = "Can't reassign a value to the final variable `%s'";
202 parse_error_context (wfl
, format
, IDENTIFIER_POINTER (name
));
206 check_final_reassigned (tree decl
, words before
)
208 int index
= DECL_BIT_INDEX (decl
);
209 /* A final local already assigned or a final parameter
210 assigned must be reported as errors */
211 if (DECL_FINAL (decl
) && index
!= -2
212 && (index
< loop_current_locals
/* I.e. -1, or outside current loop. */
213 || (DECL_LOCAL_FINAL_IUD (decl
) ? ASSIGNED_P (before
, index
)
214 : ! UNASSIGNED_P (before
, index
))))
216 final_assign_error (DECL_NAME (decl
));
220 /* Check a conditional form (TEST_EXP ? THEN_EXP : ELSE_EXP) for
221 definite [un]assignment.
222 BEFORE, WHEN_FALSE, and WHEN_TRUE are as in check_bool_init. */
225 check_cond_init (tree test_exp
, tree then_exp
, tree else_exp
,
226 words before
, words when_false
, words when_true
)
228 int save_start_current_locals
= start_current_locals
;
229 DECLARE_BUFFERS(test_false
, 6);
230 words test_true
= test_false
+ num_current_words
;
231 words then_false
= test_true
+ num_current_words
;
232 words then_true
= then_false
+ num_current_words
;
233 words else_false
= then_true
+ num_current_words
;
234 words else_true
= else_false
+ num_current_words
;
235 start_current_locals
= num_current_locals
;
237 check_bool_init (test_exp
, before
, test_false
, test_true
);
238 check_bool_init (then_exp
, test_true
, then_false
, then_true
);
239 check_bool_init (else_exp
, test_false
, else_false
, else_true
);
240 INTERSECT (when_false
, then_false
, else_false
);
241 INTERSECT (when_true
, then_true
, else_true
);
242 RELEASE_BUFFERS(test_false
);
243 start_current_locals
= save_start_current_locals
;
246 /* Check a boolean binary form CODE (EXP0, EXP1),
247 where CODE is one of EQ_EXPR, BIT_AND_EXPR, or BIT_IOR_EXPR.
248 BEFORE, WHEN_FALSE, and WHEN_TRUE are as in check_bool_init. */
251 check_bool2_init (enum tree_code code
, tree exp0
, tree exp1
,
252 words before
, words when_false
, words when_true
)
255 words tmp
= num_current_words
<= 2 ? buf
256 : ALLOC_WORDS (4 * num_current_words
);
257 words when_false_0
= tmp
;
258 words when_false_1
= tmp
+num_current_words
;
259 words when_true_0
= tmp
+2*num_current_words
;
260 words when_true_1
= tmp
+3*num_current_words
;
261 check_bool_init (exp0
, before
, when_false_0
, when_true_0
);
262 INTERSECT (before
, when_false_0
, when_true_0
);
263 check_bool_init (exp1
, before
, when_false_1
, when_true_1
);
265 INTERSECT (before
, when_false_1
, when_true_1
);
270 * when_true = (when_false_1 INTERSECTION when_true_1)
271 * UNION (when_true_0 INTERSECTION when_false_1)
272 * UNION (when_false_0 INTERSECTION when_true_1);
273 * using when_false and before as temporary working areas. */
274 INTERSECT (when_true
, when_true_0
, when_false_1
);
275 INTERSECT (when_false
, when_true_0
, when_false_1
);
276 UNION (when_true
, when_true
, when_false
);
277 UNION (when_true
, when_true
, before
);
280 * when_false = (when_false_1 INTERSECTION when_true_1)
281 * UNION (when_true_0 INTERSECTION when_true_1)
282 * UNION (when_false_0 INTERSECTION when_false_1);
283 * using before as a temporary working area. */
284 INTERSECT (when_false
, when_true_0
, when_true_1
);
285 UNION (when_false
, when_false
, before
);
286 INTERSECT (before
, when_false_0
, when_false_1
);
287 UNION (when_false
, when_false
, before
);
289 else if (code
== BIT_AND_EXPR
|| code
== TRUTH_AND_EXPR
)
291 UNION (when_true
, when_true_0
, when_true_1
);
292 INTERSECT (when_false
, when_false_0
, when_false_1
);
293 UNION (when_false
, when_false
, before
);
295 else /* if (code == BIT_IOR_EXPR || code == TRUTH_OR_EXPR) */
297 UNION (when_false
, when_false_0
, when_false_1
);
298 INTERSECT (when_true
, when_true_0
, when_true_1
);
299 UNION (when_true
, when_true
, before
);
306 /* Check a boolean expression EXP for definite [un]assignment.
307 BEFORE is the set of variables definitely [un]assigned before the
308 conditional. (This bitstring may be modified arbitrarily in this function.)
309 On output, WHEN_FALSE is the set of variables definitely [un]assigned after
310 the conditional when the conditional is false.
311 On output, WHEN_TRUE is the set of variables definitely [un]assigned after
312 the conditional when the conditional is true.
313 (WHEN_FALSE and WHEN_TRUE are overwritten with initial values ignored.)
314 (None of BEFORE, WHEN_FALSE, or WHEN_TRUE can overlap, as they may
315 be used as temporary working areas. */
318 check_bool_init (tree exp
, words before
, words when_false
, words when_true
)
320 switch (TREE_CODE (exp
))
323 check_cond_init (TREE_OPERAND (exp
, 0), TREE_OPERAND (exp
, 1),
324 TREE_OPERAND (exp
, 2),
325 before
, when_false
, when_true
);
328 case TRUTH_ANDIF_EXPR
:
329 check_cond_init (TREE_OPERAND (exp
, 0),
330 TREE_OPERAND (exp
, 1), boolean_false_node
,
331 before
, when_false
, when_true
);
333 case TRUTH_ORIF_EXPR
:
334 check_cond_init (TREE_OPERAND (exp
, 0),
335 boolean_true_node
, TREE_OPERAND (exp
, 1),
336 before
, when_false
, when_true
);
339 check_bool_init (TREE_OPERAND (exp
, 0), before
, when_true
, when_false
);
347 check_bool2_init (TREE_CODE (exp
),
348 TREE_OPERAND (exp
, 0), TREE_OPERAND (exp
, 1),
349 before
, when_false
, when_true
);
355 /* Just like EQ_EXPR, but switch when_true and when_false. */
356 check_bool2_init (EQ_EXPR
, TREE_OPERAND (exp
, 0), TREE_OPERAND (exp
, 1),
357 before
, when_true
, when_false
);
362 if (integer_zerop (exp
))
365 COPY (when_false
, before
);
369 SET_ALL (when_false
);
370 COPY (when_true
, before
);
375 check_init (exp
, before
);
376 COPY (when_false
, before
);
377 COPY (when_true
, before
);
381 /* Used to keep track of control flow branches. */
385 struct alternatives
*outer
;
387 /* The value of num_current_locals at the start of this compound. */
390 /* The value of the "before" set at the start of the control structure.
391 Used for SWITCH_EXPR but not set for LABELED_BLOCK_EXPR. */
394 int save_start_current_locals
;
396 /* If num_current_words==1, combined==&one_word, for efficiency. */
399 /* The intersection of the "after" sets from previous branches. */
405 struct alternatives
* alternatives
= NULL
;
407 /* Begin handling a control flow branch.
408 BEFORE is the state of [un]assigned variables on entry.
409 CURRENT is a struct alt to manage the branch alternatives. */
411 #define BEGIN_ALTERNATIVES(before, current) \
413 current.saved = NULL; \
414 current.num_locals = num_current_locals; \
415 current.combined = num_current_words <= 1 ? ¤t.one_word \
416 : ALLOC_WORDS (num_current_words); \
417 SET_ALL (current.combined); \
418 current.outer = alternatives; \
419 alternatives = ¤t; \
420 current.save_start_current_locals = start_current_locals; \
421 start_current_locals = num_current_locals; \
424 /* We have finished with one branch of branching control flow.
425 Store the [un]assigned state, merging (intersecting) it with the state
426 of previous alternative branches. */
429 done_alternative (words after
, struct alternatives
*current
)
431 INTERSECTN (current
->combined
, current
->combined
, after
,
432 WORDS_NEEDED (2 * current
->num_locals
));
435 /* Used when we are done with a control flow branch and are all merged again.
436 AFTER is the merged state of [un]assigned variables,
437 CURRENT is a struct alt that was passed to BEGIN_ALTERNATIVES. */
439 #define END_ALTERNATIVES(after, current) \
441 alternatives = current.outer; \
442 COPY (after, current.combined); \
443 if (current.combined != ¤t.one_word) \
444 FREE_WORDS (current.combined); \
445 start_current_locals = current.save_start_current_locals; \
448 /* Check for [un]initialized local variables in EXP. */
451 check_init (tree exp
, words before
)
455 switch (TREE_CODE (exp
))
459 if (! FIELD_STATIC (exp
) && DECL_NAME (exp
) != NULL_TREE
460 && DECL_NAME (exp
) != this_identifier_node
)
462 int index
= DECL_BIT_INDEX (exp
);
463 /* We don't want to report and mark as non-initialized class
464 initialization flags. */
465 if (! LOCAL_CLASS_INITIALIZATION_FLAG_P (exp
)
466 && index
>= 0 && ! ASSIGNED_P (before
, index
))
469 (wfl
, "Variable `%s' may not have been initialized",
470 IDENTIFIER_POINTER (DECL_NAME (exp
)));
471 /* Suppress further errors. */
472 DECL_BIT_INDEX (exp
) = -2;
478 check_init (TREE_OPERAND (exp
, 0), before
);
479 if ((tmp
= get_variable_decl (exp
)) != NULL_TREE
)
481 int index
= DECL_BIT_INDEX (tmp
);
482 if (index
>= 0 && ! ASSIGNED_P (before
, index
))
485 (wfl
, "variable `%s' may not have been initialized",
486 IDENTIFIER_POINTER (DECL_NAME (tmp
)));
487 /* Suppress further errors. */
488 DECL_BIT_INDEX (tmp
) = -2;
494 tmp
= TREE_OPERAND (exp
, 0);
495 /* We're interested in variable declaration and parameter
496 declaration when they're declared with the `final' modifier. */
497 if ((tmp
= get_variable_decl (tmp
)) != NULL_TREE
)
500 check_init (TREE_OPERAND (exp
, 1), before
);
501 check_final_reassigned (tmp
, before
);
502 index
= DECL_BIT_INDEX (tmp
);
505 SET_ASSIGNED (before
, index
);
506 CLEAR_UNASSIGNED (before
, index
);
508 /* Minor optimization. See comment for start_current_locals.
509 If we're optimizing for class initialization, we keep
510 this information to check whether the variable is
511 definitely assigned when once we checked the whole
513 if (! STATIC_CLASS_INIT_OPT_P () /* FIXME */
514 && ! DECL_FINAL (tmp
)
515 && index
>= start_current_locals
516 && index
== num_current_locals
- 1)
518 num_current_locals
--;
519 DECL_BIT_INDEX (tmp
) = -1;
523 else if (TREE_CODE (tmp
= TREE_OPERAND (exp
, 0)) == COMPONENT_REF
)
526 check_init (tmp
, before
);
527 check_init (TREE_OPERAND (exp
, 1), before
);
528 decl
= TREE_OPERAND (tmp
, 1);
529 if (DECL_FINAL (decl
))
530 final_assign_error (DECL_NAME (decl
));
533 else if (TREE_CODE (tmp
) == COMPONENT_REF
&& IS_ARRAY_LENGTH_ACCESS (tmp
))
535 /* We can't emit a more specific message here, because when
536 compiling to bytecodes we don't get here. */
537 final_assign_error (length_identifier_node
);
542 if (BLOCK_EXPR_BODY (exp
))
544 tree decl
= BLOCK_EXPR_DECLS (exp
);
548 int save_start_current_locals
= start_current_locals
;
549 int save_num_current_words
= num_current_words
;
550 start_current_locals
= num_current_locals
;
551 for (; decl
!= NULL_TREE
; decl
= TREE_CHAIN (decl
))
553 DECL_BIT_INDEX (decl
) = num_current_locals
++;
555 words_needed
= WORDS_NEEDED (2 * num_current_locals
);
556 if (words_needed
> num_current_words
)
558 tmp
= ALLOC_WORDS (words_needed
);
560 num_current_words
= words_needed
;
564 for (i
= start_current_locals
; i
< num_current_locals
; i
++)
566 CLEAR_ASSIGNED (tmp
, i
);
567 SET_UNASSIGNED (tmp
, i
);
569 check_init (BLOCK_EXPR_BODY (exp
), tmp
);
571 /* Re-set DECL_BIT_INDEX since it is also DECL_POINTER_ALIAS_SET. */
572 for (decl
= BLOCK_EXPR_DECLS (exp
);
573 decl
!= NULL_TREE
; decl
= TREE_CHAIN (decl
))
575 if (LOCAL_CLASS_INITIALIZATION_FLAG_P (decl
))
577 int index
= DECL_BIT_INDEX (decl
);
578 tree fndecl
= DECL_CONTEXT (decl
);
579 if (fndecl
&& METHOD_STATIC (fndecl
)
580 && (DECL_INITIAL (decl
) == boolean_true_node
581 || (index
>= 0 && ASSIGNED_P (tmp
, index
))))
583 (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (fndecl
),
584 DECL_FUNCTION_INIT_TEST_CLASS (decl
), INSERT
)) =
585 DECL_FUNCTION_INIT_TEST_CLASS (decl
);
587 DECL_BIT_INDEX (decl
) = -1;
590 num_current_locals
= start_current_locals
;
591 start_current_locals
= save_start_current_locals
;
594 num_current_words
= save_num_current_words
;
602 /* The JLS 2nd edition discusses a complication determining
603 definite unassignment of loop statements. They define a
604 "hypothetical" analysis model. We do something much
605 simpler: We just disallow assignments inside loops to final
606 variables declared outside the loop. This means we may
607 disallow some contrived assignments that the JLS allows, but I
608 can't see how anything except a very contrived testcase (a
609 do-while whose condition is false?) would care. */
611 struct alternatives alt
;
612 int save_loop_current_locals
= loop_current_locals
;
613 int save_start_current_locals
= start_current_locals
;
614 loop_current_locals
= num_current_locals
;
615 start_current_locals
= num_current_locals
;
616 BEGIN_ALTERNATIVES (before
, alt
);
618 check_init (TREE_OPERAND (exp
, 0), before
);
619 END_ALTERNATIVES (before
, alt
);
620 loop_current_locals
= save_loop_current_locals
;
621 start_current_locals
= save_start_current_locals
;
626 struct alternatives
*alt
= alternatives
;
627 DECLARE_BUFFERS(when_true
, 2);
628 words when_false
= when_true
+ num_current_words
;
629 #ifdef ENABLE_JC1_CHECKING
630 if (TREE_CODE (alt
->block
) != LOOP_EXPR
)
633 check_bool_init (TREE_OPERAND (exp
, 0), before
, when_false
, when_true
);
634 done_alternative (when_true
, alt
);
635 COPY (before
, when_false
);
636 RELEASE_BUFFERS(when_true
);
639 case LABELED_BLOCK_EXPR
:
641 struct alternatives alt
;
642 BEGIN_ALTERNATIVES (before
, alt
);
644 if (LABELED_BLOCK_BODY (exp
))
645 check_init (LABELED_BLOCK_BODY (exp
), before
);
646 done_alternative (before
, &alt
);
647 END_ALTERNATIVES (before
, alt
);
650 case EXIT_BLOCK_EXPR
:
652 tree block
= TREE_OPERAND (exp
, 0);
653 struct alternatives
*alt
= alternatives
;
654 while (alt
->block
!= block
)
656 done_alternative (before
, alt
);
662 struct alternatives alt
;
664 check_init (TREE_OPERAND (exp
, 0), before
);
665 BEGIN_ALTERNATIVES (before
, alt
);
666 alt
.saved
= ALLOC_BUFFER(buf
, num_current_words
);
667 COPY (alt
.saved
, before
);
669 check_init (TREE_OPERAND (exp
, 1), before
);
670 done_alternative (before
, &alt
);
671 if (! SWITCH_HAS_DEFAULT (exp
))
672 done_alternative (alt
.saved
, &alt
);
673 FREE_BUFFER(alt
.saved
, buf
);
674 END_ALTERNATIVES (before
, alt
);
681 struct alternatives
*alt
= alternatives
;
682 while (TREE_CODE (alt
->block
) != SWITCH_EXPR
)
684 COPYN (before
, alt
->saved
, WORDS_NEEDED (2 * alt
->num_locals
));
685 for (i
= alt
->num_locals
; i
< num_current_locals
; i
++)
686 CLEAR_ASSIGNED (before
, i
);
692 tree try_clause
= TREE_OPERAND (exp
, 0);
693 tree clause
= TREE_OPERAND (exp
, 1);
695 words tmp
= (num_current_words
<= 2 ? buf
696 : ALLOC_WORDS (2 * num_current_words
));
697 words save
= tmp
+ num_current_words
;
698 struct alternatives alt
;
699 BEGIN_ALTERNATIVES (before
, alt
);
702 check_init (try_clause
, tmp
);
703 done_alternative (tmp
, &alt
);
704 for ( ; clause
!= NULL_TREE
; clause
= TREE_CHAIN (clause
))
706 tree catch_clause
= TREE_OPERAND (clause
, 0);
708 check_init (catch_clause
, tmp
);
709 done_alternative (tmp
, &alt
);
715 END_ALTERNATIVES (before
, alt
);
719 case TRY_FINALLY_EXPR
:
721 DECLARE_BUFFERS(tmp
, 1);
723 check_init (TREE_OPERAND (exp
, 0), before
);
724 check_init (TREE_OPERAND (exp
, 1), tmp
);
725 UNION (before
, before
, tmp
);
726 RELEASE_BUFFERS(tmp
);
732 if (TREE_OPERAND (exp
, 0))
733 check_init (TREE_OPERAND (exp
, 0), before
);
734 goto never_continues
;
742 case TRUTH_ANDIF_EXPR
:
743 case TRUTH_ORIF_EXPR
:
745 DECLARE_BUFFERS(when_true
, 2);
746 words when_false
= when_true
+ num_current_words
;
747 check_bool_init (exp
, before
, when_false
, when_true
);
748 INTERSECT (before
, when_false
, when_true
);
749 RELEASE_BUFFERS(when_true
);
754 if (IS_EMPTY_STMT (exp
))
756 /* ... else fall through ... */
757 case UNARY_PLUS_EXPR
:
770 case NON_LVALUE_EXPR
:
771 case INSTANCEOF_EXPR
:
776 /* Avoid needless recursion. */
777 exp
= TREE_OPERAND (exp
, 0);
780 case PREDECREMENT_EXPR
:
781 case PREINCREMENT_EXPR
:
782 case POSTDECREMENT_EXPR
:
783 case POSTINCREMENT_EXPR
:
784 tmp
= get_variable_decl (TREE_OPERAND (exp
, 0));
785 if (tmp
!= NULL_TREE
&& DECL_FINAL (tmp
))
786 final_assign_error (DECL_NAME (tmp
));
788 /* Avoid needless recursion. */
789 exp
= TREE_OPERAND (exp
, 0);
793 if (IS_INIT_CHECKED (exp
))
795 IS_INIT_CHECKED (exp
) = 1;
796 exp
= TREE_OPERAND (exp
, 0);
837 check_init (TREE_OPERAND (exp
, 0), before
);
838 /* Avoid needless recursion, especially for COMPOUND_EXPR. */
839 exp
= TREE_OPERAND (exp
, 1);
847 case JAVA_EXC_OBJ_EXPR
:
853 tree func
= TREE_OPERAND (exp
, 0);
854 tree x
= TREE_OPERAND (exp
, 1);
855 if (TREE_CODE (func
) == ADDR_EXPR
)
856 func
= TREE_OPERAND (func
, 0);
857 check_init (func
, before
);
859 for ( ; x
!= NULL_TREE
; x
= TREE_CHAIN (x
))
860 check_init (TREE_VALUE (x
), before
);
861 if (func
== throw_node
)
862 goto never_continues
;
868 tree x
= CONSTRUCTOR_ELTS (TREE_OPERAND (exp
, 0));
869 for ( ; x
!= NULL_TREE
; x
= TREE_CHAIN (x
))
870 check_init (TREE_VALUE (x
), before
);
874 case EXPR_WITH_FILE_LOCATION
:
876 location_t saved_location
= input_location
;
877 tree saved_wfl
= wfl
;
878 tree body
= EXPR_WFL_NODE (exp
);
879 if (IS_EMPTY_STMT (body
))
882 input_filename
= EXPR_WFL_FILENAME (exp
);
883 input_line
= EXPR_WFL_LINENO (exp
);
884 check_init (body
, before
);
885 input_location
= saved_location
;
892 ("internal error in check-init: tree code not implemented: %s",
893 tree_code_name
[(int) TREE_CODE (exp
)]);
898 check_for_initialization (tree body
, tree mdecl
)
903 tree owner
= DECL_CONTEXT (mdecl
);
904 int is_static_method
= METHOD_STATIC (mdecl
);
905 /* We don't need to check final fields of <init> it it calls this(). */
906 int is_finit_method
= DECL_FINIT_P (mdecl
) || DECL_INSTINIT_P (mdecl
);
908 = (is_finit_method
|| DECL_CLINIT_P (mdecl
)
909 || (DECL_INIT_P (mdecl
) && ! DECL_INIT_CALLS_THIS (mdecl
)));
911 start_current_locals
= num_current_locals
= 0;
912 num_current_words
= 2;
917 for (decl
= TYPE_FIELDS (owner
);
918 decl
!= NULL_TREE
; decl
= TREE_CHAIN (decl
))
920 if (DECL_FINAL (decl
) && FIELD_STATIC (decl
) == is_static_method
)
922 if (DECL_FIELD_FINAL_IUD (decl
))
923 DECL_BIT_INDEX (decl
) = -1;
925 DECL_BIT_INDEX (decl
) = num_current_locals
++;
928 words_needed
= WORDS_NEEDED (2 * num_current_locals
);
929 if (words_needed
> 2)
931 num_current_words
= words_needed
;
932 before
= ALLOC_WORDS(words_needed
);
935 for (decl
= TYPE_FIELDS (owner
);
936 decl
!= NULL_TREE
; decl
= TREE_CHAIN (decl
))
938 if (FIELD_FINAL (decl
) && FIELD_STATIC (decl
) == is_static_method
)
940 if (! DECL_FIELD_FINAL_IUD (decl
))
942 CLEAR_ASSIGNED (before
, i
);
943 SET_UNASSIGNED (before
, i
);
951 check_init (body
, before
);
955 for (decl
= TYPE_FIELDS (owner
);
956 decl
!= NULL_TREE
; decl
= TREE_CHAIN (decl
))
958 if (FIELD_FINAL (decl
) && FIELD_STATIC (decl
) == is_static_method
)
960 int index
= DECL_BIT_INDEX (decl
);
961 if (index
>= 0 && ! ASSIGNED_P (before
, index
))
963 if (! is_finit_method
)
964 error ("%Jfinal field `%D' may not have been initialized",
967 else if (is_finit_method
)
968 DECL_FIELD_FINAL_IUD (decl
) = 1;
970 /* Re-set to initial state, since we later may use the
971 same bit for DECL_POINTER_ALIAS_SET. */
972 DECL_BIT_INDEX (decl
) = -1;
977 start_current_locals
= num_current_locals
= 0;