GP-1543: Replace Range<Long> with Lifespan, ULongSpan, KeySpan,

FieldSpan

Ghidra/Debug/Debugger-agent-dbgeng/src/main/java/agent/dbgeng/manager/DbgMemoryOperations.java

@@ -18,7 +18,7 @@ package agent.dbgeng.manager;
 import java.nio.ByteBuffer;
 import java.util.concurrent.CompletableFuture;
 
-import com.google.common.collect.RangeSet;
+import generic.ULongSpan.ULongSpanSet;
 
 public interface DbgMemoryOperations {
 
@@ -30,7 +30,7 @@ public interface DbgMemoryOperations {
 	 * @param len the length of data to read
 	 * @return a future which completes giving the ranges successfully read
 	 */
-	CompletableFuture<RangeSet<Long>> readMemory(long addr, ByteBuffer buf, int len);
+	CompletableFuture<ULongSpanSet> readMemory(long addr, ByteBuffer buf, int len);
 
 	/**
 	 * Read memory
@@ -41,7 +41,7 @@ public interface DbgMemoryOperations {
 	 * @param buf the buffer to read into
 	 * @return a future which completes giving the ranges successfully read
 	 */
-	default CompletableFuture<RangeSet<Long>> readMemory(long addr, ByteBuffer buf) {
+	default CompletableFuture<ULongSpanSet> readMemory(long addr, ByteBuffer buf) {
 		return readMemory(addr, buf, buf.remaining());
 	}
 

Ghidra/Debug/Debugger-agent-dbgeng/src/main/java/agent/dbgeng/manager/cmd/AbstractDbgReadCommand.java

@@ -0,0 +1,50 @@
+/* ###
+ * IP: GHIDRA
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package agent.dbgeng.manager.cmd;
+
+import java.nio.ByteBuffer;
+
+import agent.dbgeng.manager.impl.DbgManagerImpl;
+import generic.ULongSpan;
+import generic.ULongSpan.ULongSpanSet;
+
+public abstract class AbstractDbgReadCommand extends AbstractDbgCommand<ULongSpanSet> {
+
+	private final long addr;
+	private final ByteBuffer buf;
+	private final int len;
+
+	private int readLen;
+
+	protected AbstractDbgReadCommand(DbgManagerImpl manager, long addr, ByteBuffer buf, int len) {
+		super(manager);
+		this.addr = addr;
+		this.buf = buf;
+		this.len = len;
+	}
+
+	protected abstract int doRead(long addr, ByteBuffer buf, int len);
+
+	@Override
+	public void invoke() {
+		readLen = doRead(addr, buf, len);
+	}
+
+	@Override
+	public ULongSpanSet complete(DbgPendingCommand<?> pending) {
+		return ULongSpanSet.of(ULongSpan.extent(addr, readLen));
+	}
+}

Ghidra/Debug/Debugger-agent-dbgeng/src/main/java/agent/dbgeng/manager/cmd/DbgReadBusDataCommand.java

@@ -17,46 +17,29 @@ package agent.dbgeng.manager.cmd;
 
 import java.nio.ByteBuffer;
 
-import com.google.common.collect.*;
-
 import agent.dbgeng.manager.DbgThread;
 import agent.dbgeng.manager.impl.DbgManagerImpl;
 
 /**
  * Implementation of {@link DbgThread#readMemory(long, ByteBuffer, int)}
  */
-public class DbgReadBusDataCommand extends AbstractDbgCommand<RangeSet<Long>> {
+public class DbgReadBusDataCommand extends AbstractDbgReadCommand {
 
-	private final long addr;
-	private final ByteBuffer buf;
-	private final int len;
 	private final int busDataType;
 	private final int busNumber;
 	private final int slotNumber;
 
-	private int readLen;
-
 	public DbgReadBusDataCommand(DbgManagerImpl manager, long addr, ByteBuffer buf, int len,
 			int busDataType, int busNumber, int slotNumber) {
-		super(manager);
-		this.addr = addr;
-		this.buf = buf;
-		this.len = len;
+		super(manager, addr, buf, len);
 		this.busDataType = busDataType;
 		this.busNumber = busNumber;
 		this.slotNumber = slotNumber;
 	}
 
 	@Override
-	public RangeSet<Long> complete(DbgPendingCommand<?> pending) {
-		RangeSet<Long> rangeSet = TreeRangeSet.create();
-		rangeSet.add(Range.closedOpen(addr, addr + readLen));
-		return rangeSet;
-	}
-
-	@Override
-	public void invoke() {
-		readLen =
-			manager.getDataSpaces().readBusData(busDataType, busNumber, slotNumber, addr, buf, len);
+	protected int doRead(long addr, ByteBuffer buf, int len) {
+		return manager.getDataSpaces()
+				.readBusData(busDataType, busNumber, slotNumber, addr, buf, len);
 	}
 }

Ghidra/Debug/Debugger-agent-dbgeng/src/main/java/agent/dbgeng/manager/cmd/DbgReadControlCommand.java

@@ -17,41 +17,24 @@ package agent.dbgeng.manager.cmd;
 
 import java.nio.ByteBuffer;
 
-import com.google.common.collect.*;
-
 import agent.dbgeng.manager.DbgThread;
 import agent.dbgeng.manager.impl.DbgManagerImpl;
 
 /**
  * Implementation of {@link DbgThread#readMemory(long, ByteBuffer, int)}
  */
-public class DbgReadControlCommand extends AbstractDbgCommand<RangeSet<Long>> {
+public class DbgReadControlCommand extends AbstractDbgReadCommand {
 
-	private final long addr;
-	private final ByteBuffer buf;
-	private final int len;
-	private int processor;
-
-	private int readLen;
+	private final int processor;
 
 	public DbgReadControlCommand(DbgManagerImpl manager, long addr, ByteBuffer buf, int len,
 			int processor) {
-		super(manager);
-		this.addr = addr;
-		this.buf = buf;
-		this.len = len;
+		super(manager, addr, buf, len);
 		this.processor = processor;
 	}
 
 	@Override
-	public RangeSet<Long> complete(DbgPendingCommand<?> pending) {
-		RangeSet<Long> rangeSet = TreeRangeSet.create();
-		rangeSet.add(Range.closedOpen(addr, addr + readLen));
-		return rangeSet;
-	}
-
-	@Override
-	public void invoke() {
-		readLen = manager.getDataSpaces().readControl(processor, addr, buf, len);
+	protected int doRead(long addr, ByteBuffer buf, int len) {
+		return manager.getDataSpaces().readControl(processor, addr, buf, len);
 	}
 }

Ghidra/Debug/Debugger-agent-dbgeng/src/main/java/agent/dbgeng/manager/cmd/DbgReadDebuggerDataCommand.java

@@ -17,38 +17,20 @@ package agent.dbgeng.manager.cmd;
 
 import java.nio.ByteBuffer;
 
-import com.google.common.collect.*;
-
 import agent.dbgeng.manager.DbgThread;
 import agent.dbgeng.manager.impl.DbgManagerImpl;
 
 /**
  * Implementation of {@link DbgThread#readMemory(long, ByteBuffer, int)}
  */
-public class DbgReadDebuggerDataCommand extends AbstractDbgCommand<RangeSet<Long>> {
-
-	private final long addr;
-	private final ByteBuffer buf;
-	private final int len;
-
-	private int readLen;
+public class DbgReadDebuggerDataCommand extends AbstractDbgReadCommand {
 
 	public DbgReadDebuggerDataCommand(DbgManagerImpl manager, long addr, ByteBuffer buf, int len) {
-		super(manager);
-		this.addr = addr;
-		this.buf = buf;
-		this.len = len;
+		super(manager, addr, buf, len);
 	}
 
 	@Override
-	public RangeSet<Long> complete(DbgPendingCommand<?> pending) {
-		RangeSet<Long> rangeSet = TreeRangeSet.create();
-		rangeSet.add(Range.closedOpen(addr, addr + readLen));
-		return rangeSet;
-	}
-
-	@Override
-	public void invoke() {
-		readLen = manager.getDataSpaces().readDebuggerData((int) addr, buf, len);
+	protected int doRead(long addr, ByteBuffer buf, int len) {
+		return manager.getDataSpaces().readDebuggerData((int) addr, buf, len);
 	}
 }

Ghidra/Debug/Debugger-agent-dbgeng/src/main/java/agent/dbgeng/manager/cmd/DbgReadIoCommand.java

@@ -17,46 +17,29 @@ package agent.dbgeng.manager.cmd;
 
 import java.nio.ByteBuffer;
 
-import com.google.common.collect.*;
-
 import agent.dbgeng.manager.DbgThread;
 import agent.dbgeng.manager.impl.DbgManagerImpl;
 
 /**
  * Implementation of {@link DbgThread#readMemory(long, ByteBuffer, int)}
  */
-public class DbgReadIoCommand extends AbstractDbgCommand<RangeSet<Long>> {
+public class DbgReadIoCommand extends AbstractDbgReadCommand {
 
-	private final long addr;
-	private final ByteBuffer buf;
-	private final int len;
 	private final int interfaceType;
 	private final int busNumber;
 	private final int addressSpace;
 
-	private int readLen;
-
 	public DbgReadIoCommand(DbgManagerImpl manager, long addr, ByteBuffer buf, int len,
 			int interfaceType, int busNumber, int addressSpace) {
-		super(manager);
-		this.addr = addr;
-		this.buf = buf;
-		this.len = len;
+		super(manager, addr, buf, len);
 		this.interfaceType = interfaceType;
 		this.busNumber = busNumber;
 		this.addressSpace = addressSpace;
 	}
 
 	@Override
-	public RangeSet<Long> complete(DbgPendingCommand<?> pending) {
-		RangeSet<Long> rangeSet = TreeRangeSet.create();
-		rangeSet.add(Range.closedOpen(addr, addr + readLen));
-		return rangeSet;
-	}
-
-	@Override
-	public void invoke() {
-		readLen =
-			manager.getDataSpaces().readIo(interfaceType, busNumber, addressSpace, addr, buf, len);
+	protected int doRead(long addr, ByteBuffer buf, int len) {
+		return manager.getDataSpaces()
+				.readIo(interfaceType, busNumber, addressSpace, addr, buf, len);
 	}
 }

Ghidra/Debug/Debugger-agent-dbgeng/src/main/java/agent/dbgeng/manager/cmd/DbgReadMemoryCommand.java

@@ -17,40 +17,20 @@ package agent.dbgeng.manager.cmd;
 
 import java.nio.ByteBuffer;
 
-import com.google.common.collect.*;
-
-import agent.dbgeng.dbgeng.DebugDataSpaces;
 import agent.dbgeng.manager.DbgThread;
 import agent.dbgeng.manager.impl.DbgManagerImpl;
 
 /**
  * Implementation of {@link DbgThread#readMemory(long, ByteBuffer, int)}
  */
-public class DbgReadMemoryCommand extends AbstractDbgCommand<RangeSet<Long>> {
-
-	private final long addr;
-	private final ByteBuffer buf;
-	private final int len;
-
-	private int readLen;
+public class DbgReadMemoryCommand extends AbstractDbgReadCommand {
 
 	public DbgReadMemoryCommand(DbgManagerImpl manager, long addr, ByteBuffer buf, int len) {
-		super(manager);
-		this.addr = addr;
-		this.buf = buf;
-		this.len = len;
+		super(manager, addr, buf, len);
 	}
 
 	@Override
-	public RangeSet<Long> complete(DbgPendingCommand<?> pending) {
-		RangeSet<Long> rangeSet = TreeRangeSet.create();
-		rangeSet.add(Range.closedOpen(addr, addr + readLen));
-		return rangeSet;
-	}
-
-	@Override
-	public void invoke() {
-		DebugDataSpaces dataSpaces = manager.getDataSpaces();
-		readLen = dataSpaces.readVirtual(addr, buf, len);
+	protected int doRead(long addr, ByteBuffer buf, int len) {
+		return manager.getDataSpaces().readVirtual(addr, buf, len);
 	}
 }

Ghidra/Debug/Debugger-agent-dbgeng/src/main/java/agent/dbgeng/manager/cmd/DbgReadPhysicalMemoryCommand.java

@@ -17,39 +17,21 @@ package agent.dbgeng.manager.cmd;
 
 import java.nio.ByteBuffer;
 
-import com.google.common.collect.*;
-
 import agent.dbgeng.manager.DbgThread;
 import agent.dbgeng.manager.impl.DbgManagerImpl;
 
 /**
  * Implementation of {@link DbgThread#readMemory(long, ByteBuffer, int)}
  */
-public class DbgReadPhysicalMemoryCommand extends AbstractDbgCommand<RangeSet<Long>> {
-
-	private final long addr;
-	private final ByteBuffer buf;
-	private final int len;
-
-	private int readLen;
+public class DbgReadPhysicalMemoryCommand extends AbstractDbgReadCommand {
 
 	public DbgReadPhysicalMemoryCommand(DbgManagerImpl manager, long addr, ByteBuffer buf,
 			int len) {
-		super(manager);
-		this.addr = addr;
-		this.buf = buf;
-		this.len = len;
+		super(manager, addr, buf, len);
 	}
 
 	@Override
-	public RangeSet<Long> complete(DbgPendingCommand<?> pending) {
-		RangeSet<Long> rangeSet = TreeRangeSet.create();
-		rangeSet.add(Range.closedOpen(addr, addr + readLen));
-		return rangeSet;
-	}
-
-	@Override
-	public void invoke() {
-		readLen = manager.getDataSpaces().readPhysical(addr, buf, len);
+	protected int doRead(long addr, ByteBuffer buf, int len) {
+		return manager.getDataSpaces().readPhysical(addr, buf, len);
 	}
 }

Ghidra/Debug/Debugger-agent-dbgeng/src/main/java/agent/dbgeng/manager/impl/DbgProcessImpl.java

@@ -15,7 +15,7 @@
  */
 package agent.dbgeng.manager.impl;
 
-import static ghidra.async.AsyncUtils.*;
+import static ghidra.async.AsyncUtils.sequence;
 
 import java.nio.ByteBuffer;
 import java.util.*;
@@ -23,13 +23,12 @@ import java.util.concurrent.CompletableFuture;
 import java.util.function.Function;
 import java.util.function.Supplier;
 
-import com.google.common.collect.RangeSet;
-
 import agent.dbgeng.dbgeng.*;
 import agent.dbgeng.dbgeng.DebugClient.DebugAttachFlags;
 import agent.dbgeng.manager.*;
 import agent.dbgeng.manager.DbgManager.ExecSuffix;
 import agent.dbgeng.manager.cmd.*;
+import generic.ULongSpan.ULongSpanSet;
 import ghidra.async.TypeSpec;
 import ghidra.comm.util.BitmaskSet;
 import ghidra.dbg.target.TargetAttachable;
@@ -332,7 +331,7 @@ public class DbgProcessImpl implements DbgProcess {
 	}
 
 	@Override
-	public CompletableFuture<RangeSet<Long>> readMemory(long addr, ByteBuffer buf, int len) {
+	public CompletableFuture<ULongSpanSet> readMemory(long addr, ByteBuffer buf, int len) {
 		// I can't imagine this working without a thread....
 		return preferThread(t -> t.readMemory(addr, buf, len),
 			() -> manager.execute(new DbgReadMemoryCommand(manager, addr, buf, len)));

Ghidra/Debug/Debugger-agent-dbgeng/src/main/java/agent/dbgeng/manager/impl/DbgThreadImpl.java

@@ -20,8 +20,6 @@ import java.nio.ByteBuffer;
 import java.util.*;
 import java.util.concurrent.CompletableFuture;
 
-import com.google.common.collect.RangeSet;
-
 import agent.dbgeng.dbgeng.DebugEventInformation;
 import agent.dbgeng.dbgeng.DebugRegisters.DebugRegisterDescription;
 import agent.dbgeng.dbgeng.DebugThreadId;
@@ -32,6 +30,7 @@ import agent.dbgeng.manager.DbgManager.ExecSuffix;
 import agent.dbgeng.manager.breakpoint.DbgBreakpointInfo;
 import agent.dbgeng.manager.breakpoint.DbgBreakpointType;
 import agent.dbgeng.manager.cmd.*;
+import generic.ULongSpan.ULongSpanSet;
 import ghidra.async.AsyncLazyValue;
 import ghidra.async.AsyncReference;
 import ghidra.util.Msg;
@@ -176,7 +175,7 @@ public class DbgThreadImpl implements DbgThread {
 	}
 
 	@Override
-	public CompletableFuture<RangeSet<Long>> readMemory(long addr, ByteBuffer buf, int len) {
+	public CompletableFuture<ULongSpanSet> readMemory(long addr, ByteBuffer buf, int len) {
 		return manager.execute(new DbgReadMemoryCommand(manager, addr, buf, len));
 	}
 

Ghidra/Debug/Debugger-agent-dbgeng/src/main/java/agent/dbgeng/model/impl/DbgModelTargetMemoryContainerImpl.java

@@ -20,14 +20,13 @@ import java.util.*;
 import java.util.concurrent.CompletableFuture;
 import java.util.stream.Collectors;
 
-import com.google.common.collect.Range;
-import com.google.common.collect.RangeSet;
-
 import agent.dbgeng.manager.DbgModuleMemory;
 import agent.dbgeng.manager.cmd.*;
 import agent.dbgeng.manager.impl.DbgManagerImpl;
 import agent.dbgeng.manager.impl.DbgProcessImpl;
 import agent.dbgeng.model.iface2.*;
+import generic.ULongSpan;
+import generic.ULongSpan.ULongSpanSet;
 import ghidra.async.AsyncUtils;
 import ghidra.dbg.error.DebuggerMemoryAccessException;
 import ghidra.dbg.error.DebuggerModelAccessException;
@@ -114,16 +113,16 @@ public class DbgModelTargetMemoryContainerImpl extends DbgModelTargetObjectImpl
 		});
 	}
 
-	private byte[] readAssist(Address address, ByteBuffer buf, long offset, RangeSet<Long> set) {
+	private byte[] readAssist(Address address, ByteBuffer buf, long offset, ULongSpanSet set) {
 		if (set == null) {
 			return new byte[0];
 		}
-		Range<Long> range = set.rangeContaining(offset);
-		if (range == null) {
+		ULongSpan span = set.spanContaining(offset);
+		if (span == null) {
 			throw new DebuggerMemoryAccessException("Cannot read at " + address);
 		}
 		listeners.fire.memoryUpdated(getProxy(), address, buf.array());
-		return Arrays.copyOf(buf.array(), (int) (range.upperEndpoint() - range.lowerEndpoint()));
+		return Arrays.copyOf(buf.array(), (int) span.length());
 	}
 
 	public CompletableFuture<Void> writeVirtualMemory(Address address, byte[] data) {

Ghidra/Debug/Debugger-agent-dbgeng/src/test/java/agent/dbgeng/manager/impl/AbstractDbgManagerTest.java

@@ -15,7 +15,7 @@
  */
 package agent.dbgeng.manager.impl;
 
-import static ghidra.async.AsyncUtils.*;
+import static ghidra.async.AsyncUtils.sequence;
 import static org.junit.Assert.*;
 
 import java.io.IOException;
@@ -30,13 +30,13 @@ import java.util.concurrent.atomic.AtomicReference;
 import org.apache.commons.lang3.tuple.Pair;
 import org.junit.*;
 
-import com.google.common.collect.*;
-
 import agent.dbgeng.dbgeng.DbgEngTest;
 import agent.dbgeng.dbgeng.DebugProcessId;
 import agent.dbgeng.manager.*;
 import agent.dbgeng.manager.DbgManager.ExecSuffix;
 import agent.dbgeng.manager.breakpoint.DbgBreakpointInfo;
+import generic.ULongSpan;
+import generic.ULongSpan.ULongSpanSet;
 import ghidra.async.AsyncFence;
 import ghidra.async.TypeSpec;
 import ghidra.dbg.testutil.DummyProc;
@@ -320,11 +320,10 @@ public abstract class AbstractDbgManagerTest extends AbstractGhidraHeadlessInteg
 				thread.get().writeMemory(addr.get(), buf).handle(seq::next);
 			}).then(seq -> {
 				thread.get().readMemory(addr.get(), rBuf).handle(seq::next);
-			}, TypeSpec.obj((RangeSet<Long>) null)).then((rng, seq) -> {
+			}, TypeSpec.obj((ULongSpanSet) null)).then((rng, seq) -> {
 				rBuf.flip();
 				rBuf.order(ByteOrder.LITTLE_ENDIAN);
-				RangeSet<Long> exp = TreeRangeSet.create();
-				exp.add(Range.closedOpen(addr.get(), addr.get() + 1024));
+				ULongSpanSet exp = ULongSpanSet.of(ULongSpan.extent(addr.get(), 1024));
 				assertEquals(exp, rng);
 				for (int i = 0; i < 10; i++) {
 					assertEquals(i, rBuf.getInt());

Ghidra/Debug/Debugger-agent-dbgmodel-traceloader/ghidra_scripts/BangAddressToMemory.java

@@ -16,8 +16,6 @@
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 
-import com.google.common.collect.Range;
-
 import agent.dbgeng.manager.impl.DbgManagerImpl;
 import agent.dbgeng.model.AbstractDbgModel;
 import ghidra.app.script.GhidraScript;
@@ -26,6 +24,7 @@ import ghidra.app.services.DebuggerTraceManagerService;
 import ghidra.dbg.DebuggerObjectModel;
 import ghidra.program.model.address.*;
 import ghidra.program.model.lang.Language;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace;
 import ghidra.trace.model.memory.*;
 import ghidra.util.LockHold;
@@ -147,7 +146,7 @@ public class BangAddressToMemory extends GhidraScript {
 				AddressRange rng = rng(start, end - 1);
 				try {
 					TraceMemoryRegion region =
-						memory.addRegion(startStr, Range.atLeast(0L), rng, TraceMemoryFlag.READ,
+						memory.addRegion(startStr, Lifespan.nowOn(0), rng, TraceMemoryFlag.READ,
 							TraceMemoryFlag.WRITE, TraceMemoryFlag.EXECUTE);
 					region.setName(name);
 				}

Ghidra/Debug/Debugger-agent-dbgmodel-traceloader/ghidra_scripts/PopulateMemviewLocal.java

@@ -31,7 +31,6 @@
 import java.io.File;
 import java.util.*;
 
-import com.google.common.collect.Range;
 import com.sun.jna.Pointer;
 
 import agent.dbgeng.dbgeng.DebugClient;
@@ -46,6 +45,7 @@ import ghidra.app.script.GhidraScript;
 import ghidra.program.model.address.*;
 import ghidra.program.model.lang.Language;
 import ghidra.program.model.lang.Register;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.memory.TraceMemoryFlag;
 import ghidra.util.Swing;
 
@@ -144,7 +144,7 @@ public class PopulateMemviewLocal extends GhidraScript {
 					Long start = (Long) address.getValue();
 					Long sz = (Long) size.getValue();
 					AddressRange rng = rng(start, start + sz - 1);
-					addLoadedModule(moduleId, moduleId, Range.atLeast(snap), rng);
+					addLoadedModule(moduleId, moduleId, Lifespan.nowOn(snap), rng);
 					//addRegion(moduleId, Range.atLeast(snap), rng, TraceMemoryFlag.READ,
 					//	TraceMemoryFlag.WRITE, TraceMemoryFlag.EXECUTE);
 				}
@@ -161,7 +161,7 @@ public class PopulateMemviewLocal extends GhidraScript {
 				AddressRange rng = rng(iid, iid + 1);
 				display += " " + threadId;
 				if (display.contains("ThreadCreated")) {
-					addThread("Thread " + threadId, Range.atLeast(snap), rng);
+					addThread("Thread " + threadId, Lifespan.nowOn(snap), rng);
 				}
 				else {
 					markThreadClosed(threadId, snap);
@@ -212,8 +212,8 @@ public class PopulateMemviewLocal extends GhidraScript {
 			String heapId = "Heap " + address.getValueString();
 			Long startTick = (Long) timeStart.getValue();
 			Long stopTick = (Long) timeEnd.getValue();
-			Range<Long> interval =
-				(stopTick > 0) ? Range.open(startTick, stopTick) : Range.atLeast(startTick);
+			Lifespan interval =
+				(stopTick > 0) ? Lifespan.span(startTick, stopTick) : Lifespan.nowOn(startTick);
 			addHeap(heapId, interval, rng, TraceMemoryFlag.READ, TraceMemoryFlag.WRITE,
 				TraceMemoryFlag.EXECUTE);
 		}
@@ -237,24 +237,24 @@ public class PopulateMemviewLocal extends GhidraScript {
 		});
 	}
 
-	private void addHeap(String heapId, Range<Long> interval, AddressRange rng,
+	private void addHeap(String heapId, Lifespan interval, AddressRange rng,
 			TraceMemoryFlag read, TraceMemoryFlag write, TraceMemoryFlag execute) {
 		MemoryBox box = new MemoryBox(heapId, MemviewBoxType.HEAP_CREATE, rng, interval);
 		boxes.put(box.getId(), box);
 	}
 
-	private void addThread(String threadId, Range<Long> interval, AddressRange rng) {
+	private void addThread(String threadId, Lifespan interval, AddressRange rng) {
 		MemoryBox box = new MemoryBox(threadId, MemviewBoxType.THREAD, rng, interval);
 		boxes.put(box.getId(), box);
 	}
 
-	private void addRegion(String regionId, Range<Long> interval, AddressRange rng,
+	private void addRegion(String regionId, Lifespan interval, AddressRange rng,
 			TraceMemoryFlag read, TraceMemoryFlag write, TraceMemoryFlag execute) {
 		MemoryBox box = new MemoryBox(regionId, MemviewBoxType.IMAGE, rng, interval);
 		boxes.put(box.getId(), box);
 	}
 
-	private void addLoadedModule(String moduleId, String moduleId2, Range<Long> interval,
+	private void addLoadedModule(String moduleId, String moduleId2, Lifespan interval,
 			AddressRange rng) {
 		MemoryBox box = new MemoryBox(moduleId, MemviewBoxType.MODULE, rng, interval);
 		boxes.put(box.getId(), box);

Ghidra/Debug/Debugger-agent-dbgmodel-traceloader/ghidra_scripts/PopulateTraceLocal.java

@@ -19,8 +19,6 @@ import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 import java.util.*;
 
-import com.google.common.collect.Range;
-
 import agent.dbgeng.dbgeng.DebugClient;
 import agent.dbgeng.dbgeng.DebugControl;
 import agent.dbgmodel.dbgmodel.DbgModel;
@@ -32,6 +30,7 @@ import ghidra.app.services.DebuggerTraceManagerService;
 import ghidra.program.model.address.*;
 import ghidra.program.model.lang.*;
 import ghidra.trace.database.DBTrace;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace;
 import ghidra.trace.model.memory.*;
 import ghidra.trace.model.modules.TraceModule;
@@ -226,7 +225,7 @@ public class PopulateTraceLocal extends GhidraScript {
 						buf = ByteBuffer.allocate(sz.intValue()).order(ByteOrder.LITTLE_ENDIAN);
 						AddressRange rng = rng(start, start + sz - 1);
 						modules.addLoadedModule(moduleId, moduleId, rng, snap);
-						memory.addRegion(moduleId, Range.atLeast(snap), rng,
+						memory.addRegion(moduleId, Lifespan.nowOn(snap), rng,
 							TraceMemoryFlag.READ, TraceMemoryFlag.WRITE, TraceMemoryFlag.EXECUTE);
 						try {
 							int read =
@@ -261,7 +260,7 @@ public class PopulateTraceLocal extends GhidraScript {
 					String threadId = id.getValueString();
 					display += " " + threadId;
 					if (display.contains("ThreadCreated")) {
-						threads.addThread(threadId, Range.atLeast(snap));
+						threads.addThread(threadId, Lifespan.nowOn(snap));
 					}
 					else {
 						if (snap >= 0) {

Ghidra/Debug/Debugger-agent-frida/src/main/java/agent/frida/manager/cmd/AbstractFridaReadCommand.java

@@ -0,0 +1,59 @@
+/* ###
+ * IP: GHIDRA
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package agent.frida.manager.cmd;
+
+import java.nio.ByteBuffer;
+
+import com.google.gson.JsonElement;
+
+import agent.frida.manager.impl.FridaManagerImpl;
+import ghidra.program.model.address.*;
+import ghidra.util.NumericUtilities;
+
+public abstract class AbstractFridaReadCommand extends AbstractFridaCommand<AddressSetView> {
+
+	protected final Address addr;
+	protected final ByteBuffer buf;
+	protected final int len;
+
+	protected AbstractFridaReadCommand(FridaManagerImpl manager, Address addr, ByteBuffer buf,
+			int len) {
+		super(manager);
+		this.addr = addr;
+		this.buf = buf;
+		this.len = len;
+	}
+
+	@Override
+	public AddressSetView complete(FridaPendingCommand<?> pending) {
+		return new AddressSet(addr, addr.add(len - 1));
+	}
+
+	@Override
+	public void parseSpecifics(JsonElement element) {
+		String payload = element.getAsString();
+		String[] lines = payload.split("\n");
+		int n = 0;
+		for (String l : lines) {
+			String[] split = l.split("  ");
+			byte[] bytes = NumericUtilities.convertStringToBytes(split[1]);
+			for (int i = 0; i < 16; i++) {
+				buf.put(n + i, bytes[i]);
+			}
+			n += 16;
+		}
+	}
+}

Ghidra/Debug/Debugger-agent-frida/src/main/java/agent/frida/manager/cmd/FridaReadKernelMemoryCommand.java

@@ -17,57 +17,21 @@ package agent.frida.manager.cmd;
 
 import java.nio.ByteBuffer;
 
-import com.google.common.collect.Range;
-import com.google.common.collect.RangeSet;
-import com.google.common.collect.TreeRangeSet;
-//import com.sun.jna.Pointer;
-//import com.sun.jna.ptr.PointerByReference;
-import com.google.gson.JsonElement;
-
 import agent.frida.manager.impl.FridaManagerImpl;
 import ghidra.program.model.address.Address;
-import ghidra.util.NumericUtilities;
 
-public class FridaReadKernelMemoryCommand extends AbstractFridaCommand<RangeSet<Long>> {
+public class FridaReadKernelMemoryCommand extends AbstractFridaReadCommand {
 
-	private final Address addr;
-	private final ByteBuffer buf;
-	private final int len;
-
-	public FridaReadKernelMemoryCommand(FridaManagerImpl manager, Address addr, ByteBuffer buf, int len) {
-		super(manager);
-		this.addr = addr;
-		this.buf = buf;
-		this.len = len;
+	public FridaReadKernelMemoryCommand(FridaManagerImpl manager, Address addr, ByteBuffer buf,
+			int len) {
+		super(manager, addr, buf, len);
 	}
 
-	@Override
-	public RangeSet<Long> complete(FridaPendingCommand<?> pending) {
-		RangeSet<Long> rangeSet = TreeRangeSet.create();
-		rangeSet.add(Range.closedOpen(addr.getOffset(), addr.getOffset() + len));
-		return rangeSet;
-	}
-
-	
 	@Override
 	public void invoke() {
 		manager.loadScript(this, "read_memory",
-			"var buf = Kernel.readByteArray(ptr(0x"+addr+")"+len+"); result = hexdump(buf, {header:false});");
-	}
-	
-	@Override
-	public void parseSpecifics(JsonElement element) {
-		String payload = element.getAsString();
-		String[] lines = payload.split("\n");
-		int n = 0;
-		for (String l : lines) {
-			String[] split = l.split("  ");
-			byte[] bytes = NumericUtilities.convertStringToBytes(split[1]);
-			for (int i = 0; i < 16; i++) {
-				buf.put(n+i, bytes[i]);
-			}
-			n += 16;
-		}
+			"var buf = Kernel.readByteArray(ptr(0x" + addr + ")," + len +
+				"); result = hexdump(buf, {header:false});");
 	}
 
 }

Ghidra/Debug/Debugger-agent-frida/src/main/java/agent/frida/manager/cmd/FridaReadMemoryCommand.java

@@ -17,57 +17,20 @@ package agent.frida.manager.cmd;
 
 import java.nio.ByteBuffer;
 
-import com.google.common.collect.Range;
-import com.google.common.collect.RangeSet;
-import com.google.common.collect.TreeRangeSet;
-//import com.sun.jna.Pointer;
-//import com.sun.jna.ptr.PointerByReference;
-import com.google.gson.JsonElement;
-
 import agent.frida.manager.impl.FridaManagerImpl;
 import ghidra.program.model.address.Address;
-import ghidra.util.NumericUtilities;
 
-public class FridaReadMemoryCommand extends AbstractFridaCommand<RangeSet<Long>> {
-
-	private final Address addr;
-	private final ByteBuffer buf;
-	private final int len;
+public class FridaReadMemoryCommand extends AbstractFridaReadCommand {
 
 	public FridaReadMemoryCommand(FridaManagerImpl manager, Address addr, ByteBuffer buf, int len) {
-		super(manager);
-		this.addr = addr;
-		this.buf = buf;
-		this.len = len;
+		super(manager, addr, buf, len);
 	}
 
-	@Override
-	public RangeSet<Long> complete(FridaPendingCommand<?> pending) {
-		RangeSet<Long> rangeSet = TreeRangeSet.create();
-		rangeSet.add(Range.closedOpen(addr.getOffset(), addr.getOffset() + len));
-		return rangeSet;
-	}
-
-	
 	@Override
 	public void invoke() {
 		manager.loadScript(this, "read_memory",
-			"var buf = ptr(0x"+addr+").readByteArray("+len+"); result = hexdump(buf, {header:false});");
-	}
-	
-	@Override
-	public void parseSpecifics(JsonElement element) {
-		String payload = element.getAsString();
-		String[] lines = payload.split("\n");
-		int n = 0;
-		for (String l : lines) {
-			String[] split = l.split("  ");
-			byte[] bytes = NumericUtilities.convertStringToBytes(split[1]);
-			for (int i = 0; i < 16; i++) {
-				buf.put(n+i, bytes[i]);
-			}
-			n += 16;
-		}
+			"var buf = ptr(0x" + addr + ").readByteArray(" + len +
+				"); result = hexdump(buf, {header:false});");
 	}
 
 }

Ghidra/Debug/Debugger-agent-frida/src/main/java/agent/frida/model/impl/FridaModelTargetKernelMemoryContainerImpl.java

@@ -19,9 +19,6 @@ import java.nio.ByteBuffer;
 import java.util.*;
 import java.util.concurrent.CompletableFuture;
 
-import com.google.common.collect.Range;
-import com.google.common.collect.RangeSet;
-
 import agent.frida.frida.FridaRegionInfo;
 import agent.frida.manager.*;
 import agent.frida.manager.cmd.FridaReadKernelMemoryCommand;
@@ -35,7 +32,7 @@ import ghidra.dbg.error.DebuggerModelAccessException;
 import ghidra.dbg.target.TargetObject;
 import ghidra.dbg.target.schema.*;
 import ghidra.dbg.target.schema.TargetObjectSchema.ResyncMode;
-import ghidra.program.model.address.Address;
+import ghidra.program.model.address.*;
 import ghidra.util.Msg;
 import ghidra.util.datastruct.WeakValueHashMap;
 
@@ -61,7 +58,6 @@ public class FridaModelTargetKernelMemoryContainerImpl extends FridaModelTargetO
 	protected final Map<String, FridaModelTargetMemoryRegionImpl> memoryRegions =
 		new WeakValueHashMap<>();
 
-
 	public FridaModelTargetKernelMemoryContainerImpl(FridaModelTargetKernelImpl kernel) {
 		super(kernel.getModel(), kernel, "Memory", "MemoryContainer");
 		this.kernel = kernel;
@@ -100,16 +96,16 @@ public class FridaModelTargetKernelMemoryContainerImpl extends FridaModelTargetO
 		return new FridaModelTargetMemoryRegionImpl(this, region);
 	}
 
-	private byte[] readAssist(Address address, ByteBuffer buf, long offset, RangeSet<Long> set) {
+	private byte[] readAssist(Address address, ByteBuffer buf, AddressSetView set) {
 		if (set == null) {
 			return new byte[0];
 		}
-		Range<Long> range = set.rangeContaining(offset);
+		AddressRange range = set.getRangeContaining(address);
 		if (range == null) {
 			throw new DebuggerMemoryAccessException("Cannot read at " + address);
 		}
 		listeners.fire.memoryUpdated(getProxy(), address, buf.array());
-		return Arrays.copyOf(buf.array(), (int) (range.upperEndpoint() - range.lowerEndpoint()));
+		return Arrays.copyOf(buf.array(), (int) range.getLength());
 	}
 
 	private void writeAssist(Address address, byte[] data) {
@@ -128,12 +124,12 @@ public class FridaModelTargetKernelMemoryContainerImpl extends FridaModelTargetO
 				"Cannot process command readMemory while engine is waiting for events");
 		}
 		ByteBuffer buf = ByteBuffer.allocate(length);
-		long offset = address.getOffset();
 		if (!manager.isKernelMode() || address.getAddressSpace().getName().equals("ram")) {
 			return manager
-					.execute(new FridaReadKernelMemoryCommand(manager, address, buf, buf.remaining()))
+					.execute(
+						new FridaReadKernelMemoryCommand(manager, address, buf, buf.remaining()))
 					.thenApply(set -> {
-						return readAssist(address, buf, offset, set);
+						return readAssist(address, buf, set);
 					});
 		}
 		return CompletableFuture.completedFuture(new byte[length]);
@@ -153,7 +149,8 @@ public class FridaModelTargetKernelMemoryContainerImpl extends FridaModelTargetO
 		ByteBuffer buf = ByteBuffer.wrap(data);
 		if (!manager.isKernelMode() || address.getAddressSpace().getName().equals("ram")) {
 			return manager
-					.execute(new FridaWriteKernelMemoryCommand(manager, address, buf, buf.remaining()))
+					.execute(
+						new FridaWriteKernelMemoryCommand(manager, address, buf, buf.remaining()))
 					.thenAccept(___ -> {
 						writeAssist(address, data);
 					});
@@ -162,7 +159,8 @@ public class FridaModelTargetKernelMemoryContainerImpl extends FridaModelTargetO
 	}
 
 	@Override
-	public void regionAdded(FridaProcess process, FridaRegionInfo info, int index, FridaCause cause) {
+	public void regionAdded(FridaProcess process, FridaRegionInfo info, int index,
+			FridaCause cause) {
 		FridaModelTargetMemoryRegion targetRegion;
 		FridaMemoryRegionInfo region = info.getRegion(index);
 		synchronized (this) {
@@ -182,7 +180,8 @@ public class FridaModelTargetKernelMemoryContainerImpl extends FridaModelTargetO
 	}
 
 	@Override
-	public void regionReplaced(FridaProcess process, FridaRegionInfo info, int index, FridaCause cause) {
+	public void regionReplaced(FridaProcess process, FridaRegionInfo info, int index,
+			FridaCause cause) {
 		FridaMemoryRegionInfo region = info.getRegion(index);
 		changeElements(List.of(), List.of(getTargetMemory(region)), Map.of(), "Replaced");
 		FridaModelTargetMemoryRegion targetRegion = getTargetMemory(region);
@@ -190,7 +189,8 @@ public class FridaModelTargetKernelMemoryContainerImpl extends FridaModelTargetO
 	}
 
 	@Override
-	public void regionRemoved(FridaProcess process, FridaRegionInfo info, int index, FridaCause cause) {
+	public void regionRemoved(FridaProcess process, FridaRegionInfo info, int index,
+			FridaCause cause) {
 		FridaModelTargetMemoryRegion targetRegion = getTargetMemory(info.getRegion(index));
 		if (targetRegion != null) {
 			FridaModelImpl impl = (FridaModelImpl) model;

Ghidra/Debug/Debugger-agent-frida/src/main/java/agent/frida/model/impl/FridaModelTargetMemoryContainerImpl.java

@@ -16,37 +16,22 @@
 package agent.frida.model.impl;
 
 import java.nio.ByteBuffer;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.concurrent.CompletableFuture;
 
-import com.google.common.collect.Range;
-import com.google.common.collect.RangeSet;
-
 import agent.frida.frida.FridaRegionInfo;
-import agent.frida.manager.FridaCause;
-import agent.frida.manager.FridaMemoryRegionInfo;
-import agent.frida.manager.FridaProcess;
+import agent.frida.manager.*;
 import agent.frida.manager.cmd.FridaReadMemoryCommand;
 import agent.frida.manager.cmd.FridaWriteMemoryCommand;
 import agent.frida.manager.impl.FridaManagerImpl;
-import agent.frida.model.iface2.FridaModelTargetMemoryContainer;
-import agent.frida.model.iface2.FridaModelTargetMemoryRegion;
-import agent.frida.model.iface2.FridaModelTargetProcess;
-import agent.frida.model.methods.FridaModelTargetMemoryPatchImpl;
-import agent.frida.model.methods.FridaModelTargetMemoryProtectImpl;
-import agent.frida.model.methods.FridaModelTargetMemoryScanImpl;
-import agent.frida.model.methods.FridaModelTargetMemoryWatchImpl;
-import agent.frida.model.methods.FridaModelTargetUnloadScriptImpl;
+import agent.frida.model.iface2.*;
+import agent.frida.model.methods.*;
 import ghidra.dbg.error.DebuggerMemoryAccessException;
 import ghidra.dbg.error.DebuggerModelAccessException;
 import ghidra.dbg.target.TargetObject;
-import ghidra.dbg.target.schema.TargetAttributeType;
-import ghidra.dbg.target.schema.TargetElementType;
+import ghidra.dbg.target.schema.*;
 import ghidra.dbg.target.schema.TargetObjectSchema.ResyncMode;
-import ghidra.dbg.target.schema.TargetObjectSchemaInfo;
-import ghidra.program.model.address.Address;
+import ghidra.program.model.address.*;
 import ghidra.util.Msg;
 import ghidra.util.datastruct.WeakValueHashMap;
 
@@ -73,7 +58,6 @@ public class FridaModelTargetMemoryContainerImpl extends FridaModelTargetObjectI
 	protected final Map<String, FridaModelTargetMemoryRegionImpl> memoryRegions =
 		new WeakValueHashMap<>();
 
-
 	public FridaModelTargetMemoryContainerImpl(FridaModelTargetProcess process) {
 		super(process.getModel(), process, "Memory", "MemoryContainer");
 		this.process = process;
@@ -134,16 +118,16 @@ public class FridaModelTargetMemoryContainerImpl extends FridaModelTargetObjectI
 		return new FridaModelTargetMemoryRegionImpl(this, region);
 	}
 
-	private byte[] readAssist(Address address, ByteBuffer buf, long offset, RangeSet<Long> set) {
+	private byte[] readAssist(Address address, ByteBuffer buf, AddressSetView set) {
 		if (set == null) {
 			return new byte[0];
 		}
-		Range<Long> range = set.rangeContaining(offset);
+		AddressRange range = set.getRangeContaining(address);
 		if (range == null) {
 			throw new DebuggerMemoryAccessException("Cannot read at " + address);
 		}
 		listeners.fire.memoryUpdated(getProxy(), address, buf.array());
-		return Arrays.copyOf(buf.array(), (int) (range.upperEndpoint() - range.lowerEndpoint()));
+		return Arrays.copyOf(buf.array(), (int) range.getLength());
 	}
 
 	private void writeAssist(Address address, byte[] data) {
@@ -162,12 +146,11 @@ public class FridaModelTargetMemoryContainerImpl extends FridaModelTargetObjectI
 				"Cannot process command readMemory while engine is waiting for events");
 		}
 		ByteBuffer buf = ByteBuffer.allocate(length);
-		long offset = address.getOffset();
 		if (!manager.isKernelMode() || address.getAddressSpace().getName().equals("ram")) {
 			return manager
 					.execute(new FridaReadMemoryCommand(manager, address, buf, buf.remaining()))
 					.thenApply(set -> {
-						return readAssist(address, buf, offset, set);
+						return readAssist(address, buf, set);
 					});
 		}
 		return CompletableFuture.completedFuture(new byte[length]);
@@ -216,7 +199,8 @@ public class FridaModelTargetMemoryContainerImpl extends FridaModelTargetObjectI
 	}
 
 	@Override
-	public void regionReplaced(FridaProcess proc, FridaRegionInfo info, int index, FridaCause cause) {
+	public void regionReplaced(FridaProcess proc, FridaRegionInfo info, int index,
+			FridaCause cause) {
 		FridaMemoryRegionInfo region = info.getRegion(index);
 		changeElements(List.of(), List.of(getTargetMemory(region)), Map.of(), "Replaced");
 		FridaModelTargetMemoryRegion targetRegion = getTargetMemory(region);
@@ -224,7 +208,8 @@ public class FridaModelTargetMemoryContainerImpl extends FridaModelTargetObjectI
 	}
 
 	@Override
-	public void regionRemoved(FridaProcess proc, FridaRegionInfo info, int index, FridaCause cause) {
+	public void regionRemoved(FridaProcess proc, FridaRegionInfo info, int index,
+			FridaCause cause) {
 		FridaModelTargetMemoryRegion targetRegion = getTargetMemory(info.getRegion(index));
 		if (targetRegion != null) {
 			FridaModelImpl impl = (FridaModelImpl) model;

Ghidra/Debug/Debugger-agent-gdb/src/main/java/agent/gdb/manager/GdbMemoryOperations.java

@@ -18,7 +18,7 @@ package agent.gdb.manager;
 import java.nio.ByteBuffer;
 import java.util.concurrent.CompletableFuture;
 
-import com.google.common.collect.RangeSet;
+import generic.ULongSpan.ULongSpanSet;
 
 public interface GdbMemoryOperations {
 
@@ -30,7 +30,7 @@ public interface GdbMemoryOperations {
 	 * @param len the length of data to read
 	 * @return a future which completes giving the ranges successfully read
 	 */
-	CompletableFuture<RangeSet<Long>> readMemory(long addr, ByteBuffer buf, int len);
+	CompletableFuture<ULongSpanSet> readMemory(long addr, ByteBuffer buf, int len);
 
 	/**
 	 * Read memory
@@ -41,7 +41,7 @@ public interface GdbMemoryOperations {
 	 * @param buf the buffer to read into
 	 * @return a future which completes giving the ranges successfully read
 	 */
-	default CompletableFuture<RangeSet<Long>> readMemory(long addr, ByteBuffer buf) {
+	default CompletableFuture<ULongSpanSet> readMemory(long addr, ByteBuffer buf) {
 		return readMemory(addr, buf, buf.remaining());
 	}
 

Ghidra/Debug/Debugger-agent-gdb/src/main/java/agent/gdb/manager/impl/GdbInferiorImpl.java

@@ -24,13 +24,12 @@ import java.util.concurrent.CompletableFuture;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
-import com.google.common.collect.RangeSet;
-
 import agent.gdb.manager.*;
 import agent.gdb.manager.GdbCause.Causes;
 import agent.gdb.manager.GdbManager.StepCmd;
 import agent.gdb.manager.impl.cmd.*;
 import agent.gdb.manager.impl.cmd.GdbConsoleExecCommand.CompletesWithRunning;
+import generic.ULongSpan.ULongSpanSet;
 import ghidra.lifecycle.Internal;
 import ghidra.util.Msg;
 
@@ -480,7 +479,7 @@ public class GdbInferiorImpl implements GdbInferior {
 	}
 
 	@Override
-	public CompletableFuture<RangeSet<Long>> readMemory(long addr, ByteBuffer buf, int len) {
+	public CompletableFuture<ULongSpanSet> readMemory(long addr, ByteBuffer buf, int len) {
 		return execute(new GdbReadMemoryCommand(manager, null, addr, buf, len));
 	}
 

Ghidra/Debug/Debugger-agent-gdb/src/main/java/agent/gdb/manager/impl/GdbThreadImpl.java

@@ -20,8 +20,6 @@ import java.nio.ByteBuffer;
 import java.util.*;
 import java.util.concurrent.CompletableFuture;
 
-import com.google.common.collect.RangeSet;
-
 import agent.gdb.manager.*;
 import agent.gdb.manager.GdbManager.StepCmd;
 import agent.gdb.manager.breakpoint.GdbBreakpointInfo;
@@ -31,6 +29,7 @@ import agent.gdb.manager.impl.cmd.GdbConsoleExecCommand.CompletesWithRunning;
 import agent.gdb.manager.parsing.GdbCValueParser;
 import agent.gdb.manager.parsing.GdbParsingUtils.GdbParseError;
 import agent.gdb.manager.reason.GdbReason;
+import generic.ULongSpan.ULongSpanSet;
 import ghidra.async.*;
 
 /**
@@ -250,7 +249,7 @@ public class GdbThreadImpl implements GdbThread {
 	}
 
 	@Override
-	public CompletableFuture<RangeSet<Long>> readMemory(long addr, ByteBuffer buf, int len) {
+	public CompletableFuture<ULongSpanSet> readMemory(long addr, ByteBuffer buf, int len) {
 		return execute(new GdbReadMemoryCommand(manager, id, addr, buf, len));
 	}
 

Ghidra/Debug/Debugger-agent-gdb/src/main/java/agent/gdb/manager/impl/cmd/GdbReadMemoryCommand.java

@@ -18,21 +18,21 @@ package agent.gdb.manager.impl.cmd;
 import java.nio.ByteBuffer;
 import java.util.List;
 
-import com.google.common.collect.*;
-
 import agent.gdb.manager.GdbThread;
 import agent.gdb.manager.evt.GdbCommandDoneEvent;
 import agent.gdb.manager.impl.GdbManagerImpl;
 import agent.gdb.manager.impl.GdbPendingCommand;
 import agent.gdb.manager.parsing.GdbMiParser.GdbMiFieldList;
 import agent.gdb.manager.parsing.GdbParsingUtils;
+import generic.ULongSpan;
+import generic.ULongSpan.*;
 import ghidra.util.Msg;
 import ghidra.util.NumericUtilities;
 
 /**
  * Implementation of {@link GdbThread#readMemory(long, ByteBuffer, int)}
  */
-public class GdbReadMemoryCommand extends AbstractGdbCommandWithThreadId<RangeSet<Long>> {
+public class GdbReadMemoryCommand extends AbstractGdbCommandWithThreadId<ULongSpanSet> {
 
 	private final long addr;
 	private final ByteBuffer buf;
@@ -52,10 +52,10 @@ public class GdbReadMemoryCommand extends AbstractGdbCommandWithThreadId<RangeSe
 	}
 
 	@Override
-	public RangeSet<Long> complete(GdbPendingCommand<?> pending) {
+	public ULongSpanSet complete(GdbPendingCommand<?> pending) {
 		GdbCommandDoneEvent done = pending.checkCompletion(GdbCommandDoneEvent.class);
 		List<GdbMiFieldList> rangeList = done.assumeMemoryContentsList();
-		RangeSet<Long> rangeSet = TreeRangeSet.create();
+		MutableULongSpanSet spanSet = new DefaultULongSpanSet();
 		int pos = buf.position();
 		int max = pos;
 		for (GdbMiFieldList r : rangeList) {
@@ -74,9 +74,9 @@ public class GdbReadMemoryCommand extends AbstractGdbCommandWithThreadId<RangeSe
 			max = Math.max(max, newPos + length);
 			buf.position(newPos);
 			buf.put(contents);
-			rangeSet.add(Range.closedOpen(start, end));
+			spanSet.add(ULongSpan.extent(start, length));
 		}
 		buf.position(max);
-		return rangeSet;
+		return spanSet;
 	}
 }

Ghidra/Debug/Debugger-agent-gdb/src/main/java/agent/gdb/model/impl/GdbModelTargetProcessMemory.java

@@ -23,12 +23,11 @@ import java.util.stream.Collectors;
 
 import org.apache.commons.lang3.exception.ExceptionUtils;
 
-import com.google.common.collect.Range;
-
 import agent.gdb.manager.GdbInferior;
 import agent.gdb.manager.impl.GdbMemoryMapping;
 import agent.gdb.manager.impl.cmd.GdbCommandError;
 import agent.gdb.manager.impl.cmd.GdbStateChangeRecord;
+import generic.ULongSpan;
 import ghidra.async.AsyncFence;
 import ghidra.async.AsyncUtils;
 import ghidra.dbg.agent.DefaultTargetObject;
@@ -155,12 +154,11 @@ public class GdbModelTargetProcessMemory
 			throw new IllegalArgumentException("address,length", e);
 		}
 		return inferior.readMemory(offset, buf).thenApply(set -> {
-			Range<Long> r = set.rangeContaining(offset);
-			if (r == null) {
+			ULongSpan s = set.spanContaining(offset);
+			if (s == null) {
 				throw new DebuggerMemoryAccessException("Cannot read at " + address);
 			}
-			byte[] content =
-				Arrays.copyOf(buf.array(), (int) (r.upperEndpoint() - r.lowerEndpoint()));
+			byte[] content = Arrays.copyOf(buf.array(), (int) s.length());
 			listeners.fire.memoryUpdated(this, address, content);
 			return content;
 		}).exceptionally(e -> {

Ghidra/Debug/Debugger-agent-gdb/src/test/java/agent/gdb/manager/impl/AbstractGdbManagerTest.java

@@ -32,13 +32,13 @@ import java.util.stream.Collectors;
 
 import org.junit.*;
 
-import com.google.common.collect.*;
-
 import agent.gdb.manager.*;
 import agent.gdb.manager.GdbManager.StepCmd;
 import agent.gdb.manager.breakpoint.GdbBreakpointInfo;
 import agent.gdb.pty.PtyFactory;
 import agent.gdb.pty.linux.LinuxPtyFactory;
+import generic.ULongSpan;
+import generic.ULongSpan.ULongSpanSet;
 import ghidra.async.AsyncReference;
 import ghidra.dbg.testutil.DummyProc;
 import ghidra.test.AbstractGhidraHeadlessIntegrationTest;
@@ -401,12 +401,11 @@ public abstract class AbstractGdbManagerTest extends AbstractGhidraHeadlessInteg
 			}
 			buf.flip();
 			waitOn(thread.writeMemory(addr, buf));
-			RangeSet<Long> rng = waitOn(thread.readMemory(addr, rBuf));
+			ULongSpanSet set = waitOn(thread.readMemory(addr, rBuf));
 			rBuf.flip();
 			rBuf.order(ByteOrder.LITTLE_ENDIAN);
-			RangeSet<Long> exp = TreeRangeSet.create();
-			exp.add(Range.closedOpen(addr, addr + 1024));
-			assertEquals(exp, rng);
+			ULongSpanSet exp = ULongSpanSet.of(ULongSpan.extent(addr, 1024));
+			assertEquals(exp, set);
 			for (int i = 0; i < 10; i++) {
 				assertEquals(i, rBuf.getInt());
 			}

Ghidra/Debug/Debugger-agent-lldb/src/main/java/agent/lldb/manager/cmd/LldbReadMemoryCommand.java

@@ -22,13 +22,13 @@ import com.google.common.collect.*;
 
 import SWIG.*;
 import agent.lldb.manager.impl.LldbManagerImpl;
-import ghidra.program.model.address.Address;
+import ghidra.program.model.address.*;
 import ghidra.util.Msg;
 
 /**
  * Implementation of {@link LldbProcess#readMemory(long, ByteBuffer, int)}
  */
-public class LldbReadMemoryCommand extends AbstractLldbCommand<RangeSet<Long>> {
+public class LldbReadMemoryCommand extends AbstractLldbCommand<AddressSetView> {
 
 	private final SBProcess process;
 	private final Address addr;
@@ -45,10 +45,8 @@ public class LldbReadMemoryCommand extends AbstractLldbCommand<RangeSet<Long>> {
 	}
 
 	@Override
-	public RangeSet<Long> complete(LldbPendingCommand<?> pending) {
-		RangeSet<Long> rangeSet = TreeRangeSet.create();
-		rangeSet.add(Range.closedOpen(addr.getOffset(), addr.getOffset() + len));
-		return rangeSet;
+	public AddressSetView complete(LldbPendingCommand<?> pending) {
+		return new AddressSet(addr, addr.add(len - 1));
 	}
 
 	@Override

Ghidra/Debug/Debugger-agent-lldb/src/main/java/agent/lldb/model/impl/LldbModelTargetMemoryContainerImpl.java

@@ -20,11 +20,9 @@ import java.util.*;
 import java.util.concurrent.CompletableFuture;
 import java.util.stream.Collectors;
 
-import com.google.common.collect.Range;
-import com.google.common.collect.RangeSet;
-
 import SWIG.SBMemoryRegionInfo;
-import agent.lldb.manager.cmd.*;
+import agent.lldb.manager.cmd.LldbReadMemoryCommand;
+import agent.lldb.manager.cmd.LldbWriteMemoryCommand;
 import agent.lldb.manager.impl.LldbManagerImpl;
 import agent.lldb.model.iface2.*;
 import ghidra.dbg.error.DebuggerMemoryAccessException;
@@ -32,7 +30,7 @@ import ghidra.dbg.error.DebuggerModelAccessException;
 import ghidra.dbg.target.TargetObject;
 import ghidra.dbg.target.schema.*;
 import ghidra.dbg.target.schema.TargetObjectSchema.ResyncMode;
-import ghidra.program.model.address.Address;
+import ghidra.program.model.address.*;
 import ghidra.util.datastruct.WeakValueHashMap;
 
 @TargetObjectSchemaInfo(
@@ -81,16 +79,16 @@ public class LldbModelTargetMemoryContainerImpl extends LldbModelTargetObjectImp
 		return new LldbModelTargetMemoryRegionImpl(this, region);
 	}
 
-	private byte[] readAssist(Address address, ByteBuffer buf, long offset, RangeSet<Long> set) {
+	private byte[] readAssist(Address address, ByteBuffer buf, AddressSetView set) {
 		if (set == null) {
 			return new byte[0];
 		}
-		Range<Long> range = set.rangeContaining(offset);
+		AddressRange range = set.getRangeContaining(address);
 		if (range == null) {
 			throw new DebuggerMemoryAccessException("Cannot read at " + address);
 		}
 		listeners.fire.memoryUpdated(getProxy(), address, buf.array());
-		return Arrays.copyOf(buf.array(), (int) (range.upperEndpoint() - range.lowerEndpoint()));
+		return Arrays.copyOf(buf.array(), (int) range.getLength());
 	}
 
 	private void writeAssist(Address address, byte[] data) {
@@ -109,13 +107,12 @@ public class LldbModelTargetMemoryContainerImpl extends LldbModelTargetObjectImp
 				"Cannot process command readMemory while engine is waiting for events");
 		}
 		ByteBuffer buf = ByteBuffer.allocate(length);
-		long offset = address.getOffset();
 		if (!manager.isKernelMode() || address.getAddressSpace().getName().equals("ram")) {
 			return manager
 					.execute(new LldbReadMemoryCommand(manager, process.getProcess(), address, buf,
 						buf.remaining()))
 					.thenApply(set -> {
-						return readAssist(address, buf, offset, set);
+						return readAssist(address, buf, set);
 					});
 		}
 		return CompletableFuture.completedFuture(new byte[length]);

Ghidra/Debug/Debugger/ghidra_scripts/AddMapping.java

@@ -13,15 +13,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import com.google.common.collect.Range;
-
 import ghidra.app.script.GhidraScript;
 import ghidra.app.services.DebuggerStaticMappingService;
 import ghidra.app.services.DebuggerTraceManagerService;
 import ghidra.program.model.address.AddressSpace;
 import ghidra.program.util.ProgramLocation;
-import ghidra.trace.model.DefaultTraceLocation;
-import ghidra.trace.model.Trace;
+import ghidra.trace.model.*;
 
 public class AddMapping extends GhidraScript {
 	@Override
@@ -35,7 +32,7 @@ public class AddMapping extends GhidraScript {
 		AddressSpace statRam = currentProgram.getAddressFactory().getDefaultAddressSpace();
 
 		mappings.addMapping(
-			new DefaultTraceLocation(currentTrace, null, Range.atLeast(0L),
+			new DefaultTraceLocation(currentTrace, null, Lifespan.nowOn(0),
 				dynRam.getAddress(0x00400000)),
 			new ProgramLocation(currentProgram, statRam.getAddress(0x00400000)),
 			0x10000, false);

Ghidra/Debug/Debugger/ghidra_scripts/PopulateDemoTrace.java

@@ -18,8 +18,6 @@ import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 import java.util.*;
 
-import com.google.common.collect.Range;
-
 import ghidra.app.plugin.assembler.Assembler;
 import ghidra.app.plugin.assembler.Assemblers;
 import ghidra.app.script.GhidraScript;
@@ -33,6 +31,7 @@ import ghidra.program.model.symbol.SourceType;
 import ghidra.program.model.util.CodeUnitInsertionException;
 import ghidra.program.util.DefaultLanguageService;
 import ghidra.trace.database.DBTrace;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace;
 import ghidra.trace.model.listing.TraceCodeSpace;
 import ghidra.trace.model.memory.*;
@@ -239,8 +238,8 @@ public class PopulateDemoTrace extends GhidraScript {
 
 		TraceCodeSpace code =
 			thread.getTrace().getCodeManager().getCodeRegisterSpace(thread, true);
-		code.definedUnits().clear(Range.atLeast(tick), reg, TaskMonitor.DUMMY);
-		code.definedData().create(Range.atLeast(tick), reg, PointerDataType.dataType);
+		code.definedUnits().clear(Lifespan.nowOn(tick), reg, TaskMonitor.DUMMY);
+		code.definedData().create(Lifespan.nowOn(tick), reg, PointerDataType.dataType);
 	}
 
 	/**
@@ -320,15 +319,15 @@ public class PopulateDemoTrace extends GhidraScript {
 			 * presented as memory blocks. Thus, observations outside a region are not visible in
 			 * the UI.
 			 */
-			memory.addRegion(".text", Range.atLeast(snap), rng(0x00400000, 0x00400fff),
+			memory.addRegion(".text", Lifespan.nowOn(snap), rng(0x00400000, 0x00400fff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
-			memory.addRegion("[STACK 1]", Range.atLeast(snap), rng(0x00100000, 0x001effff),
+			memory.addRegion("[STACK 1]", Lifespan.nowOn(snap), rng(0x00100000, 0x001effff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.WRITE);
 
 			/**
 			 * Create the main thread, assumed alive from here on out.
 			 */
-			thread1 = trace.getThreadManager().addThread("Thread 1", Range.atLeast(snap));
+			thread1 = trace.getThreadManager().addThread("Thread 1", Lifespan.nowOn(snap));
 			/**
 			 * Get a handle to the main thread's register values.
 			 * 
@@ -487,10 +486,10 @@ public class PopulateDemoTrace extends GhidraScript {
 					.createSnapshot("Stepped Thread 1: CALL clone -> Thread 2")
 					.getKey();
 
-			memory.addRegion("[STACK 2]", Range.atLeast(snap), rng(0x00200000, 0x002effff),
+			memory.addRegion("[STACK 2]", Lifespan.nowOn(snap), rng(0x00200000, 0x002effff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.WRITE);
 
-			thread2 = trace.getThreadManager().addThread("Thread 2", Range.atLeast(snap));
+			thread2 = trace.getThreadManager().addThread("Thread 2", Lifespan.nowOn(snap));
 			regs2 = memory.getMemoryRegisterSpace(thread2, true);
 
 			stack1offset -= 8;

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/DebuggerCoordinates.java

@@ -21,8 +21,6 @@ import java.util.Objects;
 
 import org.jdom.Element;
 
-import com.google.common.collect.Range;
-
 import ghidra.app.services.DebuggerTraceManagerService;
 import ghidra.app.services.TraceRecorder;
 import ghidra.dbg.target.TargetObject;
@@ -31,7 +29,7 @@ import ghidra.framework.model.*;
 import ghidra.framework.options.SaveState;
 import ghidra.framework.plugintool.PluginTool;
 import ghidra.trace.database.DBTraceContentHandler;
-import ghidra.trace.database.DBTraceUtils;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace;
 import ghidra.trace.model.guest.TracePlatform;
 import ghidra.trace.model.program.TraceProgramView;
@@ -339,7 +337,7 @@ public class DebuggerCoordinates {
 	 */
 	private static boolean isAncestor(TraceObject ancestor, TraceObject successor,
 			TraceSchedule time) {
-		return successor.getCanonicalParents(Range.singleton(time.getSnap()))
+		return successor.getCanonicalParents(Lifespan.at(time.getSnap()))
 				.anyMatch(p -> p == ancestor);
 	}
 
@@ -417,7 +415,7 @@ public class DebuggerCoordinates {
 			return null;
 		}
 		long snap = view.getSnap();
-		if (!DBTraceUtils.isScratch(snap)) {
+		if (!Lifespan.isScratch(snap)) {
 			return TraceSchedule.snap(snap);
 		}
 		TraceSnapshot snapshot = view.getTrace().getTimeManager().getSnapshot(snap, false);

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/disassemble/TraceDisassembleCommand.java

@@ -15,14 +15,13 @@
  */
 package ghidra.app.plugin.core.debug.disassemble;
 
-import com.google.common.collect.Range;
-
 import ghidra.framework.cmd.TypedBackgroundCommand;
 import ghidra.program.disassemble.Disassembler;
 import ghidra.program.model.address.*;
 import ghidra.program.model.lang.*;
 import ghidra.program.model.listing.Instruction;
 import ghidra.program.model.mem.MemBuffer;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.guest.TracePlatform;
 import ghidra.trace.model.program.TraceProgramView;
 import ghidra.util.MathUtilities;
@@ -73,7 +72,7 @@ public class TraceDisassembleCommand extends TypedBackgroundCommand<TraceProgram
 		return view.getTrace()
 				.getCodeManager()
 				.instructions()
-				.addInstructionSet(Range.atLeast(view.getSnap()), platform, set, true);
+				.addInstructionSet(Lifespan.nowOn(view.getSnap()), platform, set, true);
 	}
 
 	@Override

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/action/VisibleROOnceAutoReadMemorySpec.java

@@ -20,14 +20,13 @@ import java.util.concurrent.CompletableFuture;
 
 import javax.swing.Icon;
 
-import com.google.common.collect.Range;
-
 import ghidra.app.plugin.core.debug.DebuggerCoordinates;
 import ghidra.app.plugin.core.debug.gui.DebuggerResources.AutoReadMemoryAction;
 import ghidra.app.services.TraceRecorder;
 import ghidra.async.AsyncUtils;
 import ghidra.framework.plugintool.PluginTool;
 import ghidra.program.model.address.*;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.TraceAddressSnapRange;
 import ghidra.trace.model.memory.*;
 import ghidra.util.task.TaskMonitor;
@@ -80,7 +79,7 @@ public class VisibleROOnceAutoReadMemorySpec implements AutoReadMemorySpec {
 		AddressSet readOnly = new AddressSet();
 		for (AddressRange range : visible) {
 			for (TraceMemoryRegion region : mm
-					.getRegionsIntersecting(Range.singleton(coordinates.getSnap()), range)) {
+					.getRegionsIntersecting(Lifespan.at(coordinates.getSnap()), range)) {
 				if (region.isWrite()) {
 					continue;
 				}

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/breakpoint/DebuggerBreakpointsProvider.java

@@ -25,8 +25,6 @@ import javax.swing.*;
 import javax.swing.table.TableColumn;
 import javax.swing.table.TableColumnModel;
 
-import com.google.common.collect.Range;
-
 import docking.ActionContext;
 import docking.WindowPosition;
 import docking.action.*;
@@ -44,9 +42,8 @@ import ghidra.framework.plugintool.annotation.AutoServiceConsumed;
 import ghidra.program.model.address.Address;
 import ghidra.program.model.address.AddressRange;
 import ghidra.program.util.ProgramLocation;
-import ghidra.trace.model.Trace;
+import ghidra.trace.model.*;
 import ghidra.trace.model.Trace.TraceBreakpointChangeType;
-import ghidra.trace.model.TraceDomainObjectListener;
 import ghidra.trace.model.breakpoint.TraceBreakpoint;
 import ghidra.util.*;
 import ghidra.util.database.ObjectKey;
@@ -611,8 +608,8 @@ public class DebuggerBreakpointsProvider extends ComponentProviderAdapter
 			breakpointLocationUpdated(location);
 		}
 
-		private void locationLifespanChanged(TraceBreakpoint location, Range<Long> oldSpan,
-				Range<Long> newSpan) {
+		private void locationLifespanChanged(TraceBreakpoint location, Lifespan oldSpan,
+				Lifespan newSpan) {
 			boolean isLiveOld = oldSpan.contains(recorder.getSnap());
 			boolean isLiveNew = newSpan.contains(recorder.getSnap());
 			if (isLiveOld == isLiveNew) {
@@ -831,7 +828,7 @@ public class DebuggerBreakpointsProvider extends ComponentProviderAdapter
 		Trace trace = recorder.getTrace();
 		for (AddressRange range : trace.getBaseAddressFactory().getAddressSet()) {
 			locationTableModel.addAllItems(trace.getBreakpointManager()
-					.getBreakpointsIntersecting(Range.singleton(recorder.getSnap()), range));
+					.getBreakpointsIntersecting(Lifespan.at(recorder.getSnap()), range));
 		}
 	}
 

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/control/DebuggerControlPlugin.java

@@ -26,8 +26,6 @@ import java.util.stream.Stream;
 import javax.swing.Icon;
 import javax.swing.KeyStroke;
 
-import com.google.common.collect.Range;
-
 import docking.ActionContext;
 import docking.DockingContextListener;
 import docking.action.DockingAction;
@@ -54,9 +52,8 @@ import ghidra.dbg.target.TargetSteppable.TargetStepKind;
 import ghidra.framework.plugintool.*;
 import ghidra.framework.plugintool.annotation.AutoServiceConsumed;
 import ghidra.framework.plugintool.util.PluginStatus;
-import ghidra.trace.model.Trace;
+import ghidra.trace.model.*;
 import ghidra.trace.model.Trace.TraceObjectChangeType;
-import ghidra.trace.model.TraceDomainObjectListener;
 import ghidra.trace.model.target.TraceObject;
 import ghidra.trace.model.target.TraceObjectValue;
 import ghidra.trace.model.time.schedule.Scheduler;
@@ -537,8 +534,8 @@ public class DebuggerControlPlugin extends AbstractDebuggerPlugin
 			}
 		}
 
-		private void valueLifespanChanged(TraceObjectValue value, Range<Long> oldLife,
-				Range<Long> newLife) {
+		private void valueLifespanChanged(TraceObjectValue value, Lifespan oldLife,
+				Lifespan newLife) {
 			if (newLife.contains(current.getSnap()) != oldLife.contains(current.getSnap())) {
 				Swing.runIfSwingOrRunLater(() -> updateActionsEnabled());
 			}

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/copying/DebuggerCopyIntoProgramDialog.java

@@ -27,8 +27,6 @@ import javax.swing.*;
 import javax.swing.table.TableColumn;
 import javax.swing.table.TableColumnModel;
 
-import com.google.common.collect.Range;
-
 import docking.DialogComponentProvider;
 import docking.widgets.table.*;
 import docking.widgets.table.DefaultEnumeratedColumnTableModel.EnumeratedTableColumn;
@@ -43,6 +41,7 @@ import ghidra.program.model.address.*;
 import ghidra.program.model.listing.Program;
 import ghidra.program.model.mem.Memory;
 import ghidra.program.model.mem.MemoryBlock;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.memory.TraceMemoryManager;
 import ghidra.trace.model.memory.TraceMemoryRegion;
 import ghidra.trace.model.modules.*;
@@ -632,21 +631,21 @@ public class DebuggerCopyIntoProgramDialog extends DialogComponentProvider {
 	protected String computeRegionString(AddressRange rng) {
 		TraceMemoryManager mm = source.getTrace().getMemoryManager();
 		Collection<? extends TraceMemoryRegion> regions =
-			mm.getRegionsIntersecting(Range.singleton(source.getSnap()), rng);
+			mm.getRegionsIntersecting(Lifespan.at(source.getSnap()), rng);
 		return regions.isEmpty() ? "UNKNOWN" : regions.iterator().next().getName();
 	}
 
 	protected String computeModulesString(AddressRange rng) {
 		TraceModuleManager mm = source.getTrace().getModuleManager();
 		Collection<? extends TraceModule> modules =
-			mm.getModulesIntersecting(Range.singleton(source.getSnap()), rng);
+			mm.getModulesIntersecting(Lifespan.at(source.getSnap()), rng);
 		return modules.stream().map(m -> m.getName()).collect(Collectors.joining(","));
 	}
 
 	protected String computeSectionsString(AddressRange rng) {
 		TraceModuleManager mm = source.getTrace().getModuleManager();
 		Collection<? extends TraceSection> sections =
-			mm.getSectionsIntersecting(Range.singleton(source.getSnap()), rng);
+			mm.getSectionsIntersecting(Lifespan.at(source.getSnap()), rng);
 		return sections.stream().map(s -> s.getName()).collect(Collectors.joining(","));
 	}
 
@@ -705,7 +704,7 @@ public class DebuggerCopyIntoProgramDialog extends DialogComponentProvider {
 		List<AddressRange> result = new ArrayList<>();
 		for (TraceMemoryRegion region : source.getTrace()
 				.getMemoryManager()
-				.getRegionsIntersecting(Range.singleton(source.getSnap()), srcRange)) {
+				.getRegionsIntersecting(Lifespan.at(source.getSnap()), srcRange)) {
 			AddressRange range = region.getRange().intersect(srcRange);
 			result.add(range);
 			remains.delete(range);

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/copying/DebuggerCopyPlan.java

@@ -19,8 +19,6 @@ import java.util.*;
 
 import javax.swing.JCheckBox;
 
-import com.google.common.collect.Range;
-
 import ghidra.app.plugin.core.debug.gui.DebuggerResources;
 import ghidra.app.plugin.core.debug.service.breakpoint.LogicalBreakpointInternal.ProgramBreakpoint;
 import ghidra.app.util.viewer.listingpanel.PropertyBasedBackgroundColorModel;
@@ -29,6 +27,7 @@ import ghidra.program.model.address.*;
 import ghidra.program.model.data.*;
 import ghidra.program.model.listing.*;
 import ghidra.program.model.symbol.*;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.breakpoint.TraceBreakpoint;
 import ghidra.trace.model.memory.TraceMemoryManager;
 import ghidra.trace.model.memory.TraceMemoryState;
@@ -222,7 +221,7 @@ public class DebuggerCopyPlan {
 					Address intoAddress, TaskMonitor monitor) throws Exception {
 				for (TraceBreakpoint bpt : from.getTrace()
 						.getBreakpointManager()
-						.getBreakpointsIntersecting(Range.singleton(from.getSnap()), fromRange)) {
+						.getBreakpointsIntersecting(Lifespan.at(from.getSnap()), fromRange)) {
 					monitor.checkCanceled();
 					long off = bpt.getMinAddress().subtract(fromRange.getMinAddress());
 					Address dest = intoAddress.add(off);

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/memory/DebuggerRegionsProvider.java

@@ -27,8 +27,6 @@ import javax.swing.*;
 import javax.swing.table.TableColumn;
 import javax.swing.table.TableColumnModel;
 
-import com.google.common.collect.Range;
-
 import docking.ActionContext;
 import docking.WindowPosition;
 import docking.action.*;
@@ -52,9 +50,8 @@ import ghidra.program.model.listing.Program;
 import ghidra.program.model.mem.MemoryBlock;
 import ghidra.program.util.ProgramLocation;
 import ghidra.program.util.ProgramSelection;
-import ghidra.trace.model.Trace;
+import ghidra.trace.model.*;
 import ghidra.trace.model.Trace.TraceMemoryRegionChangeType;
-import ghidra.trace.model.TraceDomainObjectListener;
 import ghidra.trace.model.memory.TraceMemoryManager;
 import ghidra.trace.model.memory.TraceMemoryRegion;
 import ghidra.util.HelpLocation;
@@ -114,7 +111,7 @@ public class DebuggerRegionsProvider extends ComponentProviderAdapter {
 	protected enum RegionTableColumns
 		implements EnumeratedTableColumn<RegionTableColumns, RegionRow> {
 		NAME("Name", String.class, RegionRow::getName, RegionRow::setName),
-		LIFESPAN("Lifespan", Range.class, RegionRow::getLifespan),
+		LIFESPAN("Lifespan", Lifespan.class, RegionRow::getLifespan),
 		START("Start", Address.class, RegionRow::getMinAddress),
 		END("End", Address.class, RegionRow::getMaxAddress),
 		LENGTH("Length", Long.class, RegionRow::getLength),
@@ -538,7 +535,7 @@ public class DebuggerRegionsProvider extends ComponentProviderAdapter {
 			Set<TraceMemoryRegion> regSel = new HashSet<>();
 			for (AddressRange range : progSel) {
 				regSel.addAll(memoryManager.getRegionsIntersecting(
-					Range.singleton(traceManager.getCurrentSnap()), range));
+					Lifespan.at(traceManager.getCurrentSnap()), range));
 			}
 			setSelectedRegions(regSel);
 			return;

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/memory/RegionRow.java

@@ -15,10 +15,9 @@
  */
 package ghidra.app.plugin.core.debug.gui.memory;
 
-import com.google.common.collect.Range;
-
 import ghidra.program.model.address.Address;
 import ghidra.program.model.address.AddressRange;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.memory.TraceMemoryRegion;
 import ghidra.util.database.UndoableTransaction;
 
@@ -44,7 +43,7 @@ public class RegionRow {
 		return region.getName();
 	}
 
-	public Range<Long> getLifespan() {
+	public Lifespan getLifespan() {
 		return region.getLifespan();
 	}
 

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/memview/DebuggerMemviewTraceListener.java

@@ -17,8 +17,6 @@ package ghidra.app.plugin.core.debug.gui.memview;
 
 import java.util.*;
 
-import com.google.common.collect.Range;
-
 import ghidra.app.plugin.core.debug.DebuggerCoordinates;
 import ghidra.app.services.TraceRecorder;
 import ghidra.async.AsyncDebouncer;
@@ -156,10 +154,9 @@ public class DebuggerMemviewTraceListener extends TraceDomainObjectListener {
 		if (!trackBytes || !trackTrace) {
 			return;
 		}
-		Range<Long> lifespan = range.getLifespan();
-		Range<Long> newspan = Range.closedOpen(lifespan.lowerEndpoint(), lifespan.lowerEndpoint());
+		Lifespan lifespan = range.getLifespan();
 		MemoryBox box = new MemoryBox("BytesChanged " + range.description(),
-			MemviewBoxType.WRITE_MEMORY, range.getRange(), newspan);
+			MemviewBoxType.WRITE_MEMORY, range.getRange(), lifespan);
 		updateList.add(box);
 		updateLabelDebouncer.contact(null);
 	}

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/memview/MemoryBox.java

@@ -20,9 +20,8 @@ import java.awt.Graphics;
 import java.util.HashMap;
 import java.util.Map;
 
-import com.google.common.collect.Range;
-
 import ghidra.program.model.address.AddressRange;
+import ghidra.trace.model.Lifespan;
 
 public class MemoryBox {
 
@@ -54,11 +53,9 @@ public class MemoryBox {
 		this.color = type.getColor();
 	}
 
-	public MemoryBox(String id, MemviewBoxType type, AddressRange range, Range<Long> trange) {
-		this(id, type, range, trange.lowerEndpoint());
-		if (trange.hasUpperBound()) {
-			setEnd(trange.upperEndpoint());
-		}
+	public MemoryBox(String id, MemviewBoxType type, AddressRange range, Lifespan trange) {
+		this(id, type, range, trange.lmin());
+		setEnd(trange.lmax());
 	}
 
 	public String getId() {
@@ -73,8 +70,8 @@ public class MemoryBox {
 		return range;
 	}
 
-	public Range<Long> getSpan() {
-		return Range.openClosed(start, stop);
+	public Lifespan getSpan() {
+		return Lifespan.span(start, stop);
 	}
 
 	public long getStart() {

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/model/AbstractQueryTableModel.java

@@ -19,16 +19,12 @@ import java.awt.Color;
 import java.util.Objects;
 import java.util.stream.Stream;
 
-import com.google.common.collect.Range;
-
 import docking.widgets.table.RangeCursorTableHeaderRenderer.SeekListener;
 import docking.widgets.table.threaded.ThreadedTableModel;
 import ghidra.framework.plugintool.Plugin;
-import ghidra.trace.database.DBTraceUtils;
-import ghidra.trace.model.Trace;
+import ghidra.trace.model.*;
 import ghidra.trace.model.Trace.TraceObjectChangeType;
 import ghidra.trace.model.Trace.TraceSnapshotChangeType;
-import ghidra.trace.model.TraceDomainObjectListener;
 import ghidra.trace.model.target.TraceObject;
 import ghidra.trace.model.target.TraceObjectValue;
 import ghidra.util.datastruct.Accumulator;
@@ -60,14 +56,14 @@ public abstract class AbstractQueryTableModel<T> extends ThreadedTableModel<T, T
 			}
 		}
 
-		protected void valueLifespanChanged(TraceObjectValue value, Range<Long> oldSpan,
-				Range<Long> newSpan) {
+		protected void valueLifespanChanged(TraceObjectValue value, Lifespan oldSpan,
+				Lifespan newSpan) {
 			if (query == null) {
 				return;
 			}
-			boolean inOld = DBTraceUtils.intersect(oldSpan, span);
-			boolean inNew = DBTraceUtils.intersect(newSpan, span);
-			boolean queryIncludes = query.includes(Range.all(), value);
+			boolean inOld = span.intersects(oldSpan);
+			boolean inNew = span.intersects(newSpan);
+			boolean queryIncludes = query.includes(Lifespan.ALL, value);
 			if (queryIncludes) {
 				if (inOld != inNew) {
 					reload();
@@ -102,7 +98,7 @@ public abstract class AbstractQueryTableModel<T> extends ThreadedTableModel<T, T
 	private Trace diffTrace;
 	private long diffSnap;
 	private ModelQuery query;
-	private Range<Long> span = Range.all();
+	private Lifespan span = Lifespan.ALL;
 	private boolean showHidden;
 
 	private final ListenerForChanges listenerForChanges = newListenerForChanges();
@@ -245,7 +241,7 @@ public abstract class AbstractQueryTableModel<T> extends ThreadedTableModel<T, T
 		reload();
 	}
 
-	public void setSpan(Range<Long> span) {
+	public void setSpan(Lifespan span) {
 		if (Objects.equals(this.span, span)) {
 			return;
 		}
@@ -254,7 +250,7 @@ public abstract class AbstractQueryTableModel<T> extends ThreadedTableModel<T, T
 		spanChanged();
 	}
 
-	public Range<Long> getSpan() {
+	public Lifespan getSpan() {
 		return span;
 	}
 
@@ -275,7 +271,7 @@ public abstract class AbstractQueryTableModel<T> extends ThreadedTableModel<T, T
 		return showHidden;
 	}
 
-	protected abstract Stream<T> streamRows(Trace trace, ModelQuery query, Range<Long> span);
+	protected abstract Stream<T> streamRows(Trace trace, ModelQuery query, Lifespan span);
 
 	@Override
 	protected void doLoad(Accumulator<T> accumulator, TaskMonitor monitor)

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/model/AbstractQueryTablePanel.java

@@ -25,11 +25,10 @@ import javax.swing.JPanel;
 import javax.swing.JScrollPane;
 import javax.swing.event.ListSelectionListener;
 
-import com.google.common.collect.Range;
-
 import docking.widgets.table.RangeCursorTableHeaderRenderer.SeekListener;
 import ghidra.app.plugin.core.debug.DebuggerCoordinates;
 import ghidra.framework.plugintool.Plugin;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.target.TraceObject;
 import ghidra.util.table.GhidraTable;
 import ghidra.util.table.GhidraTableFilterPanel;
@@ -71,7 +70,7 @@ public abstract class AbstractQueryTablePanel<T> extends JPanel {
 		tableModel.setDiffSnap(previous.getSnap());
 		tableModel.setSnap(current.getSnap());
 		if (limitToSnap) {
-			tableModel.setSpan(Range.singleton(current.getSnap()));
+			tableModel.setSpan(Lifespan.at(current.getSnap()));
 		}
 	}
 
@@ -92,7 +91,7 @@ public abstract class AbstractQueryTablePanel<T> extends JPanel {
 			return;
 		}
 		this.limitToSnap = limitToSnap;
-		tableModel.setSpan(limitToSnap ? Range.singleton(current.getSnap()) : Range.all());
+		tableModel.setSpan(limitToSnap ? Lifespan.at(current.getSnap()) : Lifespan.ALL);
 	}
 
 	public boolean isLimitToSnap() {

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/model/DisplaysModified.java

@@ -17,9 +17,8 @@ package ghidra.app.plugin.core.debug.gui.model;
 
 import java.util.Objects;
 
-import com.google.common.collect.Range;
-
 import ghidra.dbg.util.PathPredicates;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace;
 import ghidra.trace.model.target.TraceObject;
 import ghidra.trace.model.target.TraceObjectValue;
@@ -141,7 +140,7 @@ public interface DisplaysModified {
 			return isEdgesDiffer(newContains ? value : null, diffEdge);
 		}
 		TraceObjectValue diffEdge = diffTrace.getObjectManager()
-				.getValuePaths(Range.singleton(diffSnap),
+				.getValuePaths(Lifespan.at(diffSnap),
 					PathPredicates.pattern(value.getCanonicalPath().getKeyList()))
 				.findAny()
 				.map(p -> p.getLastEntry())

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/model/ModelQuery.java

@@ -19,12 +19,11 @@ import java.util.List;
 import java.util.Objects;
 import java.util.stream.Stream;
 
-import com.google.common.collect.Range;
-
 import ghidra.dbg.target.schema.TargetObjectSchema;
 import ghidra.dbg.target.schema.TargetObjectSchema.AttributeSchema;
 import ghidra.dbg.util.*;
 import ghidra.trace.database.DBTraceUtils;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace;
 import ghidra.trace.model.target.*;
 
@@ -92,7 +91,7 @@ public class ModelQuery {
 	 * @param span the span of snapshots to search, usually all or a singleton
 	 * @return the stream of resulting objects
 	 */
-	public Stream<TraceObject> streamObjects(Trace trace, Range<Long> span) {
+	public Stream<TraceObject> streamObjects(Trace trace, Lifespan span) {
 		TraceObjectManager objects = trace.getObjectManager();
 		TraceObject root = objects.getRootObject();
 		return objects.getValuePaths(span, predicates)
@@ -101,7 +100,7 @@ public class ModelQuery {
 				.map(v -> (TraceObject) v);
 	}
 
-	public Stream<TraceObjectValue> streamValues(Trace trace, Range<Long> span) {
+	public Stream<TraceObjectValue> streamValues(Trace trace, Lifespan span) {
 		TraceObjectManager objects = trace.getObjectManager();
 		return objects.getValuePaths(span, predicates).map(p -> {
 			TraceObjectValue last = p.getLastEntry();
@@ -109,7 +108,7 @@ public class ModelQuery {
 		});
 	}
 
-	public Stream<TraceObjectValPath> streamPaths(Trace trace, Range<Long> span) {
+	public Stream<TraceObjectValPath> streamPaths(Trace trace, Lifespan span) {
 		return trace.getObjectManager().getValuePaths(span, predicates).map(p -> p);
 	}
 
@@ -144,7 +143,7 @@ public class ModelQuery {
 	 * @param value the value to examine
 	 * @return true if the value would be accepted
 	 */
-	public boolean includes(Range<Long> span, TraceObjectValue value) {
+	public boolean includes(Lifespan span, TraceObjectValue value) {
 		List<String> path = predicates.getSingletonPattern().asPath();
 		if (path.isEmpty()) {
 			return value.getParent() == null;
@@ -152,7 +151,7 @@ public class ModelQuery {
 		if (!PathPredicates.keyMatches(PathUtils.getKey(path), value.getEntryKey())) {
 			return false;
 		}
-		if (!DBTraceUtils.intersect(span, value.getLifespan())) {
+		if (!span.intersects(value.getLifespan())) {
 			return false;
 		}
 		TraceObject parent = value.getParent();

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/model/ObjectTableModel.java

@@ -20,8 +20,6 @@ import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-import com.google.common.collect.*;
-
 import docking.widgets.table.DynamicTableColumn;
 import docking.widgets.table.RangeCursorTableHeaderRenderer.SeekListener;
 import docking.widgets.table.TableColumnDescriptor;
@@ -31,6 +29,8 @@ import ghidra.dbg.target.schema.SchemaContext;
 import ghidra.dbg.target.schema.TargetObjectSchema;
 import ghidra.dbg.target.schema.TargetObjectSchema.AttributeSchema;
 import ghidra.framework.plugintool.Plugin;
+import ghidra.trace.model.Lifespan;
+import ghidra.trace.model.Lifespan.*;
 import ghidra.trace.model.Trace;
 import ghidra.trace.model.target.TraceObject;
 import ghidra.trace.model.target.TraceObjectValue;
@@ -55,7 +55,7 @@ public class ObjectTableModel extends AbstractQueryTableModel<ValueRow> {
 	public interface ValueRow {
 		String getKey();
 
-		RangeSet<Long> getLife();
+		LifeSet getLife();
 
 		TraceObjectValue getValue();
 
@@ -112,8 +112,8 @@ public class ObjectTableModel extends AbstractQueryTableModel<ValueRow> {
 		}
 
 		@Override
-		public RangeSet<Long> getLife() {
-			RangeSet<Long> life = TreeRangeSet.create();
+		public LifeSet getLife() {
+			MutableLifeSet life = new DefaultLifeSet();
 			life.add(value.getLifespan());
 			return life;
 		}
@@ -306,7 +306,7 @@ public class ObjectTableModel extends AbstractQueryTableModel<ValueRow> {
 
 	protected void updateTimelineMax() {
 		Long max = getTrace() == null ? null : getTrace().getTimeManager().getMaxSnap();
-		Range<Long> fullRange = Range.closed(0L, max == null ? 1 : max + 1);
+		Lifespan fullRange = Lifespan.span(0L, max == null ? 1 : max + 1);
 		lifePlotColumn.setFullRange(fullRange);
 	}
 
@@ -379,7 +379,7 @@ public class ObjectTableModel extends AbstractQueryTableModel<ValueRow> {
 	}
 
 	@Override
-	protected Stream<ValueRow> streamRows(Trace trace, ModelQuery query, Range<Long> span) {
+	protected Stream<ValueRow> streamRows(Trace trace, ModelQuery query, Lifespan span) {
 		return distinctCanonical(query.streamValues(trace, span)
 				.filter(v -> isShowHidden() || !v.isHidden()))
 						.map(this::rowForValue);

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/model/ObjectTreeModel.java

@@ -20,17 +20,13 @@ import java.util.stream.Collectors;
 
 import javax.swing.Icon;
 
-import com.google.common.collect.Range;
-
 import docking.widgets.tree.GTreeLazyNode;
 import docking.widgets.tree.GTreeNode;
 import ghidra.app.plugin.core.debug.gui.DebuggerResources;
 import ghidra.dbg.target.*;
 import ghidra.framework.model.DomainObjectClosedListener;
-import ghidra.trace.database.DBTraceUtils;
-import ghidra.trace.model.Trace;
+import ghidra.trace.model.*;
 import ghidra.trace.model.Trace.TraceObjectChangeType;
-import ghidra.trace.model.TraceDomainObjectListener;
 import ghidra.trace.model.target.*;
 import ghidra.util.HTMLUtilities;
 import ghidra.util.datastruct.WeakValueHashMap;
@@ -85,7 +81,7 @@ public class ObjectTreeModel implements DisplaysModified {
 		}
 
 		private void valueCreated(TraceObjectValue value) {
-			if (!DBTraceUtils.intersect(value.getLifespan(), span)) {
+			if (!value.getLifespan().intersects(span)) {
 				return;
 			}
 			AbstractNode node = nodeCache.getByObject(value.getParent());
@@ -102,7 +98,7 @@ public class ObjectTreeModel implements DisplaysModified {
 		}
 
 		private void valueDeleted(TraceObjectValue value) {
-			if (!DBTraceUtils.intersect(value.getLifespan(), span)) {
+			if (!value.getLifespan().intersects(span)) {
 				return;
 			}
 			AbstractNode node = nodeCache.getByObject(value.getParent());
@@ -118,10 +114,10 @@ public class ObjectTreeModel implements DisplaysModified {
 			node.childDeleted(value);
 		}
 
-		private void valueLifespanChanged(TraceObjectValue value, Range<Long> oldSpan,
-				Range<Long> newSpan) {
-			boolean inOld = DBTraceUtils.intersect(oldSpan, span);
-			boolean inNew = DBTraceUtils.intersect(newSpan, span);
+		private void valueLifespanChanged(TraceObjectValue value, Lifespan oldSpan,
+				Lifespan newSpan) {
+			boolean inOld = oldSpan.intersects(span);
+			boolean inNew = newSpan.intersects(span);
 			if (inOld == inNew) {
 				return;
 			}
@@ -488,7 +484,7 @@ public class ObjectTreeModel implements DisplaysModified {
 	private long snap;
 	private Trace diffTrace;
 	private long diffSnap;
-	private Range<Long> span = Range.all();
+	private Lifespan span = Lifespan.ALL;
 	private boolean showHidden;
 	private boolean showPrimitives;
 	private boolean showMethods;
@@ -589,7 +585,7 @@ public class ObjectTreeModel implements DisplaysModified {
 		if (!showMethods && value.isObject() && value.getChild().isMethod(snap)) {
 			return false;
 		}
-		if (!DBTraceUtils.intersect(value.getLifespan(), span)) {
+		if (!value.getLifespan().intersects(span)) {
 			return false;
 		}
 		return true;
@@ -737,7 +733,7 @@ public class ObjectTreeModel implements DisplaysModified {
 		reload();
 	}
 
-	public void setSpan(Range<Long> span) {
+	public void setSpan(Lifespan span) {
 		if (Objects.equals(this.span, span)) {
 			return;
 		}
@@ -745,7 +741,7 @@ public class ObjectTreeModel implements DisplaysModified {
 		spanChanged();
 	}
 
-	public Range<Long> getSpan() {
+	public Lifespan getSpan() {
 		return span;
 	}
 

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/model/ObjectsTreePanel.java

@@ -25,8 +25,6 @@ import javax.swing.JPanel;
 import javax.swing.JTree;
 import javax.swing.tree.TreePath;
 
-import com.google.common.collect.Range;
-
 import docking.widgets.tree.GTree;
 import docking.widgets.tree.support.GTreeRenderer;
 import docking.widgets.tree.support.GTreeSelectionEvent.EventOrigin;
@@ -34,6 +32,7 @@ import docking.widgets.tree.support.GTreeSelectionListener;
 import ghidra.app.plugin.core.debug.DebuggerCoordinates;
 import ghidra.app.plugin.core.debug.gui.DebuggerResources;
 import ghidra.app.plugin.core.debug.gui.model.ObjectTreeModel.AbstractNode;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace;
 import ghidra.trace.model.target.TraceObjectKeyPath;
 
@@ -125,7 +124,7 @@ public class ObjectsTreePanel extends JPanel {
 			treeModel.setDiffSnap(previous.getSnap());
 			treeModel.setSnap(current.getSnap());
 			if (limitToSnap) {
-				treeModel.setSpan(Range.singleton(current.getSnap()));
+				treeModel.setSpan(Lifespan.at(current.getSnap()));
 			}
 			tree.filterChanged();
 		}
@@ -137,7 +136,7 @@ public class ObjectsTreePanel extends JPanel {
 		}
 		this.limitToSnap = limitToSnap;
 		try (KeepTreeState keep = keepTreeState()) {
-			treeModel.setSpan(limitToSnap ? Range.singleton(current.getSnap()) : Range.all());
+			treeModel.setSpan(limitToSnap ? Lifespan.at(current.getSnap()) : Lifespan.ALL);
 		}
 	}
 

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/model/PathTableModel.java

@@ -19,13 +19,12 @@ import java.awt.Color;
 import java.util.*;
 import java.util.stream.Stream;
 
-import com.google.common.collect.Range;
-
-import docking.widgets.table.TableColumnDescriptor;
 import docking.widgets.table.RangeCursorTableHeaderRenderer.SeekListener;
+import docking.widgets.table.TableColumnDescriptor;
 import ghidra.app.plugin.core.debug.gui.model.PathTableModel.PathRow;
 import ghidra.app.plugin.core.debug.gui.model.columns.*;
 import ghidra.framework.plugintool.Plugin;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace;
 import ghidra.trace.model.target.*;
 
@@ -104,7 +103,7 @@ public class PathTableModel extends AbstractQueryTableModel<PathRow> {
 
 	protected void updateTimelineMax() {
 		Long max = getTrace() == null ? null : getTrace().getTimeManager().getMaxSnap();
-		Range<Long> fullRange = Range.closed(0L, max == null ? 1 : max + 1);
+		Lifespan fullRange = Lifespan.span(0L, max == null ? 1 : max + 1);
 		lifespanPlotColumn.setFullRange(fullRange);
 	}
 
@@ -131,7 +130,7 @@ public class PathTableModel extends AbstractQueryTableModel<PathRow> {
 	}
 
 	@Override
-	protected Stream<PathRow> streamRows(Trace trace, ModelQuery query, Range<Long> span) {
+	protected Stream<PathRow> streamRows(Trace trace, ModelQuery query, Lifespan span) {
 		// TODO: For queries with early wildcards, this is not efficient
 		// May need to incorporate filtering hidden into the query execution itself.
 		return distinctKeyPath(query.streamPaths(trace, span)

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/model/columns/TracePathLastLifespanColumn.java

@@ -15,17 +15,16 @@
  */
 package ghidra.app.plugin.core.debug.gui.model.columns;
 
-import com.google.common.collect.Range;
-
 import docking.widgets.table.AbstractDynamicTableColumn;
 import ghidra.app.plugin.core.debug.gui.model.PathTableModel.PathRow;
 import ghidra.docking.settings.Settings;
 import ghidra.framework.plugintool.ServiceProvider;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace;
 import ghidra.trace.model.target.TraceObjectValue;
 
 public class TracePathLastLifespanColumn
-		extends AbstractDynamicTableColumn<PathRow, Range<Long>, Trace> {
+		extends AbstractDynamicTableColumn<PathRow, Lifespan, Trace> {
 
 	@Override
 	public String getColumnName() {
@@ -33,11 +32,11 @@ public class TracePathLastLifespanColumn
 	}
 
 	@Override
-	public Range<Long> getValue(PathRow rowObject, Settings settings, Trace data,
+	public Lifespan getValue(PathRow rowObject, Settings settings, Trace data,
 			ServiceProvider serviceProvider) throws IllegalArgumentException {
 		TraceObjectValue lastEntry = rowObject.getPath().getLastEntry();
 		if (lastEntry == null) {
-			return Range.all();
+			return Lifespan.ALL;
 		}
 		return lastEntry.getLifespan();
 	}

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/model/columns/TracePathLastLifespanPlotColumn.java

@@ -15,21 +15,21 @@
  */
 package ghidra.app.plugin.core.debug.gui.model.columns;
 
-import com.google.common.collect.Range;
-
 import docking.widgets.table.*;
 import docking.widgets.table.RangeCursorTableHeaderRenderer.SeekListener;
+import generic.Span;
 import ghidra.app.plugin.core.debug.gui.model.PathTableModel.PathRow;
 import ghidra.docking.settings.Settings;
 import ghidra.framework.plugintool.ServiceProvider;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace;
 import ghidra.trace.model.target.TraceObjectValue;
 import ghidra.util.table.column.GColumnRenderer;
 
 public class TracePathLastLifespanPlotColumn
-		extends AbstractDynamicTableColumn<PathRow, Range<Long>, Trace> {
+		extends AbstractDynamicTableColumn<PathRow, Span<Long, ?>, Trace> {
 
-	private final RangeTableCellRenderer<Long> cellRenderer = new RangeTableCellRenderer<>();
+	private final SpanTableCellRenderer<Long> cellRenderer = new SpanTableCellRenderer<>();
 	private final RangeCursorTableHeaderRenderer<Long> headerRenderer =
 		new RangeCursorTableHeaderRenderer<>();
 
@@ -39,17 +39,17 @@ public class TracePathLastLifespanPlotColumn
 	}
 
 	@Override
-	public Range<Long> getValue(PathRow rowObject, Settings settings, Trace data,
+	public Lifespan getValue(PathRow rowObject, Settings settings, Trace data,
 			ServiceProvider serviceProvider) throws IllegalArgumentException {
 		TraceObjectValue lastEntry = rowObject.getPath().getLastEntry();
 		if (lastEntry == null) {
-			return Range.all();
+			return Lifespan.ALL;
 		}
 		return lastEntry.getLifespan();
 	}
 
 	@Override
-	public GColumnRenderer<Range<Long>> getColumnRenderer() {
+	public GColumnRenderer<Span<Long, ?>> getColumnRenderer() {
 		return cellRenderer;
 	}
 
@@ -58,7 +58,7 @@ public class TracePathLastLifespanPlotColumn
 		return headerRenderer;
 	}
 
-	public void setFullRange(Range<Long> fullRange) {
+	public void setFullRange(Lifespan fullRange) {
 		cellRenderer.setFullRange(fullRange);
 		headerRenderer.setFullRange(fullRange);
 	}

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/model/columns/TraceValueLifeColumn.java

@@ -15,16 +15,15 @@
  */
 package ghidra.app.plugin.core.debug.gui.model.columns;
 
-import com.google.common.collect.RangeSet;
-
 import docking.widgets.table.AbstractDynamicTableColumn;
 import ghidra.app.plugin.core.debug.gui.model.ObjectTableModel.ValueRow;
 import ghidra.docking.settings.Settings;
 import ghidra.framework.plugintool.ServiceProvider;
+import ghidra.trace.model.Lifespan.LifeSet;
 import ghidra.trace.model.Trace;
 
 public class TraceValueLifeColumn
-		extends AbstractDynamicTableColumn<ValueRow, RangeSet<Long>, Trace> {
+		extends AbstractDynamicTableColumn<ValueRow, LifeSet, Trace> {
 
 	@Override
 	public String getColumnName() {
@@ -32,7 +31,7 @@ public class TraceValueLifeColumn
 	}
 
 	@Override
-	public RangeSet<Long> getValue(ValueRow rowObject, Settings settings, Trace data,
+	public LifeSet getValue(ValueRow rowObject, Settings settings, Trace data,
 			ServiceProvider serviceProvider) throws IllegalArgumentException {
 		return rowObject.getLife();
 	}

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/model/columns/TraceValueLifePlotColumn.java

@@ -15,21 +15,21 @@
  */
 package ghidra.app.plugin.core.debug.gui.model.columns;
 
-import com.google.common.collect.Range;
-import com.google.common.collect.RangeSet;
-
 import docking.widgets.table.*;
 import docking.widgets.table.RangeCursorTableHeaderRenderer.SeekListener;
+import generic.Span.SpanSet;
 import ghidra.app.plugin.core.debug.gui.model.ObjectTableModel.ValueRow;
 import ghidra.docking.settings.Settings;
 import ghidra.framework.plugintool.ServiceProvider;
+import ghidra.trace.model.Lifespan;
+import ghidra.trace.model.Lifespan.LifeSet;
 import ghidra.trace.model.Trace;
 import ghidra.util.table.column.GColumnRenderer;
 
 public class TraceValueLifePlotColumn
-		extends AbstractDynamicTableColumn<ValueRow, RangeSet<Long>, Trace> {
+		extends AbstractDynamicTableColumn<ValueRow, SpanSet<Long,?>, Trace> {
 
-	private final RangeSetTableCellRenderer<Long> cellRenderer = new RangeSetTableCellRenderer<>();
+	private final SpanSetTableCellRenderer<Long> cellRenderer = new SpanSetTableCellRenderer<>();
 	private final RangeCursorTableHeaderRenderer<Long> headerRenderer =
 		new RangeCursorTableHeaderRenderer<>();
 
@@ -39,13 +39,13 @@ public class TraceValueLifePlotColumn
 	}
 
 	@Override
-	public RangeSet<Long> getValue(ValueRow rowObject, Settings settings, Trace data,
+	public LifeSet getValue(ValueRow rowObject, Settings settings, Trace data,
 			ServiceProvider serviceProvider) throws IllegalArgumentException {
 		return rowObject.getLife();
 	}
 
 	@Override
-	public GColumnRenderer<RangeSet<Long>> getColumnRenderer() {
+	public GColumnRenderer<SpanSet<Long,?>> getColumnRenderer() {
 		return cellRenderer;
 	}
 
@@ -54,7 +54,7 @@ public class TraceValueLifePlotColumn
 		return headerRenderer;
 	}
 
-	public void setFullRange(Range<Long> fullRange) {
+	public void setFullRange(Lifespan fullRange) {
 		cellRenderer.setFullRange(fullRange);
 		headerRenderer.setFullRange(fullRange);
 	}

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/modules/DebuggerAddMappingDialog.java

@@ -23,11 +23,9 @@ import java.math.BigInteger;
 import javax.swing.*;
 import javax.swing.border.EmptyBorder;
 
-import com.google.common.collect.Range;
-
 import docking.DialogComponentProvider;
 import docking.widgets.model.GAddressRangeField;
-import docking.widgets.model.GLifespanField;
+import docking.widgets.model.GSpanField;
 import ghidra.app.services.DebuggerStaticMappingService;
 import ghidra.framework.model.DomainFile;
 import ghidra.program.model.address.*;
@@ -51,7 +49,7 @@ public class DebuggerAddMappingDialog extends DialogComponentProvider {
 	private final JLabel labelTrace = new JLabel();
 	private final GAddressRangeField fieldTraceRange = new GAddressRangeField();
 	private final JTextField fieldLength = new JTextField();
-	private final GLifespanField fieldSpan = new GLifespanField();
+	private final GSpanField fieldSpan = new GSpanField();
 
 	public DebuggerAddMappingDialog() {
 		super("Add Static Mapping", false, false, true, false);
@@ -316,7 +314,7 @@ public class DebuggerAddMappingDialog extends DialogComponentProvider {
 	 * @throws AddressOverflowException if the length is too large for either space
 	 */
 	public void setValues(Program program, Trace trace, Address progStart,
-			Address traceStart, long length, Range<Long> lifespan) throws AddressOverflowException {
+			Address traceStart, long length, Lifespan lifespan) throws AddressOverflowException {
 		// NB. This dialog will not validate these. The caller is responsible.
 		this.program = program;
 		this.trace = trace;

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/modules/DebuggerModulesProvider.java

@@ -28,8 +28,6 @@ import javax.swing.*;
 import javax.swing.table.TableColumn;
 import javax.swing.table.TableColumnModel;
 
-import com.google.common.collect.Range;
-
 import docking.*;
 import docking.action.*;
 import docking.action.builder.ActionBuilder;
@@ -61,10 +59,9 @@ import ghidra.program.model.listing.Program;
 import ghidra.program.model.mem.MemoryBlock;
 import ghidra.program.util.ProgramLocation;
 import ghidra.program.util.ProgramSelection;
-import ghidra.trace.model.Trace;
+import ghidra.trace.model.*;
 import ghidra.trace.model.Trace.TraceModuleChangeType;
 import ghidra.trace.model.Trace.TraceSectionChangeType;
-import ghidra.trace.model.TraceDomainObjectListener;
 import ghidra.trace.model.modules.*;
 import ghidra.util.HelpLocation;
 import ghidra.util.Msg;
@@ -188,7 +185,7 @@ public class DebuggerModulesProvider extends ComponentProviderAdapter {
 		MAX("Max Address", Address.class, ModuleRow::getMaxAddress),
 		SHORT_NAME("Name", String.class, ModuleRow::getShortName),
 		NAME("Module Name", String.class, ModuleRow::getName, ModuleRow::setName),
-		LIFESPAN("Lifespan", Range.class, ModuleRow::getLifespan),
+		LIFESPAN("Lifespan", Lifespan.class, ModuleRow::getLifespan),
 		LENGTH("Length", Long.class, ModuleRow::getLength);
 
 		private final String header;
@@ -989,7 +986,7 @@ public class DebuggerModulesProvider extends ComponentProviderAdapter {
 			return;
 		}
 		staticMappingService.addIdentityMapping(currentTrace, currentProgram,
-			Range.atLeast(traceManager.getCurrentSnap()), true);
+			Lifespan.nowOn(traceManager.getCurrentSnap()), true);
 	}
 
 	private void activatedMapManually(ActionContext ignored) {
@@ -1087,13 +1084,13 @@ public class DebuggerModulesProvider extends ComponentProviderAdapter {
 			Set<TraceSection> sectionSel = new HashSet<>();
 			for (AddressRange range : progSel) {
 				for (TraceModule module : moduleManager
-						.getModulesIntersecting(Range.singleton(snap), range)) {
+						.getModulesIntersecting(Lifespan.at(snap), range)) {
 					if (module.getSections().isEmpty()) {
 						modSel.add(module);
 					}
 				}
 				for (TraceSection section : moduleManager
-						.getSectionsIntersecting(Range.singleton(snap), range)) {
+						.getSectionsIntersecting(Lifespan.at(snap), range)) {
 					sectionSel.add(section);
 					modSel.add(section.getModule());
 				}

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/modules/DebuggerStaticMappingProvider.java

@@ -27,8 +27,6 @@ import javax.swing.*;
 import javax.swing.table.TableColumn;
 import javax.swing.table.TableColumnModel;
 
-import com.google.common.collect.Range;
-
 import docking.ActionContext;
 import docking.action.DockingAction;
 import docking.action.DockingActionIf;
@@ -48,9 +46,8 @@ import ghidra.program.model.address.*;
 import ghidra.program.model.listing.Program;
 import ghidra.program.util.ProgramLocation;
 import ghidra.program.util.ProgramSelection;
-import ghidra.trace.model.Trace;
+import ghidra.trace.model.*;
 import ghidra.trace.model.Trace.TraceStaticMappingChangeType;
-import ghidra.trace.model.TraceDomainObjectListener;
 import ghidra.trace.model.modules.TraceStaticMapping;
 import ghidra.trace.model.modules.TraceStaticMappingManager;
 import ghidra.trace.model.program.TraceProgramView;
@@ -69,7 +66,7 @@ public class DebuggerStaticMappingProvider extends ComponentProviderAdapter
 		STATIC_ADDRESS("Static Address", String.class, StaticMappingRow::getStaticAddress),
 		LENGTH("Length", BigInteger.class, StaticMappingRow::getBigLength),
 		SHIFT("Shift", Long.class, StaticMappingRow::getShift),
-		LIFESPAN("Lifespan", Range.class, StaticMappingRow::getLifespan);
+		LIFESPAN("Lifespan", Lifespan.class, StaticMappingRow::getLifespan);
 
 		private final String header;
 		private final Class<?> cls;
@@ -293,7 +290,7 @@ public class DebuggerStaticMappingProvider extends ComponentProviderAdapter
 
 		try {
 			addMappingDialog.setValues(progLoc.getProgram(), currentTrace, progStart, traceStart,
-				length, Range.atLeast(view.getSnap()));
+				length, Lifespan.nowOn(view.getSnap()));
 		}
 		catch (AddressOverflowException e) {
 			Msg.showError(this, null, "Add Mapping", "Error populating dialog");
@@ -323,7 +320,7 @@ public class DebuggerStaticMappingProvider extends ComponentProviderAdapter
 			Set<TraceStaticMapping> mappingSel = new HashSet<>();
 			for (AddressRange range : progSel) {
 				mappingSel.addAll(mappingManager.findAllOverlapping(range,
-					Range.singleton(traceManager.getCurrentSnap())));
+					Lifespan.at(traceManager.getCurrentSnap())));
 			}
 			setSelectedMappings(mappingSel);
 			return;

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/modules/ModuleRow.java

@@ -15,9 +15,8 @@
  */
 package ghidra.app.plugin.core.debug.gui.modules;
 
-import com.google.common.collect.Range;
-
 import ghidra.program.model.address.Address;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.modules.TraceModule;
 import ghidra.util.database.UndoableTransaction;
 
@@ -73,7 +72,7 @@ public class ModuleRow {
 		return snap == Long.MAX_VALUE ? null : snap;
 	}
 
-	public Range<Long> getLifespan() {
+	public Lifespan getLifespan() {
 		return module.getLifespan();
 	}
 

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/modules/StaticMappingRow.java

@@ -18,9 +18,8 @@ package ghidra.app.plugin.core.debug.gui.modules;
 import java.math.BigInteger;
 import java.net.URL;
 
-import com.google.common.collect.Range;
-
 import ghidra.program.model.address.Address;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace;
 import ghidra.trace.model.modules.TraceStaticMapping;
 
@@ -73,7 +72,7 @@ public class StaticMappingRow {
 		return mapping.getShift();
 	}
 
-	public Range<Long> getLifespan() {
+	public Lifespan getLifespan() {
 		return mapping.getLifespan();
 	}
 }

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/register/DebuggerRegistersProvider.java

@@ -31,8 +31,6 @@ import javax.swing.table.TableColumnModel;
 
 import org.apache.commons.lang3.exception.ExceptionUtils;
 
-import com.google.common.collect.Range;
-
 import docking.*;
 import docking.action.*;
 import docking.action.builder.ActionBuilder;
@@ -76,7 +74,8 @@ import ghidra.trace.model.memory.*;
 import ghidra.trace.model.program.TraceProgramView;
 import ghidra.trace.model.target.TraceObject;
 import ghidra.trace.model.thread.TraceThread;
-import ghidra.trace.util.*;
+import ghidra.trace.util.TraceAddressSpace;
+import ghidra.trace.util.TraceRegisterUtils;
 import ghidra.util.*;
 import ghidra.util.classfinder.ClassSearcher;
 import ghidra.util.data.DataTypeParser.AllowedDataTypes;
@@ -346,7 +345,7 @@ public class DebuggerRegistersProvider extends ComponentProviderAdapter
 		}
 
 		private void registerTypeLifespanChanged(TraceAddressSpace space, TraceCodeUnit unit,
-				Range<Long> oldSpan, Range<Long> newSpan) {
+				Lifespan oldSpan, Lifespan newSpan) {
 			if (!isVisible(space)) {
 				return;
 			}
@@ -375,7 +374,7 @@ public class DebuggerRegistersProvider extends ComponentProviderAdapter
 			//checkEditsEnabled();
 		}
 
-		private void threadDestroyed(TraceThread thread, Range<Long> oldSpan, Range<Long> newSpan) {
+		private void threadDestroyed(TraceThread thread, Lifespan oldSpan, Lifespan newSpan) {
 			//checkEditsEnabled();
 		}
 	}
@@ -925,9 +924,9 @@ public class DebuggerRegistersProvider extends ComponentProviderAdapter
 			long snap = current.getViewSnap();
 			TracePlatform platform = current.getPlatform();
 			space.definedUnits()
-					.clear(platform, Range.closed(snap, snap), register, TaskMonitor.DUMMY);
+					.clear(platform, Lifespan.at(snap), register, TaskMonitor.DUMMY);
 			if (dataType != null) {
-				space.definedData().create(platform, Range.atLeast(snap), register, dataType);
+				space.definedData().create(platform, Lifespan.nowOn(snap), register, dataType);
 			}
 		}
 		catch (CodeUnitInsertionException | CancelledException e) {

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/stack/StackFrameRow.java

@@ -15,13 +15,10 @@
  */
 package ghidra.app.plugin.core.debug.gui.stack;
 
-import com.google.common.collect.Range;
-
 import ghidra.program.model.address.Address;
 import ghidra.program.model.listing.Function;
 import ghidra.program.util.ProgramLocation;
-import ghidra.trace.model.DefaultTraceLocation;
-import ghidra.trace.model.TraceLocation;
+import ghidra.trace.model.*;
 import ghidra.trace.model.stack.TraceStackFrame;
 import ghidra.trace.model.thread.TraceThread;
 import ghidra.util.database.UndoableTransaction;
@@ -102,7 +99,7 @@ public class StackFrameRow {
 			return null;
 		}
 		TraceLocation dloc = new DefaultTraceLocation(curThread.getTrace(),
-			curThread, Range.singleton(getSnap()), pc);
+			curThread, Lifespan.at(getSnap()), pc);
 		ProgramLocation sloc = provider.mappingService.getOpenMappedLocation(dloc);
 		if (sloc == null) {
 			return null;

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/thread/DebuggerThreadsProvider.java

@@ -26,8 +26,6 @@ import javax.swing.event.ListSelectionEvent;
 import javax.swing.table.TableColumn;
 import javax.swing.table.TableColumnModel;
 
-import com.google.common.collect.Range;
-
 import docking.ActionContext;
 import docking.WindowPosition;
 import docking.action.*;
@@ -49,10 +47,9 @@ import ghidra.framework.model.DomainObject;
 import ghidra.framework.plugintool.AutoService;
 import ghidra.framework.plugintool.ComponentProviderAdapter;
 import ghidra.framework.plugintool.annotation.AutoServiceConsumed;
-import ghidra.trace.model.Trace;
+import ghidra.trace.model.*;
 import ghidra.trace.model.Trace.TraceSnapshotChangeType;
 import ghidra.trace.model.Trace.TraceThreadChangeType;
-import ghidra.trace.model.TraceDomainObjectListener;
 import ghidra.trace.model.thread.TraceThread;
 import ghidra.trace.model.thread.TraceThreadManager;
 import ghidra.trace.model.time.TraceSnapshot;
@@ -177,7 +174,7 @@ public class DebuggerThreadsProvider extends ComponentProviderAdapter {
 	private final BooleanChangeAdapter synchronizeFocusChangeListener =
 		this::changedSynchronizeFocus;
 	/* package access for testing */
-	final RangeTableCellRenderer<Long> rangeRenderer = new RangeTableCellRenderer<>();
+	final SpanTableCellRenderer<Long> spanRenderer = new SpanTableCellRenderer<>();
 	final RangeCursorTableHeaderRenderer<Long> headerRenderer =
 		new RangeCursorTableHeaderRenderer<>();
 
@@ -357,8 +354,8 @@ public class DebuggerThreadsProvider extends ComponentProviderAdapter {
 
 	protected void updateTimelineMax() {
 		long max = orZero(current.getTrace().getTimeManager().getMaxSnap());
-		Range<Long> fullRange = Range.closed(0L, max + 1);
-		rangeRenderer.setFullRange(fullRange);
+		Lifespan fullRange = Lifespan.span(0, max + 1);
+		spanRenderer.setFullRange(fullRange);
 		headerRenderer.setFullRange(fullRange);
 		threadTable.getTableHeader().repaint();
 	}
@@ -464,7 +461,7 @@ public class DebuggerThreadsProvider extends ComponentProviderAdapter {
 		colComment.setPreferredWidth(100);
 		TableColumn colPlot = columnModel.getColumn(ThreadTableColumns.PLOT.ordinal());
 		colPlot.setPreferredWidth(200);
-		colPlot.setCellRenderer(rangeRenderer);
+		colPlot.setCellRenderer(spanRenderer);
 		colPlot.setHeaderRenderer(headerRenderer);
 
 		headerRenderer.addSeekListener(seekListener = pos -> {

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/thread/ThreadRow.java

@@ -15,11 +15,10 @@
  */
 package ghidra.app.plugin.core.debug.gui.thread;
 
-import com.google.common.collect.Range;
-
 import ghidra.app.services.DebuggerModelService;
 import ghidra.app.services.TraceRecorder;
 import ghidra.dbg.target.TargetExecutionStateful.TargetExecutionState;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace;
 import ghidra.trace.model.thread.TraceThread;
 import ghidra.util.Msg;
@@ -63,7 +62,7 @@ public class ThreadRow {
 		return snap == Long.MAX_VALUE ? "" : Long.toString(snap);
 	}
 
-	public Range<Long> getLifespan() {
+	public Lifespan getLifespan() {
 		return thread.getLifespan();
 	}
 

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/thread/ThreadTableColumns.java

@@ -18,9 +18,8 @@ package ghidra.app.plugin.core.debug.gui.thread;
 import java.util.function.BiConsumer;
 import java.util.function.Function;
 
-import com.google.common.collect.Range;
-
 import docking.widgets.table.DefaultEnumeratedColumnTableModel.EnumeratedTableColumn;
+import ghidra.trace.model.Lifespan;
 
 public enum ThreadTableColumns implements EnumeratedTableColumn<ThreadTableColumns, ThreadRow> {
 	NAME("Name", String.class, ThreadRow::getName, ThreadRow::setName, true),
@@ -28,7 +27,7 @@ public enum ThreadTableColumns implements EnumeratedTableColumn<ThreadTableColum
 	DESTROYED("Destroyed", String.class, ThreadRow::getDestructionSnap, true),
 	STATE("State", ThreadState.class, ThreadRow::getState, true),
 	COMMENT("Comment", String.class, ThreadRow::getComment, ThreadRow::setComment, true),
-	PLOT("Plot", Range.class, ThreadRow::getLifespan, false);
+	PLOT("Plot", Lifespan.class, ThreadRow::getLifespan, false);
 
 	private final String header;
 	private final Function<ThreadRow, ?> getter;

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/watch/WatchRow.java

@@ -19,8 +19,6 @@ import java.math.BigInteger;
 import java.util.*;
 import java.util.concurrent.CompletableFuture;
 
-import com.google.common.collect.Range;
-
 import ghidra.app.plugin.core.debug.DebuggerCoordinates;
 import ghidra.app.plugin.processors.sleigh.SleighLanguage;
 import ghidra.app.services.DataTypeManagerService;
@@ -428,7 +426,7 @@ public class WatchRow {
 			return null;
 		}
 		TraceLocation dloc =
-			new DefaultTraceLocation(trace, null, Range.singleton(current.getSnap()), address);
+			new DefaultTraceLocation(trace, null, Lifespan.at(current.getSnap()), address);
 		ProgramLocation sloc = provider.mappingService.getOpenMappedLocation(dloc);
 		if (sloc == null) {
 			return null;

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/mapping/DebuggerPlatformOpinion.java

@@ -17,11 +17,10 @@ package ghidra.app.plugin.core.debug.mapping;
 
 import java.util.*;
 
-import com.google.common.collect.Range;
-
 import ghidra.dbg.target.TargetEnvironment;
 import ghidra.dbg.util.PathPredicates;
 import ghidra.program.model.lang.Endian;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace;
 import ghidra.trace.model.target.TraceObject;
 import ghidra.trace.model.target.TraceObjectValue;
@@ -71,7 +70,7 @@ public interface DebuggerPlatformOpinion extends ExtensionPoint {
 		if (pathToEnv == null) {
 			return null;
 		}
-		return root.getSuccessors(Range.singleton(snap), PathPredicates.pattern(pathToEnv))
+		return root.getSuccessors(Lifespan.at(snap), PathPredicates.pattern(pathToEnv))
 				.findAny()
 				.map(p -> p.getDestination(root))
 				.orElse(null);

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/breakpoint/DebuggerLogicalBreakpointServicePlugin.java

@@ -23,8 +23,6 @@ import java.util.stream.Collectors;
 
 import org.apache.commons.collections4.IteratorUtils;
 
-import com.google.common.collect.Range;
-
 import generic.CatenatedCollection;
 import ghidra.app.events.ProgramClosedPluginEvent;
 import ghidra.app.events.ProgramOpenedPluginEvent;
@@ -252,7 +250,7 @@ public class DebuggerLogicalBreakpointServicePlugin extends Plugin
 		}
 
 		private void breakpointLifespanChanged(TraceAddressSpace spaceIsNull,
-				TraceBreakpoint tb, Range<Long> oldSpan, Range<Long> newSpan) {
+				TraceBreakpoint tb, Lifespan oldSpan, Lifespan newSpan) {
 			// NOTE: User/script probably modified historical breakpoint
 			boolean isInOld = oldSpan.contains(info.recorder.getSnap());
 			boolean isInNew = newSpan.contains(info.recorder.getSnap());
@@ -487,7 +485,7 @@ public class DebuggerLogicalBreakpointServicePlugin extends Plugin
 			for (AddressRange range : trace.getBaseAddressFactory().getAddressSet()) {
 				live.addAll(trace
 						.getBreakpointManager()
-						.getBreakpointsIntersecting(Range.singleton(recorder.getSnap()), range));
+						.getBreakpointsIntersecting(Lifespan.at(recorder.getSnap()), range));
 			}
 			for (TraceBreakpoint tb : live) {
 				forgetTraceBreakpoint(r, tb);
@@ -523,7 +521,7 @@ public class DebuggerLogicalBreakpointServicePlugin extends Plugin
 			for (AddressRange range : trace.getBaseAddressFactory().getAddressSet()) {
 				live.addAll(trace
 						.getBreakpointManager()
-						.getBreakpointsIntersecting(Range.singleton(recorder.getSnap()), range));
+						.getBreakpointsIntersecting(Lifespan.at(recorder.getSnap()), range));
 			}
 			trackTraceBreakpoints(a, live);
 		}
@@ -552,7 +550,7 @@ public class DebuggerLogicalBreakpointServicePlugin extends Plugin
 				return null;
 			}
 			return mappingService.getOpenMappedLocation(new DefaultTraceLocation(trace,
-				null, Range.singleton(recorder.getSnap()), tb.getMinAddress()));
+				null, Lifespan.at(recorder.getSnap()), tb.getMinAddress()));
 		}
 
 		protected void trackTraceBreakpoint(AddCollector a, TraceBreakpoint tb, boolean forceUpdate)
@@ -1105,7 +1103,7 @@ public class DebuggerLogicalBreakpointServicePlugin extends Plugin
 		}
 
 		ProgramLocation staticLocation = mappingService.getOpenMappedLocation(
-			new DefaultTraceLocation(trace, null, Range.singleton(recorder.getSnap()), address));
+			new DefaultTraceLocation(trace, null, Lifespan.at(recorder.getSnap()), address));
 		if (staticLocation == null) {
 			return new LoneLogicalBreakpoint(recorder, address, length, kinds)
 					.enableForTrace(trace);

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/DebuggerEmulationServicePlugin.java

@@ -26,8 +26,6 @@ import javax.swing.event.ChangeListener;
 
 import org.apache.commons.lang3.exception.ExceptionUtils;
 
-import com.google.common.collect.Range;
-
 import docking.action.DockingAction;
 import docking.action.ToggleDockingAction;
 import ghidra.app.context.ProgramLocationActionContext;
@@ -417,7 +415,7 @@ public class DebuggerEmulationServicePlugin extends Plugin implements DebuggerEm
 			}*/
 			ProgramLocation progLoc =
 				staticMappings.getOpenMappedLocation(new DefaultTraceLocation(view.getTrace(), null,
-					Range.singleton(view.getSnap()), tracePc));
+					Lifespan.at(view.getSnap()), tracePc));
 			Program program = progLoc == null ? null : progLoc.getProgram();
 			Address programPc = progLoc == null ? null : progLoc.getAddress();
 
@@ -540,7 +538,7 @@ public class DebuggerEmulationServicePlugin extends Plugin implements DebuggerEm
 	}
 
 	protected void installBreakpoints(Trace trace, long snap, DebuggerPcodeMachine<?> emu) {
-		Range<Long> span = Range.singleton(snap);
+		Lifespan span = Lifespan.at(snap);
 		TraceBreakpointManager bm = trace.getBreakpointManager();
 		for (AddressSpace as : trace.getBaseAddressFactory().getAddressSpaces()) {
 			for (TraceBreakpoint bpt : bm.getBreakpointsIntersecting(span,

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/ProgramEmulationUtils.java

@@ -21,8 +21,6 @@ import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-import com.google.common.collect.Range;
-
 import ghidra.app.plugin.core.debug.service.modules.DebuggerStaticMappingUtils;
 import ghidra.app.services.DebuggerEmulationService;
 import ghidra.framework.model.DomainFile;
@@ -33,8 +31,7 @@ import ghidra.program.model.listing.ProgramContext;
 import ghidra.program.model.mem.MemoryBlock;
 import ghidra.program.util.ProgramLocation;
 import ghidra.trace.database.DBTrace;
-import ghidra.trace.model.DefaultTraceLocation;
-import ghidra.trace.model.Trace;
+import ghidra.trace.model.*;
 import ghidra.trace.model.memory.*;
 import ghidra.trace.model.modules.TraceConflictedMappingException;
 import ghidra.trace.model.thread.TraceThread;
@@ -166,7 +163,7 @@ public enum ProgramEmulationUtils {
 			}
 			for (Extrema extrema : extremaBySpace.values()) {
 				DebuggerStaticMappingUtils.addMapping(
-					new DefaultTraceLocation(trace, null, Range.atLeast(snapshot.getKey()),
+					new DefaultTraceLocation(trace, null, Lifespan.nowOn(snapshot.getKey()),
 						extrema.min),
 					new ProgramLocation(program, extrema.min),
 					extrema.max.subtract(extrema.min), false);

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/data/DefaultPcodeDebuggerPropertyAccess.java

@@ -15,14 +15,13 @@
  */
 package ghidra.app.plugin.core.debug.service.emulation.data;
 
-import com.google.common.collect.Range;
-
 import ghidra.app.services.DebuggerStaticMappingService;
 import ghidra.pcode.exec.trace.data.DefaultPcodeTracePropertyAccess;
 import ghidra.program.model.address.Address;
 import ghidra.program.model.util.PropertyMap;
 import ghidra.program.util.ProgramLocation;
 import ghidra.trace.model.DefaultTraceLocation;
+import ghidra.trace.model.Lifespan;
 
 /**
  * The default trace-and-debugger-property access shim
@@ -59,7 +58,7 @@ public class DefaultPcodeDebuggerPropertyAccess<T>
 			return super.whenNull(hostAddress);
 		}
 		ProgramLocation progLoc = mappingService.getOpenMappedLocation(new DefaultTraceLocation(
-			data.getPlatform().getTrace(), null, Range.singleton(data.getSnap()), hostAddress));
+			data.getPlatform().getTrace(), null, Lifespan.at(data.getSnap()), hostAddress));
 		if (progLoc == null) {
 			return super.whenNull(hostAddress);
 		}

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/model/DefaultMemoryRecorder.java

@@ -15,16 +15,17 @@
  */
 package ghidra.app.plugin.core.debug.service.model;
 
-import java.util.*;
+import java.util.Collection;
+import java.util.HashSet;
 import java.util.concurrent.CompletableFuture;
 
-import com.google.common.collect.Range;
-
 import ghidra.app.plugin.core.debug.service.model.interfaces.ManagedMemoryRecorder;
 import ghidra.app.plugin.core.debug.service.model.record.RecorderUtils;
 import ghidra.dbg.target.TargetMemory;
 import ghidra.dbg.target.TargetMemoryRegion;
-import ghidra.program.model.address.*;
+import ghidra.program.model.address.AddressRange;
+import ghidra.program.model.address.AddressSetView;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace;
 import ghidra.trace.model.memory.*;
 import ghidra.util.Msg;
@@ -80,7 +81,7 @@ public class DefaultMemoryRecorder implements ManagedMemoryRecorder {
 				if (region.getRange().getLength() != traceRange.getLength()) {
 					Msg.warn(this, "Truncated region: " + region);
 				}
-				traceRegion = memoryManager.addRegion(path, Range.atLeast(snap), traceRange,
+				traceRegion = memoryManager.addRegion(path, Lifespan.nowOn(snap), traceRange,
 					getTraceFlags(region));
 				traceRegion.setName(region.getDisplay());
 			}

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/model/record/ObjectBasedTraceRecorder.java

@@ -21,8 +21,6 @@ import java.util.*;
 import java.util.concurrent.CompletableFuture;
 import java.util.stream.Collectors;
 
-import com.google.common.collect.Range;
-
 import ghidra.app.plugin.core.debug.mapping.*;
 import ghidra.app.plugin.core.debug.service.model.DebuggerModelServicePlugin;
 import ghidra.app.plugin.core.debug.service.model.PermanentTransactionExecutor;
@@ -43,6 +41,7 @@ import ghidra.program.model.address.*;
 import ghidra.program.model.lang.Register;
 import ghidra.program.model.lang.RegisterValue;
 import ghidra.trace.database.module.TraceObjectSection;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace;
 import ghidra.trace.model.breakpoint.*;
 import ghidra.trace.model.guest.TracePlatform;
@@ -469,7 +468,7 @@ public class ObjectBasedTraceRecorder implements TraceRecorder {
 	public Set<TargetThread> getLiveTargetThreads() {
 		return trace.getObjectManager()
 				.getRootObject()
-				.querySuccessorsInterface(Range.singleton(getSnap()), TraceObjectThread.class)
+				.querySuccessorsInterface(Lifespan.at(getSnap()), TraceObjectThread.class)
 				.map(t -> objectRecorder.getTargetInterface(t.getObject(), TargetThread.class))
 				.collect(Collectors.toSet());
 	}
@@ -639,7 +638,7 @@ public class ObjectBasedTraceRecorder implements TraceRecorder {
 			this.thread = thread;
 			TraceObject object = thread.getObject();
 			this.process = object
-					.queryAncestorsTargetInterface(Range.singleton(getSnap()), TargetProcess.class)
+					.queryAncestorsTargetInterface(Lifespan.at(getSnap()), TargetProcess.class)
 					.map(p -> p.getSource(object))
 					.findFirst()
 					.orElse(null);
@@ -647,7 +646,7 @@ public class ObjectBasedTraceRecorder implements TraceRecorder {
 
 		private boolean appliesTo(TraceObjectBreakpointLocation loc) {
 			TraceObject object = loc.getObject();
-			if (object.queryAncestorsInterface(Range.singleton(getSnap()), TraceObjectThread.class)
+			if (object.queryAncestorsInterface(Lifespan.at(getSnap()), TraceObjectThread.class)
 					.anyMatch(t -> t == thread)) {
 				return true;
 			}
@@ -655,7 +654,7 @@ public class ObjectBasedTraceRecorder implements TraceRecorder {
 				return false;
 			}
 			return object
-					.queryAncestorsTargetInterface(Range.singleton(getSnap()), TargetProcess.class)
+					.queryAncestorsTargetInterface(Lifespan.at(getSnap()), TargetProcess.class)
 					.map(p -> p.getSource(object))
 					.anyMatch(p -> p == process);
 		}
@@ -669,7 +668,7 @@ public class ObjectBasedTraceRecorder implements TraceRecorder {
 		BreakpointConvention convention = new BreakpointConvention(
 			objectRecorder.getTraceInterface(thread, TraceObjectThread.class));
 		return trace.getObjectManager()
-				.queryAllInterface(Range.singleton(getSnap()), TraceObjectBreakpointLocation.class)
+				.queryAllInterface(Lifespan.at(getSnap()), TraceObjectBreakpointLocation.class)
 				.filter(convention::appliesTo)
 				.map(tl -> objectRecorder.getTargetInterface(tl.getObject(),
 					TargetBreakpointLocation.class))

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/model/record/ObjectRecorder.java

@@ -21,8 +21,6 @@ import java.util.stream.Collectors;
 import org.apache.commons.collections4.BidiMap;
 import org.apache.commons.collections4.bidimap.DualHashBidiMap;
 
-import com.google.common.collect.Range;
-
 import ghidra.dbg.DebuggerObjectModel;
 import ghidra.dbg.target.TargetAttacher.TargetAttachKind;
 import ghidra.dbg.target.TargetAttacher.TargetAttachKindSet;
@@ -38,6 +36,7 @@ import ghidra.dbg.target.schema.TargetObjectSchema;
 import ghidra.dbg.util.*;
 import ghidra.program.model.address.Address;
 import ghidra.program.model.address.AddressRange;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.TraceUniqueObject;
 import ghidra.trace.model.target.*;
 import ghidra.trace.model.thread.TraceObjectThread;
@@ -111,7 +110,7 @@ class ObjectRecorder {
 		}
 		String extras = computeExtraInterfaces(object);
 		// Note: null extras will erase previous value, if necessary.
-		traceObject.setAttribute(Range.atLeast(snap),
+		traceObject.setAttribute(Lifespan.nowOn(snap),
 			TraceObject.EXTRA_INTERFACES_ATTRIBUTE_NAME, extras);
 	}
 
@@ -127,7 +126,7 @@ class ObjectRecorder {
 			Msg.error(this, "Unknown object was invalidated: " + object);
 			return;
 		}
-		traceObject.obj.removeTree(Range.atLeast(snap));
+		traceObject.obj.removeTree(Lifespan.nowOn(snap));
 	}
 
 	protected String encodeEnum(Enum<?> e) {
@@ -209,7 +208,7 @@ class ObjectRecorder {
 			}
 		}
 		for (Map.Entry<String, Object> entry : traceAdded.entrySet()) {
-			traceObject.setAttribute(Range.atLeast(snap), entry.getKey(), entry.getValue());
+			traceObject.setAttribute(Lifespan.nowOn(snap), entry.getKey(), entry.getValue());
 		}
 	}
 
@@ -241,7 +240,7 @@ class ObjectRecorder {
 			}
 		}
 		for (Map.Entry<String, Object> entry : traceAdded.entrySet()) {
-			traceObject.setElement(Range.atLeast(snap), entry.getKey(), entry.getValue());
+			traceObject.setElement(Lifespan.nowOn(snap), entry.getKey(), entry.getValue());
 		}
 	}
 
@@ -291,7 +290,7 @@ class ObjectRecorder {
 			return null;
 		}
 		TraceObjectValPath found = object
-				.getSuccessors(Range.singleton(recorder.getSnap()), applied)
+				.getSuccessors(Lifespan.at(recorder.getSnap()), applied)
 				.findAny()
 				.orElse(null);
 		if (found == null) {
@@ -311,7 +310,7 @@ class ObjectRecorder {
 		if (seed == null) {
 			return List.of();
 		}
-		return seed.querySuccessorsTargetInterface(Range.singleton(recorder.getSnap()), targetIf)
+		return seed.querySuccessorsTargetInterface(Lifespan.at(recorder.getSnap()), targetIf)
 				.map(p -> toTarget(p.getDestination(seed)).as(targetIf))
 				.collect(Collectors.toList());
 	}

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/modules/DebuggerStaticMappingServicePlugin.java

@@ -23,8 +23,6 @@ import java.util.stream.Collectors;
 
 import org.apache.commons.lang3.ArrayUtils;
 
-import com.google.common.collect.Range;
-
 import ghidra.app.events.ProgramClosedPluginEvent;
 import ghidra.app.events.ProgramOpenedPluginEvent;
 import ghidra.app.plugin.PluginCategoryNames;
@@ -344,7 +342,7 @@ public class DebuggerStaticMappingServicePlugin extends Plugin
 			return result;
 		}
 
-		public ProgramLocation getOpenMappedLocations(Address address, Range<Long> span) {
+		public ProgramLocation getOpenMappedLocations(Address address, Lifespan span) {
 			TraceAddressSnapRange at = new ImmutableTraceAddressSnapRange(address, span);
 			for (Entry<TraceAddressSnapRange, MappingEntry> out : outbound.entrySet()) {
 				if (out.getKey().intersects(at)) {
@@ -357,7 +355,7 @@ public class DebuggerStaticMappingServicePlugin extends Plugin
 			return null;
 		}
 
-		protected void collectOpenMappedPrograms(AddressRange rng, Range<Long> span,
+		protected void collectOpenMappedPrograms(AddressRange rng, Lifespan span,
 				Map<Program, Collection<MappedAddressRange>> result) {
 			TraceAddressSnapRange tatr = new ImmutableTraceAddressSnapRange(rng, span);
 			for (Entry<TraceAddressSnapRange, MappingEntry> out : outbound.entrySet()) {
@@ -376,7 +374,7 @@ public class DebuggerStaticMappingServicePlugin extends Plugin
 		}
 
 		public Map<Program, Collection<MappedAddressRange>> getOpenMappedViews(AddressSetView set,
-				Range<Long> span) {
+				Lifespan span) {
 			Map<Program, Collection<MappedAddressRange>> result = new HashMap<>();
 			for (AddressRange rng : set) {
 				collectOpenMappedPrograms(rng, span, result);
@@ -384,7 +382,7 @@ public class DebuggerStaticMappingServicePlugin extends Plugin
 			return Collections.unmodifiableMap(result);
 		}
 
-		protected void collectMappedProgramURLsInView(AddressRange rng, Range<Long> span,
+		protected void collectMappedProgramURLsInView(AddressRange rng, Lifespan span,
 				Set<URL> result) {
 			TraceAddressSnapRange tatr = new ImmutableTraceAddressSnapRange(rng, span);
 			for (Entry<TraceAddressSnapRange, MappingEntry> out : outbound.entrySet()) {
@@ -396,7 +394,7 @@ public class DebuggerStaticMappingServicePlugin extends Plugin
 			}
 		}
 
-		public Set<URL> getMappedProgramURLsInView(AddressSetView set, Range<Long> span) {
+		public Set<URL> getMappedProgramURLsInView(AddressSetView set, Lifespan span) {
 			Set<URL> result = new HashSet<>();
 			for (AddressRange rng : set) {
 				collectMappedProgramURLsInView(rng, span, result);
@@ -772,7 +770,7 @@ public class DebuggerStaticMappingServicePlugin extends Plugin
 	}
 
 	@Override
-	public void addIdentityMapping(Trace from, Program toProgram, Range<Long> lifespan,
+	public void addIdentityMapping(Trace from, Program toProgram, Lifespan lifespan,
 			boolean truncateExisting) {
 		try (UndoableTransaction tid =
 			UndoableTransaction.start(from, "Add identity mappings")) {
@@ -868,7 +866,7 @@ public class DebuggerStaticMappingServicePlugin extends Plugin
 			TraceProgramView view = (TraceProgramView) loc.getProgram();
 			Trace trace = view.getTrace();
 			TraceLocation tloc = new DefaultTraceLocation(trace, null,
-				Range.singleton(getNonScratchSnap(view)), loc.getByteAddress());
+				Lifespan.at(getNonScratchSnap(view)), loc.getByteAddress());
 			ProgramLocation mapped = getOpenMappedLocation(tloc);
 			if (mapped == null) {
 				return null;
@@ -921,7 +919,7 @@ public class DebuggerStaticMappingServicePlugin extends Plugin
 			if (info == null) {
 				return null;
 			}
-			return info.getOpenMappedViews(set, Range.singleton(snap));
+			return info.getOpenMappedViews(set, Lifespan.at(snap));
 		}
 	}
 
@@ -946,7 +944,7 @@ public class DebuggerStaticMappingServicePlugin extends Plugin
 			if (info == null) {
 				return null;
 			}
-			urls = info.getMappedProgramURLsInView(set, Range.singleton(snap));
+			urls = info.getMappedProgramURLsInView(set, Lifespan.at(snap));
 		}
 		Set<Program> result = new HashSet<>();
 		for (URL url : urls) {

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/modules/DebuggerStaticMappingUtils.java

@@ -19,8 +19,6 @@ import java.io.IOException;
 import java.net.URL;
 import java.util.*;
 
-import com.google.common.collect.Range;
-
 import ghidra.app.plugin.core.debug.utils.ProgramURLUtils;
 import ghidra.app.services.MapEntry;
 import ghidra.framework.data.OpenedDomainFile;
@@ -31,7 +29,6 @@ import ghidra.program.model.listing.Library;
 import ghidra.program.model.listing.Program;
 import ghidra.program.model.symbol.ExternalManager;
 import ghidra.program.util.ProgramLocation;
-import ghidra.trace.database.DBTraceUtils;
 import ghidra.trace.model.*;
 import ghidra.trace.model.modules.*;
 import ghidra.trace.model.program.TraceProgramView;
@@ -207,16 +204,16 @@ public enum DebuggerStaticMappingUtils {
 		Address end = fromAddress.addWrap(length - 1);
 		// Also check end in the destination
 		AddressRangeImpl range = new AddressRangeImpl(fromAddress, end);
-		Range<Long> fromLifespan = from.getLifespan();
+		Lifespan fromLifespan = from.getLifespan();
 		if (truncateExisting) {
-			long truncEnd = DBTraceUtils.lowerEndpoint(fromLifespan) - 1;
+			long truncEnd = fromLifespan.lmin() - 1;
 			for (TraceStaticMapping existing : List
 					.copyOf(manager.findAllOverlapping(range, fromLifespan))) {
 				existing.delete();
-				if (fromLifespan.hasLowerBound() &&
-					Long.compare(existing.getStartSnap(), truncEnd) <= 0) {
+				if (fromLifespan.minIsFinite() &&
+					Lifespan.DOMAIN.compare(existing.getStartSnap(), truncEnd) <= 0) {
 					manager.add(existing.getTraceAddressRange(),
-						Range.closed(existing.getStartSnap(), truncEnd),
+						Lifespan.span(existing.getStartSnap(), truncEnd),
 						existing.getStaticProgramURL(), existing.getStaticAddress());
 				}
 			}
@@ -232,7 +229,7 @@ public enum DebuggerStaticMappingUtils {
 		addMapping(fromLoc, toLoc, length, truncateExisting);
 	}
 
-	public static void addIdentityMapping(Trace from, Program toProgram, Range<Long> lifespan,
+	public static void addIdentityMapping(Trace from, Program toProgram, Lifespan lifespan,
 			boolean truncateExisting) {
 		Map<String, Address> mins = new HashMap<>();
 		Map<String, Address> maxs = new HashMap<>();

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/modules/DefaultModuleMapProposal.java

@@ -17,14 +17,13 @@ package ghidra.app.plugin.core.debug.service.modules;
 
 import java.util.*;
 
-import com.google.common.collect.Range;
-
 import ghidra.app.services.DebuggerStaticMappingService;
 import ghidra.app.services.ModuleMapProposal;
 import ghidra.app.services.ModuleMapProposal.ModuleMapEntry;
 import ghidra.program.model.address.*;
 import ghidra.program.model.listing.Program;
 import ghidra.program.model.mem.MemoryBlock;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.memory.TraceMemoryRegion;
 import ghidra.trace.model.modules.TraceModule;
 
@@ -110,7 +109,7 @@ public class DefaultModuleMapProposal
 		}
 
 		@Override
-		public Range<Long> getFromLifespan() {
+		public Lifespan getFromLifespan() {
 			return getModule().getLifespan();
 		}
 

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/modules/DefaultRegionMapProposal.java

@@ -18,13 +18,12 @@ package ghidra.app.plugin.core.debug.service.modules;
 import java.util.*;
 import java.util.stream.Collectors;
 
-import com.google.common.collect.Range;
-
 import ghidra.app.services.RegionMapProposal;
 import ghidra.app.services.RegionMapProposal.RegionMapEntry;
 import ghidra.program.model.address.*;
 import ghidra.program.model.listing.Program;
 import ghidra.program.model.mem.MemoryBlock;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace;
 import ghidra.trace.model.memory.TraceMemoryRegion;
 
@@ -52,7 +51,7 @@ public class DefaultRegionMapProposal
 		}
 
 		@Override
-		public Range<Long> getFromLifespan() {
+		public Lifespan getFromLifespan() {
 			return getRegion().getLifespan();
 		}
 

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/modules/DefaultSectionMapProposal.java

@@ -17,8 +17,6 @@ package ghidra.app.plugin.core.debug.service.modules;
 
 import java.util.Map;
 
-import com.google.common.collect.Range;
-
 import ghidra.app.services.DebuggerStaticMappingService;
 import ghidra.app.services.SectionMapProposal;
 import ghidra.app.services.SectionMapProposal.SectionMapEntry;
@@ -26,6 +24,7 @@ import ghidra.program.model.address.AddressRange;
 import ghidra.program.model.address.AddressRangeImpl;
 import ghidra.program.model.listing.Program;
 import ghidra.program.model.mem.MemoryBlock;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.modules.TraceModule;
 import ghidra.trace.model.modules.TraceSection;
 
@@ -66,7 +65,7 @@ public class DefaultSectionMapProposal
 		}
 
 		@Override
-		public Range<Long> getFromLifespan() {
+		public Lifespan getFromLifespan() {
 			return getModule().getLifespan();
 		}
 

Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/workflow/DisassembleAtPcDebuggerBot.java

@@ -20,8 +20,6 @@ import java.util.Map.Entry;
 
 import javax.swing.event.ChangeListener;
 
-import com.google.common.collect.Range;
-
 import docking.DockingWindowManager;
 import docking.Tool;
 import ghidra.app.plugin.core.debug.mapping.DebuggerPlatformMapper;
@@ -156,9 +154,9 @@ public class DisassembleAtPcDebuggerBot implements DebuggerBot {
 			}
 			TraceViewportSpanIterator spit = new TraceViewportSpanIterator(trace, snap);
 			while (spit.hasNext()) {
-				Range<Long> span = spit.next();
-				if (span.upperEndpoint() >= 0) {
-					return span.upperEndpoint();
+				Lifespan span = spit.next();
+				if (span.lmax() >= 0) {
+					return span.lmax();
 				}
 			}
 			return snap;
@@ -229,7 +227,7 @@ public class DisassembleAtPcDebuggerBot implements DebuggerBot {
 				TraceCodeSpace regCode = codeManager.getCodeRegisterSpace(thread, frameLevel, true);
 				try {
 					pcUnit = regCode.definedData()
-							.create(Range.atLeast(pcSnap), pc, PointerDataType.dataType);
+							.create(Lifespan.nowOn(pcSnap), pc, PointerDataType.dataType);
 				}
 				catch (CodeUnitInsertionException e) {
 					// I guess something's already there. Leave it, then!
@@ -295,7 +293,7 @@ public class DisassembleAtPcDebuggerBot implements DebuggerBot {
 			 */
 			AddressSetView readOnly =
 				memoryManager.getRegionsAddressSetWith(ks, r -> !r.isWrite());
-			AddressSetView everKnown = memoryManager.getAddressesWithState(Range.atMost(ks),
+			AddressSetView everKnown = memoryManager.getAddressesWithState(Lifespan.since(ks),
 				s -> s == TraceMemoryState.KNOWN);
 			AddressSetView roEverKnown = new IntersectionAddressSetView(readOnly, everKnown);
 			AddressSetView known =

Ghidra/Debug/Debugger/src/main/java/ghidra/app/services/DebuggerStaticMappingService.java

@@ -18,8 +18,6 @@ package ghidra.app.services;
 import java.util.*;
 import java.util.concurrent.CompletableFuture;
 
-import com.google.common.collect.Range;
-
 import ghidra.app.services.ModuleMapProposal.ModuleMapEntry;
 import ghidra.app.services.RegionMapProposal.RegionMapEntry;
 import ghidra.app.services.SectionMapProposal.SectionMapEntry;
@@ -218,7 +216,7 @@ public interface DebuggerStaticMappingService {
 	 * @param truncateExisting true to delete or truncate the lifespan of overlapping entries. If
 	 *            false, overlapping entries are omitted.
 	 */
-	void addIdentityMapping(Trace from, Program toProgram, Range<Long> lifespan,
+	void addIdentityMapping(Trace from, Program toProgram, Lifespan lifespan,
 			boolean truncateExisting);
 
 	void addMapping(MapEntry<?, ?> entry, boolean truncateExisting)

Ghidra/Debug/Debugger/src/main/java/ghidra/app/services/MapEntry.java

@@ -15,13 +15,10 @@
  */
 package ghidra.app.services;
 
-import com.google.common.collect.Range;
-
 import ghidra.program.model.address.AddressRange;
 import ghidra.program.model.listing.Program;
 import ghidra.program.util.ProgramLocation;
-import ghidra.trace.model.Trace;
-import ghidra.trace.model.TraceLocation;
+import ghidra.trace.model.*;
 
 public interface MapEntry<T, P> {
 	Trace getFromTrace();
@@ -30,7 +27,7 @@ public interface MapEntry<T, P> {
 
 	AddressRange getFromRange();
 
-	Range<Long> getFromLifespan();
+	Lifespan getFromLifespan();
 
 	TraceLocation getFromTraceLocation();
 

Ghidra/Debug/Debugger/src/screen/java/ghidra/app/plugin/core/debug/gui/breakpoint/DebuggerBreakpointMarkerPluginScreenShots.java

@@ -21,8 +21,6 @@ import java.util.Set;
 import org.junit.Before;
 import org.junit.Test;
 
-import com.google.common.collect.Range;
-
 import generic.Unique;
 import ghidra.app.plugin.core.codebrowser.CodeViewerProvider;
 import ghidra.app.plugin.core.debug.gui.AbstractGhidraHeadedDebuggerGUITest.TestDebuggerTargetTraceMapper;
@@ -40,8 +38,7 @@ import ghidra.dbg.model.TestDebuggerModelBuilder;
 import ghidra.program.model.address.Address;
 import ghidra.program.model.listing.Program;
 import ghidra.program.util.ProgramLocation;
-import ghidra.trace.model.DefaultTraceLocation;
-import ghidra.trace.model.Trace;
+import ghidra.trace.model.*;
 import ghidra.trace.model.breakpoint.TraceBreakpointKind;
 import ghidra.util.Msg;
 import ghidra.util.Swing;
@@ -102,10 +99,10 @@ public class DebuggerBreakpointMarkerPluginScreenShots extends GhidraScreenShotG
 				.createFile("WinHelloCPP", program, TaskMonitor.DUMMY);
 
 		try (UndoableTransaction tid = UndoableTransaction.start(trace, "Add Mapping")) {
-			mappingService.addIdentityMapping(trace, program, Range.atLeast(0L), true);
+			mappingService.addIdentityMapping(trace, program, Lifespan.nowOn(0), true);
 		}
 		waitForValue(() -> mappingService.getOpenMappedLocation(
-			new DefaultTraceLocation(trace, null, Range.singleton(0L), mb.addr(0x00401c60))));
+			new DefaultTraceLocation(trace, null, Lifespan.at(0), mb.addr(0x00401c60))));
 
 		Msg.debug(this, "Placing breakpoint");
 		breakpointService.placeBreakpointAt(program, addr(program, 0x00401c60), 1,
@@ -152,10 +149,10 @@ public class DebuggerBreakpointMarkerPluginScreenShots extends GhidraScreenShotG
 				.createFile("WinHelloCPP", program, TaskMonitor.DUMMY);
 
 		try (UndoableTransaction tid = UndoableTransaction.start(trace, "Add Mapping")) {
-			mappingService.addIdentityMapping(trace, program, Range.atLeast(0L), true);
+			mappingService.addIdentityMapping(trace, program, Lifespan.nowOn(0), true);
 		}
 		waitForValue(() -> mappingService.getOpenMappedLocation(
-			new DefaultTraceLocation(trace, null, Range.singleton(0L), mb.addr(0x00401070))));
+			new DefaultTraceLocation(trace, null, Lifespan.at(0), mb.addr(0x00401070))));
 
 		Msg.debug(this, "Placing breakpoint");
 		breakpointService.placeBreakpointAt(program, addr(program, 0x00401070), 1,

Ghidra/Debug/Debugger/src/screen/java/ghidra/app/plugin/core/debug/gui/breakpoint/DebuggerBreakpointsPluginScreenShots.java

@@ -23,8 +23,6 @@ import java.util.Set;
 
 import org.junit.*;
 
-import com.google.common.collect.Range;
-
 import generic.Unique;
 import ghidra.app.plugin.core.debug.gui.AbstractGhidraHeadedDebuggerGUITest.TestDebuggerTargetTraceMapper;
 import ghidra.app.plugin.core.debug.service.breakpoint.DebuggerLogicalBreakpointServicePlugin;
@@ -43,8 +41,7 @@ import ghidra.program.model.address.Address;
 import ghidra.program.model.listing.Program;
 import ghidra.program.util.ProgramLocation;
 import ghidra.test.ToyProgramBuilder;
-import ghidra.trace.model.DefaultTraceLocation;
-import ghidra.trace.model.Trace;
+import ghidra.trace.model.*;
 import ghidra.trace.model.breakpoint.TraceBreakpoint;
 import ghidra.util.Msg;
 import ghidra.util.database.UndoableTransaction;
@@ -132,12 +129,12 @@ public class DebuggerBreakpointsPluginScreenShots extends GhidraScreenShotGenera
 
 		try (UndoableTransaction tid = UndoableTransaction.start(trace1, "Add mapping")) {
 			DebuggerStaticMappingUtils.addMapping(
-				new DefaultTraceLocation(trace1, null, Range.atLeast(0L), addr(trace1, 0x00400000)),
+				new DefaultTraceLocation(trace1, null, Lifespan.nowOn(0), addr(trace1, 0x00400000)),
 				new ProgramLocation(program, addr(program, 0x00400000)), 0x00210000, false);
 		}
 		try (UndoableTransaction tid = UndoableTransaction.start(trace3, "Add mapping")) {
 			DebuggerStaticMappingUtils.addMapping(
-				new DefaultTraceLocation(trace3, null, Range.atLeast(0L), addr(trace3, 0x7fac0000)),
+				new DefaultTraceLocation(trace3, null, Lifespan.nowOn(0), addr(trace3, 0x7fac0000)),
 				new ProgramLocation(program, addr(program, 0x00400000)), 0x00010000, false);
 		}
 

Ghidra/Debug/Debugger/src/screen/java/ghidra/app/plugin/core/debug/gui/copying/DebuggerCopyActionsPluginScreenShots.java

@@ -19,8 +19,6 @@ import java.util.Set;
 
 import org.junit.*;
 
-import com.google.common.collect.Range;
-
 import ghidra.app.plugin.core.debug.gui.AbstractGhidraHeadedDebuggerGUITest.TestDebuggerTargetTraceMapper;
 import ghidra.app.plugin.core.debug.gui.listing.DebuggerListingPlugin;
 import ghidra.app.plugin.core.debug.gui.listing.DebuggerListingProvider;
@@ -39,6 +37,7 @@ import ghidra.trace.database.ToyDBTraceBuilder;
 import ghidra.trace.database.memory.DBTraceMemoryManager;
 import ghidra.trace.database.module.DBTraceModuleManager;
 import ghidra.trace.model.DefaultTraceLocation;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.memory.TraceMemoryFlag;
 import ghidra.trace.model.modules.TraceModule;
 import ghidra.util.database.UndoableTransaction;
@@ -126,10 +125,10 @@ public class DebuggerCopyActionsPluginScreenShots extends GhidraScreenShotGenera
 
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			mappingService.addMapping(
-				new DefaultTraceLocation(tb.trace, null, Range.atLeast(snap), tb.addr(0x55550000)),
+				new DefaultTraceLocation(tb.trace, null, Lifespan.nowOn(snap), tb.addr(0x55550000)),
 				new ProgramLocation(program, tb.addr(stSpace, 0x00400000)), 0x10000, true);
 			mappingService.addMapping(
-				new DefaultTraceLocation(tb.trace, null, Range.atLeast(snap), tb.addr(0x55560000)),
+				new DefaultTraceLocation(tb.trace, null, Lifespan.nowOn(snap), tb.addr(0x55560000)),
 				new ProgramLocation(program, tb.addr(stSpace, 0x00600000)), 0x10000, true);
 		}
 

Ghidra/Debug/Debugger/src/screen/java/ghidra/app/plugin/core/debug/gui/listing/DebuggerListingPluginScreenShots.java

@@ -19,8 +19,6 @@ import java.util.Set;
 
 import org.junit.*;
 
-import com.google.common.collect.Range;
-
 import ghidra.app.plugin.assembler.Assembler;
 import ghidra.app.plugin.assembler.Assemblers;
 import ghidra.app.plugin.core.debug.gui.action.DebuggerGoToDialog;
@@ -30,6 +28,7 @@ import ghidra.program.model.lang.RegisterValue;
 import ghidra.program.model.symbol.SourceType;
 import ghidra.test.ToyProgramBuilder;
 import ghidra.trace.database.ToyDBTraceBuilder;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.memory.TraceMemoryFlag;
 import ghidra.trace.model.memory.TraceMemorySpace;
 import ghidra.trace.model.symbol.*;
@@ -63,7 +62,7 @@ public class DebuggerListingPluginScreenShots extends GhidraScreenShotGenerator
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			long snap = tb.trace.getTimeManager().createSnapshot("First").getKey();
 			tb.trace.getMemoryManager()
-					.addRegion(".text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+					.addRegion(".text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 						Set.of(TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE));
 
 			TraceSymbolManager symbolManager = tb.trace.getSymbolManager();
@@ -127,7 +126,7 @@ public class DebuggerListingPluginScreenShots extends GhidraScreenShotGenerator
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			tb.trace.getTimeManager().createSnapshot("First").getKey();
 			tb.trace.getMemoryManager()
-					.addRegion("bash:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+					.addRegion("bash:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 						Set.of(TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE));
 
 			traceManager.openTrace(tb.trace);

Ghidra/Debug/Debugger/src/screen/java/ghidra/app/plugin/core/debug/gui/memory/DebuggerMemoryBytesPluginScreenShots.java

@@ -19,8 +19,6 @@ import java.util.Set;
 
 import org.junit.*;
 
-import com.google.common.collect.Range;
-
 import ghidra.app.plugin.assembler.Assembler;
 import ghidra.app.plugin.assembler.Assemblers;
 import ghidra.app.plugin.core.debug.gui.listing.DebuggerListingPlugin;
@@ -30,6 +28,7 @@ import ghidra.program.model.lang.RegisterValue;
 import ghidra.program.model.symbol.SourceType;
 import ghidra.test.ToyProgramBuilder;
 import ghidra.trace.database.ToyDBTraceBuilder;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.memory.TraceMemoryFlag;
 import ghidra.trace.model.memory.TraceMemorySpace;
 import ghidra.trace.model.symbol.*;
@@ -67,7 +66,7 @@ public class DebuggerMemoryBytesPluginScreenShots extends GhidraScreenShotGenera
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			long snap = tb.trace.getTimeManager().createSnapshot("First").getKey();
 			tb.trace.getMemoryManager()
-					.addRegion(".text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+					.addRegion(".text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 						Set.of(TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE));
 
 			TraceSymbolManager symbolManager = tb.trace.getSymbolManager();

Ghidra/Debug/Debugger/src/screen/java/ghidra/app/plugin/core/debug/gui/memory/DebuggerRegionsPluginScreenShots.java

@@ -19,8 +19,6 @@ import java.util.Set;
 
 import org.junit.*;
 
-import com.google.common.collect.Range;
-
 import ghidra.app.plugin.core.debug.service.tracemgr.DebuggerTraceManagerServicePlugin;
 import ghidra.app.plugin.core.progmgr.ProgramManagerPlugin;
 import ghidra.app.services.DebuggerTraceManagerService;
@@ -32,6 +30,7 @@ import ghidra.program.model.listing.Program;
 import ghidra.test.ToyProgramBuilder;
 import ghidra.trace.database.ToyDBTraceBuilder;
 import ghidra.trace.database.memory.DBTraceMemoryManager;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.memory.TraceMemoryFlag;
 import ghidra.util.database.UndoableTransaction;
 import ghidra.util.task.TaskMonitor;
@@ -80,16 +79,16 @@ public class DebuggerRegionsPluginScreenShots extends GhidraScreenShotGenerator
 			long snap = tb.trace.getTimeManager().createSnapshot("First").getKey();
 
 			DBTraceMemoryManager mm = tb.trace.getMemoryManager();
-			mm.addRegion("/bin/bash (400000:40ffff)", Range.atLeast(snap),
+			mm.addRegion("/bin/bash (400000:40ffff)", Lifespan.nowOn(snap),
 				tb.range(0x00400000, 0x0040ffff),
 				Set.of(TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE));
-			mm.addRegion("/bin/bash (600000:60ffff)", Range.atLeast(snap),
+			mm.addRegion("/bin/bash (600000:60ffff)", Lifespan.nowOn(snap),
 				tb.range(0x00600000, 0x0060ffff),
 				Set.of(TraceMemoryFlag.READ, TraceMemoryFlag.WRITE));
-			mm.addRegion("/lib/libc (7fac0000:7facffff)", Range.atLeast(snap),
+			mm.addRegion("/lib/libc (7fac0000:7facffff)", Lifespan.nowOn(snap),
 				tb.range(0x7fac0000, 0x7facffff),
 				Set.of(TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE));
-			mm.addRegion("/lib/libc (7fcc0000:7fccffff)", Range.atLeast(snap),
+			mm.addRegion("/lib/libc (7fcc0000:7fccffff)", Lifespan.nowOn(snap),
 				tb.range(0x7fcc0000, 0x7fccffff),
 				Set.of(TraceMemoryFlag.READ, TraceMemoryFlag.WRITE));
 		}

Ghidra/Debug/Debugger/src/screen/java/ghidra/app/plugin/core/debug/gui/memview/DebuggerMemviewPluginScreenShots.java

@@ -20,16 +20,14 @@ import java.util.Set;
 
 import org.junit.*;
 
-import com.google.common.collect.Range;
-
 import ghidra.app.plugin.core.debug.service.tracemgr.DebuggerTraceManagerServicePlugin;
 import ghidra.app.plugin.core.progmgr.ProgramManagerPlugin;
 import ghidra.app.services.DebuggerTraceManagerService;
 import ghidra.app.services.ProgramManager;
-import ghidra.framework.model.DomainFolder;
 import ghidra.program.model.listing.Program;
 import ghidra.test.ToyProgramBuilder;
 import ghidra.trace.database.ToyDBTraceBuilder;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.breakpoint.TraceBreakpointKind;
 import ghidra.trace.model.memory.TraceMemoryFlag;
 import ghidra.trace.model.thread.TraceThread;
@@ -78,12 +76,12 @@ public class DebuggerMemviewPluginScreenShots extends GhidraScreenShotGenerator
 	}
 
 	private void populateTraceAndPrograms() throws Exception {
-		DomainFolder root = tool.getProject().getProjectData().getRootFolder();
+		tool.getProject().getProjectData().getRootFolder();
 		TraceThread thread1;
 		try (UndoableTransaction tid = tb.startTransaction()) {
-			thread1 = tb.trace.getThreadManager().addThread("[0]", Range.openClosed(0L, 40L));
-			tb.trace.getThreadManager().addThread("[1]", Range.openClosed(3L, 50L));
-			tb.trace.getThreadManager().addThread("[2]", Range.openClosed(5L, 20L));
+			thread1 = tb.trace.getThreadManager().addThread("[0]", Lifespan.span(1, 40));
+			tb.trace.getThreadManager().addThread("[1]", Lifespan.span(4, 50));
+			tb.trace.getThreadManager().addThread("[2]", Lifespan.span(6, 20));
 		}
 
 		try (UndoableTransaction tid = tb.startTransaction()) {
@@ -96,17 +94,17 @@ public class DebuggerMemviewPluginScreenShots extends GhidraScreenShotGenerator
 
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			tb.trace.getMemoryManager()
-					.addRegion("bash.text", Range.atLeast(5L), tb.range(0x00400000, 0x0040ffff),
+					.addRegion("bash.text", Lifespan.nowOn(5), tb.range(0x00400000, 0x0040ffff),
 						TraceMemoryFlag.EXECUTE);
 			tb.trace.getMemoryManager()
-					.addRegion("bash.data", Range.atLeast(6L), tb.range(0x00500000, 0x0060ffff),
+					.addRegion("bash.data", Lifespan.nowOn(6), tb.range(0x00500000, 0x0060ffff),
 						TraceMemoryFlag.READ, TraceMemoryFlag.WRITE);
 
 			tb.trace.getMemoryManager()
-					.addRegion("libc.text", Range.atLeast(15L), tb.range(0x7fac0000, 0x7facffff),
+					.addRegion("libc.text", Lifespan.nowOn(15), tb.range(0x7fac0000, 0x7facffff),
 						TraceMemoryFlag.EXECUTE);
 			tb.trace.getMemoryManager()
-					.addRegion("libc.data", Range.atLeast(16L), tb.range(0x7fae0000, 0x7faeffff),
+					.addRegion("libc.data", Lifespan.nowOn(16), tb.range(0x7fae0000, 0x7faeffff),
 						TraceMemoryFlag.READ, TraceMemoryFlag.WRITE);
 		}
 
@@ -116,7 +114,7 @@ public class DebuggerMemviewPluginScreenShots extends GhidraScreenShotGenerator
 			threads.add(thread1);
 			kinds.add(TraceBreakpointKind.HW_EXECUTE);
 			tb.trace.getBreakpointManager()
-					.addBreakpoint("bpt1", Range.closed(17L, 25L), tb.range(0x7fac1234, 0x7fc1238),
+					.addBreakpoint("bpt1", Lifespan.span(17, 25), tb.range(0x7fac1234, 0x7fc1238),
 						threads, kinds, true, "break here");
 		}
 

Ghidra/Debug/Debugger/src/screen/java/ghidra/app/plugin/core/debug/gui/pcode/DebuggerPcodeStepperPluginScreenShots.java

@@ -17,8 +17,6 @@ package ghidra.app.plugin.core.debug.gui.pcode;
 
 import org.junit.*;
 
-import com.google.common.collect.Range;
-
 import ghidra.app.plugin.assembler.Assembler;
 import ghidra.app.plugin.assembler.Assemblers;
 import ghidra.app.plugin.core.debug.service.tracemgr.DebuggerTraceManagerServicePlugin;
@@ -27,6 +25,7 @@ import ghidra.pcode.exec.PcodeExecutor;
 import ghidra.pcode.exec.trace.TraceSleighUtils;
 import ghidra.test.ToyProgramBuilder;
 import ghidra.trace.database.ToyDBTraceBuilder;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.memory.TraceMemoryFlag;
 import ghidra.trace.model.thread.TraceThread;
 import ghidra.trace.model.time.schedule.TraceSchedule;
@@ -61,7 +60,7 @@ public class DebuggerPcodeStepperPluginScreenShots extends GhidraScreenShotGener
 			long snap0 = tb.trace.getTimeManager().createSnapshot("First").getKey();
 
 			tb.trace.getMemoryManager()
-					.addRegion("[echo:.text]", Range.atLeast(snap0),
+					.addRegion("[echo:.text]", Lifespan.nowOn(snap0),
 						tb.range(0x00400000, 0x0040ffff), TraceMemoryFlag.READ,
 						TraceMemoryFlag.EXECUTE);
 

Ghidra/Debug/Debugger/src/screen/java/ghidra/app/plugin/core/debug/gui/register/DebuggerRegistersPluginScreenShots.java

@@ -19,8 +19,6 @@ import java.math.BigInteger;
 
 import org.junit.*;
 
-import com.google.common.collect.Range;
-
 import ghidra.app.plugin.core.debug.service.tracemgr.DebuggerTraceManagerServicePlugin;
 import ghidra.app.services.DebuggerTraceManagerService;
 import ghidra.program.model.data.PointerDataType;
@@ -28,6 +26,7 @@ import ghidra.program.model.lang.Language;
 import ghidra.program.model.lang.RegisterValue;
 import ghidra.test.ToyProgramBuilder;
 import ghidra.trace.database.ToyDBTraceBuilder;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.memory.TraceMemorySpace;
 import ghidra.trace.model.thread.TraceThread;
 import ghidra.util.database.UndoableTransaction;
@@ -94,7 +93,7 @@ public class DebuggerRegistersPluginScreenShots extends GhidraScreenShotGenerato
 			tb.trace.getCodeManager()
 					.getCodeRegisterSpace(thread, true)
 					.definedData()
-					.create(Range.atLeast(snap0), lang.getRegister("RIP"),
+					.create(Lifespan.nowOn(snap0), lang.getRegister("RIP"),
 						PointerDataType.dataType);
 
 			traceManager.openTrace(tb.trace);

Ghidra/Debug/Debugger/src/screen/java/ghidra/app/plugin/core/debug/gui/stack/DebuggerStackPluginScreenShots.java

@@ -17,8 +17,6 @@ package ghidra.app.plugin.core.debug.gui.stack;
 
 import org.junit.*;
 
-import com.google.common.collect.Range;
-
 import ghidra.app.plugin.core.debug.service.modules.DebuggerStaticMappingServicePlugin;
 import ghidra.app.plugin.core.debug.service.modules.DebuggerStaticMappingUtils;
 import ghidra.app.plugin.core.debug.service.tracemgr.DebuggerTraceManagerServicePlugin;
@@ -33,6 +31,7 @@ import ghidra.program.util.ProgramLocation;
 import ghidra.test.ToyProgramBuilder;
 import ghidra.trace.database.ToyDBTraceBuilder;
 import ghidra.trace.model.DefaultTraceLocation;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.stack.TraceStack;
 import ghidra.trace.model.stack.TraceStackFrame;
 import ghidra.trace.model.thread.TraceThread;
@@ -106,17 +105,17 @@ public class DebuggerStackPluginScreenShots extends GhidraScreenShotGenerator {
 
 			TraceStackFrame frame;
 			frame = stack.getFrame(0, false);
-			frame.setProgramCounter(Range.all(), tb.addr(0x00404321));
+			frame.setProgramCounter(Lifespan.ALL, tb.addr(0x00404321));
 			frame = stack.getFrame(1, false);
-			frame.setProgramCounter(Range.all(), tb.addr(0x00401234));
+			frame.setProgramCounter(Lifespan.ALL, tb.addr(0x00401234));
 			frame = stack.getFrame(2, false);
-			frame.setProgramCounter(Range.all(), tb.addr(0x00401001));
+			frame.setProgramCounter(Lifespan.ALL, tb.addr(0x00401001));
 		}
 		root.createFile("trace", tb.trace, TaskMonitor.DUMMY);
 		root.createFile("echo", program, TaskMonitor.DUMMY);
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			DebuggerStaticMappingUtils.addMapping(
-				new DefaultTraceLocation(tb.trace, null, Range.atLeast(snap), tb.addr(0x00400000)),
+				new DefaultTraceLocation(tb.trace, null, Lifespan.nowOn(snap), tb.addr(0x00400000)),
 				new ProgramLocation(program, addr(program, 0x00400000)), 0x10000, false);
 		}
 

Ghidra/Debug/Debugger/src/test/java/ghidra/app/plugin/core/debug/disassemble/DebuggerDisassemblyTest.java

@@ -27,8 +27,6 @@ import java.util.stream.Collectors;
 
 import org.junit.*;
 
-import com.google.common.collect.Range;
-
 import docking.action.DockingActionIf;
 import generic.Unique;
 import ghidra.app.context.ListingActionContext;
@@ -60,6 +58,7 @@ import ghidra.trace.database.memory.DBTraceMemorySpace;
 import ghidra.trace.database.program.DBTraceVariableSnapProgramView;
 import ghidra.trace.database.target.DBTraceObject;
 import ghidra.trace.database.target.DBTraceObjectManager;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.guest.TraceGuestPlatform;
 import ghidra.trace.model.memory.TraceMemoryFlag;
 import ghidra.trace.model.memory.TraceObjectMemoryRegion;
@@ -157,7 +156,7 @@ public class DebuggerDisassemblyTest extends AbstractGhidraHeadedDebuggerGUITest
 			DBTraceObject env =
 				objects.createObject(TraceObjectKeyPath.parse("Targets[0].Environment"));
 			assertEquals(ctx.getSchema(new SchemaName("Environment")), env.getTargetSchema());
-			Range<Long> zeroOn = Range.atLeast(0L);
+			Lifespan zeroOn = Lifespan.nowOn(0);
 			env.insert(zeroOn, ConflictResolution.DENY);
 			env.setAttribute(zeroOn, TargetEnvironment.DEBUGGER_ATTRIBUTE_NAME, "test");
 			env.setAttribute(zeroOn, TargetEnvironment.ARCH_ATTRIBUTE_NAME, arch);

Ghidra/Debug/Debugger/src/test/java/ghidra/app/plugin/core/debug/gui/breakpoint/DebuggerBreakpointMarkerPluginTest.java

@@ -33,8 +33,6 @@ import org.junit.Before;
 import org.junit.Test;
 import org.junit.experimental.categories.Category;
 
-import com.google.common.collect.Range;
-
 import docking.action.DockingAction;
 import docking.widgets.fieldpanel.FieldPanel;
 import generic.Unique;
@@ -63,8 +61,7 @@ import ghidra.program.model.listing.Program;
 import ghidra.program.model.mem.MemoryConflictException;
 import ghidra.program.model.symbol.SourceType;
 import ghidra.program.util.ProgramLocation;
-import ghidra.trace.model.DefaultTraceLocation;
-import ghidra.trace.model.Trace;
+import ghidra.trace.model.*;
 import ghidra.trace.model.breakpoint.TraceBreakpointKind;
 import ghidra.trace.model.program.TraceProgramView;
 import ghidra.util.SystemUtilities;
@@ -150,7 +147,7 @@ public class DebuggerBreakpointMarkerPluginTest extends AbstractGhidraHeadedDebu
 	protected void addMapping(Trace trace) throws Exception {
 		try (UndoableTransaction tid = UndoableTransaction.start(trace, "Add mapping")) {
 			DebuggerStaticMappingUtils.addMapping(
-				new DefaultTraceLocation(trace, null, Range.atLeast(0L), addr(trace, 0x55550123)),
+				new DefaultTraceLocation(trace, null, Lifespan.nowOn(0), addr(trace, 0x55550123)),
 				new ProgramLocation(program, addr(program, 0x00400123)), 0x1000, false);
 		}
 	}

Ghidra/Debug/Debugger/src/test/java/ghidra/app/plugin/core/debug/gui/breakpoint/DebuggerBreakpointsProviderTest.java

@@ -27,8 +27,6 @@ import org.junit.Before;
 import org.junit.Test;
 import org.junit.experimental.categories.Category;
 
-import com.google.common.collect.Range;
-
 import docking.widgets.table.RowWrappedEnumeratedColumnTableModel;
 import generic.Unique;
 import generic.test.category.NightlyCategory;
@@ -47,8 +45,7 @@ import ghidra.program.model.address.AddressOverflowException;
 import ghidra.program.model.listing.Program;
 import ghidra.program.model.mem.MemoryConflictException;
 import ghidra.program.util.ProgramLocation;
-import ghidra.trace.model.DefaultTraceLocation;
-import ghidra.trace.model.Trace;
+import ghidra.trace.model.*;
 import ghidra.trace.model.breakpoint.TraceBreakpoint;
 import ghidra.util.SystemUtilities;
 import ghidra.util.database.UndoableTransaction;
@@ -83,7 +80,7 @@ public class DebuggerBreakpointsProviderTest extends AbstractGhidraHeadedDebugge
 	protected void addMapping(Trace trace, Program prog) throws Exception {
 		try (UndoableTransaction tid = UndoableTransaction.start(trace, "Add mapping")) {
 			DebuggerStaticMappingUtils.addMapping(
-				new DefaultTraceLocation(trace, null, Range.atLeast(0L), addr(trace, 0x55550000)),
+				new DefaultTraceLocation(trace, null, Lifespan.nowOn(0), addr(trace, 0x55550000)),
 				new ProgramLocation(prog, addr(prog, 0x00400000)), 0x1000, false);
 		}
 	}

Ghidra/Debug/Debugger/src/test/java/ghidra/app/plugin/core/debug/gui/control/DebuggerControlPluginTest.java

@@ -26,8 +26,6 @@ import java.util.concurrent.CompletableFuture;
 import org.junit.Before;
 import org.junit.Test;
 
-import com.google.common.collect.Range;
-
 import docking.ActionContext;
 import docking.action.DockingAction;
 import docking.action.DockingActionIf;
@@ -61,7 +59,7 @@ import ghidra.program.model.lang.CompilerSpecID;
 import ghidra.program.model.lang.LanguageID;
 import ghidra.program.model.listing.Instruction;
 import ghidra.program.util.ProgramLocation;
-import ghidra.trace.database.DBTraceUtils;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.memory.TraceMemoryFlag;
 import ghidra.trace.model.program.TraceVariableSnapProgramView;
 import ghidra.trace.model.thread.TraceThread;
@@ -462,7 +460,7 @@ public class DebuggerControlPluginTest extends AbstractGhidraHeadedDebuggerGUITe
 		assertEquals(2, ins.getLength());
 
 		long snap = traceManager.getCurrent().getViewSnap();
-		assertTrue(DBTraceUtils.isScratch(snap));
+		assertTrue(Lifespan.isScratch(snap));
 		byte[] bytes = new byte[2];
 		view.getMemory().getBytes(tb.addr(0x00400123), bytes);
 		assertArrayEquals(tb.arr(0x30, 0xd2), bytes);
@@ -483,7 +481,7 @@ public class DebuggerControlPluginTest extends AbstractGhidraHeadedDebuggerGUITe
 						Set.of(TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE));
 			tb.trace.getCodeManager()
 					.definedData()
-					.create(Range.atLeast(0L), tb.addr(0x00400123), ShortDataType.dataType);
+					.create(Lifespan.nowOn(0), tb.addr(0x00400123), ShortDataType.dataType);
 		}
 
 		CodeViewerProvider listingProvider = listingPlugin.getProvider();
@@ -515,7 +513,7 @@ public class DebuggerControlPluginTest extends AbstractGhidraHeadedDebuggerGUITe
 		// assertEquals(2, data.getLength());
 
 		long snap = traceManager.getCurrent().getViewSnap();
-		assertTrue(DBTraceUtils.isScratch(snap));
+		assertTrue(Lifespan.isScratch(snap));
 		byte[] bytes = new byte[2];
 		view.getMemory().getBytes(tb.addr(0x00400123), bytes);
 		assertArrayEquals(tb.arr(0, 5), bytes);
@@ -575,7 +573,7 @@ public class DebuggerControlPluginTest extends AbstractGhidraHeadedDebuggerGUITe
 		byte[] bytes = new byte[4];
 		waitForPass(noExc(() -> {
 			long snap = traceManager.getCurrent().getViewSnap();
-			assertTrue(DBTraceUtils.isScratch(snap));
+			assertTrue(Lifespan.isScratch(snap));
 			view.getMemory().getBytes(tb.addr(0x00400123), bytes);
 			assertArrayEquals(tb.arr(0x12, 0x34, 0x56, 0x78), bytes);
 		}));

Ghidra/Debug/Debugger/src/test/java/ghidra/app/plugin/core/debug/gui/copying/DebuggerCopyActionsPluginTest.java

@@ -24,8 +24,6 @@ import org.junit.Before;
 import org.junit.Test;
 import org.junit.experimental.categories.Category;
 
-import com.google.common.collect.Range;
-
 import docking.action.DockingActionIf;
 import generic.Unique;
 import generic.test.category.NightlyCategory;
@@ -46,8 +44,7 @@ import ghidra.program.model.mem.MemoryBlock;
 import ghidra.program.util.ProgramLocation;
 import ghidra.test.ToyProgramBuilder;
 import ghidra.trace.database.memory.DBTraceMemoryManager;
-import ghidra.trace.model.DefaultTraceLocation;
-import ghidra.trace.model.TraceLocation;
+import ghidra.trace.model.*;
 import ghidra.trace.model.memory.TraceMemoryFlag;
 import ghidra.util.database.UndoableTransaction;
 
@@ -237,7 +234,7 @@ public class DebuggerCopyActionsPluginTest extends AbstractGhidraHeadedDebuggerG
 		}
 
 		TraceLocation tloc =
-			new DefaultTraceLocation(tb.trace, null, Range.atLeast(0L), tb.addr(0x55550000));
+			new DefaultTraceLocation(tb.trace, null, Lifespan.nowOn(0), tb.addr(0x55550000));
 		ProgramLocation ploc = new ProgramLocation(program, tb.addr(stSpace, 0x00400000));
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			mappingService.addMapping(tloc, ploc, 0x10000, true);
@@ -299,7 +296,7 @@ public class DebuggerCopyActionsPluginTest extends AbstractGhidraHeadedDebuggerG
 		}
 
 		TraceLocation tloc =
-			new DefaultTraceLocation(tb.trace, null, Range.atLeast(0L), tb.addr(0x55550000));
+			new DefaultTraceLocation(tb.trace, null, Lifespan.nowOn(0), tb.addr(0x55550000));
 		ProgramLocation ploc = new ProgramLocation(program, tb.addr(stSpace, 0x00400000));
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			mappingService.addMapping(tloc, ploc, 0x10000, true);

Ghidra/Debug/Debugger/src/test/java/ghidra/app/plugin/core/debug/gui/copying/DebuggerCopyPlanTests.java

@@ -26,8 +26,6 @@ import javax.swing.JCheckBox;
 
 import org.junit.Test;
 
-import com.google.common.collect.Range;
-
 import ghidra.app.plugin.assembler.Assembler;
 import ghidra.app.plugin.assembler.Assemblers;
 import ghidra.app.plugin.core.debug.gui.AbstractGhidraHeadedDebuggerGUITest;
@@ -47,6 +45,7 @@ import ghidra.trace.database.breakpoint.DBTraceBreakpointManager;
 import ghidra.trace.database.memory.DBTraceMemoryManager;
 import ghidra.trace.database.program.DBTraceVariableSnapProgramView;
 import ghidra.trace.database.symbol.*;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.breakpoint.TraceBreakpointKind;
 import ghidra.trace.model.memory.TraceMemoryFlag;
 import ghidra.trace.model.memory.TraceMemoryState;
@@ -290,7 +289,7 @@ public class DebuggerCopyPlanTests extends AbstractGhidraHeadedDebuggerGUITest {
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			DBTraceMemoryManager memory = tb.trace.getMemoryManager();
 			memory.createRegion(".text", 0, trng, TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
-			tb.trace.getRegisterContextManager().setValue(tb.language, rv, Range.atLeast(0L), trng);
+			tb.trace.getRegisterContextManager().setValue(tb.language, rv, Lifespan.nowOn(0), trng);
 
 			// TODO: Once GP-1426 is resolved, use the assembler
 			/*

Ghidra/Debug/Debugger/src/test/java/ghidra/app/plugin/core/debug/gui/listing/DebuggerListingProviderTest.java

@@ -27,8 +27,6 @@ import java.util.Set;
 import org.junit.*;
 import org.junit.experimental.categories.Category;
 
-import com.google.common.collect.Range;
-
 import docking.menu.ActionState;
 import docking.menu.MultiStateDockingAction;
 import docking.widgets.EventTrigger;
@@ -121,10 +119,10 @@ public class DebuggerListingProviderTest extends AbstractGhidraHeadedDebuggerGUI
 		}
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			DBTraceMemoryManager memory = tb.trace.getMemoryManager();
-			memory.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			memory.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 			TraceLocation from =
-				new DefaultTraceLocation(tb.trace, null, Range.atLeast(0L), tb.addr(0x00400000));
+				new DefaultTraceLocation(tb.trace, null, Lifespan.nowOn(0), tb.addr(0x00400000));
 			ProgramLocation to = new ProgramLocation(program, ss.getAddress(0x00600000));
 			DebuggerStaticMappingUtils.addMapping(from, to, 0x8000, false);
 		}
@@ -140,7 +138,7 @@ public class DebuggerListingProviderTest extends AbstractGhidraHeadedDebuggerGUI
 		traceManager.activateTrace(tb.trace);
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			DBTraceMemoryManager memory = tb.trace.getMemoryManager();
-			memory.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			memory.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 		}
 		waitForDomainObject(tb.trace);
@@ -154,7 +152,7 @@ public class DebuggerListingProviderTest extends AbstractGhidraHeadedDebuggerGUI
 		createAndOpenTrace();
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			DBTraceMemoryManager memory = tb.trace.getMemoryManager();
-			memory.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			memory.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 		}
 		waitForDomainObject(tb.trace);
@@ -170,7 +168,7 @@ public class DebuggerListingProviderTest extends AbstractGhidraHeadedDebuggerGUI
 		createAndOpenTrace();
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			DBTraceMemoryManager memory = tb.trace.getMemoryManager();
-			memory.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			memory.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 			TraceThread thread = tb.getOrAddThread("Thread1", 0);
 			waitForDomainObject(tb.trace);
@@ -196,7 +194,7 @@ public class DebuggerListingProviderTest extends AbstractGhidraHeadedDebuggerGUI
 		createAndOpenTrace();
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			DBTraceMemoryManager memory = tb.trace.getMemoryManager();
-			memory.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			memory.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 			TraceThread thread = tb.getOrAddThread("Thread1", 0);
 			waitForDomainObject(tb.trace);
@@ -229,7 +227,7 @@ public class DebuggerListingProviderTest extends AbstractGhidraHeadedDebuggerGUI
 		TraceThread thread2;
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			DBTraceMemoryManager memory = tb.trace.getMemoryManager();
-			memory.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			memory.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 			thread1 = tb.getOrAddThread("Thread1", 0);
 			thread2 = tb.getOrAddThread("Thread2", 0);
@@ -275,7 +273,7 @@ public class DebuggerListingProviderTest extends AbstractGhidraHeadedDebuggerGUI
 				.get();
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			DBTraceMemoryManager memory = tb.trace.getMemoryManager();
-			memory.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			memory.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 			thread1 = tb.getOrAddThread("Thread1", 0);
 			thread2 = tb.getOrAddThread("Thread2", 0);
@@ -311,9 +309,9 @@ public class DebuggerListingProviderTest extends AbstractGhidraHeadedDebuggerGUI
 		createAndOpenTrace();
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			DBTraceMemoryManager memory = tb.trace.getMemoryManager();
-			memory.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			memory.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
-			memory.addRegion("[stack]", Range.atLeast(0L), tb.range(0x01000000, 0x01ffffff),
+			memory.addRegion("[stack]", Lifespan.nowOn(0), tb.range(0x01000000, 0x01ffffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.WRITE);
 			TraceThread thread = tb.getOrAddThread("Thread1", 0);
 			waitForDomainObject(tb.trace);
@@ -351,7 +349,7 @@ public class DebuggerListingProviderTest extends AbstractGhidraHeadedDebuggerGUI
 			try (UndoableTransaction tid = b1.startTransaction()) {
 				b1.trace.getTimeManager().createSnapshot("First snap");
 				DBTraceMemoryManager memory = b1.trace.getMemoryManager();
-				memory.addRegion("exe:.text", Range.atLeast(0L), b1.range(0x00400000, 0x0040ffff),
+				memory.addRegion("exe:.text", Lifespan.nowOn(0), b1.range(0x00400000, 0x0040ffff),
 					TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 				t1 = b1.getOrAddThread("Thread1", 0);
 
@@ -363,7 +361,7 @@ public class DebuggerListingProviderTest extends AbstractGhidraHeadedDebuggerGUI
 			try (UndoableTransaction tid = b2.startTransaction()) {
 				b2.trace.getTimeManager().createSnapshot("First snap");
 				DBTraceMemoryManager memory = b2.trace.getMemoryManager();
-				memory.addRegion("exe:.text", Range.atLeast(0L), b2.range(0x00400000, 0x0040ffff),
+				memory.addRegion("exe:.text", Lifespan.nowOn(0), b2.range(0x00400000, 0x0040ffff),
 					TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 				t2 = b2.getOrAddThread("Thread2", 0);
 
@@ -407,7 +405,7 @@ public class DebuggerListingProviderTest extends AbstractGhidraHeadedDebuggerGUI
 			try (UndoableTransaction tid = b1.startTransaction()) {
 				b1.trace.getTimeManager().createSnapshot("First snap");
 				DBTraceMemoryManager memory = b1.trace.getMemoryManager();
-				memory.addRegion("exe:.text", Range.atLeast(0L), b1.range(0x00400000, 0x0040ffff),
+				memory.addRegion("exe:.text", Lifespan.nowOn(0), b1.range(0x00400000, 0x0040ffff),
 					TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 				t1 = b1.getOrAddThread("Thread1", 0);
 
@@ -419,7 +417,7 @@ public class DebuggerListingProviderTest extends AbstractGhidraHeadedDebuggerGUI
 			try (UndoableTransaction tid = b2.startTransaction()) {
 				b2.trace.getTimeManager().createSnapshot("First snap");
 				DBTraceMemoryManager memory = b2.trace.getMemoryManager();
-				memory.addRegion("exe:.text", Range.atLeast(0L), b2.range(0x00400000, 0x0040ffff),
+				memory.addRegion("exe:.text", Lifespan.nowOn(0), b2.range(0x00400000, 0x0040ffff),
 					TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 				t2 = b2.getOrAddThread("Thread2", 0);
 
@@ -496,10 +494,10 @@ public class DebuggerListingProviderTest extends AbstractGhidraHeadedDebuggerGUI
 		TraceThread thread;
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			DBTraceMemoryManager memory = tb.trace.getMemoryManager();
-			memory.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			memory.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 			TraceLocation from =
-				new DefaultTraceLocation(tb.trace, null, Range.atLeast(0L), tb.addr(0x00400000));
+				new DefaultTraceLocation(tb.trace, null, Lifespan.nowOn(0), tb.addr(0x00400000));
 			ProgramLocation to = new ProgramLocation(program, ss.getAddress(0x00600000));
 			DebuggerStaticMappingUtils.addMapping(from, to, 0x8000, false);
 
@@ -575,7 +573,7 @@ public class DebuggerListingProviderTest extends AbstractGhidraHeadedDebuggerGUI
 		TraceThread thread;
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			DBTraceMemoryManager memory = tb.trace.getMemoryManager();
-			memory.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			memory.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 			// To keep gray out of the color equation
 			memory.setState(0, tb.range(0x00401233, 0x00401235), TraceMemoryState.KNOWN);
@@ -609,10 +607,10 @@ public class DebuggerListingProviderTest extends AbstractGhidraHeadedDebuggerGUI
 		TraceThread thread;
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			DBTraceMemoryManager memory = tb.trace.getMemoryManager();
-			memory.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			memory.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 			TraceLocation from =
-				new DefaultTraceLocation(tb.trace, null, Range.atLeast(0L), tb.addr(0x00400000));
+				new DefaultTraceLocation(tb.trace, null, Lifespan.nowOn(0), tb.addr(0x00400000));
 			ProgramLocation to = new ProgramLocation(program, ss.getAddress(0x00600000));
 			DebuggerStaticMappingUtils.addMapping(from, to, 0x8000, false);
 
@@ -765,7 +763,7 @@ public class DebuggerListingProviderTest extends AbstractGhidraHeadedDebuggerGUI
 
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			DBTraceMemoryManager memory = tb.trace.getMemoryManager();
-			memory.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			memory.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 			memory.setState(0, tb.addr(0x00401234), TraceMemoryState.KNOWN);
 			memory.setState(0, tb.addr(0x00401235), TraceMemoryState.ERROR);
@@ -825,7 +823,7 @@ public class DebuggerListingProviderTest extends AbstractGhidraHeadedDebuggerGUI
 		TraceThread thread;
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			DBTraceMemoryManager mm = tb.trace.getMemoryManager();
-			mm.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			mm.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 			thread = tb.getOrAddThread("Thread 1", 0);
 			TraceMemorySpace regs = mm.getMemoryRegisterSpace(thread, true);
@@ -866,9 +864,9 @@ public class DebuggerListingProviderTest extends AbstractGhidraHeadedDebuggerGUI
 		TraceThread thread;
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			DBTraceMemoryManager mm = tb.trace.getMemoryManager();
-			mm.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			mm.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
-			mm.addRegion("[stack]", Range.atLeast(0L), tb.range(0x1f000000, 0x1fffffff),
+			mm.addRegion("[stack]", Lifespan.nowOn(0), tb.range(0x1f000000, 0x1fffffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.WRITE);
 			thread = tb.getOrAddThread("Thread 1", 0);
 			TraceMemorySpace regs = mm.getMemoryRegisterSpace(thread, true);
@@ -1013,7 +1011,7 @@ public class DebuggerListingProviderTest extends AbstractGhidraHeadedDebuggerGUI
 		TraceThread thread2;
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			DBTraceMemoryManager memory = tb.trace.getMemoryManager();
-			memory.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			memory.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 			thread1 = tb.getOrAddThread("Thread1", 0);
 			thread2 = tb.getOrAddThread("Thread2", 0);
@@ -1065,7 +1063,7 @@ public class DebuggerListingProviderTest extends AbstractGhidraHeadedDebuggerGUI
 		createAndOpenTrace();
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			tb.trace.getMemoryManager()
-					.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x55550000, 0x555500ff),
+					.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x55550000, 0x555500ff),
 						TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 		}
 		ProgramSelection sel = new ProgramSelection(tb.set(tb.range(0x55550040, 0x5555004f)));
@@ -1181,7 +1179,7 @@ public class DebuggerListingProviderTest extends AbstractGhidraHeadedDebuggerGUI
 		createAndOpenTrace();
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			tb.trace.getMemoryManager()
-					.addRegion("bash:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0041ffff),
+					.addRegion("bash:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0041ffff),
 						Set.of(TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE));
 
 			TraceModule bin = tb.trace.getModuleManager()
@@ -1212,7 +1210,7 @@ public class DebuggerListingProviderTest extends AbstractGhidraHeadedDebuggerGUI
 		createAndOpenTrace();
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			tb.trace.getMemoryManager()
-					.addRegion("bash:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0041ffff),
+					.addRegion("bash:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0041ffff),
 						Set.of(TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE));
 
 			tb.trace.getModuleManager()
@@ -1243,7 +1241,7 @@ public class DebuggerListingProviderTest extends AbstractGhidraHeadedDebuggerGUI
 
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			tb.trace.getMemoryManager()
-					.addRegion("test_region", Range.atLeast(0L), tb.range(0x55550000, 0x555502ff),
+					.addRegion("test_region", Lifespan.nowOn(0), tb.range(0x55550000, 0x555502ff),
 						TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 		}
 		waitForDomainObject(tb.trace);
@@ -1253,7 +1251,7 @@ public class DebuggerListingProviderTest extends AbstractGhidraHeadedDebuggerGUI
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			modExe = tb.trace.getModuleManager()
 					.addModule("modExe", "modExe", tb.range(0x55550000, 0x555501ff),
-						Range.atLeast(0L));
+						Lifespan.nowOn(0));
 		}
 		waitForDomainObject(tb.trace);
 		waitForPass(() -> assertEquals("modExe", listingProvider.locationLabel.getText()));
@@ -1319,7 +1317,7 @@ public class DebuggerListingProviderTest extends AbstractGhidraHeadedDebuggerGUI
 		TraceThread thread2;
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			DBTraceMemoryManager mm = tb.trace.getMemoryManager();
-			mm.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			mm.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 			thread1 = tb.getOrAddThread("Thread 1", 0);
 			thread2 = tb.getOrAddThread("Thread 2", 0);
@@ -1350,7 +1348,7 @@ public class DebuggerListingProviderTest extends AbstractGhidraHeadedDebuggerGUI
 		TraceThread thread;
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			DBTraceMemoryManager mm = tb.trace.getMemoryManager();
-			mm.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			mm.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 			thread = tb.getOrAddThread("Thread 1", 0);
 			TraceMemorySpace regs = mm.getMemoryRegisterSpace(thread, true);
@@ -1378,13 +1376,13 @@ public class DebuggerListingProviderTest extends AbstractGhidraHeadedDebuggerGUI
 		TraceThread thread;
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			DBTraceMemoryManager mm = tb.trace.getMemoryManager();
-			mm.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			mm.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 			thread = tb.getOrAddThread("Thread 1", 0);
 			DBTraceStackManager sm = tb.trace.getStackManager();
 			TraceStack stack = sm.getStack(thread, 0, true);
-			stack.getFrame(0, true).setProgramCounter(Range.all(), tb.addr(0x00401234));
-			stack.getFrame(1, true).setProgramCounter(Range.all(), tb.addr(0x00404321));
+			stack.getFrame(0, true).setProgramCounter(Lifespan.ALL, tb.addr(0x00401234));
+			stack.getFrame(1, true).setProgramCounter(Lifespan.ALL, tb.addr(0x00404321));
 		}
 		waitForDomainObject(tb.trace);
 		traceManager.activateThread(thread);
@@ -1408,7 +1406,7 @@ public class DebuggerListingProviderTest extends AbstractGhidraHeadedDebuggerGUI
 		Register pc = tb.language.getProgramCounter();
 		TraceThread thread;
 		try (UndoableTransaction tid = tb.startTransaction()) {
-			mm.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			mm.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 			thread = tb.getOrAddThread("Thread 1", 0);
 			TraceMemorySpace regs = mm.getMemoryRegisterSpace(thread, true);
@@ -1439,7 +1437,7 @@ public class DebuggerListingProviderTest extends AbstractGhidraHeadedDebuggerGUI
 		Register pc = tb.language.getProgramCounter();
 		TraceThread thread;
 		try (UndoableTransaction tid = tb.startTransaction()) {
-			mm.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			mm.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 			thread = tb.getOrAddThread("Thread 1", 0);
 			TraceMemorySpace regs = mm.getMemoryRegisterSpace(thread, true);
@@ -1474,11 +1472,11 @@ public class DebuggerListingProviderTest extends AbstractGhidraHeadedDebuggerGUI
 		TraceThread thread;
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			DBTraceMemoryManager mm = tb.trace.getMemoryManager();
-			mm.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			mm.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 			thread = tb.getOrAddThread("Thread 1", 0);
 			TraceStack stack = sm.getStack(thread, 0, true);
-			stack.getFrame(0, true).setProgramCounter(Range.all(), tb.addr(0x00401234));
+			stack.getFrame(0, true).setProgramCounter(Lifespan.ALL, tb.addr(0x00401234));
 		}
 		waitForDomainObject(tb.trace);
 		traceManager.activateThread(thread);
@@ -1488,7 +1486,7 @@ public class DebuggerListingProviderTest extends AbstractGhidraHeadedDebuggerGUI
 
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			TraceStack stack = sm.getStack(thread, 0, true);
-			stack.getFrame(0, true).setProgramCounter(Range.all(), tb.addr(0x00404321));
+			stack.getFrame(0, true).setProgramCounter(Lifespan.ALL, tb.addr(0x00404321));
 		}
 		waitForDomainObject(tb.trace);
 
@@ -1512,10 +1510,10 @@ public class DebuggerListingProviderTest extends AbstractGhidraHeadedDebuggerGUI
 		}
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			DBTraceMemoryManager memory = tb.trace.getMemoryManager();
-			memory.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			memory.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 			TraceLocation from =
-				new DefaultTraceLocation(tb.trace, null, Range.atLeast(0L), tb.addr(0x00400000));
+				new DefaultTraceLocation(tb.trace, null, Lifespan.nowOn(0), tb.addr(0x00400000));
 			ProgramLocation to = new ProgramLocation(program, ss.getAddress(0x00600000));
 			mappingService.addMapping(from, to, 0x8000, false);
 		}

Ghidra/Debug/Debugger/src/test/java/ghidra/app/plugin/core/debug/gui/memory/DebuggerMemoryBytesProviderTest.java

@@ -30,8 +30,6 @@ import java.util.Objects;
 import org.junit.*;
 import org.junit.experimental.categories.Category;
 
-import com.google.common.collect.Range;
-
 import docking.ActionContext;
 import docking.action.DockingActionIf;
 import docking.dnd.GClipboard;
@@ -63,6 +61,7 @@ import ghidra.program.util.ProgramSelection;
 import ghidra.trace.database.ToyDBTraceBuilder;
 import ghidra.trace.database.memory.DBTraceMemoryManager;
 import ghidra.trace.database.stack.DBTraceStackManager;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.Trace;
 import ghidra.trace.model.memory.*;
 import ghidra.trace.model.modules.TraceModule;
@@ -115,7 +114,7 @@ public class DebuggerMemoryBytesProviderTest extends AbstractGhidraHeadedDebugge
 		traceManager.activateTrace(tb.trace);
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			DBTraceMemoryManager memory = tb.trace.getMemoryManager();
-			memory.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			memory.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 		}
 		waitForDomainObject(tb.trace);
@@ -131,7 +130,7 @@ public class DebuggerMemoryBytesProviderTest extends AbstractGhidraHeadedDebugge
 		createAndOpenTrace();
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			DBTraceMemoryManager memory = tb.trace.getMemoryManager();
-			memory.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			memory.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 		}
 		waitForDomainObject(tb.trace);
@@ -147,7 +146,7 @@ public class DebuggerMemoryBytesProviderTest extends AbstractGhidraHeadedDebugge
 		createAndOpenTrace();
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			DBTraceMemoryManager memory = tb.trace.getMemoryManager();
-			memory.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			memory.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 			TraceThread thread = tb.getOrAddThread("Thread1", 0);
 			waitForDomainObject(tb.trace);
@@ -173,7 +172,7 @@ public class DebuggerMemoryBytesProviderTest extends AbstractGhidraHeadedDebugge
 		createAndOpenTrace();
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			DBTraceMemoryManager memory = tb.trace.getMemoryManager();
-			memory.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			memory.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 			TraceThread thread = tb.getOrAddThread("Thread1", 0);
 			waitForDomainObject(tb.trace);
@@ -207,7 +206,7 @@ public class DebuggerMemoryBytesProviderTest extends AbstractGhidraHeadedDebugge
 		TraceThread thread2;
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			DBTraceMemoryManager memory = tb.trace.getMemoryManager();
-			memory.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			memory.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 			thread1 = tb.getOrAddThread("Thread1", 0);
 			thread2 = tb.getOrAddThread("Thread2", 0);
@@ -253,7 +252,7 @@ public class DebuggerMemoryBytesProviderTest extends AbstractGhidraHeadedDebugge
 				.get();
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			DBTraceMemoryManager memory = tb.trace.getMemoryManager();
-			memory.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			memory.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 			thread1 = tb.getOrAddThread("Thread1", 0);
 			thread2 = tb.getOrAddThread("Thread2", 0);
@@ -289,9 +288,9 @@ public class DebuggerMemoryBytesProviderTest extends AbstractGhidraHeadedDebugge
 		createAndOpenTrace();
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			DBTraceMemoryManager memory = tb.trace.getMemoryManager();
-			memory.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			memory.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
-			memory.addRegion("[stack]", Range.atLeast(0L), tb.range(0x01000000, 0x01ffffff),
+			memory.addRegion("[stack]", Lifespan.nowOn(0), tb.range(0x01000000, 0x01ffffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.WRITE);
 			TraceThread thread = tb.getOrAddThread("Thread1", 0);
 			waitForDomainObject(tb.trace);
@@ -328,7 +327,7 @@ public class DebuggerMemoryBytesProviderTest extends AbstractGhidraHeadedDebugge
 			try (UndoableTransaction tid = b1.startTransaction()) {
 				b1.trace.getTimeManager().createSnapshot("First snap");
 				DBTraceMemoryManager memory = b1.trace.getMemoryManager();
-				memory.addRegion("exe:.text", Range.atLeast(0L), b1.range(0x00400000, 0x0040ffff),
+				memory.addRegion("exe:.text", Lifespan.nowOn(0), b1.range(0x00400000, 0x0040ffff),
 					TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 				t1 = b1.getOrAddThread("Thread1", 0);
 
@@ -340,7 +339,7 @@ public class DebuggerMemoryBytesProviderTest extends AbstractGhidraHeadedDebugge
 			try (UndoableTransaction tid = b2.startTransaction()) {
 				b2.trace.getTimeManager().createSnapshot("First snap");
 				DBTraceMemoryManager memory = b2.trace.getMemoryManager();
-				memory.addRegion("exe:.text", Range.atLeast(0L), b2.range(0x00400000, 0x0040ffff),
+				memory.addRegion("exe:.text", Lifespan.nowOn(0), b2.range(0x00400000, 0x0040ffff),
 					TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 				t2 = b2.getOrAddThread("Thread2", 0);
 
@@ -379,7 +378,7 @@ public class DebuggerMemoryBytesProviderTest extends AbstractGhidraHeadedDebugge
 			try (UndoableTransaction tid = b1.startTransaction()) {
 				b1.trace.getTimeManager().createSnapshot("First snap");
 				DBTraceMemoryManager memory = b1.trace.getMemoryManager();
-				memory.addRegion("exe:.text", Range.atLeast(0L), b1.range(0x00400000, 0x0040ffff),
+				memory.addRegion("exe:.text", Lifespan.nowOn(0), b1.range(0x00400000, 0x0040ffff),
 					TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 				t1 = b1.getOrAddThread("Thread1", 0);
 
@@ -391,7 +390,7 @@ public class DebuggerMemoryBytesProviderTest extends AbstractGhidraHeadedDebugge
 			try (UndoableTransaction tid = b2.startTransaction()) {
 				b2.trace.getTimeManager().createSnapshot("First snap");
 				DBTraceMemoryManager memory = b2.trace.getMemoryManager();
-				memory.addRegion("exe:.text", Range.atLeast(0L), b2.range(0x00400000, 0x0040ffff),
+				memory.addRegion("exe:.text", Lifespan.nowOn(0), b2.range(0x00400000, 0x0040ffff),
 					TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 				t2 = b2.getOrAddThread("Thread2", 0);
 
@@ -450,7 +449,7 @@ public class DebuggerMemoryBytesProviderTest extends AbstractGhidraHeadedDebugge
 		TraceThread thread;
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			DBTraceMemoryManager memory = tb.trace.getMemoryManager();
-			memory.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			memory.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 			// To keep gray out of the color equation
 			memory.setState(0, tb.range(0x00401233, 0x00401235), TraceMemoryState.KNOWN);
@@ -552,7 +551,7 @@ public class DebuggerMemoryBytesProviderTest extends AbstractGhidraHeadedDebugge
 
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			DBTraceMemoryManager memory = tb.trace.getMemoryManager();
-			memory.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			memory.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 			memory.setState(0, tb.addr(0x00401234), TraceMemoryState.KNOWN);
 			memory.setState(0, tb.addr(0x00401235), TraceMemoryState.ERROR);
@@ -615,7 +614,7 @@ public class DebuggerMemoryBytesProviderTest extends AbstractGhidraHeadedDebugge
 		TraceThread thread;
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			DBTraceMemoryManager mm = tb.trace.getMemoryManager();
-			mm.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			mm.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 			thread = tb.getOrAddThread("Thread 1", 0);
 			TraceMemorySpace regs = mm.getMemoryRegisterSpace(thread, true);
@@ -656,9 +655,9 @@ public class DebuggerMemoryBytesProviderTest extends AbstractGhidraHeadedDebugge
 		TraceThread thread;
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			DBTraceMemoryManager mm = tb.trace.getMemoryManager();
-			mm.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			mm.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
-			mm.addRegion("[stack]", Range.atLeast(0L), tb.range(0x1f000000, 0x1fffffff),
+			mm.addRegion("[stack]", Lifespan.nowOn(0), tb.range(0x1f000000, 0x1fffffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.WRITE);
 			thread = tb.getOrAddThread("Thread 1", 0);
 			TraceMemorySpace regs = mm.getMemoryRegisterSpace(thread, true);
@@ -709,7 +708,7 @@ public class DebuggerMemoryBytesProviderTest extends AbstractGhidraHeadedDebugge
 		TraceThread thread2;
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			DBTraceMemoryManager memory = tb.trace.getMemoryManager();
-			memory.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			memory.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 			thread1 = tb.getOrAddThread("Thread1", 0);
 			thread2 = tb.getOrAddThread("Thread2", 0);
@@ -762,7 +761,7 @@ public class DebuggerMemoryBytesProviderTest extends AbstractGhidraHeadedDebugge
 		createAndOpenTrace();
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			tb.trace.getMemoryManager()
-					.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x55550000, 0x555500ff),
+					.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x55550000, 0x555500ff),
 						TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 		}
 		ProgramSelection sel = new ProgramSelection(tb.set(tb.range(0x55550040, 0x5555004f)));
@@ -882,7 +881,7 @@ public class DebuggerMemoryBytesProviderTest extends AbstractGhidraHeadedDebugge
 
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			tb.trace.getMemoryManager()
-					.addRegion("test_region", Range.atLeast(0L), tb.range(0x55550000, 0x555502ff),
+					.addRegion("test_region", Lifespan.nowOn(0), tb.range(0x55550000, 0x555502ff),
 						TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 		}
 		waitForDomainObject(tb.trace);
@@ -894,7 +893,7 @@ public class DebuggerMemoryBytesProviderTest extends AbstractGhidraHeadedDebugge
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			modExe = tb.trace.getModuleManager()
 					.addModule("modExe", "modExe", tb.range(0x55550000, 0x555501ff),
-						Range.atLeast(0L));
+						Lifespan.nowOn(0));
 		}
 		waitForDomainObject(tb.trace);
 		waitForPass(() -> assertEquals("modExe", memBytesProvider.locationLabel.getText()));
@@ -917,7 +916,7 @@ public class DebuggerMemoryBytesProviderTest extends AbstractGhidraHeadedDebugge
 		TraceThread thread2;
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			DBTraceMemoryManager mm = tb.trace.getMemoryManager();
-			mm.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			mm.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 			thread1 = tb.getOrAddThread("Thread 1", 0);
 			thread2 = tb.getOrAddThread("Thread 2", 0);
@@ -948,7 +947,7 @@ public class DebuggerMemoryBytesProviderTest extends AbstractGhidraHeadedDebugge
 		TraceThread thread;
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			DBTraceMemoryManager mm = tb.trace.getMemoryManager();
-			mm.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			mm.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 			thread = tb.getOrAddThread("Thread 1", 0);
 			TraceMemorySpace regs = mm.getMemoryRegisterSpace(thread, true);
@@ -976,13 +975,13 @@ public class DebuggerMemoryBytesProviderTest extends AbstractGhidraHeadedDebugge
 		TraceThread thread;
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			DBTraceMemoryManager mm = tb.trace.getMemoryManager();
-			mm.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			mm.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 			thread = tb.getOrAddThread("Thread 1", 0);
 			DBTraceStackManager sm = tb.trace.getStackManager();
 			TraceStack stack = sm.getStack(thread, 0, true);
-			stack.getFrame(0, true).setProgramCounter(Range.all(), tb.addr(0x00401234));
-			stack.getFrame(1, true).setProgramCounter(Range.all(), tb.addr(0x00404321));
+			stack.getFrame(0, true).setProgramCounter(Lifespan.ALL, tb.addr(0x00401234));
+			stack.getFrame(1, true).setProgramCounter(Lifespan.ALL, tb.addr(0x00404321));
 		}
 		waitForDomainObject(tb.trace);
 		traceManager.activateThread(thread);
@@ -1006,7 +1005,7 @@ public class DebuggerMemoryBytesProviderTest extends AbstractGhidraHeadedDebugge
 		Register pc = tb.language.getProgramCounter();
 		TraceThread thread;
 		try (UndoableTransaction tid = tb.startTransaction()) {
-			mm.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			mm.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 			thread = tb.getOrAddThread("Thread 1", 0);
 			TraceMemorySpace regs = mm.getMemoryRegisterSpace(thread, true);
@@ -1037,7 +1036,7 @@ public class DebuggerMemoryBytesProviderTest extends AbstractGhidraHeadedDebugge
 		Register pc = tb.language.getProgramCounter();
 		TraceThread thread;
 		try (UndoableTransaction tid = tb.startTransaction()) {
-			mm.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			mm.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 			thread = tb.getOrAddThread("Thread 1", 0);
 			TraceMemorySpace regs = mm.getMemoryRegisterSpace(thread, true);
@@ -1072,11 +1071,11 @@ public class DebuggerMemoryBytesProviderTest extends AbstractGhidraHeadedDebugge
 		TraceThread thread;
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			DBTraceMemoryManager mm = tb.trace.getMemoryManager();
-			mm.addRegion("exe:.text", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			mm.addRegion("exe:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 			thread = tb.getOrAddThread("Thread 1", 0);
 			TraceStack stack = sm.getStack(thread, 0, true);
-			stack.getFrame(0, true).setProgramCounter(Range.all(), tb.addr(0x00401234));
+			stack.getFrame(0, true).setProgramCounter(Lifespan.ALL, tb.addr(0x00401234));
 		}
 		waitForDomainObject(tb.trace);
 		traceManager.activateThread(thread);
@@ -1086,7 +1085,7 @@ public class DebuggerMemoryBytesProviderTest extends AbstractGhidraHeadedDebugge
 
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			TraceStack stack = sm.getStack(thread, 0, true);
-			stack.getFrame(0, true).setProgramCounter(Range.all(), tb.addr(0x00404321));
+			stack.getFrame(0, true).setProgramCounter(Lifespan.ALL, tb.addr(0x00404321));
 		}
 		waitForDomainObject(tb.trace);
 

Ghidra/Debug/Debugger/src/test/java/ghidra/app/plugin/core/debug/gui/memory/DebuggerRegionsProviderTest.java

@@ -23,8 +23,6 @@ import org.junit.Before;
 import org.junit.Test;
 import org.junit.experimental.categories.Category;
 
-import com.google.common.collect.Range;
-
 import generic.Unique;
 import generic.test.category.NightlyCategory;
 import ghidra.app.plugin.core.debug.gui.AbstractGhidraHeadedDebuggerGUITest;
@@ -39,6 +37,7 @@ import ghidra.program.model.address.AddressSet;
 import ghidra.program.model.mem.Memory;
 import ghidra.program.model.mem.MemoryBlock;
 import ghidra.program.util.ProgramSelection;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.memory.*;
 import ghidra.trace.model.modules.TraceStaticMapping;
 import ghidra.util.database.UndoableTransaction;
@@ -107,7 +106,7 @@ public class DebuggerRegionsProviderTest extends AbstractGhidraHeadedDebuggerGUI
 		TraceMemoryRegion region;
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			TraceMemoryManager mm = tb.trace.getMemoryManager();
-			region = mm.addRegion("Memory[bin:.text]", Range.atLeast(0L),
+			region = mm.addRegion("Memory[bin:.text]", Lifespan.nowOn(0),
 				tb.range(0x00400000, 0x0040ffff), TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 		}
 
@@ -124,7 +123,7 @@ public class DebuggerRegionsProviderTest extends AbstractGhidraHeadedDebuggerGUI
 		assertEquals(0x10000, row.getLength());
 		assertEquals(0L, row.getCreatedSnap());
 		assertEquals("", row.getDestroyedSnap());
-		assertEquals(Range.atLeast(0L), row.getLifespan());
+		assertEquals(Lifespan.nowOn(0), row.getLifespan());
 	}
 
 	@Test
@@ -135,7 +134,7 @@ public class DebuggerRegionsProviderTest extends AbstractGhidraHeadedDebuggerGUI
 		TraceMemoryRegion region;
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			TraceMemoryManager mm = tb.trace.getMemoryManager();
-			region = mm.addRegion("Memory[bin:.text]", Range.atLeast(0L),
+			region = mm.addRegion("Memory[bin:.text]", Lifespan.nowOn(0),
 				tb.range(0x00400000, 0x0040ffff), TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 		}
 
@@ -152,7 +151,7 @@ public class DebuggerRegionsProviderTest extends AbstractGhidraHeadedDebuggerGUI
 		TraceMemoryRegion region;
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			TraceMemoryManager mm = tb.trace.getMemoryManager();
-			region = mm.addRegion("Memory[bin:.text]", Range.atLeast(0L),
+			region = mm.addRegion("Memory[bin:.text]", Lifespan.nowOn(0),
 				tb.range(0x00400000, 0x0040ffff), TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 		}
 
@@ -177,7 +176,7 @@ public class DebuggerRegionsProviderTest extends AbstractGhidraHeadedDebuggerGUI
 
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			TraceMemoryManager mm = tb.trace.getMemoryManager();
-			mm.addRegion("Memory[bin:.text]", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			mm.addRegion("Memory[bin:.text]", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 		}
 
@@ -200,7 +199,7 @@ public class DebuggerRegionsProviderTest extends AbstractGhidraHeadedDebuggerGUI
 
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			TraceMemoryManager mm = tb.trace.getMemoryManager();
-			mm.addRegion("Memory[bin:.text]", Range.atLeast(0L), tb.range(0x00400000, 0x0040ffff),
+			mm.addRegion("Memory[bin:.text]", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
 				TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 
 			waitForDomainObject(tb.trace);
@@ -221,7 +220,7 @@ public class DebuggerRegionsProviderTest extends AbstractGhidraHeadedDebuggerGUI
 		TraceMemoryRegion region;
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			TraceMemoryManager mm = tb.trace.getMemoryManager();
-			region = mm.addRegion("Memory[bin:.text]", Range.atLeast(0L),
+			region = mm.addRegion("Memory[bin:.text]", Lifespan.nowOn(0),
 				tb.range(0x00400000, 0x0040ffff), TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 		}
 
@@ -309,13 +308,13 @@ public class DebuggerRegionsProviderTest extends AbstractGhidraHeadedDebuggerGUI
 		TraceStaticMapping sm;
 
 		sm = mit.next();
-		assertEquals(Range.atLeast(0L), sm.getLifespan());
+		assertEquals(Lifespan.nowOn(0), sm.getLifespan());
 		assertEquals("ram:00400000", sm.getStaticAddress());
 		assertEquals(0x100, sm.getLength());
 		assertEquals(tb.addr(0x55550000), sm.getMinTraceAddress());
 
 		sm = mit.next();
-		assertEquals(Range.atLeast(0L), sm.getLifespan());
+		assertEquals(Lifespan.nowOn(0), sm.getLifespan());
 		assertEquals("ram:00600000", sm.getStaticAddress());
 		assertEquals(0x80, sm.getLength());
 		assertEquals(tb.addr(0x55750000), sm.getMinTraceAddress());
@@ -336,7 +335,7 @@ public class DebuggerRegionsProviderTest extends AbstractGhidraHeadedDebuggerGUI
 		TraceMemoryRegion region;
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			TraceMemoryManager mm = tb.trace.getMemoryManager();
-			region = mm.addRegion("Memory[bin:.text]", Range.atLeast(0L),
+			region = mm.addRegion("Memory[bin:.text]", Lifespan.nowOn(0),
 				tb.range(0x00400000, 0x0040ffff), TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 		}
 
@@ -368,7 +367,7 @@ public class DebuggerRegionsProviderTest extends AbstractGhidraHeadedDebuggerGUI
 		TraceMemoryRegion region;
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			TraceMemoryManager mm = tb.trace.getMemoryManager();
-			region = mm.addRegion("Memory[bin:.text]", Range.atLeast(0L),
+			region = mm.addRegion("Memory[bin:.text]", Lifespan.nowOn(0),
 				tb.range(0x00400000, 0x0040ffff), TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE);
 		}
 

Ghidra/Debug/Debugger/src/test/java/ghidra/app/plugin/core/debug/gui/model/DebuggerModelProviderTest.java

@@ -23,8 +23,6 @@ import java.util.Set;
 import org.jdom.JDOMException;
 import org.junit.*;
 
-import com.google.common.collect.Range;
-
 import docking.widgets.table.DynamicTableColumn;
 import docking.widgets.table.GDynamicColumnTableModel;
 import docking.widgets.tree.support.GTreeSelectionEvent.EventOrigin;
@@ -41,6 +39,7 @@ import ghidra.dbg.target.TargetObject;
 import ghidra.dbg.target.schema.SchemaContext;
 import ghidra.dbg.target.schema.TargetObjectSchema.SchemaName;
 import ghidra.dbg.target.schema.XmlSchemaContext;
+import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.target.*;
 import ghidra.trace.model.target.TraceObject.ConflictResolution;
 import ghidra.trace.model.thread.TraceObjectThread;
@@ -145,17 +144,17 @@ public class DebuggerModelProviderTest extends AbstractGhidraHeadedDebuggerGUITe
 		TraceObjectManager objects = tb.trace.getObjectManager();
 		TraceObjectKeyPath threadContainerPath = TraceObjectKeyPath.parse("Processes[0].Threads");
 		TraceObject thread = objects.createObject(threadContainerPath.index(i));
-		thread.insert(Range.closed(i, 10L), ConflictResolution.DENY);
-		thread.insert(Range.atLeast(10 + i), ConflictResolution.DENY);
-		thread.setAttribute(Range.atLeast(i), "Attribute " + i, "Some value");
-		thread.setAttribute(Range.atLeast(i), "_display", "Thread " + i);
-		thread.setAttribute(Range.atLeast(i), "_self", thread);
+		thread.insert(Lifespan.span(i, 10), ConflictResolution.DENY);
+		thread.insert(Lifespan.nowOn(10 + i), ConflictResolution.DENY);
+		thread.setAttribute(Lifespan.nowOn(i), "Attribute " + i, "Some value");
+		thread.setAttribute(Lifespan.nowOn(i), "_display", "Thread " + i);
+		thread.setAttribute(Lifespan.nowOn(i), "_self", thread);
 		if (prevThread != null) {
-			thread.setAttribute(Range.atLeast(i), "_prev", prevThread);
-			prevThread.setAttribute(Range.atLeast(i), "_next", thread);
+			thread.setAttribute(Lifespan.nowOn(i), "_prev", prevThread);
+			prevThread.setAttribute(Lifespan.nowOn(i), "_next", thread);
 		}
 		objects.getRootObject()
-				.setAttribute(Range.atLeast(i), TargetEventScope.EVENT_OBJECT_ATTRIBUTE_NAME,
+				.setAttribute(Lifespan.nowOn(i), TargetEventScope.EVENT_OBJECT_ATTRIBUTE_NAME,
 					thread);
 		return thread;
 	}
@@ -166,9 +165,9 @@ public class DebuggerModelProviderTest extends AbstractGhidraHeadedDebuggerGUITe
 			TraceObjectManager objects = tb.trace.getObjectManager();
 			TraceObject stack = objects.createObject(stackPath);
 			objects.createObject(stackPath.index(0))
-					.insert(thread.getLife().span(), ConflictResolution.TRUNCATE);
+					.insert(thread.getLife().bound(), ConflictResolution.TRUNCATE);
 			objects.createObject(stackPath.index(1))
-					.insert(thread.getLife().span(), ConflictResolution.TRUNCATE);
+					.insert(thread.getLife().bound(), ConflictResolution.TRUNCATE);
 			return stack;
 		}
 	}
@@ -196,9 +195,9 @@ public class DebuggerModelProviderTest extends AbstractGhidraHeadedDebuggerGUITe
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			TraceObject handleContainer =
 				objects.createObject(TraceObjectKeyPath.parse("Processes[0].Handles"));
-			handleContainer.insert(Range.atLeast(0L), ConflictResolution.DENY);
+			handleContainer.insert(Lifespan.nowOn(0), ConflictResolution.DENY);
 			for (int i = 0; i < 10; i++) {
-				handleContainer.setElement(Range.atLeast((long) -i), i,
+				handleContainer.setElement(Lifespan.nowOn(-i), i,
 					(i * 0xdeadbeef) % 0xbadc0de);
 			}
 		}
@@ -210,9 +209,9 @@ public class DebuggerModelProviderTest extends AbstractGhidraHeadedDebuggerGUITe
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			TraceObject linkContainer =
 				objects.createObject(TraceObjectKeyPath.parse("Processes[0].Links"));
-			linkContainer.insert(Range.atLeast(0L), ConflictResolution.DENY);
+			linkContainer.insert(Lifespan.nowOn(0), ConflictResolution.DENY);
 			for (int i = 0; i < 10; i++) {
-				linkContainer.setElement(Range.atLeast(0L), i,
+				linkContainer.setElement(Lifespan.nowOn(0), i,
 					objects.getObjectByCanonicalPath(threadContainerPath.index(9 - i)));
 			}
 		}
@@ -223,9 +222,9 @@ public class DebuggerModelProviderTest extends AbstractGhidraHeadedDebuggerGUITe
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			TraceObject boxed =
 				objects.createObject(TraceObjectKeyPath.parse("Processes[0].Boxed"));
-			boxed.insert(Range.atLeast(0L), ConflictResolution.DENY);
-			boxed.setAttribute(Range.atLeast(2L), TargetObject.DISPLAY_ATTRIBUTE_NAME, "2");
-			boxed.setAttribute(Range.atLeast(4L), TargetObject.DISPLAY_ATTRIBUTE_NAME, "4");
+			boxed.insert(Lifespan.nowOn(0), ConflictResolution.DENY);
+			boxed.setAttribute(Lifespan.nowOn(2), TargetObject.DISPLAY_ATTRIBUTE_NAME, "2");
+			boxed.setAttribute(Lifespan.nowOn(4), TargetObject.DISPLAY_ATTRIBUTE_NAME, "4");
 		}
 	}
 
@@ -656,7 +655,7 @@ public class DebuggerModelProviderTest extends AbstractGhidraHeadedDebuggerGUITe
 
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			TraceObject thread = tb.trace.getObjectManager().getObjectByCanonicalPath(path);
-			thread.setAttribute(Range.atLeast(0L), "NewAttribute", 11);
+			thread.setAttribute(Lifespan.nowOn(0), "NewAttribute", 11);
 		}
 		waitForTasks();
 
@@ -677,7 +676,7 @@ public class DebuggerModelProviderTest extends AbstractGhidraHeadedDebuggerGUITe
 
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			TraceObject threads = tb.trace.getObjectManager().getObjectByCanonicalPath(path);
-			threads.setElement(Range.all(), 2, null);
+			threads.setElement(Lifespan.ALL, 2, null);
 		}
 		waitForTasks();
 
@@ -698,7 +697,7 @@ public class DebuggerModelProviderTest extends AbstractGhidraHeadedDebuggerGUITe
 
 		try (UndoableTransaction tid = tb.startTransaction()) {
 			TraceObject thread = tb.trace.getObjectManager().getObjectByCanonicalPath(path);
-			thread.setAttribute(Range.all(), "_self", null);
+			thread.setAttribute(Lifespan.ALL, "_self", null);
 		}
 		waitForTasks();
 
@@ -722,14 +721,14 @@ public class DebuggerModelProviderTest extends AbstractGhidraHeadedDebuggerGUITe
 		assertPathIs(path, 3, 0);
 
 		try (UndoableTransaction tid = tb.startTransaction()) {
-			element2.setLifespan(Range.atLeast(10L), ConflictResolution.DENY);
+			element2.setLifespan(Lifespan.nowOn(10), ConflictResolution.DENY);
 		}
 		waitForTasks();
 
 		assertPathIs(path, 2, 0);
 
 		try (UndoableTransaction tid = tb.startTransaction()) {
-			element2.setLifespan(Range.atLeast(2L), ConflictResolution.DENY);
+			element2.setLifespan(Lifespan.nowOn(2), ConflictResolution.DENY);
 		}
 		waitForTasks();
 
@@ -754,14 +753,14 @@ public class DebuggerModelProviderTest extends AbstractGhidraHeadedDebuggerGUITe
 		assertPathIs(path, 0, 4); // _next created at snap 3
 
 		try (UndoableTransaction tid = tb.startTransaction()) {
-			attrSelf.setLifespan(Range.atLeast(10L), ConflictResolution.DENY);
+			attrSelf.setLifespan(Lifespan.nowOn(10), ConflictResolution.DENY);
 		}
 		waitForTasks();
 
 		assertPathIs(path, 0, 3);
 
 		try (UndoableTransaction tid = tb.startTransaction()) {
-			attrSelf.setLifespan(Range.atLeast(2L), ConflictResolution.DENY);
+			attrSelf.setLifespan(Lifespan.nowOn(2), ConflictResolution.DENY);
 		}
 		waitForTasks();
 
@@ -784,7 +783,7 @@ public class DebuggerModelProviderTest extends AbstractGhidraHeadedDebuggerGUITe
 		assertEquals("<html>[2]", node.getDisplayText());
 
 		try (UndoableTransaction tid = tb.startTransaction()) {
-			thread.setAttribute(Range.atLeast(0L), "_display", "Renamed Thread");
+			thread.setAttribute(Lifespan.nowOn(0), "_display", "Renamed Thread");
 		}
 		waitForTasks();