From 22064a49c774d09ae9477d6d34bec63ee891a5db Mon Sep 17 00:00:00 2001
From: yetmorecode <yetmorecode@posteo.net>
Date: Sun, 5 Dec 2021 08:19:01 +0100
Subject: [PATCH] Implemented fixups for types 3 (16:16 pointer) and 8 (32bit
 self-ref)

---
 .../ghidra/format/lx/FixupRecord.java         |   5 -
 .../ghidra/format/lx/LxExecutable.java        |   7 +-
 .../ghidra/format/lx/LxHeader.java            |   7 +-
 .../ghidra/format/lx/ObjectMapEntry.java      |  20 --
 .../ghidra/format/lx/ObjectTableEntry.java    |  44 +++
 .../ghidra/loader/lx/LxLoader.java            | 314 +++++++++++++++---
 6 files changed, 312 insertions(+), 85 deletions(-)
 delete mode 100644 src/main/java/yetmorecode/ghidra/format/lx/FixupRecord.java
 delete mode 100644 src/main/java/yetmorecode/ghidra/format/lx/ObjectMapEntry.java
 create mode 100644 src/main/java/yetmorecode/ghidra/format/lx/ObjectTableEntry.java

diff --git a/src/main/java/yetmorecode/ghidra/format/lx/FixupRecord.java b/src/main/java/yetmorecode/ghidra/format/lx/FixupRecord.java
deleted file mode 100644
index ff199f9..0000000
--- a/src/main/java/yetmorecode/ghidra/format/lx/FixupRecord.java
+++ /dev/null
@@ -1,5 +0,0 @@
-package yetmorecode.ghidra.format.lx;
-
-public class FixupRecord {
-
-}
diff --git a/src/main/java/yetmorecode/ghidra/format/lx/LxExecutable.java b/src/main/java/yetmorecode/ghidra/format/lx/LxExecutable.java
index df89754..cd9103f 100644
--- a/src/main/java/yetmorecode/ghidra/format/lx/LxExecutable.java
+++ b/src/main/java/yetmorecode/ghidra/format/lx/LxExecutable.java
@@ -7,7 +7,6 @@
 import ghidra.app.util.bin.ByteProvider;
 import ghidra.app.util.bin.format.FactoryBundledWithBinaryReader;
 import ghidra.app.util.bin.format.mz.DOSHeader;
-import yetmorecode.file.format.lx.ObjectTableEntry;
 import yetmorecode.ghidra.format.lx.exception.InvalidHeaderException;
 
 
@@ -15,7 +14,7 @@ public class LxExecutable extends yetmorecode.file.format.lx.LxExecutable {
     private FactoryBundledWithBinaryReader reader;
     DOSHeader mzHeader;
     
-    public ArrayList<ObjectMapEntry> objects = new ArrayList<>();
+    public ArrayList<ObjectTableEntry> objects = new ArrayList<>();
     
 	public LxExecutable(GenericFactory factory, ByteProvider bp) throws IOException, InvalidHeaderException {
     	reader = new FactoryBundledWithBinaryReader(factory, bp, true);
@@ -27,7 +26,7 @@ public LxExecutable(GenericFactory factory, ByteProvider bp) throws IOException,
         	//objectTable = new ArrayList<ObjectMapEntry>(header.objectCount);
         	int objectTableOffset = mzHeader.e_lfanew() + header.objectTableOffset;
         	for (int i = 0; i < header.objectCount; i++) {
-        		ObjectMapEntry e = new ObjectMapEntry(reader, objectTableOffset + i * ObjectTableEntry.SIZE);
+        		ObjectTableEntry e = new ObjectTableEntry(reader, objectTableOffset + i * yetmorecode.file.format.lx.ObjectTableEntry.SIZE);
         		e.number = i+1;
         		//objectTable.add(e);
         		objects.add(e);
@@ -55,7 +54,7 @@ public LxHeader getLeHeader() {
 		return (LxHeader) header;
 	}
 
-	public ArrayList<ObjectMapEntry> getObjects() {
+	public ArrayList<ObjectTableEntry> getObjects() {
 		return objects;
 	}
 }
diff --git a/src/main/java/yetmorecode/ghidra/format/lx/LxHeader.java b/src/main/java/yetmorecode/ghidra/format/lx/LxHeader.java
index bc17dcc..6733b54 100644
--- a/src/main/java/yetmorecode/ghidra/format/lx/LxHeader.java
+++ b/src/main/java/yetmorecode/ghidra/format/lx/LxHeader.java
@@ -4,7 +4,6 @@
 
 import ghidra.app.util.bin.format.FactoryBundledWithBinaryReader;
 import ghidra.util.Conv;
-import ghidra.util.Msg;
 import yetmorecode.ghidra.format.lx.exception.InvalidHeaderException;
 
 public class LxHeader extends yetmorecode.file.format.lx.LxHeader {
@@ -14,8 +13,10 @@ public LxHeader(FactoryBundledWithBinaryReader reader, short index) throws IOExc
 		reader.setPointerIndex(Conv.shortToInt(index));
 
 		signature = reader.readNextShort();
-		if (signature != yetmorecode.file.format.lx.LxHeader.SIGNATURE_LE) {
-			Msg.info("LE", String.format("wrong magic %x", signature));
+		if (signature != yetmorecode.file.format.lx.LxHeader.SIGNATURE_LE &&
+			signature != yetmorecode.file.format.lx.LxHeader.SIGNATURE_LX &&
+			signature != yetmorecode.file.format.lx.LxHeader.SIGNATURE_LC
+		) {
 			throw new InvalidHeaderException();
 		}
 		
diff --git a/src/main/java/yetmorecode/ghidra/format/lx/ObjectMapEntry.java b/src/main/java/yetmorecode/ghidra/format/lx/ObjectMapEntry.java
deleted file mode 100644
index b772e67..0000000
--- a/src/main/java/yetmorecode/ghidra/format/lx/ObjectMapEntry.java
+++ /dev/null
@@ -1,20 +0,0 @@
-package yetmorecode.ghidra.format.lx;
-
-import java.io.IOException;
-
-import ghidra.app.util.bin.format.FactoryBundledWithBinaryReader;
-import yetmorecode.file.format.lx.ObjectTableEntry;
-
-public class ObjectMapEntry extends ObjectTableEntry {
-
-	public ObjectMapEntry(FactoryBundledWithBinaryReader reader, int index) throws IOException {
-		long oldIndex = reader.getPointerIndex();
-		reader.setPointerIndex(index);
-		size = reader.readNextInt();
-		base = reader.readNextInt();
-		flags = reader.readNextInt();
-		pageTableIndex = reader.readNextInt();
-		pageCount = reader.readNextInt();
-		reader.setPointerIndex(oldIndex);
-	}
-}
\ No newline at end of file
diff --git a/src/main/java/yetmorecode/ghidra/format/lx/ObjectTableEntry.java b/src/main/java/yetmorecode/ghidra/format/lx/ObjectTableEntry.java
new file mode 100644
index 0000000..86f9028
--- /dev/null
+++ b/src/main/java/yetmorecode/ghidra/format/lx/ObjectTableEntry.java
@@ -0,0 +1,44 @@
+package yetmorecode.ghidra.format.lx;
+
+import java.io.IOException;
+import java.util.ArrayList;
+
+import ghidra.app.util.bin.format.FactoryBundledWithBinaryReader;
+
+public class ObjectTableEntry extends yetmorecode.file.format.lx.ObjectTableEntry {
+
+	public ObjectTableEntry(FactoryBundledWithBinaryReader reader, int index) throws IOException {
+		long oldIndex = reader.getPointerIndex();
+		reader.setPointerIndex(index);
+		size = reader.readNextInt();
+		base = reader.readNextInt();
+		flags = reader.readNextInt();
+		pageTableIndex = reader.readNextInt();
+		pageCount = reader.readNextInt();
+		reader.setPointerIndex(oldIndex);
+	}
+	
+	public String getPermissionFlagsLabel() {
+		return String.format(
+			"%s%s%s",
+			(flags & FLAG_READABLE) > 0 ? "r" : "-",
+			(flags & FLAG_WRITEABLE) > 0 ? "w" : "-",
+			(flags & FLAG_EXECUTABLE) > 0 ? "x" : "-"			
+		);
+	}
+	
+	public String getExtraFlagsLabel() {
+		ArrayList<String> f = new ArrayList<>();
+		f.add(getPermissionFlagsLabel());
+		if ((flags & FLAG_PRELOAD_PAGES) > 0) {
+			f.add("preload pages");
+		}
+		if ((flags & FLAG_1616_ALIAS) > 0) {
+			f.add("16:16 alias");
+		}
+		if ((flags & FLAG_BIG_DEFAULT_BIT) > 0) {
+			f.add("big default");
+		}
+		return String.format("%04x (%s)", flags, String.join(", ", f));
+	}
+}
\ No newline at end of file
diff --git a/src/main/java/yetmorecode/ghidra/loader/lx/LxLoader.java b/src/main/java/yetmorecode/ghidra/loader/lx/LxLoader.java
index 84f6c01..363ffab 100644
--- a/src/main/java/yetmorecode/ghidra/loader/lx/LxLoader.java
+++ b/src/main/java/yetmorecode/ghidra/loader/lx/LxLoader.java
@@ -23,9 +23,9 @@
 import ghidra.program.model.listing.Program;
 import ghidra.util.exception.CancelledException;
 import ghidra.util.task.TaskMonitor;
+import yetmorecode.file.format.lx.LxFixupRecord;
 import yetmorecode.ghidra.format.lx.LxExecutable;
-import yetmorecode.ghidra.format.lx.LxHeader;
-import yetmorecode.ghidra.format.lx.ObjectMapEntry;
+import yetmorecode.ghidra.format.lx.ObjectTableEntry;
 import yetmorecode.ghidra.format.lx.PageMapEntry;
 import yetmorecode.ghidra.format.lx.exception.InvalidHeaderException;
 
@@ -34,14 +34,39 @@
  */
 public class LxLoader extends AbstractLibrarySupportLoader {
 
-	private final static String OPTION_BASE_ADDRESSES = "Override object base addresses (comma-seperated)";
+	private final static String GROUP_OVERRIDES = "Runtime overrides (comma-separated)";
+	private final static String GROUP_LOGGING = "Logging";
+	private final static String GROUP_INIT = "Initialization";
+
+	private final static String OPTION_LOG_32BIT_OFFSET = "Log 32-bit offset fixups";
+	private final static String OPTION_LOG_16BIT_OFFSET = "Log 16-bit offset fixups";
+	private final static String OPTION_LOG_32BIT_SELFREL = "Log 32-bit self-rel fixups";
+	private final static String OPTION_LOG_1616_POINTER = "Log 16:16 pointer fixups";
+	private final static String OPTION_WARN_UNHANDLED_FIXUP = "Warn on unhandled fixups";
+	private final static String OPTION_BASE_ADDRESSES = "Object base addresses";
+	private final static String OPTION_OBJECT_SELECTORS = "Object segment selectors";
+	private final static String OPTION_OMIT_ENTRY = "Omit entry point";
+	private final static String OPTION_DISASSEMBLE = "Disassemble from entry";
+	
 	
 	private MessageLog log;
+	
+	private boolean logOffsets32bit = false;
+	private boolean logOffsets16bit = false;
+	private boolean logSelfRel = false;
+	private boolean log1616pointer = false;
+	private boolean warnUnhandled = true;
+	private boolean omitEntry = false;
+	private boolean disassembleEntry = true;
+	
 	private int[] baseAddresses;
+	private int[] selectors;
+	
+	private String name = "Linear Executable (LX/LE/LC)";
 	
 	@Override
 	public String getName() {
-		return "Linear Executable (LE/LX)";
+		return name;
 	}
 
 	@Override
@@ -57,7 +82,7 @@ public Collection<LoadSpec> findSupportedLoadSpecs(ByteProvider provider) throws
 		} catch (IOException e) {
 			e.printStackTrace();
 		} catch (InvalidHeaderException e) {
-			// Everything is ok, but the provided data is not a valid LX/LE header
+			// Everything is ok, but the provided data is not a valid LX/LE/LC
 		}
 		return loadSpecs;
 	}
@@ -79,20 +104,22 @@ protected void load(ByteProvider provider, LoadSpec loadSpec, List<Option> optio
 		LxExecutable executable;
 		try {
 			executable = new LxExecutable(factory, provider);
-			LxHeader header = executable.getLeHeader();
+			var header = executable.getLeHeader();
 			log.appendMsg(String.format("Number of objects: %x", header.objectCount));
 			
-			for (ObjectMapEntry object : executable.getObjects()) {
+			// Log verbose object table information
+			for (var object : executable.getObjects()) {
 				log.appendMsg(String.format(
-					"Object #%x base: %08x - %08x (%06x), pages: %03x - %03x (%x)",
+					"Object #%x base: %08x - %08x (%08x), pages: %03x - %03x (%03x total), flags: %s",
 					object.number,
 					object.base, object.base + object.size, object.size,
-					object.pageTableIndex, object.pageTableIndex + object.pageCount - 1, object.pageCount 
+					object.pageTableIndex, object.pageTableIndex + object.pageCount - 1, object.pageCount,
+					object.getExtraFlagsLabel()
 				));
 			}
 			
 			// Map each object
-			for (ObjectMapEntry object : executable.getObjects()) {
+			for (var object : executable.getObjects()) {
 				byte[] block = createObjectBlock(executable, object, object.number == executable.getObjects().size());
 				program.getMemory().createInitializedBlock(
 					"object" + object.number, 
@@ -103,38 +130,49 @@ protected void load(ByteProvider provider, LoadSpec loadSpec, List<Option> optio
 				);
 			}
 			
-			FlatProgramAPI api = new FlatProgramAPI(program, monitor);
-			int eip = executable.getLeHeader().eip;
-			var o = executable.getObjects().get(executable.getLeHeader().eipObject-1);
-			eip += getBaseAddress(o);			
-			log.appendMsg(String.format("Entrypoint set at %08x (%08x + %08x)", eip, getBaseAddress(o), executable.getLeHeader().eip));
-			api.addEntryPoint(api.toAddr(eip));
-			api.disassemble(api.toAddr(eip));
-			api.createFunction(api.toAddr(eip), "_entry");
+			// Initialization (entry point, disassemble, ...)
+			if (!omitEntry) {
+				var api = new FlatProgramAPI(program, monitor);
+				int eip = executable.getLeHeader().eip;
+				var o = executable.getObjects().get(executable.getLeHeader().eipObject-1);
+				eip += getBaseAddress(o);			
+				log.appendMsg(String.format("Entrypoint set at %08x (%08x + %08x)", eip, getBaseAddress(o), executable.getLeHeader().eip));
+				api.addEntryPoint(api.toAddr(eip));
+				if (disassembleEntry) {
+					api.disassemble(api.toAddr(eip));	
+				}
+				api.createFunction(api.toAddr(eip), "_entry");	
+			}
 		} catch (Exception e) {
 			e.printStackTrace();
-		}	
+		}
 	}
 	
-	private byte[] createObjectBlock(LxExecutable le, ObjectMapEntry object, boolean isLastObject) throws IOException {
+	private byte[] createObjectBlock(LxExecutable le, ObjectTableEntry object, boolean isLastObject) throws IOException {
 		// Temporary memory to assemble all pages to one block
 		byte block[] = new byte[object.size+4096];
 		long blockIndex = 0;
 		
-		// Loop through all pages for this object and add them together
-		LxHeader ib = le.getLeHeader();
-		long pageMapOffset = le.getDosHeader().e_lfanew() + ib.pageTableOffset;
-		long fixupPageMapOffset = le.getDosHeader().e_lfanew() + ib.fixupPageTableOffset;
-		long fixupRecordOffset = le.getDosHeader().e_lfanew() + ib.fixupRecordTableOffset;
-		long pageSize = ib.pageSize; 
+		var header = le.getLeHeader();
+		long pageMapOffset = le.getDosHeader().e_lfanew() + header.pageTableOffset;
+		long fixupPageMapOffset = le.getDosHeader().e_lfanew() + header.fixupPageTableOffset;
+		long fixupRecordOffset = le.getDosHeader().e_lfanew() + header.fixupRecordTableOffset;
+		long pageSize = header.pageSize; 
 		
-		int unhandled = 0;
-		log.appendMsg(String.format("Mapping object #%x to memory location %08x - %08x", 
+		// Some statistics on fixups
+		int fixupCount = 0;
+		int fixupsHandled = 0;
+		int fixupsUnhandled = 0;
+		int fixupsByType[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+		
+		log.appendMsg(String.format("[Object#%x] Mapping to memory location %08x - %08x (selector %03x)", 
 				object.number, 
 				getBaseAddress(object),
-				getBaseAddress(object) + object.size
+				getBaseAddress(object) + object.size,
+				getSelector(object)
 		));
 		
+		// Loop through all pages for this object, apply fixups per page and add them together
 		for (int j = 0; j < object.pageCount; j++) {
 			// Page map indices are one-based, so subtract one 
 			long index = object.pageTableIndex + j - 1;
@@ -143,7 +181,7 @@ private byte[] createObjectBlock(LxExecutable le, ObjectMapEntry object, boolean
 			
 			int fixupBegin = le.getReader().readInt(fixupPageMapOffset + index*4);
 			int fixupEnd = le.getReader().readInt(fixupPageMapOffset + index*4 + 4);					
-			long pageOffset  = ib.dataPagesOffset + (entry.getIndex()-1)*pageSize;
+			long pageOffset  = header.dataPagesOffset + (entry.getIndex()-1)*pageSize;
 
 			
 			// Read page from file
@@ -152,7 +190,7 @@ private byte[] createObjectBlock(LxExecutable le, ObjectMapEntry object, boolean
 			byte[] pageData;
 			var isLastPage = j == object.pageCount - 1;
 			if (isLastObject && isLastPage) {
-				pageData = r.readNextByteArray(ib.lastPageSize);
+				pageData = r.readNextByteArray(header.lastPageSize);
 			} else {
 				pageData = r.readNextByteArray((int) pageSize);	
 			}
@@ -164,21 +202,35 @@ private byte[] createObjectBlock(LxExecutable le, ObjectMapEntry object, boolean
 				
 				int current = 0;
 				while (current < fixupDataSize) {
+					/**
+					 * Fixup Record "SRC / FLAGS / SRCOFF" 
+					 */
+					
+					// SRC
 					byte sourceType = fixupData[current];
+					
+					// FLAGS
 					byte targetFlags = fixupData[current+1];
+					String targetFlagsLabel = "";
 					boolean isSourceList = (sourceType & 0x20) > 0;
+					//boolean isSourceAlias = (sourceType & 0x10) > 0;
 					boolean is16bitSelectorFixup = (sourceType & 0xf) == 2;
 					boolean is32bitTargetOffset = false;
 					boolean objectNumber16Bit = false;
 					if ((targetFlags & 0x10) > 0) {
 						is32bitTargetOffset = true;
-						//targetFlagsLabel += " 32-bit target offset,";
+						targetFlagsLabel += " 32-bit target offset,";
+					} else {
+						targetFlagsLabel += " 16-bit target offset,";
 					}
 					if ((targetFlags & 0x40) > 0) {
 						objectNumber16Bit = true;
-						//targetFlagsLabel += " 16-bit object number,";
+						targetFlagsLabel += " 16-bit object number,";
+					} else {
+						targetFlagsLabel += " 8-bit object number,";
 					}
 					
+					// SRCOFF
 					byte sourceCount = 0;
 					short sourceOffset = 0;
 					if (isSourceList) {
@@ -193,9 +245,12 @@ private byte[] createObjectBlock(LxExecutable le, ObjectMapEntry object, boolean
 						current += 4;
 					}
 					
+					/*
+					 * Fixup Record "Target data" (OBJNUM / TRGOFF)
+					 */
+					
+					// Get target object number
 					short objectNumber = 0;
-					// Target data
-
 					if (objectNumber16Bit) {
 						ByteBuffer bb = ByteBuffer.allocate(2);
 						bb.order(ByteOrder.LITTLE_ENDIAN);
@@ -208,6 +263,7 @@ private byte[] createObjectBlock(LxExecutable le, ObjectMapEntry object, boolean
 						current++;
 					}
 					
+					// Get target offset (i.e the target address to fix at the source)
 					int targetOffset = 0;
 					if ((targetFlags & 0x3) == 0) {
 						if (is16bitSelectorFixup) {
@@ -239,14 +295,74 @@ private byte[] createObjectBlock(LxExecutable le, ObjectMapEntry object, boolean
 					if (isSourceList) {
 						for (int k = 0; k < sourceCount; k++) {
 							current += 2;
-							
 							// read sources..
 						}
 					}
 					
-					if ((sourceType & 0xf) == 7) {
-						int base = getBaseAddress(le.getObjects().get(objectNumber-1));
-						int value = base + targetOffset;								
+					// Apply the actual fixup
+					int base = getBaseAddress(le.getObjects().get(objectNumber-1));
+					fixupsByType[sourceType & 0xf]++;
+					if ((sourceType & 0xf) == LxFixupRecord.SOURCE_32BIT_OFFSET_FIXUP) {
+						int value = base + targetOffset;
+						if (logOffsets32bit) {
+							log.appendMsg(String.format(
+								"32-bit offset fixup #%x at %08x (page %03x) -> %x (object #%x, target flags: %2x %s)",
+								fixupCount, 
+								getBaseAddress(object) + j*pageSize + sourceOffset,
+								index,
+								value, objectNumber,
+								targetFlags, targetFlagsLabel
+							));
+							fixupCount++;
+						}
+						if (sourceOffset >= 0 && sourceOffset < pageData.length) {
+							pageData[sourceOffset] = (byte)(value & 0xff);
+						}
+						if (sourceOffset+1 >= 0 && sourceOffset+1 < pageData.length) {
+							pageData[sourceOffset+1] = (byte)((value & 0xff00)>>8);						
+						}
+						if (sourceOffset+2 >= 0 && sourceOffset+2 < pageData.length) {
+							pageData[sourceOffset+2] = (byte)((value & 0xff0000)>>16);
+						}
+						if (sourceOffset+3 >= 0 && sourceOffset+3 < pageData.length) {
+							pageData[sourceOffset+3] = (byte)((value & 0xff000000)>>24);
+						}
+						fixupsHandled++;
+					} else if ((sourceType & 0xf) == LxFixupRecord.SOURCE_16BIT_OFFSET_FIXUP) {
+						int value = base + targetOffset;
+						if (logOffsets16bit) {
+							log.appendMsg(String.format(
+								"16-bit offset fixup #%x at %08x (page %03x) -> %x (object #%x, target flags: %2x %s)",
+								fixupCount, 
+								getBaseAddress(object) + j*pageSize + sourceOffset,
+								index,
+								value, objectNumber,
+								targetFlags, targetFlagsLabel
+							));
+							fixupCount++;
+						}
+						if (sourceOffset >= 0 && sourceOffset < pageData.length) {
+							pageData[sourceOffset] = (byte)(value & 0xff);
+						}
+						if (sourceOffset+1 >= 0 && sourceOffset+1 < pageData.length) {
+							pageData[sourceOffset+1] = (byte)((value & 0xff00)>>8);						
+						}
+						fixupsHandled++;
+					} else if ((sourceType & 0xf) == LxFixupRecord.SOURCE_32BIT__SELF_REF_OFFSET_FIXUP) {
+						int value = base + targetOffset;
+						if (logSelfRel) {
+							log.appendMsg(String.format(
+								"32-bit self-ref fixup #%x at %08x (page %03x) -> %x (object #%x, target flags: %2x %s)",
+								fixupCount, 
+								getBaseAddress(object) + j*pageSize + sourceOffset,
+								index,
+								value, objectNumber,
+								targetFlags, targetFlagsLabel
+							));
+							fixupCount++;
+						}
+						long address = getBaseAddress(object) + j*pageSize + sourceOffset;
+						value = (int) (value - address - 4);
 						if (sourceOffset >= 0 && sourceOffset < pageData.length) {
 							pageData[sourceOffset] = (byte)(value & 0xff);
 						}
@@ -257,34 +373,82 @@ private byte[] createObjectBlock(LxExecutable le, ObjectMapEntry object, boolean
 							pageData[sourceOffset+2] = (byte)((value & 0xff0000)>>16);
 						}
 						if (sourceOffset+3 >= 0 && sourceOffset+3 < pageData.length) {
-
 							pageData[sourceOffset+3] = (byte)((value & 0xff000000)>>24);
 						}
-					} else if ((sourceType & 0xf) == 2) {
+						fixupsHandled++;
+					} else if ((sourceType & 0xf) == LxFixupRecord.SOURCE_1616PTR_FIXUP) {
+						if (log1616pointer) {
+							log.appendMsg(String.format(
+								"16:16 pointer fixup #%x at %08x (page %03x) -> %02x:%04x (object #%x, target flags: %2x %s)",
+								fixupCount, 
+								getBaseAddress(object) + j*pageSize + sourceOffset,
+								index,
+								base, targetOffset, objectNumber,
+								targetFlags, targetFlagsLabel
+							));
+							fixupCount++;
+						}
+						if (sourceOffset >= 0 && sourceOffset < pageData.length) {
+							pageData[sourceOffset] = (byte)(base & 0xff);
+						}
+						if (sourceOffset+1 >= 0 && sourceOffset+1 < pageData.length) {
+							pageData[sourceOffset+1] = (byte)((base & 0xff00)>>8);						
+						}
+						if (sourceOffset+2 >= 0 && sourceOffset+2 < pageData.length) {
+							pageData[sourceOffset+2] = (byte)(targetOffset & 0xff);
+						}
+						if (sourceOffset+3 >= 0 && sourceOffset+3 < pageData.length) {
+							pageData[sourceOffset+3] = (byte)((targetOffset & 0xff00)>>8);
+						}
+						fixupsHandled++;
+					} else if ((sourceType & 0xf) == LxFixupRecord.SOURCE_16BIT_SELECTOR_FIXUP) {
 						// 16 bit selector fixup
+						fixupsHandled++;
 					} else {
-						log.appendMsg(String.format(
-							"WARNING: unhandled fixup #%x at %08x (type %x, page %03x): %s -> object#%x:%x",
-							unhandled, 
-							getBaseAddress(object) + index * pageSize + sourceOffset,
-							sourceType, index,
-							isSourceList ? "source list " + sourceCount : String.format("%x", sourceOffset),
-							objectNumber, targetOffset
-						));
-						unhandled++;
+						if (warnUnhandled) {
+							log.appendMsg(String.format(
+								"WARNING: unhandled fixup #%x at %08x (type %02x, page %03x): %s -> object#%x:%x, target flags: %2x",
+								fixupCount, 
+								base + index * pageSize + sourceOffset,
+								sourceType, index,
+								isSourceList ? "source list " + sourceCount : String.format("%x", sourceOffset),
+								objectNumber, targetOffset,
+								targetFlags
+							));
+							fixupCount++;
+						}
+						fixupsUnhandled++;
 					}
 				}
 			}
 			
+			
+			
 			// Copy page into object block
 			System.arraycopy(pageData, 0, block, (int) blockIndex, pageData.length);
 			blockIndex += pageSize;
 		}
 		
+		// Log fixup statistics
+		ArrayList<String> byType = new ArrayList<>();
+		for (int i = 0; i < 9; i++) {
+			if (fixupsByType[i] > 0) {
+				byType.add(String.format("%d(%d)", fixupsByType[i], i));
+			}
+		}
+		log.appendMsg(String.format(
+			"Object #%x: Found %d fixups total, %d handled, %d unhandled, by type: %s",
+			object.number,
+			fixupsHandled + fixupsUnhandled, 
+			fixupsHandled, 
+			fixupsUnhandled,
+			String.join(", ", byType)
+		));
+		
 		return block;
 	}
 	
-	private int getBaseAddress(ObjectMapEntry object) {
+	private int getBaseAddress(ObjectTableEntry object) {
 		int index = object.number - 1;
 		if (baseAddresses != null && baseAddresses.length > index) {
 			if (baseAddresses[index] != 0) {
@@ -293,12 +457,30 @@ private int getBaseAddress(ObjectMapEntry object) {
 		}
 		return object.base;
 	}
+	
+	private int getSelector(ObjectTableEntry object) {
+		int index = object.number - 1;
+		if (selectors != null && selectors.length > index) {
+			if (selectors[index] != 0) {
+				return selectors[index];
+			}
+		}
+		return index;
+	}
 
 	@Override
 	public List<Option> getDefaultOptions(ByteProvider provider, LoadSpec loadSpec,
 			DomainObject domainObject, boolean isLoadIntoProgram) {
 		var list = new ArrayList<Option>();
-		list.add(new Option(OPTION_BASE_ADDRESSES, ""));
+		list.add(new Option(GROUP_OVERRIDES, OPTION_BASE_ADDRESSES, ""));
+		list.add(new Option(GROUP_OVERRIDES, OPTION_OBJECT_SELECTORS, ""));
+		list.add(new Option(GROUP_LOGGING, OPTION_WARN_UNHANDLED_FIXUP, true));
+		list.add(new Option(GROUP_LOGGING, OPTION_LOG_16BIT_OFFSET, false));
+		list.add(new Option(GROUP_LOGGING, OPTION_LOG_32BIT_OFFSET, false));
+		list.add(new Option(GROUP_LOGGING, OPTION_LOG_32BIT_SELFREL, false));
+		list.add(new Option(GROUP_LOGGING, OPTION_LOG_1616_POINTER, false));
+		list.add(new Option(GROUP_INIT, OPTION_DISASSEMBLE, true));
+		list.add(new Option(GROUP_INIT, OPTION_OMIT_ENTRY, false));
 		return list;
 	}
 
@@ -317,8 +499,34 @@ public String validateOptions(ByteProvider provider, LoadSpec loadSpec, List<Opt
 					} else {
 						baseAddresses[i] = 0;
 					}
-					
 				}
+			} else if (option.getName().equals(OPTION_OBJECT_SELECTORS)) {
+				String value = option.getValue().toString();
+				String[] values = value.split(",");
+				selectors = new int[values.length];
+				for (int i = 0; i < values.length; i++) {
+					String v = values[i];
+					v = v.replaceAll("0x", "");
+					if (v.length() > 0) {
+						selectors[i] = Integer.parseInt(v, 16);	
+					} else {
+						selectors[i] = 0;
+					}
+				}
+			} else if (option.getName().equals(OPTION_OMIT_ENTRY)) {
+				omitEntry = Boolean.parseBoolean(option.getValue().toString());
+			} else if (option.getName().equals(OPTION_DISASSEMBLE)) {
+				disassembleEntry = Boolean.parseBoolean(option.getValue().toString());
+			} else if (option.getName().equals(OPTION_LOG_16BIT_OFFSET)) {
+				logOffsets16bit = Boolean.parseBoolean(option.getValue().toString());
+			} else if (option.getName().equals(OPTION_LOG_32BIT_OFFSET)) {
+				logOffsets32bit = Boolean.parseBoolean(option.getValue().toString());
+			} else if (option.getName().equals(OPTION_LOG_32BIT_SELFREL)) {
+				logSelfRel = Boolean.parseBoolean(option.getValue().toString());
+			} else if (option.getName().equals(OPTION_LOG_1616_POINTER)) {
+				log1616pointer = Boolean.parseBoolean(option.getValue().toString());
+			} else if (option.getName().equals(OPTION_WARN_UNHANDLED_FIXUP)) {
+				warnUnhandled = Boolean.parseBoolean(option.getValue().toString());
 			}
 		}