Merge remote-tracking branch 'origin/GP-3535_ryanmkurtz_swift--SQUASHED'

Author: ryanmkurtz

Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/analysis/SwiftTypeMetadataAnalyzer.java

@@ -31,6 +31,8 @@ public class SwiftTypeMetadataAnalyzer extends AbstractAnalyzer {
 	private static final String NAME = "Swift Type Metadata Analyzer";
 	private static final String DESCRIPTION = "Discovers Swift type metadata records.";
 
+	private SwiftTypeMetadata typeMetadata;
+
 	public SwiftTypeMetadataAnalyzer() {
 		super(NAME, DESCRIPTION, AnalyzerType.BYTE_ANALYZER);
 		setDefaultEnablement(true);
@@ -45,13 +47,21 @@ public boolean canAnalyze(Program program) {
 	@Override
 	public boolean added(Program program, AddressSetView set, TaskMonitor monitor, MessageLog log)
 			throws CancelledException {
+		if (typeMetadata != null) {
+			return true;
+		}
 		try {
-			SwiftTypeMetadata typeMetadata = new SwiftTypeMetadata(program, monitor, log);
+			typeMetadata = new SwiftTypeMetadata(program, monitor, log);
 			typeMetadata.markup();
 		}
 		catch (IOException e) {
 			return false;
 		}
 		return true;
 	}
+
+	@Override
+	public void analysisEnded(Program program) {
+		typeMetadata = null;
+	}
 }

Ghidra/Features/Base/src/main/java/ghidra/app/util/bin/format/swift/SwiftSection.java

@@ -35,8 +35,9 @@ public enum SwiftSection {
 	BLOCK_PROTOCS("__swift5_protos", "swift5_protocols", ".sw5prt"),
 	BLOCK_ACFUNCS("__swift5_acfuncs", "swift5_accessible_functions", ".sw5acfn"),
 	BLOCK_MPENUM("__swift5_mpenum", "swift5_mpenum", ".sw5mpen"),
-	BLOCK_TYPES("__swift5_types", "swift5_types", ".sw5tymd"),
-	BLOCK_ENTRY("__swift5_entry", "swift5_entry", ".sw5entr");
+	BLOCK_TYPES("__swift5_types", "swift5_type_metadata", ".sw5tymd"),
+	BLOCK_ENTRY("__swift5_entry", "swift5_entry", ".sw5entr"),
+	BLOCK_SWIFTAST("__swift_ast", ".swift_ast", "swiftast");
 
 	private List<String> sectionNames;
 

Ghidra/Features/Base/src/main/java/ghidra/app/util/bin/format/swift/SwiftTypeMetadata.java

@@ -16,8 +16,7 @@
 package ghidra.app.util.bin.format.swift;
 
 import java.io.IOException;
-import java.util.ArrayList;
-import java.util.List;
+import java.util.*;
 
 import ghidra.app.util.bin.*;
 import ghidra.app.util.bin.format.swift.types.*;
@@ -43,11 +42,11 @@ public class SwiftTypeMetadata {
 
 	private List<EntryPoint> entryPoints = new ArrayList<>();
 	private List<BuiltinTypeDescriptor> builtinTypeDescriptors = new ArrayList<>();
-	private List<FieldDescriptor> fieldDescriptors = new ArrayList<>();
+	private Map<Long, FieldDescriptor> fieldDescriptors = new HashMap<>();
 	private List<AssociatedTypeDescriptor> associatedTypeDescriptors = new ArrayList<>();
 	private List<CaptureDescriptor> captureDescriptors = new ArrayList<>();
 	private List<MultiPayloadEnumDescriptor> mpEnumDescriptors = new ArrayList<>();
-	private List<TargetTypeContextDescriptor> typeDescriptors = new ArrayList<>();
+	private Map<String, TargetTypeContextDescriptor> typeDescriptors = new HashMap<>();
 	private List<TargetProtocolDescriptor> protocolDescriptors = new ArrayList<>();
 	private List<TargetProtocolConformanceDescriptor> protocolConformanceDescriptors =
 		new ArrayList<>();
@@ -72,6 +71,69 @@ public SwiftTypeMetadata(Program program, TaskMonitor monitor, MessageLog log)
 		parse();
 	}
 
+	/**
+	 * {@return the entry points}
+	 */
+	public List<EntryPoint> getEntryPoints() {
+		return entryPoints;
+	}
+
+	/**
+	 * {@return the built-in type descriptors}
+	 */
+	public List<BuiltinTypeDescriptor> getBuiltinTypeDescriptors() {
+		return builtinTypeDescriptors;
+	}
+	
+	/**
+	 * {@return the field descriptors}
+	 */
+	public Map<Long, FieldDescriptor> getFieldDescriptors() {
+		return fieldDescriptors;
+	}
+
+	/**
+	 * {@return the associated type descriptors}
+	 */
+	public List<AssociatedTypeDescriptor> getAssociatedTypeDescriptor() {
+		return associatedTypeDescriptors;
+	}
+
+	/**
+	 * {@return the capture descriptors}
+	 */
+	public List<CaptureDescriptor> getCaptureDescriptors() {
+		return captureDescriptors;
+	}
+
+	/**
+	 * {@return the multi-payload enum descriptors}
+	 */
+	public List<MultiPayloadEnumDescriptor> getMultiPayloadEnumDescriptors() {
+		return mpEnumDescriptors;
+	}
+
+	/**
+	 * {@return the type descriptors}
+	 */
+	public Map<String, TargetTypeContextDescriptor> getTargetTypeContextDescriptors() {
+		return typeDescriptors;
+	}
+
+	/**
+	 * {@return the target protocol descriptors}
+	 */
+	public List<TargetProtocolDescriptor> getTargetProtocolDescriptors() {
+		return protocolDescriptors;
+	}
+
+	/**
+	 * {@return the target protocol conformance descriptors}
+	 */
+	public List<TargetProtocolConformanceDescriptor> getTargetProtocolConformanceDescriptors() {
+		return protocolConformanceDescriptors;
+	}
+
 	/**
 	 * Parses the {@link SwiftTypeMetadata}
 	 * 
@@ -137,14 +199,15 @@ private void parseBuiltinTypeDescriptors(SwiftSection section, BinaryReader read
 			for (MemoryBlock block : SwiftUtils.getSwiftBlocks(section, program)) {
 				Address blockStart = block.getStart();
 				reader.setPointerIndex(blockStart.getOffset());
-				int i = 0;
+				int i = skipZeroEntries(reader, 0, block.getSize());
 				while (i + BuiltinTypeDescriptor.SIZE <= block.getSize()) {
 					monitor.checkCancelled();
 					BuiltinTypeDescriptor descriptor = new BuiltinTypeDescriptor(reader);
 					builtinTypeDescriptors.add(descriptor);
 					markupList.add(new SwiftStructureInfo(descriptor,
 						new SwiftStructureAddress(blockStart.add(i), null)));
 					i += BuiltinTypeDescriptor.SIZE;
+					i = skipZeroEntries(reader, i, block.getSize());
 				}
 			}
 		}
@@ -168,11 +231,11 @@ private void parseFieldDescriptors(SwiftSection section, BinaryReader reader)
 			for (MemoryBlock block : SwiftUtils.getSwiftBlocks(section, program)) {
 				Address blockStart = block.getStart();
 				reader.setPointerIndex(blockStart.getOffset());
-				int i = 0;
+				int i = skipZeroEntries(reader, 0, block.getSize());
 				while (i + FieldDescriptor.SIZE <= block.getSize()) {
 					monitor.checkCancelled();
 					FieldDescriptor descriptor = new FieldDescriptor(reader);
-					fieldDescriptors.add(descriptor);
+					fieldDescriptors.put(descriptor.getBase(), descriptor);
 					markupList.add(new SwiftStructureInfo(descriptor,
 						new SwiftStructureAddress(blockStart.add(i), null)));
 					List<FieldRecord> records = descriptor.getFieldRecords();
@@ -184,6 +247,7 @@ private void parseFieldDescriptors(SwiftSection section, BinaryReader reader)
 								null)));
 					}
 					i += descriptor.getNumFields() * FieldRecord.SIZE;
+					i = skipZeroEntries(reader, i, block.getSize());
 				}
 			}
 		}
@@ -207,7 +271,7 @@ private void parseAssociatedTypeDescriptors(SwiftSection section, BinaryReader r
 			for (MemoryBlock block : SwiftUtils.getSwiftBlocks(section, program)) {
 				Address blockStart = block.getStart();
 				reader.setPointerIndex(blockStart.getOffset());
-				int i = 0;
+				int i = skipZeroEntries(reader, 0, block.getSize());
 				while (i + AssociatedTypeDescriptor.SIZE <= block.getSize()) {
 					monitor.checkCancelled();
 					AssociatedTypeDescriptor descriptor = new AssociatedTypeDescriptor(reader);
@@ -223,6 +287,7 @@ private void parseAssociatedTypeDescriptors(SwiftSection section, BinaryReader r
 								blockStart.add(i + j * AssociatedTypeRecord.SIZE), null)));
 					}
 					i += descriptor.getNumAssociatedTypes() * AssociatedTypeRecord.SIZE;
+					i = skipZeroEntries(reader, i, block.getSize());
 				}
 			}
 		}
@@ -246,7 +311,7 @@ private void parseCaptureTypeDescriptors(SwiftSection section, BinaryReader read
 			for (MemoryBlock block : SwiftUtils.getSwiftBlocks(section, program)) {
 				Address blockStart = block.getStart();
 				reader.setPointerIndex(blockStart.getOffset());
-				int i = 0;
+				int i = skipZeroEntries(reader, 0, block.getSize());
 				while (i + CaptureDescriptor.SIZE <= block.getSize()) {
 					monitor.checkCancelled();
 					CaptureDescriptor descriptor = new CaptureDescriptor(reader);
@@ -271,6 +336,7 @@ private void parseCaptureTypeDescriptors(SwiftSection section, BinaryReader read
 								blockStart.add(i + j * MetadataSourceRecord.SIZE), null)));
 					}
 					i += descriptor.getNumMetadataSources() * MetadataSourceRecord.SIZE;
+					i = skipZeroEntries(reader, i, block.getSize());
 				}
 			}
 		}
@@ -294,14 +360,15 @@ private void parseMultiPayloadEnumDescriptors(SwiftSection section, BinaryReader
 			for (MemoryBlock block : SwiftUtils.getSwiftBlocks(section, program)) {
 				Address blockStart = block.getStart();
 				reader.setPointerIndex(blockStart.getOffset());
-				int i = 0;
+				int i = skipZeroEntries(reader, 0, block.getSize());
 				while (i < block.getSize()) {
 					monitor.checkCancelled();
 					MultiPayloadEnumDescriptor descriptor = new MultiPayloadEnumDescriptor(reader);
 					mpEnumDescriptors.add(descriptor);
 					markupList.add(new SwiftStructureInfo(descriptor,
 						new SwiftStructureAddress(blockStart.add(i), null)));
 					i += MultiPayloadEnumDescriptor.SIZE + descriptor.getContentsSize();
+					i = skipZeroEntries(reader, i, block.getSize());
 				}
 			}
 		}
@@ -397,7 +464,7 @@ private void parseTypeDescriptors(SwiftSection section, BinaryReader reader)
 						yield null;
 				};
 				if (descriptor != null) {
-					typeDescriptors.add(descriptor);
+					typeDescriptors.put(descriptor.getName(), descriptor);
 					markupList.add(new SwiftStructureInfo(descriptor,
 						new SwiftStructureAddress(addrPair.structAddr(), addrPair.pointerAddr())));
 				}
@@ -409,7 +476,7 @@ private void parseTypeDescriptors(SwiftSection section, BinaryReader reader)
 	}
 
 	/**
-	 * Parses a table of pointers to {@link SwiftStructure}s found in the given section
+	 * Parses a table of pointers to {@link SwiftTypeMetadataStructure}s found in the given section
 	 * 
 	 * @param section The {@link SwiftSection} that contains the pointer table
 	 * @param reader A {@link BinaryReader}
@@ -428,11 +495,10 @@ private List<SwiftStructureAddress> parsePointerTable(SwiftSection section, Bina
 					reader.setPointerIndex(blockAddr.getOffset() + i);
 					Address pointerAddr = blockAddr.add(i);
 					int offset = reader.readInt(pointerAddr.getOffset());
-					if (offset == 0) {
-						break;
+					if (offset != 0) {
+						Address structAddr = pointerAddr.add(offset);
+						result.add(new SwiftStructureAddress(structAddr, pointerAddr));
 					}
-					Address structAddr = pointerAddr.add(offset);
-					result.add(new SwiftStructureAddress(structAddr, pointerAddr));
 				}
 			}
 		}
@@ -454,7 +520,7 @@ public void markup() throws CancelledException {
 			monitor.checkCancelled();
 			monitor.incrementProgress(1);
 			try {
-				SwiftStructure struct = structInfo.struct();
+				SwiftTypeMetadataStructure struct = structInfo.struct();
 				DataType dt = struct.toDataType();
 				DataUtilities.createData(program, structInfo.addr().structAddr(), dt, -1,
 					ClearDataMode.CLEAR_ALL_DEFAULT_CONFLICT_DATA);
@@ -465,12 +531,37 @@ public void markup() throws CancelledException {
 						relativePtrDataType, -1, ClearDataMode.CLEAR_ALL_DEFAULT_CONFLICT_DATA);
 				}
 			}
-			catch (CodeUnitInsertionException | DuplicateNameException | IOException e) {
+			catch (CodeUnitInsertionException e) {
+				// Probably just called more than once
+			}
+			catch (DuplicateNameException | IOException e) {
 				log("Failed to markup: " + structInfo);
 			}
 		}
 	}
 
+	/**
+	 * Reads past zeroed out entries in Swift type metadata sections
+	 * 
+	 * @param reader A {@link BinaryReader} positioned within a type metadata section
+	 * @param offset The current offset from the start of the type metadata section
+	 * @param size The size of the type metadata section (in bytes)
+	 * @return The offset from the start of the type metadata section that contains the next
+	 *   non-zero entry
+	 * @throws IOException if an IO-related error occurred
+	 */
+	private int skipZeroEntries(BinaryReader reader, int offset, long size) throws IOException {
+		while (offset + 8 <= size) {
+			long possibleZero = reader.readNextLong();
+			if (possibleZero != 0) {
+				reader.setPointerIndex(reader.getPointerIndex() - 8);
+				return offset;
+			}
+			offset += 8;
+		}
+		return offset;
+	}
+
 	/**
 	 * Convenience method to perform logging
 	 * 
@@ -481,22 +572,24 @@ private void log(String message) {
 	}
 
 	/**
-	 * The {@link Address} of a {@link SwiftStructure} and the optional {@link Address} of its 
-	 * pointer
+	 * The {@link Address} of a {@link SwiftTypeMetadataStructure} and the optional {@link Address} 
+	 * of its pointer
 	 * 
-	 * @param structAddr The {@link Address} of a {@link SwiftStructure}
-	 * @param pointerAddr The {@link Address} of a pointer to a {@link SwiftStructure} (could be 
-	 *   null if there is no associated pointer}
+	 * @param structAddr The {@link Address} of a {@link SwiftTypeMetadataStructure}
+	 * @param pointerAddr The {@link Address} of a pointer to a {@link SwiftTypeMetadataStructure}
+	 *   (could be null if there is no associated pointer}
 	 */
 	private record SwiftStructureAddress(Address structAddr, Address pointerAddr) {}
 
 	/**
-	 * Information about a {@link SwiftStructure}
+	 * Information about a {@link SwiftTypeMetadataStructure}
 	 * 
-	 * @param struct The {@link SwiftStructure}
-	 * @param addr The {@link SwiftStructureAddress address} of the {@link SwiftStructure}
+	 * @param struct The {@link SwiftTypeMetadataStructure}
+	 * @param addr The {@link SwiftStructureAddress address} of the 
+	 *   {@link SwiftTypeMetadataStructure}
 	 */
-	private record SwiftStructureInfo(SwiftStructure struct, SwiftStructureAddress addr) {
+	private record SwiftStructureInfo(SwiftTypeMetadataStructure struct,
+			SwiftStructureAddress addr) {
 
 		@Override
 		public String toString() {

Ghidra/Features/Base/src/main/java/ghidra/app/util/bin/format/swift/SwiftTypeMetadataStructure.java

@@ -0,0 +1,55 @@
+/* ###
+ * 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.bin.format.swift;
+
+import ghidra.app.util.bin.StructConverter;
+
+/**
+ * Implemented by all Swift type metadata structures
+ */
+public abstract class SwiftTypeMetadataStructure implements StructConverter {
+
+	public static final String DATA_TYPE_CATEGORY = "/SwiftTypeMetadata";
+	
+	private long base;
+
+	public SwiftTypeMetadataStructure(long base) {
+		this.base = base;
+	}
+
+	/**
+	 * Gets the base "address" of this {@link SwiftTypeMetadataStructure}
+	 * 
+	 * @return The base "address" of this {@link SwiftTypeMetadataStructure}
+	 */
+	public long getBase() {
+		return base;
+	}
+
+	/**
+	 * Gets the name of the {@link SwiftTypeMetadataStructure}
+	 * 
+	 * @return The name of the {@link SwiftTypeMetadataStructure}
+	 */
+	public abstract String getStructureName();
+
+	/**
+	 * Gets a short description of the {@link SwiftTypeMetadataStructure}
+	 * 
+	 * @return A short description of the {@link SwiftTypeMetadataStructure}
+	 */
+	public abstract String getDescription();
+}