Ghidra is a software reverse engineering (SRE) framework
GP-6382: Add the Tenet loader
ghidra_red441442bf94c5
diff --git a/Ghidra/Debug/Debugger-importers/Module.manifest b/Ghidra/Debug/Debugger-importers/Module.manifestnew file mode 100644index 0000000000..e69de29bb2diff --git a/Ghidra/Debug/Debugger-importers/README.md b/Ghidra/Debug/Debugger-importers/README.mdnew file mode 100644index 0000000000..9826cb3fdb--- /dev/null+++ b/Ghidra/Debug/Debugger-importers/README.md@@ -0,0 +1 @@+# Debugger-importersdiff --git a/Ghidra/Debug/Debugger-importers/build.gradle b/Ghidra/Debug/Debugger-importers/build.gradlenew file mode 100644index 0000000000..f26b4dfdbe--- /dev/null+++ b/Ghidra/Debug/Debugger-importers/build.gradle@@ -0,0 +1,37 @@+/* ###+ * 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.+ */++apply from: "${rootProject.projectDir}/gradle/javaProject.gradle"+apply from: "${rootProject.projectDir}/gradle/helpProject.gradle"+apply from: "${rootProject.projectDir}/gradle/jacocoProject.gradle"+apply from: "${rootProject.projectDir}/gradle/javaTestProject.gradle"+apply from: "${rootProject.projectDir}/gradle/distributableGhidraModule.gradle"+apply from: "${rootProject.projectDir}/gradle/javadoc.gradle"++apply plugin: 'eclipse'+eclipse.project.name = 'Debug Debugger-importers'++dependencies {+ api project(':ProposedUtils')+ api project(':Pty')+ api project(':Debugger')+ api project(':Debugger-api')++ testImplementation project(path: ':Generic', configuration: 'testArtifacts')+ testImplementation project(path: ':Debugger', configuration: 'testArtifacts')+ testImplementation project(path: ':Framework-TraceModeling', configuration: 'testArtifacts')+}+diff --git a/Ghidra/Debug/Debugger-importers/certification.manifest b/Ghidra/Debug/Debugger-importers/certification.manifestnew file mode 100644index 0000000000..6841c5219a--- /dev/null+++ b/Ghidra/Debug/Debugger-importers/certification.manifest@@ -0,0 +1,3 @@+##VERSION: 2.0+Module.manifest||GHIDRA||||END|+README.md||GHIDRA||||END|diff --git a/Ghidra/Debug/Debugger-importers/src/main/java/ghidra/app/util/opinion/TenetLoader.java b/Ghidra/Debug/Debugger-importers/src/main/java/ghidra/app/util/opinion/TenetLoader.javanew file mode 100644index 0000000000..d2b434c916--- /dev/null+++ b/Ghidra/Debug/Debugger-importers/src/main/java/ghidra/app/util/opinion/TenetLoader.java@@ -0,0 +1,526 @@+/* ###+ * 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 ghidra.app.util.opinion;++import java.io.*;+import java.math.BigInteger;+import java.net.URL;+import java.nio.ByteBuffer;+import java.nio.charset.StandardCharsets;+import java.util.*;+import java.util.regex.Matcher;+import java.util.regex.Pattern;++import org.jdom2.JDOMException;++import db.Transaction;+import ghidra.app.util.Option;+import ghidra.app.util.bin.ByteProvider;+import ghidra.app.util.importer.DomainFileOption;+import ghidra.app.util.importer.MessageLog;+import ghidra.framework.model.DomainFile;+import ghidra.framework.model.DomainObject;+import ghidra.program.database.ProgramContentHandler;+import ghidra.program.model.address.*;+import ghidra.program.model.lang.*;+import ghidra.program.model.listing.Program;+import ghidra.program.model.symbol.RefType;+import ghidra.program.model.symbol.SourceType;+import ghidra.program.util.AddressEvaluator;+import ghidra.trace.database.DBTrace;+import ghidra.trace.database.target.DBTraceObjectManager;+import ghidra.trace.model.Lifespan;+import ghidra.trace.model.Trace;+import ghidra.trace.model.memory.TraceMemoryFlag;+import ghidra.trace.model.memory.TraceOverlappedRegionException;+import ghidra.trace.model.modules.TraceModuleManager;+import ghidra.trace.model.modules.TraceStaticMappingManager;+import ghidra.trace.model.stack.TraceStackFrame;+import ghidra.trace.model.target.TraceObject;+import ghidra.trace.model.target.TraceObject.ConflictResolution;+import ghidra.trace.model.target.TraceObjectManager;+import ghidra.trace.model.target.path.KeyPath;+import ghidra.trace.model.target.schema.*;+import ghidra.trace.model.target.schema.TraceObjectSchema.SchemaName;+import ghidra.trace.model.thread.TraceThread;+import ghidra.trace.model.time.TraceSnapshot;+import ghidra.util.Msg;+import ghidra.util.NumericUtilities;+import ghidra.util.exception.*;+import ghidra.util.task.TaskMonitor;++public class TenetLoader implements Loader {+ private static final String TRACE_SUFFIX = ".trace";+ private static final String TENET_SUFFIX = ".tenet";+ private static final Set<String> SUFFIXES = Set.of(TRACE_SUFFIX, TENET_SUFFIX);++ private static final Pattern SLIDE_PATTERN = Pattern.compile("slide=0x([0-9a-fA-F]+)");+ private static final Pattern MEM_PATTERN =+ Pattern.compile("(?:^|,)(mr|mw)=0x([^:]+):([0-9a-fA-F]+)");+ private static final Pattern REG_PATTERN =+ Pattern.compile("(?:^|,)(?!(?:mr|mw|slide)=)([a-zA-Z0-9]+)=0x([0-9a-fA-F]+)");++ static final int ERROR_THRESHOLD = 10;++ static final String DOMAIN_FILE_OPTION_NAME = "Program to associate trace file with";+ private static final String TENET_CTX_XML = """+ <context>+ <schema name='TenetSession' canonical='yes'>+ <interface name='Aggregate'/>+ <interface name='Process'/>+ <attribute name='Thread' schema='Thread'/>+ <attribute name='Memory' schema='Memory'/>+ <attribute name='Breakpoints' schema='BreakpointContainer'/>+ <attribute name='Modules' schema='ModuleContainer'/>+ </schema>+ <schema name='Thread'>+ <interface name='Aggregate'/>+ <interface name='Thread'/>+ <interface name='ExecutionStateful'/>+ <attribute name='Stack' schema='Stack'/>+ </schema>+ <schema name='Stack' canonical='yes'>+ <interface name='Stack'/>+ <interface name='Aggregate'/>+ <element schema='Frame'/>+ </schema>+ <schema name='Frame'>+ <interface name='Aggregate'/>+ <interface name='StackFrame'/>+ <attribute name='Registers' schema='RegisterContainer'/>+ </schema>+ <schema name='RegisterContainer'>+ <interface name='RegisterContainer'/>+ <element schema='Register'/>+ </schema>+ <schema name='Register'>+ <interface name='Register'/>+ </schema>+ <schema name='Memory' canonical='yes'>+ <interface name='Memory'/>+ <element schema='MemoryRegion'/>+ </schema>+ <schema name='MemoryRegion'>+ <interface name='MemoryRegion'/>+ </schema>+ <schema name='ModuleContainer' canonical='yes'>+ <element schema='Module'/>+ </schema>+ <schema name='Module'>+ <interface name='Module'/>+ <attribute name='Sections' schema='SectionContainer'/>+ </schema>+ <schema name='SectionContainer' canonical='yes'>+ <element schema='Section'/>+ </schema>+ <schema name='Section'>+ <interface name='Section'/>+ </schema>+ <schema name='BreakpointContainer' canonical='yes'>+ <element schema='Breakpoint'/>+ </schema>+ <schema name='Breakpoint'>+ <interface name='BreakpointSpec'/>+ <interface name='BreakpointLocation'/>+ </schema>+ </context>+ """;+ private static final SchemaContext SAMPLE_CTX;++ private static final TraceObjectSchema TENET_SESSION_SCHEMA;+ static {+ try {+ SAMPLE_CTX = XmlSchemaContext.deserialize(TENET_CTX_XML);+ }+ catch (final JDOMException e) {+ throw new AssertionError(e);+ }+ TENET_SESSION_SCHEMA = SAMPLE_CTX.getSchema(new SchemaName("TenetSession"));+ }++ private static AddressSpace defaultSpace;+ private static Program program;++ private static boolean STORE_REG_ATTRS = false;++ /**+ * Create an address in the processor's default space.+ *+ * @param offset the byte offset+ * @return the address+ */+ private static Address addr(final long offset) {+ return defaultSpace.getAddress(offset);+ }++ private static boolean isTenetFile(final ByteProvider provider) {+ final String nameLower = provider.getName().toLowerCase();++ if (!SUFFIXES.stream().anyMatch(nameLower::endsWith)) {+ return false;+ }++ return true;+ }++ /**+ * Create an address range in the processor's default space.+ *+ * @param min the minimum byte offset+ * @param max the maximum (inclusive) byte offset+ * @return the range+ */+ private static AddressRange rng(final long min, final long max) {+ return new AddressRangeImpl(addr(min), addr(max));+ }++ private static Address toAddr(final String addressString) {+ return AddressEvaluator.evaluate(program, addressString);+ }++ @Override+ public Collection<LoadSpec> findSupportedLoadSpecs(final ByteProvider provider)+ throws IOException {+ final List<LoadSpec> loadSpecs = new ArrayList<>();+ if (isTenetFile(provider)) {+ // TODO: This LanguageCompilerSpecPair is not used by the loader+ // just putting a dummy value in so the user doesn't have to+ loadSpecs.add(new LoadSpec(this, 0,+ new LanguageCompilerSpecPair("DATA:LE:64:default", "pointer64"), true));+ }+ return loadSpecs;+ }++ @Override+ public List<Option> getDefaultOptions(final ByteProvider provider, final LoadSpec loadSpec,+ final DomainObject domainObject, final boolean loadIntoProgram,+ final boolean mirrorFsLayout) {+ final List<Option> list = new ArrayList<>();+ list.add(new DomainFileOption(DOMAIN_FILE_OPTION_NAME, "", false));+ return list;+ }++ @Override+ public String getName() {+ return "Tenet Trace Format";+ }++ @Override+ public LoaderTier getTier() {+ return LoaderTier.GENERIC_TARGET_LOADER;+ }++ @Override+ public int getTierPriority() {+ return 0;+ }++ @Override+ public LoadResults<? extends DomainObject> load(final ImporterSettings settings)+ throws IOException, CancelledException, VersionException, LoadException {+ Trace trace;+ String programPath = null;++ for (final Option option : settings.options()) {+ final String name = option.getName();+ if (name.equals(DOMAIN_FILE_OPTION_NAME)) {+ programPath = (String) option.getValue();+ }+ }++ if ((programPath == null) || programPath.isBlank()) {+ throw new LoadException("No progam to associate with trace was given");+ }++ Msg.info(this, "Loading trace for %s".formatted(programPath));++ final DomainFile df = settings.project().getProjectData().getFile(programPath);+ if (!df.getContentType().equals(ProgramContentHandler.PROGRAM_CONTENT_TYPE)) {+ throw new LoadException("Selected file is not a program");+ }+ Program program = null;++ try {+ program = (Program) df.getDomainObject(this, false, false, settings.monitor());++ final long start = System.currentTimeMillis();++ trace = this.loadTrace(settings.provider(), settings.importName(), program,+ settings.consumer(), settings.log(), settings.monitor());++ final long loadDone = System.currentTimeMillis();++ // TODO: This is needed because+ // ghidra.trace.database.DBTraceContentHandler.createFile can't do+ // it, due to a lock in+ // ghidra.framework.data.GhidraFolderData.createFile+ final DBTraceObjectManager objManager = (DBTraceObjectManager) trace.getObjectManager();+ objManager.flushWbCaches();++ final long flushDone = System.currentTimeMillis();++ settings.log()+ .appendMsg("%d ms to load trace | %d ms to flush cache | %d ms total time"+ .formatted(loadDone - start, flushDone - loadDone, flushDone - start));++ return new LoadResults<>(new Loaded<>(trace, settings));+ }+ catch (final CancelledException e) {+ throw e;+ }+ finally {+ if (program != null) {+ program.release(this);+ }+ }+ }++ @Override+ public void loadInto(final Program program, final ImporterSettings settings)+ throws IOException, LoadException, CancelledException {+ throw new LoadException("Cannot add Trace to a program");+ }++ private Trace loadTrace(final ByteProvider provider, final String name, final Program program,+ final Object consumer, final MessageLog log, final TaskMonitor monitor)+ throws LanguageNotFoundException, IOException, CancelledException {++ TenetLoader.program = program;+ final Language lang = program.getLanguage();+ TenetLoader.defaultSpace = lang.getAddressFactory().getDefaultAddressSpace();++ final Trace trace = new DBTrace(name, program.getCompilerSpec(), consumer);++ try (Transaction tx = trace.openTransaction("Import Tenet Trace: %s".formatted(name))) {+ final TraceObjectManager om = trace.getObjectManager();+ om.createRootObject(TENET_SESSION_SCHEMA);++ final TraceThread traceThread =+ trace.getThreadManager().createThread("Thread", "Thread", 0);++ trace.getObjectManager()+ .createObject(KeyPath.parse("Breakpoints"))+ .insert(Lifespan.ALL, ConflictResolution.DENY);++ final Pattern ipPattern = Pattern.compile(+ "(?:^|,)%s=0x([0-9a-fA-F]+)".formatted(lang.getProgramCounter().getName()),+ Pattern.CASE_INSENSITIVE);++ final BufferedReader lineCounter = new BufferedReader(+ new InputStreamReader(provider.getInputStream(0), StandardCharsets.UTF_8));+ final long numLines = lineCounter.lines().count();+ lineCounter.close();+ monitor.setMaximum(numLines);++ try (BufferedReader reader = new BufferedReader(+ new InputStreamReader(provider.getInputStream(0), StandardCharsets.UTF_8))) {+ String line = reader.readLine();+ long slideValue = 0;+ long curIp = 0;+ final Matcher slideMatcher = SLIDE_PATTERN.matcher(line);+ int lineNumber = 1;+ int errorCount = 0;+ int snapNumber = 0;++ if (slideMatcher.find()) {+ slideValue = Long.parseLong(slideMatcher.group(1), 16);+ lineNumber++;+ line = reader.readLine();+ }++ final TraceSnapshot snapshot =+ trace.getTimeManager().createSnapshot("Snapshot %d".formatted(snapNumber));+ long snap = snapshot.getKey();++ snapNumber++;++ this.setupMemoryAndMapping(program, trace, slideValue, snap);++ try {+ while (line != null) {+ monitor.checkCancelled();++ if (errorCount >= ERROR_THRESHOLD) {+ throw new LoadException("Encountered too many errors with this trace");+ }++ final Matcher ipMatcher = ipPattern.matcher(line);+ if (!ipMatcher.find()) {+ log.appendMsg(+ "Line %d: Unable to find PC, skipping...".formatted(lineNumber));+ errorCount++;+ lineNumber++;+ monitor.setProgress(lineNumber);++ line = reader.readLine();+ if (line != null) {+ snap = trace.getTimeManager()+ .createSnapshot("Snapshot %d".formatted(snapNumber))+ .getKey();+ snapNumber++;+ }+ continue;+ }+ curIp = Long.parseLong(ipMatcher.group(1), 16);++ if (!this.parseRegisterOperations(snap, curIp, line, lineNumber,+ traceThread, trace, log, monitor)) {+ errorCount++;+ lineNumber++;+ monitor.setProgress(lineNumber);++ line = reader.readLine();+ if (line != null) {+ snap = trace.getTimeManager()+ .createSnapshot("Snapshot %d".formatted(snapNumber))+ .getKey();+ snapNumber++;+ }+ continue;+ }+ this.parseMemoryOperations(snap, curIp, line, trace, monitor);++ lineNumber++;+ monitor.setProgress(lineNumber);++ line = reader.readLine();+ if (line != null) {+ snap = trace.getTimeManager()+ .createSnapshot("Snapshot %d".formatted(snapNumber))+ .getKey();+ snapNumber++;++ }+ }+ }+ catch (final CancelledException e) {+ throw e;+ }+ catch (final Exception e) {+ throw new LoadException(e);+ }+ }+ }+ catch (TraceOverlappedRegionException | DuplicateNameException e) {+ // This should not happen+ throw new AssertionError(e);+ }+ return trace;+ }++ private void parseMemoryOperations(final long snap, final long curIp, final String line,+ final Trace trace, final TaskMonitor monitor) throws Exception {++ final Matcher memMatcher = MEM_PATTERN.matcher(line);++ // TODO Speed this up+ while (memMatcher.find()) {+ monitor.checkCancelled();+ final RefType refType = memMatcher.group(1).equals("mr") ? RefType.READ : RefType.WRITE;+ final Address address = toAddr(memMatcher.group(2));+ final byte[] bytes = NumericUtilities.convertStringToBytes(memMatcher.group(3));++ trace.getReferenceManager()+ .addMemoryReference(Lifespan.at(snap), addr(curIp),+ new AddressRangeImpl(address, bytes.length), refType, SourceType.IMPORTED,+ -1);+ trace.getMemoryManager().putBytes(snap, address, ByteBuffer.wrap(bytes));+ }+ }++ private boolean parseRegisterOperations(final long snap, final long curIp, final String line,+ final int lineNumber, final TraceThread traceThread, final Trace trace,+ final MessageLog log, final TaskMonitor monitor) throws Exception {+ final TraceStackFrame frame =+ trace.getStackManager().getStack(traceThread, snap, true).getFrame(snap, 0, true);+ frame.setProgramCounter(Lifespan.nowOn(snap), addr(curIp));++ final KeyPath traceRegistersPath = frame.getObject().getCanonicalPath().extend("Registers");+ final TraceObject traceRegisters =+ trace.getObjectManager().createObject(traceRegistersPath);+ traceRegisters.insert(Lifespan.ALL, ConflictResolution.DENY);++ final Matcher regMatcher = REG_PATTERN.matcher(line);+ while (regMatcher.find()) {+ monitor.checkCancelled();++ final BigInteger val = new BigInteger(regMatcher.group(2), 16);+ final Register regObj = trace.getProgramView().getRegister(regMatcher.group(1));+ if (regObj == null) {+ log.appendMsg("Line %d: Register %s not found in program language!"+ .formatted(lineNumber, regMatcher.group(1)));+ return false;+ }++ if (STORE_REG_ATTRS) {+ traceRegisters.setElement(Lifespan.nowOn(snap), regObj.getName(), val.longValue());+ }+ trace.getMemoryManager()+ .getMemoryRegisterSpace(frame, true)+ .setValue(snap, new RegisterValue(regObj, val));+ }+ return true;+ }++ private void setupMemoryAndMapping(final Program program, final Trace trace, final long slideValue,+ final long snap) throws DuplicateNameException, TraceOverlappedRegionException {+ final TraceModuleManager modMan = trace.getModuleManager();+ final TraceStaticMappingManager mapMan = trace.getStaticMappingManager();+ final URL projectUrl = program.getDomainFile().getLocalProjectURL("");++ if (slideValue != 0) {+ Msg.info(this, "Adding slide %x".formatted(slideValue));+ mapMan.add(rng(slideValue, slideValue + program.getMemory().getSize()),+ Lifespan.nowOn(snap), projectUrl, "ram:%s".formatted(program.getImageBase()));+ modMan.addLoadedModule("Modules[%s]".formatted(program.getName()),+ program.getExecutablePath(),+ rng(slideValue, slideValue + program.getMemory().getSize()), snap);+ }+ else {+ mapMan.add(+ rng(program.getImageBase().getUnsignedOffset(),+ program.getImageBase().add(program.getMemory().getSize()).getUnsignedOffset()),+ Lifespan.nowOn(snap), projectUrl, "ram:%s".formatted(program.getImageBase()));+ modMan.addLoadedModule("Modules[%s]".formatted(program.getName()),+ program.getExecutablePath(),+ rng(program.getImageBase().getUnsignedOffset(), program.getMemory().getSize()),+ snap);+ }++ // Add one giant memory region+ // TODO: Maybe make this more accurate in the future through+ // some analysis?+ trace.getMemoryManager()+ .addRegion("Memory[ALL]", Lifespan.nowOn(0), rng(0x0, 0xFFFF_FFFF_FFFF_FFFFL),+ TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE, TraceMemoryFlag.WRITE);+ }++ @Override+ public String validateOptions(final ByteProvider provider, final LoadSpec loadSpec,+ final List<Option> options, final Program program) {+ if (options != null) {+ for (final Option option : options) {+ final String name = option.getName();+ if (name.equals(DOMAIN_FILE_OPTION_NAME) &&+ !String.class.isAssignableFrom(option.getValueClass())) {+ return "Invalid type for option: " + name + " - " + option.getValueClass();+ }+ }+ }+ return null;+ }++}diff --git a/Ghidra/Debug/Debugger-importers/src/test/java/ghidra/app/util/opinion/TenetLoaderTest.java b/Ghidra/Debug/Debugger-importers/src/test/java/ghidra/app/util/opinion/TenetLoaderTest.javanew file mode 100644index 0000000000..1b79cac9ab--- /dev/null+++ b/Ghidra/Debug/Debugger-importers/src/test/java/ghidra/app/util/opinion/TenetLoaderTest.java@@ -0,0 +1,293 @@+/* ###+ * 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 ghidra.app.util.opinion;++import static org.junit.Assert.*;++import java.nio.ByteBuffer;+import java.util.List;++import org.junit.Ignore;+import org.junit.Test;++import generic.Unique;+import ghidra.app.plugin.core.debug.gui.AbstractGhidraHeadedDebuggerTest;+import ghidra.app.plugin.core.debug.gui.listing.DebuggerListingPlugin;+import ghidra.app.plugin.core.debug.gui.model.DebuggerModelPlugin;+import ghidra.app.plugin.core.debug.gui.register.DebuggerRegistersPlugin;+import ghidra.app.plugin.core.debug.gui.thread.DebuggerThreadsPlugin;+import ghidra.app.plugin.core.debug.gui.time.DebuggerTimePlugin;+import ghidra.app.util.Option;+import ghidra.app.util.bin.ByteArrayProvider;+import ghidra.app.util.bin.ByteProvider;+import ghidra.app.util.importer.MessageLog;+import ghidra.app.util.opinion.Loader.ImporterSettings;+import ghidra.framework.model.DomainObject;+import ghidra.program.model.address.AddressSpace;+import ghidra.trace.model.Trace;+import ghidra.trace.model.memory.TraceMemorySpace;+import ghidra.trace.model.modules.TraceStaticMapping;+import ghidra.trace.model.thread.TraceThread;++public class TenetLoaderTest extends AbstractGhidraHeadedDebuggerTest {++ /**+ * Create a byte array+ *+ * <p>+ * This is basically syntactic sugar, since expressing a byte array literal can get obtuse in+ * Java. {@code new byte[] {0, 1, 2, (byte) 0x80, (byte) 0xff}} vs+ * {@code arr(0, 1, 2, 0x80, 0xff)}.+ *+ * @param e the bytes' values+ * @return the array+ */+ private byte[] arr(final int... e) {+ final byte[] result = new byte[e.length];+ for (int i = 0; i < e.length; i++) {+ result[i] = (byte) e[i];+ }+ return result;+ }++ private Trace createTraceWithLoader(final String testFile) throws Exception {+ this.createProgram();+ this.intoProject(this.program);++ final TenetLoader loader = new TenetLoader();+ final ByteProvider provider =+ new ByteArrayProvider("test.tenet", testFile.getBytes("utf8"));+ final LoadSpec loadSpec = Unique.assertOne(loader.findSupportedLoadSpecs(provider));++ final List<Option> options =+ loader.getDefaultOptions(provider, loadSpec, null, false, false);+ final Option programOption = Unique.assertOne(+ options.stream().filter(o -> o.getName().equals(TenetLoader.DOMAIN_FILE_OPTION_NAME)));+ programOption.setValue(this.program.getDomainFile().getPathname());++ final MessageLog log = new MessageLog();+ final ImporterSettings settings = new ImporterSettings(provider, "test",+ this.env.getProject(), "/", false, loadSpec, options, this, log, this.monitor);++ final LoadResults<? extends DomainObject> results = loader.load(settings);+ if (!(results.getPrimary().domainObject instanceof final Trace trace)) {+ fail("Import result was not a trace");+ return null;+ }++ return trace;++ }++ /*+ * Test that the loader continues on a bad register name+ */+ @Test+ public void testBadRegisterNames() throws Exception {+ final String testFile = """+ pc=0x1,rax=0x1234+ """;+ final Trace trace = this.createTraceWithLoader(testFile);+ assertNotNull(trace);+ }++ /*+ * Test the filename check for the loader+ */+ @Test+ public void testFileName() throws Exception {+ final String testFile = """+ slide=0x0+ pc=0x1,r0=0x1234+ pc=0x2,r1=0x4321+ """;++ this.createProgram();+ this.intoProject(this.program);++ final TenetLoader loader = new TenetLoader();++ ByteProvider provider = new ByteArrayProvider("test.tenet", testFile.getBytes("utf8"));+ Unique.assertOne(loader.findSupportedLoadSpecs(provider));++ provider = new ByteArrayProvider("test.trace", testFile.getBytes("utf8"));+ Unique.assertOne(loader.findSupportedLoadSpecs(provider));++ provider = new ByteArrayProvider("test.anythingelse", testFile.getBytes("utf8"));+ assertEquals(0, loader.findSupportedLoadSpecs(provider).size());+ }++ /*+ * Automate loading a trace for manual testing purposes+ */+ @Ignore+ public void testManual() throws Exception {+ final String testFile = """+ slide=0x0+ pc=0x1,r0=0x1234+ pc=0x2,r1=0x4321+ """;++ addPlugin(this.tool, DebuggerRegistersPlugin.class);+ addPlugin(this.tool, DebuggerModelPlugin.class);+ addPlugin(this.tool, DebuggerThreadsPlugin.class);+ addPlugin(this.tool, DebuggerListingPlugin.class);+ addPlugin(this.tool, DebuggerTimePlugin.class);++ final Trace trace = this.createTraceWithLoader(testFile);++ this.traceManager.openTrace(trace);+ this.traceManager.activateTrace(trace);++ Thread.sleep(1000);+ }++ /*+ * Test that the loader after more than {@link TenetLoader.ERROR_THRESHOLD}+ * lines with bad register names+ */+ @Test+ public void testManyLinesBadRegisterNames() throws Exception {+ // Should fail after 10 lines with bad registers+ final String badTestFile = "pc=0x1,rax=0x1234\n".repeat(TenetLoader.ERROR_THRESHOLD + 1);+ assertThrows(LoadException.class, () -> this.createTraceWithLoader(badTestFile));+ }++ /*+ * Test that the loader fails after {@TenetLoader.ERROR_THRESHOLD} lines+ * without a PC+ */+ @Test+ public void testManyLinesNoPc() throws Exception {+ // Should fail after {@TenetLoader.ERROR_THRESHOLD} lines with no PC+ final String badTestFile = "r1=0x1234\n".repeat(TenetLoader.ERROR_THRESHOLD + 1);+ assertThrows(LoadException.class, () -> this.createTraceWithLoader(badTestFile));+ }++ /*+ * Test how the loader handles overlapping memory reads/writes+ */+ @Test+ public void testMemoryValueOverlap() throws Exception {+ final String testFile = """+ pc=0x1,r0=0x1234,mr=0x1000:0000000000001337+ pc=0x2,r1=0x4321,mw=0x2000:deadbeefdeadbeef+ pc=0x3,mw=0x1000:87654321,mr=0x2000:c0ffee+ """;++ final Trace trace = this.createTraceWithLoader(testFile);++ final AddressSpace addrSpace =+ trace.getBaseLanguage().getAddressFactory().getDefaultAddressSpace();+ final ByteBuffer buffer =+ ByteBuffer.allocate(trace.getBaseLanguage().getProgramCounter().getNumBytes());++ trace.getMemoryManager().getBytes(0, addrSpace.getAddress(0x1000), buffer);+ assertArrayEquals(this.arr(0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x13, 0x37), buffer.array());++ buffer.clear();+ trace.getMemoryManager().getBytes(1, addrSpace.getAddress(0x2000), buffer);+ assertArrayEquals(this.arr(0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef), buffer.array());++ buffer.clear();+ trace.getMemoryManager().getBytes(2, addrSpace.getAddress(0x1000), buffer);+ assertArrayEquals(this.arr(0x87, 0x65, 0x43, 0x21, 0x00, 0x00, 0x13, 0x37), buffer.array());++ buffer.clear();+ trace.getMemoryManager().getBytes(2, addrSpace.getAddress(0x2000), buffer);+ assertArrayEquals(this.arr(0xc0, 0xff, 0xee, 0xef, 0xde, 0xad, 0xbe, 0xef), buffer.array());+ }++ /*+ * Test that the loader continues after a line with no PC+ */+ @Test+ public void testNoPc() throws Exception {+ final String testFile = """+ pc=0x1,r1=0x1234+ r2=0x1234+ """;+ final Trace trace = this.createTraceWithLoader(testFile);+ assertNotNull(trace);+ }++ /*+ * Test that the loader handles no slide value properly+ */+ @Test+ public void testNoSlideValue() throws Exception {+ final String testFile = """+ pc=0x1,r0=0x1234+ pc=0x2,r1=0x4321+ """;++ final Trace trace = this.createTraceWithLoader(testFile);++ final TraceStaticMapping staticMapping =+ Unique.assertOne(trace.getStaticMappingManager().getAllEntries());+ assertEquals(this.program.getImageBase().getUnsignedOffset(),+ staticMapping.getMinTraceAddress().getUnsignedOffset());+ }++ /*+ * Test that the loader parses register values properly+ */+ @Test+ public void testRegisterValues() throws Exception {+ final String testFile = """+ slide=0x0+ pc=0x1,r0=0x1234+ pc=0x2,r1=0x4321+ """;++ final Trace trace = this.createTraceWithLoader(testFile);++ final TraceThread thread = Unique.assertOne(trace.getThreadManager().getAllThreads());+ final TraceMemorySpace regs =+ trace.getMemoryManager().getMemoryRegisterSpace(thread, false);++ assertNotNull(regs);+ assertEquals("1",+ regs.getValue(0, this.program.getLanguage().getProgramCounter())+ .getUnsignedValue()+ .toString(16));++ assertEquals("2",+ regs.getValue(1, this.program.getLanguage().getProgramCounter())+ .getUnsignedValue()+ .toString(16));++ }++ /*+ * Test that the loader handles a slide value properly+ */+ @Test+ public void testWithSlideValue() throws Exception {+ final String testFile = """+ slide=0x10000+ pc=0x1,r0=0x1234+ pc=0x2,r1=0x4321+ """;++ final Trace trace = this.createTraceWithLoader(testFile);++ final TraceStaticMapping staticMapping =+ Unique.assertOne(trace.getStaticMappingManager().getAllEntries());+ assertEquals(this.program.getImageBase().getUnsignedOffset() + 0x10000,+ staticMapping.getMinTraceAddress().getUnsignedOffset());+ }+}