GP-3707 revised and implemented missing RISCV ELF relocations.

Corrected ElfRelocation to maintain signed addend value.

Author: ghidra1

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

@@ -85,7 +85,7 @@ public class ElfRelocation implements StructConverter {
 
 	private long r_offset;
 	private long r_info;
-	private long r_addend;
+	private long r_addend; // signed-value
 
 	private boolean hasAddend;
 	private boolean is32bit;
@@ -116,7 +116,7 @@ static ElfRelocation createElfRelocation(BinaryReader reader,
 	 * @param withAddend true if if RELA entry with addend, else false
 	 * @param r_offset The offset for the entry
 	 * @param r_info The info value for the entry
-	 * @param r_addend The addend for the entry
+	 * @param r_addend The signed-addend for the entry (32-bit addends should be signed-extended to 64-bits)
 	 * @return ELF relocation object
 	 * @throws IOException if an IO or parse error occurs
 	 */
@@ -193,7 +193,8 @@ protected void initElfRelocation(BinaryReader reader, ElfHeader elfHeader,
 	 * @param withAddend true if if RELA entry with addend, else false
 	 * @param offset The offset for the entry (r_offset)
 	 * @param info The info value for the entry (r_info)
-	 * @param addend The addend for the entry (r_addend)
+	 * @param addend The signed-addend (r_addend) for the entry (32-bit addends should 
+	 * be signed-extended to 64-bits)
 	 * @throws IOException if an IO or parse error occurs
 	 */
 	protected void initElfRelocation(ElfHeader elfHeader, int relocationTableIndex,
@@ -205,16 +206,13 @@ protected void initElfRelocation(ElfHeader elfHeader, int relocationTableIndex,
 		if (is32bit) {
 			this.r_offset = Integer.toUnsignedLong((int) offset);
 			this.r_info = Integer.toUnsignedLong((int) info);
-			if (hasAddend) {
-				this.r_addend = Integer.toUnsignedLong((int) addend);
-			}
 		}
 		else {
 			this.r_offset = offset;
 			this.r_info = info;
-			if (hasAddend) {
-				this.r_addend = addend;
-			}
+		}
+		if (hasAddend) {
+			this.r_addend = addend;
 		}
 	}
 
@@ -223,7 +221,7 @@ private void readEntryData(BinaryReader reader) throws IOException {
 			this.r_offset = Integer.toUnsignedLong(reader.readNextInt());
 			this.r_info = Integer.toUnsignedLong(reader.readNextInt());
 			if (hasAddend) {
-				r_addend = Integer.toUnsignedLong(reader.readNextInt());
+				r_addend = reader.readNextInt();
 			}
 		}
 		else {
@@ -307,10 +305,13 @@ public long getRelocationInfo() {
 	}
 
 	/**
-	 * This member specifies a constant addend used to compute 
+	 * This member specifies the RELA signed-constant addend used to compute 
 	 * the value to be stored into the relocatable field.  This
-	 * value will be 0 for REL entries which do not supply an addend.
-	 * @return a constant addend
+	 * value will be 0 for REL entries which do not supply an addend and may
+	 * rely on an implicit addend stored at the relocation offset.
+	 * See {@link #hasAddend()} which is true for RELA / Elf_Rela and false
+	 * for REL / Elf_Rel relocations.
+	 * @return addend as 64-bit signed constant
 	 */
 	public long getAddend() {
 		return r_addend;

Ghidra/Processors/RISCV/src/main/java/ghidra/app/util/bin/format/elf/relocation/RISCV_ElfRelocationContext.java

@@ -0,0 +1,83 @@
+/* ###
+ * 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.elf.relocation;
+
+import java.util.*;
+
+import ghidra.app.util.bin.format.elf.*;
+import ghidra.program.model.address.Address;
+
+class RISCV_ElfRelocationContext extends ElfRelocationContext {
+
+	protected RISCV_ElfRelocationContext(ElfRelocationHandler handler, ElfLoadHelper loadHelper,
+			Map<ElfSymbol, Address> symbolMap) {
+		super(handler, loadHelper, symbolMap);
+	}
+
+	/**
+	 * <code>OffsetComparator</code> provides ability to compare a Long ElfSymbol offset value with an
+	 * ElfRelocation object's relocation offset.
+	 */
+	private static class OffsetComparator implements Comparator<Object> {
+
+		public static final OffsetComparator INSTANCE = new OffsetComparator();
+
+		@Override
+		public int compare(Object o1, Object o2) {
+			if (o1 instanceof Long) {
+				return -compare(o2, o1);
+			}
+			ElfRelocation rel = (ElfRelocation) o1;
+			long relOffset = rel.getOffset();
+			long offset = (Long) o2;
+			if (relOffset == offset) {
+				return 0;
+			}
+			return Long.compareUnsigned(relOffset, offset);
+		}
+
+	}
+
+	/**
+	 * Find the HI20 relocation whose offset matches the value of of the specified symbol.
+	 * @param hi20Symbol ELF symbol which corresponds to HI20 relocation
+	 * @return matching relocation or null if not found
+	 */
+	ElfRelocation getHi20Relocation(ElfSymbol hi20Symbol) {
+
+		Long symValue = hi20Symbol.getValue();
+
+		// Search for first relocation within table whose offset matches the specified hi20Symbol value
+		ElfRelocation[] relocations = relocationTable.getRelocations();
+		int relIndex = Arrays.binarySearch(relocations, symValue, OffsetComparator.INSTANCE);
+		if (relIndex < 0) {
+			return null; // relocation not found
+		}
+		// back-up in the event there is more than one matching relocation offset
+		while (relIndex > 0 && relocations[relIndex - 1].getOffset() == symValue) {
+			--relIndex;
+		}
+		// look for hi20 relocation
+		while (relIndex < relocations.length && relocations[relIndex - 1].getOffset() == symValue) {
+			int type = relocations[relIndex].getType();
+			if ((type == RISCV_ElfRelocationConstants.R_RISCV_PCREL_HI20) ||
+				(type == RISCV_ElfRelocationConstants.R_RISCV_GOT_HI20)) {
+				return relocations[relIndex];
+			}
+		}
+		return null;
+	}
+}