Attachment #200895 for bug #353605

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

Lines 69-75 public abstract class Scope implements IScope { Link Here

(-)a/org.eclipse.cdt.debug.edc/src/org/eclipse/cdt/debug/edc/internal/symbols/Scope.java (-6 / +11 lines)
69	return (lowAddress == null \|\| highAddress == null)	69	return (lowAddress == null \|\| highAddress == null)
70	\|\| (lowAddress.isZero() && highAddress.isZero())	70	\|\| (lowAddress.isZero() && highAddress.isZero())
71	\|\| (lowAddress.getValue().longValue() == -1 && highAddress.isZero()); // TODO: remove this case	71	\|\| (lowAddress.getValue().longValue() == -1 && highAddress.isZero()); // TODO: remove this case
72	}	72	}//FIXME: looks like a bug: no test that lowAddress.equals(highAddress)
73		73
74	/**	74	/**
75	* Return the list of non-contiguous ranges for this scope.	75	* Return the list of non-contiguous ranges for this scope.
Lines 244-249 public abstract class Scope implements IScope { Link Here
244	}	244	}
245		245
246	if (kid.getLowAddress().compareTo(baseAddress) > 0) {	246	if (kid.getLowAddress().compareTo(baseAddress) > 0) {
		247	IRangeList kidRanges = kid.getRangeList();
		248	if (kidRanges == null){// If it didn't have ranges it still has one range
		249	kidRanges = new RangeList();
		250	((RangeList)kidRanges).addRange(kid.getLowAddress().getValue().longValue(),kid.getHighAddress().getValue().longValue());
		251	}
		252	newRangeList = RangeList.mergeRangeLists(newRangeList,kidRanges);
		253
247	if (kid.getLowAddress().compareTo(newLowAddress) < 0) {	254	if (kid.getLowAddress().compareTo(newLowAddress) < 0) {
248	newLowAddress = kid.getLowAddress();	255	newLowAddress = kid.getLowAddress();
249	any = true;	256	any = true;
Lines 287-294 public abstract class Scope implements IScope { Link Here
287	{	294	{
288	if (rangeList != null) {	295	if (rangeList != null) {
289	if (scope.getRangeList() != null) {	296	if (scope.getRangeList() != null) {
290	// TODO: merge properly	297	rangeList = RangeList.mergeRangeLists(rangeList,scope.getRangeList());
291	rangeList = null;
292	} else {	298	} else {
293	((RangeList)rangeList).addLowRange(scope.getLowAddress().getValue().longValue());	299	((RangeList)rangeList).addLowRange(scope.getLowAddress().getValue().longValue());
294	}	300	}
Lines 298-305 public abstract class Scope implements IScope { Link Here
298	if (scope.getHighAddress() != null && scope.getHighAddress().compareTo(highAddress) > 0) {	304	if (scope.getHighAddress() != null && scope.getHighAddress().compareTo(highAddress) > 0) {
299	if (rangeList != null) {	305	if (rangeList != null) {
300	if (scope.getRangeList() != null) {	306	if (scope.getRangeList() != null) {
301	// TODO: merge properly	307	rangeList = RangeList.mergeRangeLists(rangeList,scope.getRangeList());
302	rangeList = null;
303	} else {	308	} else {
304	((RangeList)rangeList).addHighRange(scope.getHighAddress().getValue().longValue());	309	((RangeList)rangeList).addHighRange(scope.getHighAddress().getValue().longValue());
305	}	310	}
Lines 308-314 public abstract class Scope implements IScope { Link Here
308	}	313	}
309	}	314	}
310	}	315	}
311		316
312	protected void addLineInfoToParent(IScope scope) {	317	protected void addLineInfoToParent(IScope scope) {
313	IScope cu = parent;	318	IScope cu = parent;
314	while (cu != null) {	319	while (cu != null) {




		}
		return false;
	}

	public static RangeList mergeRangeLists(IRangeList first, IRangeList second){
		Iterator<IRangeList.Entry> firstIterator = first.iterator();
		Iterator<IRangeList.Entry> secondIterator = second.iterator();
		RangeList answer = new RangeList();
		IRangeList.Entry firstHead = null;
		IRangeList.Entry secondHead = null;
		while (firstIterator.hasNext() || secondIterator.hasNext()
				|| firstHead != null || secondHead != null){
			if (firstHead == null && firstIterator.hasNext()){
				firstHead = firstIterator.next();
			}
			if (secondHead == null && secondIterator.hasNext()){
				secondHead = secondIterator.next();
			}
			if (firstHead == null){
				if (secondHead != null){
					answer.addRange(secondHead.low, secondHead.high);
					secondHead = null;
				}// else we have no more work to do and will exit at the end of the loop
			} else {
				if (secondHead == null){
					answer.addRange(firstHead.low,firstHead.high);
					firstHead = null;
				} else {// both not null so work to do
					long low,high;
					if (firstHead.low <= secondHead.low){
						low = firstHead.low;
						if (firstHead.high < secondHead.low){// we are just using firstHead
							high = firstHead.high;
							firstHead = null;
						} else {// overlap so use both
							high = Math.max(firstHead.high, secondHead.high);
							firstHead = null;
							secondHead = null;
						}
					} else {
						low = secondHead.low;
						if (secondHead.high < firstHead.low){// just using secondHead
							high = secondHead.high;
							secondHead = null;
						} else { // overlap so use both
							high = Math.max(firstHead.high, secondHead.high);
							firstHead = null;
							secondHead = null;
						}
					}
					answer.addRange(low,high);
				}
			}
		}
		return answer;
	}
}
- 
--
.../cdt/debug/edc/symbols/tests/TestRangeList.java |   92 ++++++++++++++++++++
.../eclipse/cdt/debug/edc/tests/AllEDCTests.java   |    2 +
.../edc/internal/symbols/dwarf/RangeList.java      |    2 +-
3 files changed, 95 insertions(+), 1 deletions(-)
create mode 100644 org.eclipse.cdt.debug.edc.tests/src/org/eclipse/cdt/debug/edc/symbols/tests/TestRangeList.java




/*******************************************************************************
 * Copyright (c) 2011 Broadcom 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * Broadcom - Initial API and implementation
 *******************************************************************************/
package org.eclipse.cdt.debug.edc.symbols.tests;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;

import java.util.Iterator;

import org.eclipse.cdt.debug.edc.internal.symbols.dwarf.RangeList;
import org.eclipse.cdt.debug.edc.symbols.IRangeList;
import org.eclipse.cdt.debug.edc.symbols.IRangeList.Entry;
import org.junit.BeforeClass;
import org.junit.Test;

public class TestRangeList {

	private static RangeList first;
	private static int low;
	private static int high;
	private static RangeList second;
	private static RangeList expectedMerged;

	@BeforeClass
	public static void init(){
		low = 0;
		high = 120;
		first = new RangeList();
		first.addRange(low,10);
		first.addRange(25,32);
		first.addRange(60,68);
		first.addRange(107,high);

		second = new RangeList();
		second.addRange(7,18);
		second.addRange(32,35);
		second.addRange(52,60);
		second.addRange(75,80);
		second.addRange(93,high);

		expectedMerged = new RangeList();
		expectedMerged.addRange(low,18);
		expectedMerged.addRange(25,35);
		expectedMerged.addRange(52,68);
		expectedMerged.addRange(75,80);
		expectedMerged.addRange(93,high);
	}

	@Test
	public void lowHigh(){
		assertEquals(low,first.getLowAddress());
		assertEquals(high,first.getHighAddress());

		assertEquals(low,expectedMerged.getLowAddress());
		assertEquals(high,expectedMerged.getHighAddress());
	}

	@Test
	public void merge(){
		IRangeList merged = RangeList.mergeRangeLists(first, second);
		Iterator<Entry> mergedIter = merged.iterator();
		Iterator<Entry> expectedIter = expectedMerged.iterator();
		while (mergedIter.hasNext() && expectedIter.hasNext()){
			assertEquals("Entries should be equal",expectedIter.next(),mergedIter.next());
		}
		assertFalse("Should be finished",mergedIter.hasNext());
		assertFalse("Should be finished",expectedIter.hasNext());
	}

	@Test
	public void isInRange(){
		checkInRange(7,true,true,true);
		checkInRange(8,true,true,true);
		checkInRange(10,false,true,true);
		checkInRange(20,false,false,false);
		checkInRange(60,true,false,true);
	}

	private void checkInRange(int point, boolean inFirst, boolean inSecond, boolean inExpectedMerged) {
		assertEquals(inFirst,first.isInRange(point));
		assertEquals(inSecond,second.isInRange(point));
		assertEquals(inExpectedMerged,expectedMerged.isInRange(point));
	}
}

Lines 24-29 import org.eclipse.cdt.debug.edc.debugger.tests.RegisterFrameTestsBlackFlagRVCT; Link Here

(-)a/org.eclipse.cdt.debug.edc.tests/src/org/eclipse/cdt/debug/edc/tests/AllEDCTests.java (+2 lines)
24	import org.eclipse.cdt.debug.edc.debugger.tests.RegisterFrameTestsLinux;	24	import org.eclipse.cdt.debug.edc.debugger.tests.RegisterFrameTestsLinux;
25	import org.eclipse.cdt.debug.edc.debugger.tests.RegisterView;	25	import org.eclipse.cdt.debug.edc.debugger.tests.RegisterView;
26	import org.eclipse.cdt.debug.edc.debugger.tests.SnapshotTests;	26	import org.eclipse.cdt.debug.edc.debugger.tests.SnapshotTests;
		27	import org.eclipse.cdt.debug.edc.symbols.tests.TestRangeList;
27	import org.eclipse.cdt.debug.edc.system.tests.K9SystemViewTest;	28	import org.eclipse.cdt.debug.edc.system.tests.K9SystemViewTest;
28	import org.junit.runner.RunWith;	29	import org.junit.runner.RunWith;
29	import org.junit.runners.Suite;	30	import org.junit.runners.Suite;
Lines 59-64 import org.junit.runners.Suite; Link Here
59	TestFindCodeLine.class,	60	TestFindCodeLine.class,
60	TestMemoryStreamBuffer.class,	61	TestMemoryStreamBuffer.class,
61	TestOpcodeARM.class,	62	TestOpcodeARM.class,
		63	TestRangeList.class,
62	TestSourceToAddressMapping.class,	64	TestSourceToAddressMapping.class,
63	TestUnmanglerEABI.class,	65	TestUnmanglerEABI.class,
64	})	66	})

Lines 124-130 public class RangeList implements IRangeList { Link Here

(-)a/org.eclipse.cdt.debug.edc/src/org/eclipse/cdt/debug/edc/internal/symbols/dwarf/RangeList.java (-3 / +1 lines)
124	*/	124	*/
125	public boolean isInRange(long addr) {	125	public boolean isInRange(long addr) {
126	for (Entry entry : this) {	126	for (Entry entry : this) {
127	if (entry.low >= addr && addr < entry.high)	127	if (entry.low <= addr && addr < entry.high)
128	return true;	128	return true;
129	}	129	}
130	return false;	130	return false;
131	-
132	--
133	.../cdt/debug/edc/internal/symbols/Scope.java \| 9 +++++++--	131	.../cdt/debug/edc/internal/symbols/Scope.java \| 9 +++++++--
134	1 files changed, 7 insertions(+), 2 deletions(-)	132	1 files changed, 7 insertions(+), 2 deletions(-)

Lines 232-237 public abstract class Scope implements IScope { Link Here

(-)a/org.eclipse.cdt.debug.edc/src/org/eclipse/cdt/debug/edc/internal/symbols/Scope.java (-4 / +7 lines)
232	// figure it out from the functions	232	// figure it out from the functions
233	IAddress newLowAddress = Addr64.MAX;	233	IAddress newLowAddress = Addr64.MAX;
234	IAddress newHighAddress = Addr64.ZERO;	234	IAddress newHighAddress = Addr64.ZERO;
		235	IRangeList newRangeList = new RangeList();
235	boolean any = false;	236	boolean any = false;
236		237
237	for (IScope kid : getChildren()) {	238	for (IScope kid : getChildren()) {
Lines 242-248 public abstract class Scope implements IScope { Link Here
242	if (kid.hasEmptyRange()) {	243	if (kid.hasEmptyRange()) {
243	continue;	244	continue;
244	}	245	}
245		246
246	if (kid.getLowAddress().compareTo(baseAddress) > 0) {	247	if (kid.getLowAddress().compareTo(baseAddress) > 0) {
247	IRangeList kidRanges = kid.getRangeList();	248	IRangeList kidRanges = kid.getRangeList();
248	if (kidRanges == null){// If it didn't have ranges it still has one range	249	if (kidRanges == null){// If it didn't have ranges it still has one range
Lines 267-273 public abstract class Scope implements IScope { Link Here
267	//System.out.println("Needed to fix up ranges for " + getName());	268	//System.out.println("Needed to fix up ranges for " + getName());
268	lowAddress = newLowAddress;	269	lowAddress = newLowAddress;
269	highAddress = newHighAddress;	270	highAddress = newHighAddress;
270	rangeList = null;	271	int entryCount = 0;
		272	for (@SuppressWarnings("unused") IRangeList.Entry entry : newRangeList){
		273	++entryCount;
		274	}
		275	rangeList = (entryCount > 1) ? newRangeList : null;
271	} else {	276	} else {
272	if (lowAddress == null) {	277	if (lowAddress == null) {
273	lowAddress = highAddress = Addr32.ZERO;	278	lowAddress = highAddress = Addr32.ZERO;
274	-
275	--
276	.../internal/symbols/dwarf/DwarfInfoReader.java \| 5 ++++-	279	.../internal/symbols/dwarf/DwarfInfoReader.java \| 5 ++++-
277	1 files changed, 4 insertions(+), 1 deletions(-)	280	1 files changed, 4 insertions(+), 1 deletions(-)

Lines 1915-1920 public class DwarfInfoReader { Link Here

(-)a/org.eclipse.cdt.debug.edc/src/org/eclipse/cdt/debug/edc/internal/symbols/dwarf/DwarfInfoReader.java (-2 / +4 lines)
1915	*/	1915	*/
1916		1916
1917	RangeList list = new RangeList();	1917	RangeList list = new RangeList();
		1918	//Whether the list actually got anything added - otherwise we should return null
		1919	boolean listAddedTo = false;
1918		1920
1919	long base = 0;	1921	long base = 0;
1920	long start = data.getInt();	1922	long start = data.getInt();
Lines 1937-1942 public class DwarfInfoReader { Link Here
1937	// ignore bogus entries: GCC-E sometimes generates these buggily (for artifical non-inlined functions)	1939	// ignore bogus entries: GCC-E sometimes generates these buggily (for artifical non-inlined functions)
1938	if (base + start >= codeRanges.getLowAddress()) {	1940	if (base + start >= codeRanges.getLowAddress()) {
1939	list.addRange(base + start, base + end);	1941	list.addRange(base + start, base + end);
		1942	listAddedTo = true;
1940	}	1943	}
1941	}	1944	}
1942	start = data.getInt();	1945	start = data.getInt();
Lines 1944-1950 public class DwarfInfoReader { Link Here
1944		1947
1945	} while (true);	1948	} while (true);
1946		1949
1947	return list;	1950	return (listAddedTo) ? list : null;
1948		1951
1949	} catch (Throwable t) {	1952	} catch (Throwable t) {
1950	EDCDebugger.getMessageLogger().logError(DwarfMessages.DwarfInfoReader_RangeReadFailed, t);	1953	EDCDebugger.getMessageLogger().logError(DwarfMessages.DwarfInfoReader_RangeReadFailed, t);
1951	-

Return to bug 353605

Added Link Here

(-)a/org.eclipse.cdt.debug.edc.tests/src/org/eclipse/cdt/debug/edc/symbols/tests/TestRangeList.java (+92 lines)
1	/*******************************************************************************
2	* Copyright (c) 2011 Broadcom and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Broadcom - Initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.cdt.debug.edc.symbols.tests;
12
13	import static org.junit.Assert.assertEquals;
14	import static org.junit.Assert.assertFalse;
15
16	import java.util.Iterator;
17
18	import org.eclipse.cdt.debug.edc.internal.symbols.dwarf.RangeList;
19	import org.eclipse.cdt.debug.edc.symbols.IRangeList;
20	import org.eclipse.cdt.debug.edc.symbols.IRangeList.Entry;
21	import org.junit.BeforeClass;
22	import org.junit.Test;
23
24	public class TestRangeList {
25
26	private static RangeList first;
27	private static int low;
28	private static int high;
29	private static RangeList second;
30	private static RangeList expectedMerged;
31
32	@BeforeClass
33	public static void init(){
34	low = 0;
35	high = 120;
36	first = new RangeList();
37	first.addRange(low,10);
38	first.addRange(25,32);
39	first.addRange(60,68);
40	first.addRange(107,high);
41
42	second = new RangeList();
43	second.addRange(7,18);
44	second.addRange(32,35);
45	second.addRange(52,60);
46	second.addRange(75,80);
47	second.addRange(93,high);
48
49	expectedMerged = new RangeList();
50	expectedMerged.addRange(low,18);
51	expectedMerged.addRange(25,35);
52	expectedMerged.addRange(52,68);
53	expectedMerged.addRange(75,80);
54	expectedMerged.addRange(93,high);
55	}
56
57	@Test
58	public void lowHigh(){
59	assertEquals(low,first.getLowAddress());
60	assertEquals(high,first.getHighAddress());
61
62	assertEquals(low,expectedMerged.getLowAddress());
63	assertEquals(high,expectedMerged.getHighAddress());
64	}
65
66	@Test
67	public void merge(){
68	IRangeList merged = RangeList.mergeRangeLists(first, second);
69	Iterator<Entry> mergedIter = merged.iterator();
70	Iterator<Entry> expectedIter = expectedMerged.iterator();
71	while (mergedIter.hasNext() && expectedIter.hasNext()){
72	assertEquals("Entries should be equal",expectedIter.next(),mergedIter.next());
73	}
74	assertFalse("Should be finished",mergedIter.hasNext());
75	assertFalse("Should be finished",expectedIter.hasNext());
76	}
77
78	@Test
79	public void isInRange(){
80	checkInRange(7,true,true,true);
81	checkInRange(8,true,true,true);
82	checkInRange(10,false,true,true);
83	checkInRange(20,false,false,false);
84	checkInRange(60,true,false,true);
85	}
86
87	private void checkInRange(int point, boolean inFirst, boolean inSecond, boolean inExpectedMerged) {
88	assertEquals(inFirst,first.isInRange(point));
89	assertEquals(inSecond,second.isInRange(point));
90	assertEquals(inExpectedMerged,expectedMerged.isInRange(point));
91	}
92	}