Merge remote-tracking branch 'origin/GP-4239_ghidra1_ElfRelocationTypeEnum--SQUASHED'

Author: ryanmkurtz

Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/reloc/ElfRelocationFixupHandler.java

@@ -0,0 +1,65 @@
+/* ###
+ * 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.plugin.core.reloc;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import ghidra.app.util.bin.format.elf.relocation.ElfRelocationType;
+
+public abstract class ElfRelocationFixupHandler extends RelocationFixupHandler {
+
+	private Map<Integer, ElfRelocationType> relocationTypesMap;
+
+	/**
+	 * Abstract constructor for an {@link ElfRelocationFixupHandler}.
+	 * 
+	 * @param relocationEnumClass specifies the {@link ElfRelocationType} enum which defines
+	 * all supported relocation types for this relocation handler.
+	 */
+	protected ElfRelocationFixupHandler(Class<? extends ElfRelocationType> relocationEnumClass) {
+		initRelocationTypeMap(relocationEnumClass);
+	}
+
+	private void initRelocationTypeMap(Class<? extends ElfRelocationType> relocationEnumClass) {
+		if (!relocationEnumClass.isEnum() ||
+			!ElfRelocationType.class.isAssignableFrom(relocationEnumClass)) {
+			throw new IllegalArgumentException(
+				"Invalid class specified - expected enum which implements ElfRelocationType: " +
+					relocationEnumClass.getName());
+		}
+		relocationTypesMap = new HashMap<>();
+		for (ElfRelocationType t : relocationEnumClass.getEnumConstants()) {
+			relocationTypesMap.put(t.typeId(), t);
+		}
+	}
+
+	/**
+	 * Get the relocation type enum value which corresponds to the specified type value.
+	 * 
+	 * @param type relocation type value
+	 * @return relocation type enum value or null if type not found or this handler was not
+	 * constructed with a {@link ElfRelocationType} enum class.  The returned value may be
+	 * safely cast to the relocation enum class specified during handler construction.
+	 */
+	public ElfRelocationType getRelocationType(int type) {
+		if (relocationTypesMap == null) {
+			return null;
+		}
+		return relocationTypesMap.get(type);
+	}
+
+}

Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/reloc/RelocationFixupHandler.java

@@ -1,6 +1,5 @@
 /* ###
  * IP: GHIDRA
- * REVIEWED: YES
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -26,15 +25,21 @@
 
 public abstract class RelocationFixupHandler implements ExtensionPoint {
 
+	/**
+	 * Default abstract constructor for an {@link RelocationFixupHandler}.
+	 */
+	protected RelocationFixupHandler() {
+	}
+
 	public abstract boolean processRelocation(Program program, Relocation relocation,
-			Address oldImageBase, Address newImageBase) throws MemoryAccessException,
-			CodeUnitInsertionException;
+			Address oldImageBase, Address newImageBase)
+			throws MemoryAccessException, CodeUnitInsertionException;
 
 	public abstract boolean handlesProgram(Program program);
 
 	protected boolean process32BitRelocation(Program program, Relocation relocation,
-			Address oldImageBase, Address newImageBase) throws MemoryAccessException,
-			CodeUnitInsertionException {
+			Address oldImageBase, Address newImageBase)
+			throws MemoryAccessException, CodeUnitInsertionException {
 		long diff = newImageBase.subtract(oldImageBase);
 
 		Address address = relocation.getAddress();
@@ -52,8 +57,8 @@ protected boolean process32BitRelocation(Program program, Relocation relocation,
 	}
 
 	public boolean process64BitRelocation(Program program, Relocation relocation,
-			Address oldImageBase, Address newImageBase) throws MemoryAccessException,
-			CodeUnitInsertionException {
+			Address oldImageBase, Address newImageBase)
+			throws MemoryAccessException, CodeUnitInsertionException {
 
 		long diff = newImageBase.subtract(oldImageBase);
 

Ghidra/Features/Base/src/main/java/ghidra/app/util/bin/format/elf/ElfRelocation.java

@@ -22,7 +22,7 @@
 import ghidra.app.util.bin.StructConverter;
 import ghidra.app.util.bin.format.elf.extend.ElfLoadAdapter;
 import ghidra.app.util.bin.format.elf.relocation.ElfRelocationContext;
-import ghidra.app.util.bin.format.elf.relocation.ElfRelocationHandler;
+import ghidra.app.util.bin.format.elf.relocation.AbstractElfRelocationHandler;
 import ghidra.program.model.data.*;
 
 /**
@@ -62,7 +62,7 @@
  * 
  * RELR entry (see SHT_RELR, DT_RELR):
  *    NOTE: Relocation type is data <i>relative</i> and must be specified by appropriate relocation handler
- *    (see {@link ElfRelocationHandler#getRelrRelocationType()}) since it is not contained within the 
+ *    (see {@link AbstractElfRelocationHandler#getRelrRelocationType()}) since it is not contained within the 
  *    relocation table which only specifies <i>r_offset</i> for each entry.
  * 
  * </pre>
@@ -272,27 +272,27 @@ public int getSymbolIndex() {
 	}
 
 	/**
-	 * The type of relocation to apply.
-	 * NOTE 1: Relocation types are processor-specific (see {@link ElfRelocationHandler}).
-	 * NOTE 2: A type of 0 is returned by default for RELR relocations and must be updated 
+	 * The type ID value for this relocation
+	 * NOTE 1: Relocation types are processor-specific (see {@link AbstractElfRelocationHandler}).
+	 * NOTE 2: A type ID of 0 is returned by default for RELR relocations and must be updated 
 	 * during relocation processing (see {@link #setType(long)}).  The appropriate RELR 
 	 * relocation type can be obtained from the appropriate 
-	 * {@link ElfRelocationHandler#getRelrRelocationType()} or 
+	 * {@link AbstractElfRelocationHandler#getRelrRelocationType()} or 
 	 * {@link ElfRelocationContext#getRelrRelocationType()} if available.
-	 * @return type of relocation to apply
+	 * @return type ID for this relocation
 	 */
 	public int getType() {
 		return (int) (is32bit ? (r_info & BYTE_MASK) : (r_info & INT_MASK));
 	}
 
 	/**
-	 * Set the relocation type associated with this relocation.
+	 * Set the relocation type ID associated with this relocation.
 	 * Updating the relocation type is required for RELR relocations.
-	 * @param type relocation type to be applied
+	 * @param typeId relocation type ID value for this relocation
 	 */
-	public void setType(long type) {
+	public void setType(long typeId) {
 		long mask = is32bit ? BYTE_MASK : INT_MASK;
-		r_info = (r_info & ~mask) + (type & mask);
+		r_info = (r_info & ~mask) + (typeId & mask);
 	}
 
 	/**