Ghidra is a software reverse engineering (SRE) framework
GP-5815 Added ELF Loader GOT allocation support for AARCH64 in support of object module loading.
ghidra1438725bafd2d
diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/bin/format/elf/relocation/ElfGotRelocationContext.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/bin/format/elf/relocation/ElfGotRelocationContext.javanew file mode 100644index 0000000000..2f260c0159--- /dev/null+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/bin/format/elf/relocation/ElfGotRelocationContext.java@@ -0,0 +1,294 @@+/* ###+ * 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.MemoryBlockUtils;+import ghidra.app.util.bin.format.elf.*;+import ghidra.program.model.address.*;+import ghidra.program.model.data.PointerDataType;+import ghidra.program.model.mem.MemoryAccessException;+import ghidra.program.model.mem.MemoryBlock;+import ghidra.util.*;+import ghidra.util.exception.InvalidInputException;+import ghidra.util.exception.NotFoundException;++/**+ * <code>ElfGotRelocationContext</code> provides ability to generate a+ * Global Offset Table (GOT) to facilitate GOT related relocations encountered within+ * object modules.+ * <P>+ * NOTE: This should be considered experimental and has its limitations with GOT size and+ * placement which could behave improperly for large binaries.+ *+ * @param <H> ELF relocation handler class+ */+public abstract class ElfGotRelocationContext<H extends ElfRelocationHandler>+ extends ElfRelocationContext<H> {++ private AddressRange allocatedGotLimits;+ private Address allocatedGotAddress;+ private Address lastAllocatedGotEntryAddress;+ private Address nextAllocatedGotEntryAddress;++ private Map<Long, Address> gotMap;++ ElfGotRelocationContext(H handler, ElfLoadHelper loadHelper,+ Map<ElfSymbol, Address> symbolMap) {+ super(handler, loadHelper, symbolMap);+ }++ @Override+ public long getSymbolValue(ElfSymbol symbol) {+ long symbolValue = super.getSymbolValue(symbol);+ if (symbolValue == 0 && ElfConstants.GOT_SYMBOL_NAME.equals(symbol.getNameAsString())) {+ Address gotAddr = symbolMap.get(symbol);+ if (gotAddr == null) {+ gotAddr = allocateGot();+ }+ if (gotAddr != null) {+ return gotAddr.getOffset();+ }+ }+ return symbolValue;+ }++ @Override+ public long getGOTValue() throws NotFoundException {+ try {+ return super.getGOTValue();+ }+ catch (NotFoundException e) {+ Address gotAddr = allocateGot();+ if (gotAddr != null) {+ return gotAddr.getOffset();+ }+ throw e;+ }+ }++ private ElfSymbol findGotElfSymbol() {+ for (ElfSymbolTable st : getElfHeader().getSymbolTables()) {+ for (ElfSymbol s : st.getSymbols()) {+ if (ElfConstants.GOT_SYMBOL_NAME.equals(s.getNameAsString())) {+ return s;+ }+ }+ }+ return null;+ }++ private int computeRequiredGotSize() {+ // NOTE: GOT allocation calculation assumes all GOT entries correspond to a specific+ // symbol and not a computed offset. This assumption may need to be revised based upon+ // uses of getGotEntryAddress method+ Set<Long> uniqueSymbolValues = new HashSet<>();+ for (ElfRelocationTable rt : getElfHeader().getRelocationTables()) {+ ElfSymbolTable st = rt.getAssociatedSymbolTable();+ if (st == null) {+ continue;+ }+ for (ElfRelocation r : rt.getRelocations()) {+ int symbolIndex = r.getSymbolIndex();+ if (!requiresGotEntry(r) || symbolIndex == 0) {+ continue;+ }+ ElfSymbol elfSymbol = st.getSymbol(symbolIndex);+ if (elfSymbol == null) {+ continue;+ }+ long symbolValue = getSymbolValue(elfSymbol);+ if (!uniqueSymbolValues.add(symbolValue)) {+ System.out.println("Duplicate sym value 0x" + Long.toHexString(symbolValue) ++ " for " + elfSymbol.getNameAsString());+ }+ }+ }+ return Math.max(8, uniqueSymbolValues.size() * 8);+ }++ /**+ * {@return true if the specified relocation type requires a GOT entry.}+ * <P>+ * NOTE: It is very important that all relocations types which invoke+ * {@link #getGotEntryAddress(ElfSymbol)} result in this method returning true. Failure to+ * do so could result in an under allocation of the GOT memory block.+ * @param r relocation type+ */+ protected abstract boolean requiresGotEntry(ElfRelocation r);++ private Address allocateGot() {++ if (allocatedGotAddress != null) {+ if (allocatedGotAddress == Address.NO_ADDRESS) {+ return null;+ }+ return allocatedGotAddress;+ }++ allocatedGotAddress = Address.NO_ADDRESS;+ nextAllocatedGotEntryAddress = Address.NO_ADDRESS;++ ElfSymbol gotElfSymbol = findGotElfSymbol();++ if (gotElfSymbol == null && !getElfHeader().isRelocatable()) {+ loadHelper+ .log("GOT allocatiom failed. " + ElfConstants.GOT_SYMBOL_NAME + " not defined");+ return null;+ }++ if (gotElfSymbol != null && gotElfSymbol.getValue() != 0) {+ loadHelper.log(+ "GOT allocatiom failed. " + ElfConstants.GOT_SYMBOL_NAME + " already defined");+ return null;+ }++ int alignment = getLoadAdapter().getLinkageBlockAlignment();+ int gotSize = computeRequiredGotSize();+ allocatedGotLimits = getLoadHelper().allocateLinkageBlock(alignment, gotSize,+ ElfRelocationHandler.GOT_BLOCK_NAME);+ if (allocatedGotLimits != null &&+ allocatedGotLimits.getMinAddress().getOffset() < Integer.MAX_VALUE) {+ // NOTE: GOT must fall within first 32-bit segment+ if (gotElfSymbol != null) {+ // remember where GOT was allocated+ try {+ loadHelper.createSymbol(allocatedGotLimits.getMinAddress(),+ ElfConstants.GOT_SYMBOL_NAME, true, false, null);+ }+ catch (InvalidInputException e) {+ throw new AssertionError("Unexpected exception", e);+ }+ symbolMap.put(gotElfSymbol, allocatedGotLimits.getMinAddress());+ }+ allocatedGotAddress = allocatedGotLimits.getMinAddress();+ nextAllocatedGotEntryAddress = allocatedGotAddress;+ gotMap = new HashMap<>();+ loadHelper.log("Created " + ElfRelocationHandler.GOT_BLOCK_NAME ++ " block required for GOT relocation processing");+ return allocatedGotAddress;+ }++ loadHelper.log("Failed to allocate GOT block required for relocation processing");+ return null;+ }++ /**+ * Allocate the next section GOT entry location. If GOT has not been allocated an attempt+ * will be made to create one. If allocated gotMap will also be established.+ * @return Address of GOT entry or {@link Address#NO_ADDRESS} if unable to allocate.+ */+ private Address getNextAllocatedGotEntryAddress() {+ if (nextAllocatedGotEntryAddress == null) {+ if (allocateGot() == null) {+ return Address.NO_ADDRESS; // failed to allocate got+ }+ }++ Address addr = nextAllocatedGotEntryAddress;+ if (addr == Address.NO_ADDRESS) {+ return Address.NO_ADDRESS; // insufficient space in got+ }++ try {+ // verify that entry fits in got+ int pointerSize = loadHelper.getProgram().getDefaultPointerSize();+ Address lastAddr = nextAllocatedGotEntryAddress.addNoWrap(pointerSize - 1);+ if (allocatedGotLimits.contains(lastAddr)) {+ // entry fits in got - update and return entry address+ lastAllocatedGotEntryAddress = lastAddr;+ nextAllocatedGotEntryAddress = lastAllocatedGotEntryAddress.addNoWrap(1);+ if (!allocatedGotLimits.contains(nextAllocatedGotEntryAddress)) {+ // allocated got space fully consumed+ nextAllocatedGotEntryAddress = Address.NO_ADDRESS;+ }+ return addr;+ }+ }+ catch (AddressOverflowException e) {+ // ignore+ }++ // insufficient space in got - fail future allocation attempts+ nextAllocatedGotEntryAddress = Address.NO_ADDRESS;+ return Address.NO_ADDRESS;+ }++ /**+ * Get or allocate a GOT entry for the specified symbolValue.+ * NOTE: This is restricted to object modules only which do not of a GOT.+ * @param elfSymbol ELF symbol+ * @return GOT entry address or null if unable to allocate+ */+ public Address getGotEntryAddress(ElfSymbol elfSymbol) {+ long symbolValue = getSymbolValue(elfSymbol);+ Address addr = null;+ if (gotMap != null) {+ addr = gotMap.get(symbolValue);+ }+ if (addr == null) {+ addr = getNextAllocatedGotEntryAddress();+ if (gotMap != null) {+ gotMap.put(symbolValue, addr);+ }+ }+ return addr == Address.NO_ADDRESS ? null : addr;+ }++ /**+ * Flush the section GOT table to a new %got memory block+ */+ private void createGot() {+ if (lastAllocatedGotEntryAddress == null) {+ return;+ }+ int size = (int) lastAllocatedGotEntryAddress.subtract(allocatedGotAddress) + 1;+ try {+ MemoryBlock block = MemoryBlockUtils.createInitializedBlock(program, false,+ ElfRelocationHandler.GOT_BLOCK_NAME, allocatedGotAddress, size,+ "NOTE: This block is artificial and allows ELF Relocations to work correctly",+ "Elf Loader", true, false, false, loadHelper.getLog());++ // Mark block as an artificial fabrication+ block.setArtificial(true);++ DataConverter converter =+ program.getMemory().isBigEndian() ? BigEndianDataConverter.INSTANCE+ : LittleEndianDataConverter.INSTANCE;+ for (long symbolValue : gotMap.keySet()) {+ Address addr = gotMap.get(symbolValue);+ byte[] bytes = converter.getBytes(symbolValue); // 8-byte pointer value+ block.putBytes(addr, bytes);+ loadHelper.createData(addr, PointerDataType.dataType);+ }+ }+ catch (MemoryAccessException e) {+ String msg = "Failed to create GOT at " + allocatedGotAddress;+ loadHelper.log(msg);+ Msg.error(this, msg, e);+ }+ }++ @Override+ public void dispose() {++ // Generate the object module GOT table if required+ createGot();++ super.dispose();+ }+}diff --git a/Ghidra/Processors/AARCH64/src/main/java/ghidra/app/util/bin/format/elf/relocation/AARCH64_ElfRelocationContext.java b/Ghidra/Processors/AARCH64/src/main/java/ghidra/app/util/bin/format/elf/relocation/AARCH64_ElfRelocationContext.javanew file mode 100644index 0000000000..1f19733a36--- /dev/null+++ b/Ghidra/Processors/AARCH64/src/main/java/ghidra/app/util/bin/format/elf/relocation/AARCH64_ElfRelocationContext.java@@ -0,0 +1,62 @@+/* ###+ * 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.Map;++import ghidra.app.util.bin.format.elf.*;+import ghidra.program.model.address.Address;++/**+ * <code>AARCH64_ElfRelocationContext</code> provides ability to generate a+ * Global Offset Table (GOT) to facilitate GOT related relocations encountered within+ * object modules.+ */+class AARCH64_ElfRelocationContext extends ElfGotRelocationContext<AARCH64_ElfRelocationHandler> {++ AARCH64_ElfRelocationContext(AARCH64_ElfRelocationHandler handler, ElfLoadHelper loadHelper,+ Map<ElfSymbol, Address> symbolMap) {+ super(handler, loadHelper, symbolMap);+ }++ @Override+ protected boolean requiresGotEntry(ElfRelocation r) {++ AARCH64_ElfRelocationType type = handler.getRelocationType(r.getType());+ if (type == null) {+ return false;+ }++ switch (type) {++ // NOTE: There are many more relocation types that require a GOT allocation.+ //@formatter:off++ //case R_AARCH64_P32_GOT_LD_PREL19:+ case R_AARCH64_P32_ADR_GOT_PAGE:+ case R_AARCH64_P32_LD32_GOT_LO12_NC:+ //case R_AARCH64_P32_LD32_GOTPAGE_LO14:+ case R_AARCH64_ADR_GOT_PAGE:+ case R_AARCH64_LD64_GOT_LO12_NC:+ return true;++ //@formatter:on+ default:+ return false;+ }+ }++}diff --git a/Ghidra/Processors/AARCH64/src/main/java/ghidra/app/util/bin/format/elf/relocation/AARCH64_ElfRelocationHandler.java b/Ghidra/Processors/AARCH64/src/main/java/ghidra/app/util/bin/format/elf/relocation/AARCH64_ElfRelocationHandler.javaindex aec97b4af7..3e8cb5e6e7 100644--- a/Ghidra/Processors/AARCH64/src/main/java/ghidra/app/util/bin/format/elf/relocation/AARCH64_ElfRelocationHandler.java+++ b/Ghidra/Processors/AARCH64/src/main/java/ghidra/app/util/bin/format/elf/relocation/AARCH64_ElfRelocationHandler.java@@ -4,9 +4,9 @@* 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.@@ -15,6 +15,8 @@*/package ghidra.app.util.bin.format.elf.relocation;+import java.util.Map;+import org.apache.commons.lang3.StringUtils;import ghidra.app.util.bin.format.elf.*;@@ -25,8 +27,8 @@ import ghidra.program.model.mem.*;import ghidra.program.model.reloc.Relocation.Status;import ghidra.program.model.reloc.RelocationResult;-public class AARCH64_ElfRelocationHandler- extends AbstractElfRelocationHandler<AARCH64_ElfRelocationType, ElfRelocationContext<?>> {+public class AARCH64_ElfRelocationHandler extends+ AbstractElfRelocationHandler<AARCH64_ElfRelocationType, AARCH64_ElfRelocationContext> {/*** Constructor@@ -46,11 +48,17 @@ public class AARCH64_ElfRelocationHandler}@Override- protected RelocationResult relocate(ElfRelocationContext<?> elfRelocationContext,+ public AARCH64_ElfRelocationContext createRelocationContext(ElfLoadHelper loadHelper,+ Map<ElfSymbol, Address> symbolMap) {+ return new AARCH64_ElfRelocationContext(this, loadHelper, symbolMap);+ }++ @Override+ protected RelocationResult relocate(AARCH64_ElfRelocationContext elfRelocationContext,ElfRelocation relocation, AARCH64_ElfRelocationType type, Address relocationAddress,ElfSymbol sym, Address symbolAddr, long symbolValue, String symbolName)throws MemoryAccessException {-+Program program = elfRelocationContext.getProgram();Memory memory = program.getMemory();boolean isBigEndianInstructions =@@ -58,13 +66,13 @@ public class AARCH64_ElfRelocationHandlerlong addend = relocation.getAddend(); // will be 0 for REL caselong offset = relocationAddress.getOffset();-+int symbolIndex = relocation.getSymbolIndex();boolean is64bit = true;boolean overflowCheck = true; // *_NC type relocations specify "no overflow check"long newValue = 0;int byteLength = 4; // most relocations affect 4-bytes (change if different)-+// Handle relative relocations that do not require symbolAddr or symbolValueswitch (type) {case R_AARCH64_P32_RELATIVE:@@ -84,7 +92,7 @@ public class AARCH64_ElfRelocationHandlerdefault:break;}-+// Check for unresolved symbolAddr and symbolValue required by remaining relocation types handled belowif (handleUnresolvedSymbol(elfRelocationContext, relocation, relocationAddress)) {return RelocationResult.FAILURE;@@ -308,8 +316,7 @@ public class AARCH64_ElfRelocationHandler// LD/ST64: (S+A) & 0xff8case R_AARCH64_LDST64_ABS_LO12_NC:- case R_AARCH64_P32_LDST64_ABS_LO12_NC:- case R_AARCH64_LD64_GOT_LO12_NC: {+ case R_AARCH64_P32_LDST64_ABS_LO12_NC: {int oldValue = memory.getInt(relocationAddress, isBigEndianInstructions);newValue = (int) ((symbolValue + addend) & 0xff8) >> 3;@@ -330,6 +337,53 @@ public class AARCH64_ElfRelocationHandlerbreak;}+ // ADRP: Page(G(GDAT(S)))-Page(P)+ // Page of GOT entry address for S minus page of relocation address+ // Set the immediate value of an ADRP to bits [32:12] of X+ case R_AARCH64_ADR_GOT_PAGE:+ case R_AARCH64_P32_ADR_GOT_PAGE: {+ int oldValue = memory.getInt(relocationAddress, isBigEndianInstructions);+ Address symbolGotAddress = elfRelocationContext.getGotEntryAddress(sym);+ if (symbolGotAddress == null) {+ markAsError(program, relocationAddress, type, symbolName, symbolIndex,+ "GOT allocation failure", elfRelocationContext.getLog());+ return RelocationResult.FAILURE;+ }+ newValue = page(symbolGotAddress.getOffset()) - page(relocationAddress.getOffset());+ newValue = (newValue & 0x1fffff000L) >>> 12;+ int loBits = (int) newValue & 0x3;+ int hiBits = (int) newValue >>> 2;++ newValue = (oldValue & 0x9f00001fL) | (loBits << 29) | (hiBits << 5);+ memory.setInt(relocationAddress, (int) newValue, isBigEndianInstructions);+ break;+ }++ // LD/ST: G(GDAT(S))+ case R_AARCH64_P32_LD32_GOT_LO12_NC: // Set the LD/ST immediate field to bits [11:2] of X+ case R_AARCH64_LD64_GOT_LO12_NC: // Set the LD/ST immediate field to bits [11:3] of X+ {+ int oldValue = memory.getInt(relocationAddress, isBigEndianInstructions);+ Address symbolGotAddress = elfRelocationContext.getGotEntryAddress(sym);+ if (symbolGotAddress == null) {+ markAsError(program, relocationAddress, type, symbolName, symbolIndex,+ "GOT allocation failure", elfRelocationContext.getLog());+ return RelocationResult.FAILURE;+ }+ int lo12bits = (int) (symbolGotAddress.getOffset() & 0xfff);+ if (type == AARCH64_ElfRelocationType.R_AARCH64_P32_LD32_GOT_LO12_NC) {+ lo12bits &= ~0x3;+ }+ else {+ lo12bits &= ~0x7;+ }++ // Bits [21:10] — imm12: 12-bit unsigned immediate offset+ newValue = (oldValue & 0xffc003ffL) | (lo12bits << 10);+ memory.setInt(relocationAddress, (int) newValue, isBigEndianInstructions);+ break;+ }+case R_AARCH64_P32_GLOB_DAT:is64bit = false;case R_AARCH64_GLOB_DAT: {@@ -379,6 +433,10 @@ public class AARCH64_ElfRelocationHandlerreturn new RelocationResult(Status.APPLIED, byteLength);}+ private long page(long offset) {+ return offset & ~0xfff;+ }+/*** Set the new value in memory* @param memory memorydiff --git a/Ghidra/Processors/AARCH64/src/main/java/ghidra/app/util/bin/format/elf/relocation/AARCH64_ElfRelocationType.java b/Ghidra/Processors/AARCH64/src/main/java/ghidra/app/util/bin/format/elf/relocation/AARCH64_ElfRelocationType.javaindex 8b990df668..2a668a0f50 100644--- a/Ghidra/Processors/AARCH64/src/main/java/ghidra/app/util/bin/format/elf/relocation/AARCH64_ElfRelocationType.java+++ b/Ghidra/Processors/AARCH64/src/main/java/ghidra/app/util/bin/format/elf/relocation/AARCH64_ElfRelocationType.java@@ -4,9 +4,9 @@* 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.@@ -17,6 +17,17 @@ package ghidra.app.util.bin.format.elf.relocation;public enum AARCH64_ElfRelocationType implements ElfRelocationType {+ // Comment macros:+ // S - symbol address+ // A - addend+ // P - relocation address+ // X - result of a relocation operation+ // PG(expr) = Page(expr) = expr & ~0xFFF+ // G(expr) = Address of GOT entry corresponding to expr+ // GDAT(expr) = GOT entry for expression expr value+ //+ // Reference: https://github.com/ARM-software/abi-aa/blob/main/aaelf64/aaelf64.rst+R_AARCH64_NONE(0),R_AARCH64_P32_ABS32(1), // .word: (S+A)R_AARCH64_P32_ABS16(2), // .half: (S+A)@@ -40,10 +51,10 @@ public enum AARCH64_ElfRelocationType implements ElfRelocationType {R_AARCH64_P32_JUMP26(20), // B: ((S+A-P) >> 2) & 0x3ffffff.R_AARCH64_P32_CALL26(21), // BL: ((S+A-P) >> 2) & 0x3ffffff.- R_AARCH64_P32_GOT_LD_PREL19(25),- R_AARCH64_P32_ADR_GOT_PAGE(26),- R_AARCH64_P32_LD32_GOT_LO12_NC(27),- R_AARCH64_P32_LD32_GOTPAGE_LO14(28),+ R_AARCH64_P32_GOT_LD_PREL19(25), // G(GDAT(S))- P+ R_AARCH64_P32_ADR_GOT_PAGE(26), // ADRP: Page(G(GDAT(S)))-Page(P)+ R_AARCH64_P32_LD32_GOT_LO12_NC(27), // LD/ST: G(GDAT(S))+ R_AARCH64_P32_LD32_GOTPAGE_LO14(28), // LD/ST: G(GDAT(S))-Page(GOT)R_AARCH64_P32_TLSGD_ADR_PREL21(80),R_AARCH64_P32_TLSGD_ADR_PAGE21(81),@@ -82,9 +93,9 @@ public enum AARCH64_ElfRelocationType implements ElfRelocationType {R_AARCH64_P32_TLSDESC_ADD_LO12_NC(126),R_AARCH64_P32_TLSDESC_CALL(127),- R_AARCH64_P32_COPY(180), // Copy symbol at runtime.- R_AARCH64_P32_GLOB_DAT(181), // Create GOT entry.- R_AARCH64_P32_JUMP_SLOT(182), // Create PLT entry.+ R_AARCH64_P32_COPY(180), // Copy symbol value at runtime.+ R_AARCH64_P32_GLOB_DAT(181), // Relocate GOT entry.+ R_AARCH64_P32_JUMP_SLOT(182), // Relocate PLT entry.// Adjust by program base.R_AARCH64_P32_RELATIVE(183),@@ -127,28 +138,28 @@ public enum AARCH64_ElfRelocationType implements ElfRelocationType {R_AARCH64_LDST16_ABS_LO12_NC(284), // LD/ST16: (S+A) & 0xffeR_AARCH64_LDST32_ABS_LO12_NC(285), // LD/ST32: (S+A) & 0xffcR_AARCH64_LDST64_ABS_LO12_NC(286), // LD/ST64: (S+A) & 0xff8- R_AARCH64_MOVW_PREL_G0(287),- R_AARCH64_MOVW_PREL_G0_NC(288),- R_AARCH64_MOVW_PREL_G1(289),- R_AARCH64_MOVW_PREL_G1_NC(290),- R_AARCH64_MOVW_PREL_G2(291),- R_AARCH64_MOVW_PREL_G2_NC(292),- R_AARCH64_MOVW_PREL_G3(293),+ R_AARCH64_MOVW_PREL_G0(287), // S+A-P+ R_AARCH64_MOVW_PREL_G0_NC(288), // S+A-P+ R_AARCH64_MOVW_PREL_G1(289), // S+A-P+ R_AARCH64_MOVW_PREL_G1_NC(290), // S+A-P+ R_AARCH64_MOVW_PREL_G2(291), // S+A-P+ R_AARCH64_MOVW_PREL_G2_NC(292), // S+A-P+ R_AARCH64_MOVW_PREL_G3(293), // S+A-PR_AARCH64_LDST128_ABS_LO12_NC(299), // LD/ST128: (S+A) & 0xff0- R_AARCH64_MOVW_GOTOFF_G0(300),- R_AARCH64_MOVW_GOTOFF_G0_NC(301),- R_AARCH64_MOVW_GOTOFF_G1(302),- R_AARCH64_MOVW_GOTOFF_G1_NC(303),- R_AARCH64_MOVW_GOTOFF_G2(304),- R_AARCH64_MOVW_GOTOFF_G2_NC(305),- R_AARCH64_MOVW_GOTOFF_G3(306),- R_AARCH64_GOTREL64(307),- R_AARCH64_GOTREL32(308),- R_AARCH64_GOT_LD_PREL19(309),- R_AARCH64_LD64_GOTOFF_LO15(310),- R_AARCH64_ADR_GOT_PAGE(311),- R_AARCH64_LD64_GOT_LO12_NC(312),- R_AARCH64_LD64_GOTPAGE_LO15(313),+ R_AARCH64_MOVW_GOTOFF_G0(300), // MOV[NZ]: G(GDAT(S)) -GOT+ R_AARCH64_MOVW_GOTOFF_G0_NC(301), // MOVK: G(GDAT(S)) -GOT+ R_AARCH64_MOVW_GOTOFF_G1(302), // MOV[NZ]: G(GDAT(S)) -GOT+ R_AARCH64_MOVW_GOTOFF_G1_NC(303), // MOVK: G(GDAT(S)) -GOT+ R_AARCH64_MOVW_GOTOFF_G2(304), // MOV[NZ]: G(GDAT(S)) -GOT+ R_AARCH64_MOVW_GOTOFF_G2_NC(305), // MOVK: G(GDAT(S)) -GOT+ R_AARCH64_MOVW_GOTOFF_G3(306), // MOV[NZ]: G(GDAT(S)) -GOT+ R_AARCH64_GOTREL64(307), // S+A-GOT+ R_AARCH64_GOTREL32(308), // S+A-GOT+ R_AARCH64_GOT_LD_PREL19(309), // G(GDAT(S))- P+ R_AARCH64_LD64_GOTOFF_LO15(310), // LD/ST: G(GDAT(S))- GOT+ R_AARCH64_ADR_GOT_PAGE(311), // ADRP: Page(G(GDAT(S)))-Page(P)+ R_AARCH64_LD64_GOT_LO12_NC(312), // LD/ST: G(GDAT(S))+ R_AARCH64_LD64_GOTPAGE_LO15(313), // LD/ST: G(GDAT(S))-Page(GOT)R_AARCH64_TLSGD_ADR_PREL21(512),R_AARCH64_TLSGD_ADR_PAGE21(513),@@ -226,9 +237,9 @@ public enum AARCH64_ElfRelocationType implements ElfRelocationType {R_AARCH64_TLS_DTPMOD64(1028),R_AARCH64_TLS_DTPREL64(1029),R_AARCH64_TLS_TPREL64(1030),- R_AARCH64_TLS_DTPMOD(1028),- R_AARCH64_TLS_DTPREL(1029),- R_AARCH64_TLS_TPREL(1030),+ R_AARCH64_TLS_DTPMOD(1028), // aka R_AARCH64_TLS_DTPMOD64+ R_AARCH64_TLS_DTPREL(1029), // aka R_AARCH64_TLS_DTPREL64+ R_AARCH64_TLS_TPREL(1030), // aka R_AARCH64_TLS_TPREL64R_AARCH64_TLSDESC(1031),R_AARCH64_IRELATIVE(1032);diff --git a/Ghidra/Processors/x86/src/main/java/ghidra/app/util/bin/format/elf/relocation/X86_64_ElfRelocationContext.java b/Ghidra/Processors/x86/src/main/java/ghidra/app/util/bin/format/elf/relocation/X86_64_ElfRelocationContext.javaindex 9ee63b228e..cc359b73d2 100644--- a/Ghidra/Processors/x86/src/main/java/ghidra/app/util/bin/format/elf/relocation/X86_64_ElfRelocationContext.java+++ b/Ghidra/Processors/x86/src/main/java/ghidra/app/util/bin/format/elf/relocation/X86_64_ElfRelocationContext.java@@ -15,31 +15,17 @@*/package ghidra.app.util.bin.format.elf.relocation;-import java.util.*;+import java.util.Map;-import ghidra.app.util.MemoryBlockUtils;import ghidra.app.util.bin.format.elf.*;-import ghidra.program.model.address.*;-import ghidra.program.model.data.PointerDataType;-import ghidra.program.model.mem.MemoryAccessException;-import ghidra.program.model.mem.MemoryBlock;-import ghidra.util.*;-import ghidra.util.exception.InvalidInputException;-import ghidra.util.exception.NotFoundException;+import ghidra.program.model.address.Address;/*** <code>X86_64_ElfRelocationContext</code> provides ability to generate a* Global Offset Table (GOT) to facilitate GOT related relocations encountered within* object modules.*/-class X86_64_ElfRelocationContext extends ElfRelocationContext<X86_64_ElfRelocationHandler> {-- private AddressRange allocatedGotLimits;- private Address allocatedGotAddress;- private Address lastAllocatedGotEntryAddress;- private Address nextAllocatedGotEntryAddress;-- private Map<Long, Address> gotMap;+class X86_64_ElfRelocationContext extends ElfGotRelocationContext<X86_64_ElfRelocationHandler> {X86_64_ElfRelocationContext(X86_64_ElfRelocationHandler handler, ElfLoadHelper loadHelper,Map<ElfSymbol, Address> symbolMap) {@@ -47,75 +33,7 @@ class X86_64_ElfRelocationContext extends ElfRelocationContext<X86_64_ElfRelocat}@Override- public long getSymbolValue(ElfSymbol symbol) {- long symbolValue = super.getSymbolValue(symbol);- if (symbolValue == 0 && ElfConstants.GOT_SYMBOL_NAME.equals(symbol.getNameAsString())) {- Address gotAddr = symbolMap.get(symbol);- if (gotAddr == null) {- gotAddr = allocateGot();- }- if (gotAddr != null) {- return gotAddr.getOffset();- }- }- return symbolValue;- }-- @Override- public long getGOTValue() throws NotFoundException {- try {- return super.getGOTValue();- }- catch (NotFoundException e) {- Address gotAddr = allocateGot();- if (gotAddr != null) {- return gotAddr.getOffset();- }- throw e;- }- }-- private ElfSymbol findGotElfSymbol() {- for (ElfSymbolTable st : getElfHeader().getSymbolTables()) {- for (ElfSymbol s : st.getSymbols()) {- if (ElfConstants.GOT_SYMBOL_NAME.equals(s.getNameAsString())) {- return s;- }- }- }- return null;- }-- private int computeRequiredGotSize() {- // NOTE: GOT allocation calculation assumes all GOT entries correspond to a specific- // symbol and not a computed offset. This assumption may need to be revised based upon- // uses of getGotEntryAddress method- Set<Long> uniqueSymbolValues = new HashSet<>();- for (ElfRelocationTable rt : getElfHeader().getRelocationTables()) {- ElfSymbolTable st = rt.getAssociatedSymbolTable();- if (st == null) {- continue;- }- for (ElfRelocation r : rt.getRelocations()) {- int symbolIndex = r.getSymbolIndex();- if (!requiresGotEntry(r) || symbolIndex == 0) {- continue;- }- ElfSymbol elfSymbol = st.getSymbol(symbolIndex);- if (elfSymbol == null) {- continue;- }- long symbolValue = getSymbolValue(elfSymbol);- if (!uniqueSymbolValues.add(symbolValue)) {- System.out.println("Duplicate sym value 0x" + Long.toHexString(symbolValue) +- " for " + elfSymbol.getNameAsString());- }- }- }- return Math.max(8, uniqueSymbolValues.size() * 8);- }-- private boolean requiresGotEntry(ElfRelocation r) {+ protected boolean requiresGotEntry(ElfRelocation r) {X86_64_ElfRelocationType type = handler.getRelocationType(r.getType());if (type == null) {@@ -140,164 +58,4 @@ class X86_64_ElfRelocationContext extends ElfRelocationContext<X86_64_ElfRelocat}}- private Address allocateGot() {-- if (allocatedGotAddress != null) {- if (allocatedGotAddress == Address.NO_ADDRESS) {- return null;- }- return allocatedGotAddress;- }-- allocatedGotAddress = Address.NO_ADDRESS;- nextAllocatedGotEntryAddress = Address.NO_ADDRESS;-- ElfSymbol gotElfSymbol = findGotElfSymbol();-- if (gotElfSymbol == null && !getElfHeader().isRelocatable()) {- loadHelper- .log("GOT allocatiom failed. " + ElfConstants.GOT_SYMBOL_NAME + " not defined");- return null;- }-- if (gotElfSymbol != null && gotElfSymbol.getValue() != 0) {- loadHelper- .log("GOT allocatiom failed. " + ElfConstants.GOT_SYMBOL_NAME + " already defined");- return null;- }-- int alignment = getLoadAdapter().getLinkageBlockAlignment();- int gotSize = computeRequiredGotSize();- allocatedGotLimits = getLoadHelper().allocateLinkageBlock(alignment, gotSize,- ElfRelocationHandler.GOT_BLOCK_NAME);- if (allocatedGotLimits != null &&- allocatedGotLimits.getMinAddress().getOffset() < Integer.MAX_VALUE) {- // NOTE: GOT must fall within first 32-bit segment- if (gotElfSymbol != null) {- // remember where GOT was allocated- try {- loadHelper.createSymbol(allocatedGotLimits.getMinAddress(),- ElfConstants.GOT_SYMBOL_NAME, true, false, null);- }- catch (InvalidInputException e) {- throw new AssertionError("Unexpected exception", e);- }- symbolMap.put(gotElfSymbol, allocatedGotLimits.getMinAddress());- }- allocatedGotAddress = allocatedGotLimits.getMinAddress();- nextAllocatedGotEntryAddress = allocatedGotAddress;- gotMap = new HashMap<>();- loadHelper.log("Created " + ElfRelocationHandler.GOT_BLOCK_NAME +- " block required for GOT relocation processing");- return allocatedGotAddress;- }-- loadHelper.log("Failed to allocate GOT block required for relocation processing");- return null;- }-- /**- * Allocate the next section GOT entry location. If GOT has not been allocated an attempt- * will be made to create one. If allocated gotMap will also be established.- * @return Address of GOT entry or {@link Address#NO_ADDRESS} if unable to allocate.- */- private Address getNextAllocatedGotEntryAddress() {- if (nextAllocatedGotEntryAddress == null) {- if (allocateGot() == null) {- return Address.NO_ADDRESS; // failed to allocate got- }- }-- Address addr = nextAllocatedGotEntryAddress;- if (addr == Address.NO_ADDRESS) {- return Address.NO_ADDRESS; // insufficient space in got- }-- try {- // verify that entry fits in got- int pointerSize = loadHelper.getProgram().getDefaultPointerSize();- Address lastAddr = nextAllocatedGotEntryAddress.addNoWrap(pointerSize - 1);- if (allocatedGotLimits.contains(lastAddr)) {- // entry fits in got - update and return entry address- lastAllocatedGotEntryAddress = lastAddr;- nextAllocatedGotEntryAddress = lastAllocatedGotEntryAddress.addNoWrap(1);- if (!allocatedGotLimits.contains(nextAllocatedGotEntryAddress)) {- // allocated got space fully consumed- nextAllocatedGotEntryAddress = Address.NO_ADDRESS;- }- return addr;- }- }- catch (AddressOverflowException e) {- // ignore- }-- // insufficient space in got - fail future allocation attempts- nextAllocatedGotEntryAddress = Address.NO_ADDRESS;- return Address.NO_ADDRESS;- }-- /**- * Get or allocate a GOT entry for the specified symbolValue.- * NOTE: This is restricted to object modules only which do not of a GOT.- * @param elfSymbol ELF symbol- * @return GOT entry address or null if unable to allocate- */- public Address getGotEntryAddress(ElfSymbol elfSymbol) {- long symbolValue = getSymbolValue(elfSymbol);- Address addr = null;- if (gotMap != null) {- addr = gotMap.get(symbolValue);- }- if (addr == null) {- addr = getNextAllocatedGotEntryAddress();- if (gotMap != null) {- gotMap.put(symbolValue, addr);- }- }- return addr == Address.NO_ADDRESS ? null : addr;- }-- /**- * Flush the section GOT table to a new %got memory block- */- private void createGot() {- if (lastAllocatedGotEntryAddress == null) {- return;- }- int size = (int) lastAllocatedGotEntryAddress.subtract(allocatedGotAddress) + 1;- try {- MemoryBlock block = MemoryBlockUtils.createInitializedBlock(program, false,- ElfRelocationHandler.GOT_BLOCK_NAME, allocatedGotAddress, size,- "NOTE: This block is artificial and allows ELF Relocations to work correctly",- "Elf Loader", true, false, false, loadHelper.getLog());-- // Mark block as an artificial fabrication- block.setArtificial(true);-- DataConverter converter =- program.getMemory().isBigEndian() ? BigEndianDataConverter.INSTANCE- : LittleEndianDataConverter.INSTANCE;- for (long symbolValue : gotMap.keySet()) {- Address addr = gotMap.get(symbolValue);- byte[] bytes = converter.getBytes(symbolValue); // 8-byte pointer value- block.putBytes(addr, bytes);- loadHelper.createData(addr, PointerDataType.dataType);- }- }- catch (MemoryAccessException e) {- String msg = "Failed to create GOT at " + allocatedGotAddress;- loadHelper.log(msg);- Msg.error(this, msg, e);- }- }-- @Override- public void dispose() {-- // Generate the object module GOT table if required- createGot();-- super.dispose();- }}