Attachment #187078 for bug #333089




/*******************************************************************************
 * Copyright (c) 2006, 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

			return nullS + "]>"; //$NON-NLS-1$
	}
}

/**
 * Mark a local as potentially having been assigned to an unknown value.
 * @param local the local to mark
 */
public void markPotentiallyUnknownBit(LocalVariableBinding local) {
	// protected from non-object locals in calling methods
	if (this != DEAD_END) {
		this.tagBits |= NULL_FLAG_MASK;
        int position;
        long mask;
        if ((position = local.id + this.maxFieldCount) < BitCacheSize) {
            // use bits
        	mask = 1L << position;
        	isTrue((this.nullBit1 & mask) == 0, "Adding 'unknown' mark in unexpected state"); //$NON-NLS-1$
            this.nullBit4 |= mask;
            if (COVERAGE_TEST_FLAG) {
				if(CoverageTestId == 46) {
				  	this.nullBit4 = ~0;
				}
			}
        } else {
    		// use extra vector
    		int vectorIndex = (position / BitCacheSize) - 1;
    		if (this.extra == null) {
    			int length = vectorIndex + 1;
    			this.extra = new long[extraLength][];
    			for (int j = 2; j < extraLength; j++) {
    				this.extra[j] = new long[length];
    			}
    		} else {
    			int oldLength; // might need to grow the arrays
    			if (vectorIndex >= (oldLength = this.extra[2].length)) {
    				for (int j = 2; j < extraLength; j++) {
    					System.arraycopy(this.extra[j], 0,
    						(this.extra[j] = new long[vectorIndex + 1]), 0,
    						oldLength);
    				}
    			}
    		}
    		mask = 1L << (position % BitCacheSize);
    		isTrue((this.extra[2][vectorIndex] & mask) == 0, "Adding 'unknown' mark in unexpected state"); //$NON-NLS-1$
    		this.extra[5][vectorIndex] |= mask;
    		if (COVERAGE_TEST_FLAG) {
				if(CoverageTestId == 47) {
					this.extra[5][vectorIndex] = ~0;
				}
			}
    	}
	}
}

public void markPotentiallyNullBit(LocalVariableBinding local) {
	if (this != DEAD_END) {
		this.tagBits |= NULL_FLAG_MASK;
        int position;
        long mask;
        if ((position = local.id + this.maxFieldCount) < BitCacheSize) {
            // use bits
        	mask = 1L << position;
        	isTrue((this.nullBit1 & mask) == 0, "Adding 'potentially null' mark in unexpected state"); //$NON-NLS-1$
            this.nullBit2 |= mask;
            if (COVERAGE_TEST_FLAG) {
				if(CoverageTestId == 40) {
				  	this.nullBit4 = ~0;
				}
			}
        } else {
    		// use extra vector
    		int vectorIndex = (position / BitCacheSize) - 1;
    		if (this.extra == null) {
    			int length = vectorIndex + 1;
    			this.extra = new long[extraLength][];
    			for (int j = 2; j < extraLength; j++) {
    				this.extra[j] = new long[length];
    			}
    		} else {
    			int oldLength; // might need to grow the arrays
    			if (vectorIndex >= (oldLength = this.extra[2].length)) {
    				for (int j = 2; j < extraLength; j++) {
    					System.arraycopy(this.extra[j], 0,
    						(this.extra[j] = new long[vectorIndex + 1]), 0,
    						oldLength);
    				}
    			}
    		}
    		mask = 1L << (position % BitCacheSize);
    		this.extra[3][vectorIndex] |= mask;
    		isTrue((this.extra[2][vectorIndex] & mask) == 0, "Adding 'potentially null' mark in unexpected state"); //$NON-NLS-1$
    		if (COVERAGE_TEST_FLAG) {
				if(CoverageTestId == 41) {
					this.extra[5][vectorIndex] = ~0;
				}
			}
    	}
	}
}

public void markPotentiallyNonNullBit(LocalVariableBinding local) {
	if (this != DEAD_END) {
		this.tagBits |= NULL_FLAG_MASK;
        int position;
        long mask;
        if ((position = local.id + this.maxFieldCount) < BitCacheSize) {
            // use bits
        	mask = 1L << position;
        	isTrue((this.nullBit1 & mask) == 0, "Adding 'potentially non-null' mark in unexpected state"); //$NON-NLS-1$
            this.nullBit3 |= mask;
            if (COVERAGE_TEST_FLAG) {
				if(CoverageTestId == 42) {
				  	this.nullBit4 = ~0;
				}
			}
        } else {
    		// use extra vector
    		int vectorIndex  = (position / BitCacheSize) - 1;
    		if (this.extra == null) {
    			int length = vectorIndex + 1;
    			this.extra = new long[extraLength][];
    			for (int j = 2; j < extraLength; j++) {
    				this.extra[j] = new long[length];
    			}
    		} else {
    			int oldLength; // might need to grow the arrays
    			if (vectorIndex >= (oldLength = this.extra[2].length)) {
    				for (int j = 2; j < extraLength; j++) {
    					System.arraycopy(this.extra[j], 0,
    						(this.extra[j] = new long[vectorIndex + 1]), 0,
    						oldLength);
    				}
    			}
    		}
    		mask = 1L << (position % BitCacheSize);
    		isTrue((this.extra[2][vectorIndex] & mask) == 0, "Adding 'potentially non-null' mark in unexpected state"); //$NON-NLS-1$
    		this.extra[4][vectorIndex] |= mask;
    		if (COVERAGE_TEST_FLAG) {
				if(CoverageTestId == 43) {
					this.extra[5][vectorIndex] = ~0;
				}
			}
    	}
	}
}
}


Lines 1-5 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/flow/UnconditionalFlowInfo.java (-4 / +60 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2010 IBM Corporation and others.	2	* Copyright (c) 2000, 2011 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 996-1002 Link Here
996	* @return <code>true</code> if the check passes (does not return	996	* @return <code>true</code> if the check passes (does not return
997	* if the check fails)	997	* if the check fails)
998	*/	998	*/
999	private static boolean isTrue(boolean expression, String message) {	999	protected static boolean isTrue(boolean expression, String message) {
1000	if (!expression)	1000	if (!expression)
1001	throw new AssertionFailedException("assertion failed: " + message); //$NON-NLS-1$	1001	throw new AssertionFailedException("assertion failed: " + message); //$NON-NLS-1$
1002	return expression;	1002	return expression;
Lines 1367-1374 Link Here
1367	this.nullBit4 &= mask;	1367	this.nullBit4 &= mask;
1368	} else {	1368	} else {
1369	// use extra vector	1369	// use extra vector
1370	int vectorIndex ;	1370	int vectorIndex = (position / BitCacheSize) - 1;
1371	this.extra[2][vectorIndex = (position / BitCacheSize) - 1]	1371	if (this.extra == null \|\| vectorIndex >= this.extra[2].length) {
		1372	// in case we attempt to reset the null info of a variable that has not been encountered
		1373	// before and for which no null bits exist.
		1374	return;
		1375	}
		1376	this.extra[2][vectorIndex]
1372	&= (mask = ~(1L << (position % BitCacheSize)));	1377	&= (mask = ~(1L << (position % BitCacheSize)));
1373	this.extra[3][vectorIndex] &= mask;	1378	this.extra[3][vectorIndex] &= mask;
1374	this.extra[4][vectorIndex] &= mask;	1379	this.extra[4][vectorIndex] &= mask;
Lines 1400-1405 Link Here
1400	} else {	1405	} else {
1401	// use extra vector	1406	// use extra vector
1402	int vectorIndex = (position / BitCacheSize) - 1;	1407	int vectorIndex = (position / BitCacheSize) - 1;
		1408	if (this.extra == null) {
		1409	int length = vectorIndex + 1;
		1410	this.extra = new long[extraLength][];
		1411	for (int j = 0; j < extraLength; j++) {
		1412	this.extra[j] = new long[length];
		1413	}
		1414	}
		1415	else {
		1416	int oldLength; // might need to grow the arrays
		1417	if (vectorIndex >= (oldLength = this.extra[0].length)) {
		1418	for (int j = 0; j < extraLength; j++) {
		1419	System.arraycopy(this.extra[j], 0,
		1420	(this.extra[j] = new long[vectorIndex + 1]), 0,
		1421	oldLength);
		1422	}
		1423	}
		1424	}
1403	mask = 1L << (position % BitCacheSize);	1425	mask = 1L << (position % BitCacheSize);
1404	isTrue((this.extra[2][vectorIndex] & mask) == 0, "Adding 'unknown' mark in unexpected state"); //$NON-NLS-1$	1426	isTrue((this.extra[2][vectorIndex] & mask) == 0, "Adding 'unknown' mark in unexpected state"); //$NON-NLS-1$
1405	this.extra[5][vectorIndex] \|= mask;	1427	this.extra[5][vectorIndex] \|= mask;
Lines 1430-1435 Link Here
1430	} else {	1452	} else {
1431	// use extra vector	1453	// use extra vector
1432	int vectorIndex = (position / BitCacheSize) - 1;	1454	int vectorIndex = (position / BitCacheSize) - 1;
		1455	if (this.extra == null) {
		1456	int length = vectorIndex + 1;
		1457	this.extra = new long[extraLength][];
		1458	for (int j = 0; j < extraLength; j++) {
		1459	this.extra[j] = new long[length];
		1460	}
		1461	}
		1462	else {
		1463	int oldLength; // might need to grow the arrays
		1464	if (vectorIndex >= (oldLength = this.extra[0].length)) {
		1465	for (int j = 0; j < extraLength; j++) {
		1466	System.arraycopy(this.extra[j], 0,
		1467	(this.extra[j] = new long[vectorIndex + 1]), 0,
		1468	oldLength);
		1469	}
		1470	}
		1471	}
1433	mask = 1L << (position % BitCacheSize);	1472	mask = 1L << (position % BitCacheSize);
1434	this.extra[3][vectorIndex] \|= mask;	1473	this.extra[3][vectorIndex] \|= mask;
1435	isTrue((this.extra[2][vectorIndex] & mask) == 0, "Adding 'potentially null' mark in unexpected state"); //$NON-NLS-1$	1474	isTrue((this.extra[2][vectorIndex] & mask) == 0, "Adding 'potentially null' mark in unexpected state"); //$NON-NLS-1$
Lines 1460-1465 Link Here
1460	} else {	1499	} else {
1461	// use extra vector	1500	// use extra vector
1462	int vectorIndex = (position / BitCacheSize) - 1;	1501	int vectorIndex = (position / BitCacheSize) - 1;
		1502	if (this.extra == null) {
		1503	int length = vectorIndex + 1;
		1504	this.extra = new long[extraLength][];
		1505	for (int j = 0; j < extraLength; j++) {
		1506	this.extra[j] = new long[length];
		1507	}
		1508	}
		1509	else {
		1510	int oldLength; // might need to grow the arrays
		1511	if (vectorIndex >= (oldLength = this.extra[0].length)) {
		1512	for (int j = 0; j < extraLength; j++) {
		1513	System.arraycopy(this.extra[j], 0,
		1514	(this.extra[j] = new long[vectorIndex + 1]), 0,
		1515	oldLength);
		1516	}
		1517	}
		1518	}
1463	mask = 1L << (position % BitCacheSize);	1519	mask = 1L << (position % BitCacheSize);
1464	isTrue((this.extra[2][vectorIndex] & mask) == 0, "Adding 'potentially non-null' mark in unexpected state"); //$NON-NLS-1$	1520	isTrue((this.extra[2][vectorIndex] & mask) == 0, "Adding 'potentially non-null' mark in unexpected state"); //$NON-NLS-1$
1465	this.extra[4][vectorIndex] \|= mask;	1521	this.extra[4][vectorIndex] \|= mask;




/*******************************************************************************
 * Copyright (c) 2005, 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

		"Done\n" + 
		"-1");
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=333089 
// null analysis -- to make sure no AIOOBE or NPE is thrown while calling UnconditionalFlowInfo.markNullStatus(..)
public void testBug333089() {
	this.runConformTest(
		new String[] {
			"X.java",
			"public class X {\n" + 
			"	public static void foo(Object s1) {\n" + 
	        "    int i00, i01, i02, i03, i04, i05, i06, i07, i08, i09;\n" +
	        "    int i10, i11, i12, i13, i14, i15, i16, i17, i18, i19;\n" +
	        "    int i20, i21, i22, i23, i24, i25, i26, i27, i28, i29;\n" +
	        "    int i30, i31, i32, i33, i34, i35, i36, i37, i38, i39;\n" +
	        "    int i40, i41, i42, i43, i44, i45, i46, i47, i48, i49;\n" +
	        "    int i50, i51, i52, i53, i54, i55, i56, i57, i58, i59;\n" +
	        "    int i60, i61, i62, i63, i64, i65, i66, i67, i68, i69;\n" +
			"	 Object local1;\n" + 
			"	 if (s1 == null){}\n" + 
			"	 try {" +
			"		local1 = s1;\n" +
			"	 } finally {\n" +
			"	 }\n" + 
			"	}\n" + 
			"}"},
		"");
}
}

Return to bug 333089

Lines 1-5 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/NullReferenceTest.java (-1 / +27 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2005, 2010 IBM Corporation and others.	2	* Copyright (c) 2005, 2011 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 13806-13809 Link Here
13806	"Done\n" +	13806	"Done\n" +
13807	"-1");	13807	"-1");
13808	}	13808	}
		13809
		13810	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=333089
		13811	// null analysis -- to make sure no AIOOBE or NPE is thrown while calling UnconditionalFlowInfo.markNullStatus(..)
		13812	public void testBug333089() {
		13813	this.runConformTest(
		13814	new String[] {
		13815	"X.java",
		13816	"public class X {\n" +
		13817	" public static void foo(Object s1) {\n" +
		13818	" int i00, i01, i02, i03, i04, i05, i06, i07, i08, i09;\n" +
		13819	" int i10, i11, i12, i13, i14, i15, i16, i17, i18, i19;\n" +
		13820	" int i20, i21, i22, i23, i24, i25, i26, i27, i28, i29;\n" +
		13821	" int i30, i31, i32, i33, i34, i35, i36, i37, i38, i39;\n" +
		13822	" int i40, i41, i42, i43, i44, i45, i46, i47, i48, i49;\n" +
		13823	" int i50, i51, i52, i53, i54, i55, i56, i57, i58, i59;\n" +
		13824	" int i60, i61, i62, i63, i64, i65, i66, i67, i68, i69;\n" +
		13825	" Object local1;\n" +
		13826	" if (s1 == null){}\n" +
		13827	" try {" +
		13828	" local1 = s1;\n" +
		13829	" } finally {\n" +
		13830	" }\n" +
		13831	" }\n" +
		13832	"}"},
		13833	"");
		13834	}
13809	}	13835	}