Attachment #56874 for bug #169017




	// for local variables table attributes
	int mergedInitStateIndex = -1;
	int preTryInitStateIndex = -1;
	int naturalExitMergeInitStateIndex = -1;

public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {


		FlowInfo tryInfo;
		if (this.tryBlock.isEmptyBlock()) {
			tryInfo = flowInfo;
			this.postTryInitStateIndex = currentScope.methodScope().recordInitializationStates(tryInfo);
		} else {
			tryInfo = this.tryBlock.analyseCode(currentScope, handlingContext, flowInfo.copy());
			if ((tryInfo.tagBits & FlowInfo.UNREACHABLE) != 0)
				this.bits |= ASTNode.IsTryBlockExiting;
			this.postTryInitStateIndex = currentScope.methodScope().recordInitializationStates(tryInfo);
		}

		// check unreachable catch blocks

		FlowInfo tryInfo;
		if (this.tryBlock.isEmptyBlock()) {
			tryInfo = flowInfo;
			this.postTryInitStateIndex = currentScope.methodScope().recordInitializationStates(tryInfo);
		} else {
			tryInfo = this.tryBlock.analyseCode(currentScope, handlingContext, flowInfo.copy());
			if ((tryInfo.tagBits & FlowInfo.UNREACHABLE) != 0)
				this.bits |= ASTNode.IsTryBlockExiting;
			this.postTryInitStateIndex = currentScope.methodScope().recordInitializationStates(tryInfo);
		}

		// check unreachable catch blocks

				currentScope.methodScope().recordInitializationStates(subInfo);
			return subInfo;
		} else {
			this.naturalExitMergeInitStateIndex =
				currentScope.methodScope().recordInitializationStates(tryInfo);
			FlowInfo mergedInfo = tryInfo.addInitializationsFrom(subInfo);
			this.mergedInitStateIndex =
				currentScope.methodScope().recordInitializationStates(mergedInfo);

				case FINALLY_SUBROUTINE :
				case FINALLY_INLINE :
					requiresNaturalExit = true;
					if (this.naturalExitMergeInitStateIndex != -1) {
						codeStream.removeNotDefinitelyAssignedVariables(currentScope, this.naturalExitMergeInitStateIndex);
						codeStream.addDefinitelyAssignedVariables(currentScope, this.naturalExitMergeInitStateIndex);
					}
					codeStream.goto_(naturalExitLabel);
					break;
				case NO_FINALLY :
					if (this.naturalExitMergeInitStateIndex != -1) {
						codeStream.removeNotDefinitelyAssignedVariables(currentScope, this.naturalExitMergeInitStateIndex);
						codeStream.addDefinitelyAssignedVariables(currentScope, this.naturalExitMergeInitStateIndex);
					}
					codeStream.goto_(naturalExitLabel);
					break;

							requiresNaturalExit = true;
							// fall through
						case NO_FINALLY :
							if (this.naturalExitMergeInitStateIndex != -1) {
								codeStream.removeNotDefinitelyAssignedVariables(currentScope, this.naturalExitMergeInitStateIndex);
								codeStream.addDefinitelyAssignedVariables(currentScope, this.naturalExitMergeInitStateIndex);
							}
							codeStream.goto_(naturalExitLabel);
							break;

			if (this.preTryInitStateIndex != -1) {
				// reset initialization state, as for a normal catch block
				codeStream.removeNotDefinitelyAssignedVariables(currentScope, this.preTryInitStateIndex);
				codeStream.addDefinitelyAssignedVariables(currentScope, this.preTryInitStateIndex);
			}
			this.placeAllAnyExceptionHandler();
			if (naturalExitExceptionHandler != null) naturalExitExceptionHandler.place();

						break;
					case FINALLY_INLINE :
						// inlined finally here can see all merged variables
						boolean isStackMapFrameCodeStream = codeStream instanceof StackMapFrameCodeStream;
						if (isStackMapFrameCodeStream) {
							((StackMapFrameCodeStream) codeStream).pushStateIndex(this.naturalExitMergeInitStateIndex);
						}
						if (this.naturalExitMergeInitStateIndex != -1) {
							codeStream.removeNotDefinitelyAssignedVariables(currentScope, this.naturalExitMergeInitStateIndex);
							codeStream.addDefinitelyAssignedVariables(currentScope, this.naturalExitMergeInitStateIndex);
						}
						naturalExitLabel.place();
						// entire sequence for finally is associated to finally block

									position,
									this.finallyBlock.sourceEnd);
						}
						if (isStackMapFrameCodeStream) {
							((StackMapFrameCodeStream) codeStream).popStateIndex();
						}
						break;
					case FINALLY_DOES_NOT_COMPLETE :
						break;

}

/**
 * @see SubRoutineStatement#generateSubRoutineInvocation(BlockScope, CodeStream, Object, int, LocalVariableBinding)
 */
public boolean generateSubRoutineInvocation(BlockScope currentScope, CodeStream codeStream, Object targetLocation, int stateIndex, LocalVariableBinding secretLocal) {

	int finallyMode = finallyMode();
	switch(finallyMode) {

		BranchLabel reusableJSRSequenceStartLabel = new BranchLabel(codeStream);
		reusableJSRSequenceStartLabel.place();
		this.reusableJSRSequenceStartLabels[this.reusableJSRTargetsCount++] = reusableJSRSequenceStartLabel;
	}
	if (finallyMode == FINALLY_INLINE) {
		boolean isStackMapFrameCodeStream = codeStream instanceof StackMapFrameCodeStream;
		if (isStackMapFrameCodeStream) {
			((StackMapFrameCodeStream) codeStream).pushStateIndex(stateIndex);
		}
		if (this.naturalExitMergeInitStateIndex != -1 || stateIndex != -1) {
			// reset initialization state, as for a normal catch block
			codeStream.removeNotDefinitelyAssignedVariables(currentScope, this.naturalExitMergeInitStateIndex);
			codeStream.addDefinitelyAssignedVariables(currentScope, this.naturalExitMergeInitStateIndex);
		}
		if (secretLocal != null) {
			codeStream.addVariable(secretLocal);
		}
		// cannot use jsr bytecode, then simply inline the subroutine
		// inside try block, ensure to deactivate all catch block exception handlers while inlining finally block
		exitAnyExceptionHandler();
		exitDeclaredExceptionHandlers(codeStream);
		this.finallyBlock.generateCode(currentScope, codeStream);
		if (isStackMapFrameCodeStream) {
			((StackMapFrameCodeStream) codeStream).popStateIndex();
		}
	} else {
		// classic subroutine invocation, distinguish case of non-returning subroutine
		codeStream.jsr(this.subRoutineStartLabel);

	}
	return false;
}

public boolean isSubRoutineEscaping() {
	return (this.bits & ASTNode.IsSubRoutineEscaping) != 0;
}

Lines 13-18 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/SubRoutineStatement.java (-1 / +2 lines)
13	import org.eclipse.jdt.internal.compiler.codegen.CodeStream;	13	import org.eclipse.jdt.internal.compiler.codegen.CodeStream;
14	import org.eclipse.jdt.internal.compiler.codegen.ExceptionLabel;	14	import org.eclipse.jdt.internal.compiler.codegen.ExceptionLabel;
15	import org.eclipse.jdt.internal.compiler.lookup.BlockScope;	15	import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
		16	import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding;
16		17
17	/**	18	/**
18	* Extra behavior for statements which are generating subroutines	19	* Extra behavior for statements which are generating subroutines
Lines 55-61 Link Here
55	}	56	}
56		57
57		58
58	public abstract boolean generateSubRoutineInvocation(BlockScope currentScope, CodeStream codeStream, Object targetLocation);	59	public abstract boolean generateSubRoutineInvocation(BlockScope currentScope, CodeStream codeStream, Object targetLocation, int stateIndex, LocalVariableBinding secretLocal);
59		60
60	public abstract boolean isSubRoutineEscaping();	61	public abstract boolean isSubRoutineEscaping();
61		62

Lines 45-51 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/BranchStatement.java (-1 / +1 lines)
45	if (this.subroutines != null){	45	if (this.subroutines != null){
46	for (int i = 0, max = this.subroutines.length; i < max; i++){	46	for (int i = 0, max = this.subroutines.length; i < max; i++){
47	SubRoutineStatement sub = this.subroutines[i];	47	SubRoutineStatement sub = this.subroutines[i];
48	boolean didEscape = sub.generateSubRoutineInvocation(currentScope, codeStream, this.targetLabel);	48	boolean didEscape = sub.generateSubRoutineInvocation(currentScope, codeStream, null, this.initStateIndex, null);
49	if (didEscape) {	49	if (didEscape) {
50	codeStream.recordPositionsFrom(pc, this.sourceStart);	50	codeStream.recordPositionsFrom(pc, this.sourceStart);
51	SubRoutineStatement.reenterAllExceptionHandlers(this.subroutines, i, codeStream);	51	SubRoutineStatement.reenterAllExceptionHandlers(this.subroutines, i, codeStream);

Lines 152-160 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/SynchronizedStatement.java (-2 / +2 lines)
152	}	152	}
153		153
154	/**	154	/**
155	* @see SubRoutineStatement#generateSubRoutineInvocation(BlockScope, CodeStream, Object)	155	* @see SubRoutineStatement#generateSubRoutineInvocation(BlockScope, CodeStream, Object, int, LocalVariableBinding)
156	*/	156	*/
157	public boolean generateSubRoutineInvocation(BlockScope currentScope, CodeStream codeStream, Object targetLocation) {	157	public boolean generateSubRoutineInvocation(BlockScope currentScope, CodeStream codeStream, Object targetLocation, int stateIndex, LocalVariableBinding secretLocal) {
158	codeStream.load(this.synchroVariable);	158	codeStream.load(this.synchroVariable);
159	codeStream.monitorexit();	159	codeStream.monitorexit();
160	exitAnyExceptionHandler();	160	exitAnyExceptionHandler();




	
	// generation of code responsible for invoking the finally blocks in sequence
	if (this.subroutines != null) {
		Object reusableJSRTarget = this.expression == null ? (Object)TypeBinding.VOID : this.expression.reusableJSRTarget();
		for (int i = 0, max = this.subroutines.length; i < max; i++) {
			SubRoutineStatement sub = this.subroutines[i];
			boolean didEscape = sub.generateSubRoutineInvocation(currentScope, codeStream, null, this.initStateIndex, this.saveValueVariable);
			if (didEscape) {
					if (this.initStateIndex != -1) {
						codeStream.removeNotDefinitelyAssignedVariables(currentScope, this.initStateIndex);

}

public void generateStoreSaveValueIfNecessary(CodeStream codeStream){
	if (this.saveValueVariable != null) {
		codeStream.store(this.saveValueVariable, false);
	}
}

public boolean needValue() {




	
	public ArrayList variablesModificationsPositions;
	
	public int[] stateIndexes;
	public int stateIndexesCounter;
	
public StackMapFrameCodeStream(ClassFile givenClassFile) {
	super(givenClassFile);
}

}
public void addDefinitelyAssignedVariables(Scope scope, int initStateIndex) {
	// Required to fix 1PR0XVS: LFRE:WINNT - Compiler: variable table for method appears incorrect
	loop: for (int i = 0; i < visibleLocalsCount; i++) {
		LocalVariableBinding localBinding = visibleLocals[i];
		if (localBinding != null) {
			// Check if the local is definitely assigned
			boolean isDefinitelyAssigned = isDefinitelyAssigned(scope, initStateIndex, localBinding);
			if (!isDefinitelyAssigned) {
				if (this.stateIndexes != null) {
					for (int j = 0, max = this.stateIndexesCounter; j < max; j++) {
						if (isDefinitelyAssigned(scope, this.stateIndexes[j], localBinding)) {
							currentFrame.putLocal(localBinding.resolvedPosition, new VerificationTypeInfo(localBinding.type));
							continue loop;
						}
					}
					 * 	is not closed yet.
					 */
					currentFrame.putLocal(localBinding.resolvedPosition, new VerificationTypeInfo(localBinding.type));
				}
			} else {
				currentFrame.putLocal(localBinding.resolvedPosition, new VerificationTypeInfo(localBinding.type));
			}
		}
	}

			this.currentFrame.numberOfStackItems -= 2;
	}
}
public void popStateIndex() {
	this.stateIndexesCounter--;
}
public void pushOnStack(TypeBinding binding) {
	super.pushOnStack(binding);
	this.currentFrame.addStackItem(binding);

	super.putfield(fieldBinding);
	this.currentFrame.numberOfStackItems -= 2;	
}

public void pushStateIndex(int naturalExitMergeInitStateIndex) {
	if (this.stateIndexes == null) {
		this.stateIndexes = new int[3];
	}
	int length = this.stateIndexes.length;
	if (length == this.stateIndexesCounter) {
		// resize
		System.arraycopy(this.stateIndexes, 0, (this.stateIndexes = new int[length * 2]), 0, length);
	}
	this.stateIndexes[this.stateIndexesCounter++] = naturalExitMergeInitStateIndex;
}
public void putstatic(FieldBinding fieldBinding) {
	super.putstatic(fieldBinding);
	this.currentFrame.numberOfStackItems--;	

}
public void removeNotDefinitelyAssignedVariables(Scope scope, int initStateIndex) {
	int index = this.visibleLocalsCount;
	loop : for (int i = 0; i < index; i++) {
		LocalVariableBinding localBinding = visibleLocals[i];
		if (localBinding != null && localBinding.initializationCount > 0) {
			boolean isDefinitelyAssigned = isDefinitelyAssigned(scope, initStateIndex, localBinding);
			if (!isDefinitelyAssigned) {
				if (this.stateIndexes != null) {
					for (int j = 0, max = this.stateIndexesCounter; j < max; j++) {
						if (isDefinitelyAssigned(scope, this.stateIndexes[j], localBinding)) {
							continue loop;
						}
					}
				}
				this.currentFrame.removeLocals(localBinding.resolvedPosition);
			}
		}
	}
	Integer newValue = new Integer(this.position);

Return to bug 169017

Lines 57-63 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/TryStatement.java (-23 / +39 lines)
57	// for local variables table attributes	57	// for local variables table attributes
58	int mergedInitStateIndex = -1;	58	int mergedInitStateIndex = -1;
59	int preTryInitStateIndex = -1;	59	int preTryInitStateIndex = -1;
60	int postTryInitStateIndex = -1;	60	int naturalExitMergeInitStateIndex = -1;
61		61
62	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {	62	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {
63		63
Lines 95-106 Link Here
95	FlowInfo tryInfo;	95	FlowInfo tryInfo;
96	if (this.tryBlock.isEmptyBlock()) {	96	if (this.tryBlock.isEmptyBlock()) {
97	tryInfo = flowInfo;	97	tryInfo = flowInfo;
98	this.postTryInitStateIndex = currentScope.methodScope().recordInitializationStates(tryInfo);
99	} else {	98	} else {
100	tryInfo = this.tryBlock.analyseCode(currentScope, handlingContext, flowInfo.copy());	99	tryInfo = this.tryBlock.analyseCode(currentScope, handlingContext, flowInfo.copy());
101	if ((tryInfo.tagBits & FlowInfo.UNREACHABLE) != 0)	100	if ((tryInfo.tagBits & FlowInfo.UNREACHABLE) != 0)
102	this.bits \|= ASTNode.IsTryBlockExiting;	101	this.bits \|= ASTNode.IsTryBlockExiting;
103	this.postTryInitStateIndex = currentScope.methodScope().recordInitializationStates(tryInfo);
104	}	102	}
105		103
106	// check unreachable catch blocks	104	// check unreachable catch blocks
Lines 207-218 Link Here
207	FlowInfo tryInfo;	205	FlowInfo tryInfo;
208	if (this.tryBlock.isEmptyBlock()) {	206	if (this.tryBlock.isEmptyBlock()) {
209	tryInfo = flowInfo;	207	tryInfo = flowInfo;
210	this.postTryInitStateIndex = currentScope.methodScope().recordInitializationStates(tryInfo);
211	} else {	208	} else {
212	tryInfo = this.tryBlock.analyseCode(currentScope, handlingContext, flowInfo.copy());	209	tryInfo = this.tryBlock.analyseCode(currentScope, handlingContext, flowInfo.copy());
213	if ((tryInfo.tagBits & FlowInfo.UNREACHABLE) != 0)	210	if ((tryInfo.tagBits & FlowInfo.UNREACHABLE) != 0)
214	this.bits \|= ASTNode.IsTryBlockExiting;	211	this.bits \|= ASTNode.IsTryBlockExiting;
215	this.postTryInitStateIndex = currentScope.methodScope().recordInitializationStates(tryInfo);
216	}	212	}
217		213
218	// check unreachable catch blocks	214	// check unreachable catch blocks
Lines 298-303 Link Here
298	currentScope.methodScope().recordInitializationStates(subInfo);	294	currentScope.methodScope().recordInitializationStates(subInfo);
299	return subInfo;	295	return subInfo;
300	} else {	296	} else {
		297	this.naturalExitMergeInitStateIndex =
		298	currentScope.methodScope().recordInitializationStates(tryInfo);
301	FlowInfo mergedInfo = tryInfo.addInitializationsFrom(subInfo);	299	FlowInfo mergedInfo = tryInfo.addInitializationsFrom(subInfo);
302	this.mergedInitStateIndex =	300	this.mergedInitStateIndex =
303	currentScope.methodScope().recordInitializationStates(mergedInfo);	301	currentScope.methodScope().recordInitializationStates(mergedInfo);
Lines 404-419 Link Here
404	case FINALLY_SUBROUTINE :	402	case FINALLY_SUBROUTINE :
405	case FINALLY_INLINE :	403	case FINALLY_INLINE :
406	requiresNaturalExit = true;	404	requiresNaturalExit = true;
407	if (this.postTryInitStateIndex != -1) {	405	if (this.naturalExitMergeInitStateIndex != -1) {
408	codeStream.removeNotDefinitelyAssignedVariables(currentScope, this.postTryInitStateIndex);	406	codeStream.removeNotDefinitelyAssignedVariables(currentScope, this.naturalExitMergeInitStateIndex);
409	codeStream.addDefinitelyAssignedVariables(currentScope, this.postTryInitStateIndex);	407	codeStream.addDefinitelyAssignedVariables(currentScope, this.naturalExitMergeInitStateIndex);
410	}	408	}
411	codeStream.goto_(naturalExitLabel);	409	codeStream.goto_(naturalExitLabel);
412	break;	410	break;
413	case NO_FINALLY :	411	case NO_FINALLY :
414	if (this.postTryInitStateIndex != -1) {	412	if (this.naturalExitMergeInitStateIndex != -1) {
415	codeStream.removeNotDefinitelyAssignedVariables(currentScope, this.postTryInitStateIndex);	413	codeStream.removeNotDefinitelyAssignedVariables(currentScope, this.naturalExitMergeInitStateIndex);
416	codeStream.addDefinitelyAssignedVariables(currentScope, this.postTryInitStateIndex);	414	codeStream.addDefinitelyAssignedVariables(currentScope, this.naturalExitMergeInitStateIndex);
417	}	415	}
418	codeStream.goto_(naturalExitLabel);	416	codeStream.goto_(naturalExitLabel);
419	break;	417	break;
Lines 464-472 Link Here
464	requiresNaturalExit = true;	462	requiresNaturalExit = true;
465	// fall through	463	// fall through
466	case NO_FINALLY :	464	case NO_FINALLY :
467	if (this.postTryInitStateIndex != -1) {	465	if (this.naturalExitMergeInitStateIndex != -1) {
468	codeStream.removeNotDefinitelyAssignedVariables(currentScope, this.postTryInitStateIndex);	466	codeStream.removeNotDefinitelyAssignedVariables(currentScope, this.naturalExitMergeInitStateIndex);
469	codeStream.addDefinitelyAssignedVariables(currentScope, this.postTryInitStateIndex);	467	codeStream.addDefinitelyAssignedVariables(currentScope, this.naturalExitMergeInitStateIndex);
470	}	468	}
471	codeStream.goto_(naturalExitLabel);	469	codeStream.goto_(naturalExitLabel);
472	break;	470	break;
Lines 491-496 Link Here
491	if (this.preTryInitStateIndex != -1) {	489	if (this.preTryInitStateIndex != -1) {
492	// reset initialization state, as for a normal catch block	490	// reset initialization state, as for a normal catch block
493	codeStream.removeNotDefinitelyAssignedVariables(currentScope, this.preTryInitStateIndex);	491	codeStream.removeNotDefinitelyAssignedVariables(currentScope, this.preTryInitStateIndex);
		492	codeStream.addDefinitelyAssignedVariables(currentScope, this.preTryInitStateIndex);
494	}	493	}
495	this.placeAllAnyExceptionHandler();	494	this.placeAllAnyExceptionHandler();
496	if (naturalExitExceptionHandler != null) naturalExitExceptionHandler.place();	495	if (naturalExitExceptionHandler != null) naturalExitExceptionHandler.place();
Lines 557-565 Link Here
557	break;	556	break;
558	case FINALLY_INLINE :	557	case FINALLY_INLINE :
559	// inlined finally here can see all merged variables	558	// inlined finally here can see all merged variables
560	if (this.postTryInitStateIndex != -1) {	559	boolean isStackMapFrameCodeStream = codeStream instanceof StackMapFrameCodeStream;
561	codeStream.removeNotDefinitelyAssignedVariables(currentScope, this.postTryInitStateIndex);	560	if (isStackMapFrameCodeStream) {
562	codeStream.addDefinitelyAssignedVariables(currentScope, this.postTryInitStateIndex);	561	((StackMapFrameCodeStream) codeStream).pushStateIndex(this.naturalExitMergeInitStateIndex);
		562	}
		563	if (this.naturalExitMergeInitStateIndex != -1) {
		564	codeStream.removeNotDefinitelyAssignedVariables(currentScope, this.naturalExitMergeInitStateIndex);
		565	codeStream.addDefinitelyAssignedVariables(currentScope, this.naturalExitMergeInitStateIndex);
563	}	566	}
564	naturalExitLabel.place();	567	naturalExitLabel.place();
565	// entire sequence for finally is associated to finally block	568	// entire sequence for finally is associated to finally block
Lines 572-577 Link Here
572	position,	575	position,
573	this.finallyBlock.sourceEnd);	576	this.finallyBlock.sourceEnd);
574	}	577	}
		578	if (isStackMapFrameCodeStream) {
		579	((StackMapFrameCodeStream) codeStream).popStateIndex();
		580	}
575	break;	581	break;
576	case FINALLY_DOES_NOT_COMPLETE :	582	case FINALLY_DOES_NOT_COMPLETE :
577	break;	583	break;
Lines 617-625 Link Here
617	}	623	}
618		624
619	/**	625	/**
620	* @see SubRoutineStatement#generateSubRoutineInvocation(BlockScope, CodeStream, Object)	626	* @see SubRoutineStatement#generateSubRoutineInvocation(BlockScope, CodeStream, Object, int, LocalVariableBinding)
621	*/	627	*/
622	public boolean generateSubRoutineInvocation(BlockScope currentScope, CodeStream codeStream, Object targetLocation) {	628	public boolean generateSubRoutineInvocation(BlockScope currentScope, CodeStream codeStream, Object targetLocation, int stateIndex, LocalVariableBinding secretLocal) {
623		629
624	int finallyMode = finallyMode();	630	int finallyMode = finallyMode();
625	switch(finallyMode) {	631	switch(finallyMode) {
Lines 663-679 Link Here
663	BranchLabel reusableJSRSequenceStartLabel = new BranchLabel(codeStream);	669	BranchLabel reusableJSRSequenceStartLabel = new BranchLabel(codeStream);
664	reusableJSRSequenceStartLabel.place();	670	reusableJSRSequenceStartLabel.place();
665	this.reusableJSRSequenceStartLabels[this.reusableJSRTargetsCount++] = reusableJSRSequenceStartLabel;	671	this.reusableJSRSequenceStartLabels[this.reusableJSRTargetsCount++] = reusableJSRSequenceStartLabel;
666	}	672	}
667	if (finallyMode == FINALLY_INLINE) {	673	if (finallyMode == FINALLY_INLINE) {
668	if (this.preTryInitStateIndex != -1) {	674	boolean isStackMapFrameCodeStream = codeStream instanceof StackMapFrameCodeStream;
		675	if (isStackMapFrameCodeStream) {
		676	((StackMapFrameCodeStream) codeStream).pushStateIndex(stateIndex);
		677	}
		678	if (this.naturalExitMergeInitStateIndex != -1 \|\| stateIndex != -1) {
669	// reset initialization state, as for a normal catch block	679	// reset initialization state, as for a normal catch block
670	codeStream.removeNotDefinitelyAssignedVariables(currentScope, this.preTryInitStateIndex);	680	codeStream.removeNotDefinitelyAssignedVariables(currentScope, this.naturalExitMergeInitStateIndex);
		681	codeStream.addDefinitelyAssignedVariables(currentScope, this.naturalExitMergeInitStateIndex);
		682	}
		683	if (secretLocal != null) {
		684	codeStream.addVariable(secretLocal);
671	}	685	}
672	// cannot use jsr bytecode, then simply inline the subroutine	686	// cannot use jsr bytecode, then simply inline the subroutine
673	// inside try block, ensure to deactivate all catch block exception handlers while inlining finally block	687	// inside try block, ensure to deactivate all catch block exception handlers while inlining finally block
674	exitAnyExceptionHandler();	688	exitAnyExceptionHandler();
675	exitDeclaredExceptionHandlers(codeStream);	689	exitDeclaredExceptionHandlers(codeStream);
676	this.finallyBlock.generateCode(currentScope, codeStream);	690	this.finallyBlock.generateCode(currentScope, codeStream);
		691	if (isStackMapFrameCodeStream) {
		692	((StackMapFrameCodeStream) codeStream).popStateIndex();
		693	}
677	} else {	694	} else {
678	// classic subroutine invocation, distinguish case of non-returning subroutine	695	// classic subroutine invocation, distinguish case of non-returning subroutine
679	codeStream.jsr(this.subRoutineStartLabel);	696	codeStream.jsr(this.subRoutineStartLabel);
Lines 682-688 Link Here
682	}	699	}
683	return false;	700	return false;
684	}	701	}
685
686	public boolean isSubRoutineEscaping() {	702	public boolean isSubRoutineEscaping() {
687	return (this.bits & ASTNode.IsSubRoutineEscaping) != 0;	703	return (this.bits & ASTNode.IsSubRoutineEscaping) != 0;
688	}	704	}

Lines 129-138 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ReturnStatement.java (-3 / +4 lines)
129		129
130	// generation of code responsible for invoking the finally blocks in sequence	130	// generation of code responsible for invoking the finally blocks in sequence
131	if (this.subroutines != null) {	131	if (this.subroutines != null) {
132	Object reusableJSRTarget = this.expression == null ? (Object)TypeBinding.VOID : this.expression.reusableJSRTarget();
133	for (int i = 0, max = this.subroutines.length; i < max; i++) {	132	for (int i = 0, max = this.subroutines.length; i < max; i++) {
134	SubRoutineStatement sub = this.subroutines[i];	133	SubRoutineStatement sub = this.subroutines[i];
135	boolean didEscape = sub.generateSubRoutineInvocation(currentScope, codeStream, reusableJSRTarget);	134	boolean didEscape = sub.generateSubRoutineInvocation(currentScope, codeStream, null, this.initStateIndex, this.saveValueVariable);
136	if (didEscape) {	135	if (didEscape) {
137	if (this.initStateIndex != -1) {	136	if (this.initStateIndex != -1) {
138	codeStream.removeNotDefinitelyAssignedVariables(currentScope, this.initStateIndex);	137	codeStream.removeNotDefinitelyAssignedVariables(currentScope, this.initStateIndex);
Lines 174-180 Link Here
174	}	173	}
175		174
176	public void generateStoreSaveValueIfNecessary(CodeStream codeStream){	175	public void generateStoreSaveValueIfNecessary(CodeStream codeStream){
177	if (this.saveValueVariable != null) codeStream.store(this.saveValueVariable, false);	176	if (this.saveValueVariable != null) {
		177	codeStream.store(this.saveValueVariable, false);
		178	}
178	}	179	}
179		180
180	public boolean needValue() {	181	public boolean needValue() {

Lines 38-43 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/codegen/StackMapFrameCodeStream.java (-17 / +43 lines)
38		38
39	public ArrayList variablesModificationsPositions;	39	public ArrayList variablesModificationsPositions;
40		40
		41	public int[] stateIndexes;
		42	public int stateIndexesCounter;
		43
41	public StackMapFrameCodeStream(ClassFile givenClassFile) {	44	public StackMapFrameCodeStream(ClassFile givenClassFile) {
42	super(givenClassFile);	45	super(givenClassFile);
43	}	46	}
Lines 56-78 Link Here
56	}	59	}
57	public void addDefinitelyAssignedVariables(Scope scope, int initStateIndex) {	60	public void addDefinitelyAssignedVariables(Scope scope, int initStateIndex) {
58	// Required to fix 1PR0XVS: LFRE:WINNT - Compiler: variable table for method appears incorrect	61	// Required to fix 1PR0XVS: LFRE:WINNT - Compiler: variable table for method appears incorrect
59	for (int i = 0; i < visibleLocalsCount; i++) {	62	loop: for (int i = 0; i < visibleLocalsCount; i++) {
60	LocalVariableBinding localBinding = visibleLocals[i];	63	LocalVariableBinding localBinding = visibleLocals[i];
61	if (localBinding != null) {	64	if (localBinding != null) {
62	// Check if the local is definitely assigned	65	// Check if the local is definitely assigned
63	if (isDefinitelyAssigned(scope, initStateIndex, localBinding)) {	66	boolean isDefinitelyAssigned = isDefinitelyAssigned(scope, initStateIndex, localBinding);
64	if ((localBinding.initializationCount == 0) \|\| (localBinding.initializationPCs[((localBinding.initializationCount - 1) << 1) + 1] != -1)) {	67	if (!isDefinitelyAssigned) {
65	/* There are two cases:	68	if (this.stateIndexes != null) {
66	* 1) there is no initialization interval opened ==> add an opened interval	69	for (int j = 0, max = this.stateIndexesCounter; j < max; j++) {
67	* 2) there is already some initialization intervals but the last one is closed ==> add an opened interval	70	if (isDefinitelyAssigned(scope, this.stateIndexes[j], localBinding)) {
68	* An opened interval means that the value at localBinding.initializationPCs[localBinding.initializationCount - 1][1]	71	currentFrame.putLocal(localBinding.resolvedPosition, new VerificationTypeInfo(localBinding.type));
69	* is equals to -1.	72	continue loop;
70	* initializationPCs is a collection of pairs of int:	73	}
71	* first value is the startPC and second value is the endPC. -1 one for the last value means that the interval	74	}
72	* is not closed yet.
73	*/
74	currentFrame.putLocal(localBinding.resolvedPosition, new VerificationTypeInfo(localBinding.type));
75	}	75	}
		76	} else {
		77	currentFrame.putLocal(localBinding.resolvedPosition, new VerificationTypeInfo(localBinding.type));
76	}	78	}
77	}	79	}
78	}	80	}
Lines 1746-1751 Link Here
1746	this.currentFrame.numberOfStackItems -= 2;	1748	this.currentFrame.numberOfStackItems -= 2;
1747	}	1749	}
1748	}	1750	}
		1751	public void popStateIndex() {
		1752	this.stateIndexesCounter--;
		1753	}
1749	public void pushOnStack(TypeBinding binding) {	1754	public void pushOnStack(TypeBinding binding) {
1750	super.pushOnStack(binding);	1755	super.pushOnStack(binding);
1751	this.currentFrame.addStackItem(binding);	1756	this.currentFrame.addStackItem(binding);
Lines 1754-1759 Link Here
1754	super.putfield(fieldBinding);	1759	super.putfield(fieldBinding);
1755	this.currentFrame.numberOfStackItems -= 2;	1760	this.currentFrame.numberOfStackItems -= 2;
1756	}	1761	}
		1762
		1763	public void pushStateIndex(int naturalExitMergeInitStateIndex) {
		1764	if (this.stateIndexes == null) {
		1765	this.stateIndexes = new int[3];
		1766	}
		1767	int length = this.stateIndexes.length;
		1768	if (length == this.stateIndexesCounter) {
		1769	// resize
		1770	System.arraycopy(this.stateIndexes, 0, (this.stateIndexes = new int[length * 2]), 0, length);
		1771	}
		1772	this.stateIndexes[this.stateIndexesCounter++] = naturalExitMergeInitStateIndex;
		1773	}
1757	public void putstatic(FieldBinding fieldBinding) {	1774	public void putstatic(FieldBinding fieldBinding) {
1758	super.putstatic(fieldBinding);	1775	super.putstatic(fieldBinding);
1759	this.currentFrame.numberOfStackItems--;	1776	this.currentFrame.numberOfStackItems--;
Lines 1768-1778 Link Here
1768	}	1785	}
1769	public void removeNotDefinitelyAssignedVariables(Scope scope, int initStateIndex) {	1786	public void removeNotDefinitelyAssignedVariables(Scope scope, int initStateIndex) {
1770	int index = this.visibleLocalsCount;	1787	int index = this.visibleLocalsCount;
1771	for (int i = 0; i < index; i++) {	1788	loop : for (int i = 0; i < index; i++) {
1772	LocalVariableBinding localBinding = visibleLocals[i];	1789	LocalVariableBinding localBinding = visibleLocals[i];
1773	if (localBinding != null && !isDefinitelyAssigned(scope, initStateIndex, localBinding)	1790	if (localBinding != null && localBinding.initializationCount > 0) {
1774	&& localBinding.initializationCount > 0) {	1791	boolean isDefinitelyAssigned = isDefinitelyAssigned(scope, initStateIndex, localBinding);
1775	this.currentFrame.removeLocals(localBinding.resolvedPosition);	1792	if (!isDefinitelyAssigned) {
		1793	if (this.stateIndexes != null) {
		1794	for (int j = 0, max = this.stateIndexesCounter; j < max; j++) {
		1795	if (isDefinitelyAssigned(scope, this.stateIndexes[j], localBinding)) {
		1796	continue loop;
		1797	}
		1798	}
		1799	}
		1800	this.currentFrame.removeLocals(localBinding.resolvedPosition);
		1801	}
1776	}	1802	}
1777	}	1803	}
1778	Integer newValue = new Integer(this.position);	1804	Integer newValue = new Integer(this.position);