| //===-- RuntimeDyldELFMips.cpp ---- ELF/Mips specific code. -----*- C++ -*-===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "RuntimeDyldELFMips.h" |
| #include "llvm/BinaryFormat/ELF.h" |
| |
| #define DEBUG_TYPE "dyld" |
| |
| void RuntimeDyldELFMips::resolveRelocation(const RelocationEntry &RE, |
| uint64_t Value) { |
| const SectionEntry &Section = Sections[RE.SectionID]; |
| if (IsMipsO32ABI) |
| resolveMIPSO32Relocation(Section, RE.Offset, Value, RE.RelType, RE.Addend); |
| else if (IsMipsN32ABI) { |
| resolveMIPSN32Relocation(Section, RE.Offset, Value, RE.RelType, RE.Addend, |
| RE.SymOffset, RE.SectionID); |
| } else if (IsMipsN64ABI) |
| resolveMIPSN64Relocation(Section, RE.Offset, Value, RE.RelType, RE.Addend, |
| RE.SymOffset, RE.SectionID); |
| else |
| llvm_unreachable("Mips ABI not handled"); |
| } |
| |
| uint64_t RuntimeDyldELFMips::evaluateRelocation(const RelocationEntry &RE, |
| uint64_t Value, |
| uint64_t Addend) { |
| if (IsMipsN32ABI) { |
| const SectionEntry &Section = Sections[RE.SectionID]; |
| Value = evaluateMIPS64Relocation(Section, RE.Offset, Value, RE.RelType, |
| Addend, RE.SymOffset, RE.SectionID); |
| return Value; |
| } |
| llvm_unreachable("Not reachable"); |
| } |
| |
| void RuntimeDyldELFMips::applyRelocation(const RelocationEntry &RE, |
| uint64_t Value) { |
| if (IsMipsN32ABI) { |
| const SectionEntry &Section = Sections[RE.SectionID]; |
| applyMIPSRelocation(Section.getAddressWithOffset(RE.Offset), Value, |
| RE.RelType); |
| return; |
| } |
| llvm_unreachable("Not reachable"); |
| } |
| |
| int64_t |
| RuntimeDyldELFMips::evaluateMIPS32Relocation(const SectionEntry &Section, |
| uint64_t Offset, uint64_t Value, |
| uint32_t Type) { |
| |
| LLVM_DEBUG(dbgs() << "evaluateMIPS32Relocation, LocalAddress: 0x" |
| << format("%llx", Section.getAddressWithOffset(Offset)) |
| << " FinalAddress: 0x" |
| << format("%llx", Section.getLoadAddressWithOffset(Offset)) |
| << " Value: 0x" << format("%llx", Value) << " Type: 0x" |
| << format("%x", Type) << "\n"); |
| |
| switch (Type) { |
| default: |
| llvm_unreachable("Unknown relocation type!"); |
| return Value; |
| case ELF::R_MIPS_32: |
| return Value; |
| case ELF::R_MIPS_26: |
| return Value >> 2; |
| case ELF::R_MIPS_HI16: |
| // Get the higher 16-bits. Also add 1 if bit 15 is 1. |
| return (Value + 0x8000) >> 16; |
| case ELF::R_MIPS_LO16: |
| return Value; |
| case ELF::R_MIPS_PC32: { |
| uint32_t FinalAddress = Section.getLoadAddressWithOffset(Offset); |
| return Value - FinalAddress; |
| } |
| case ELF::R_MIPS_PC16: { |
| uint32_t FinalAddress = Section.getLoadAddressWithOffset(Offset); |
| return (Value - FinalAddress) >> 2; |
| } |
| case ELF::R_MIPS_PC19_S2: { |
| uint32_t FinalAddress = Section.getLoadAddressWithOffset(Offset); |
| return (Value - (FinalAddress & ~0x3)) >> 2; |
| } |
| case ELF::R_MIPS_PC21_S2: { |
| uint32_t FinalAddress = Section.getLoadAddressWithOffset(Offset); |
| return (Value - FinalAddress) >> 2; |
| } |
| case ELF::R_MIPS_PC26_S2: { |
| uint32_t FinalAddress = Section.getLoadAddressWithOffset(Offset); |
| return (Value - FinalAddress) >> 2; |
| } |
| case ELF::R_MIPS_PCHI16: { |
| uint32_t FinalAddress = Section.getLoadAddressWithOffset(Offset); |
| return (Value - FinalAddress + 0x8000) >> 16; |
| } |
| case ELF::R_MIPS_PCLO16: { |
| uint32_t FinalAddress = Section.getLoadAddressWithOffset(Offset); |
| return Value - FinalAddress; |
| } |
| } |
| } |
| |
| int64_t RuntimeDyldELFMips::evaluateMIPS64Relocation( |
| const SectionEntry &Section, uint64_t Offset, uint64_t Value, uint32_t Type, |
| int64_t Addend, uint64_t SymOffset, SID SectionID) { |
| |
| LLVM_DEBUG(dbgs() << "evaluateMIPS64Relocation, LocalAddress: 0x" |
| << format("%llx", Section.getAddressWithOffset(Offset)) |
| << " FinalAddress: 0x" |
| << format("%llx", Section.getLoadAddressWithOffset(Offset)) |
| << " Value: 0x" << format("%llx", Value) << " Type: 0x" |
| << format("%x", Type) << " Addend: 0x" |
| << format("%llx", Addend) |
| << " Offset: " << format("%llx" PRIx64, Offset) |
| << " SID: " << format("%d", SectionID) |
| << " SymOffset: " << format("%x", SymOffset) << "\n"); |
| |
| switch (Type) { |
| default: |
| llvm_unreachable("Not implemented relocation type!"); |
| break; |
| case ELF::R_MIPS_JALR: |
| case ELF::R_MIPS_NONE: |
| break; |
| case ELF::R_MIPS_32: |
| case ELF::R_MIPS_64: |
| return Value + Addend; |
| case ELF::R_MIPS_26: |
| return ((Value + Addend) >> 2) & 0x3ffffff; |
| case ELF::R_MIPS_GPREL16: { |
| uint64_t GOTAddr = getSectionLoadAddress(SectionToGOTMap[SectionID]); |
| return Value + Addend - (GOTAddr + 0x7ff0); |
| } |
| case ELF::R_MIPS_SUB: |
| return Value - Addend; |
| case ELF::R_MIPS_HI16: |
| // Get the higher 16-bits. Also add 1 if bit 15 is 1. |
| return ((Value + Addend + 0x8000) >> 16) & 0xffff; |
| case ELF::R_MIPS_LO16: |
| return (Value + Addend) & 0xffff; |
| case ELF::R_MIPS_HIGHER: |
| return ((Value + Addend + 0x80008000) >> 32) & 0xffff; |
| case ELF::R_MIPS_HIGHEST: |
| return ((Value + Addend + 0x800080008000) >> 48) & 0xffff; |
| case ELF::R_MIPS_CALL16: |
| case ELF::R_MIPS_GOT_DISP: |
| case ELF::R_MIPS_GOT_PAGE: { |
| uint8_t *LocalGOTAddr = |
| getSectionAddress(SectionToGOTMap[SectionID]) + SymOffset; |
| uint64_t GOTEntry = readBytesUnaligned(LocalGOTAddr, getGOTEntrySize()); |
| |
| Value += Addend; |
| if (Type == ELF::R_MIPS_GOT_PAGE) |
| Value = (Value + 0x8000) & ~0xffff; |
| |
| if (GOTEntry) |
| assert(GOTEntry == Value && |
| "GOT entry has two different addresses."); |
| else |
| writeBytesUnaligned(Value, LocalGOTAddr, getGOTEntrySize()); |
| |
| return (SymOffset - 0x7ff0) & 0xffff; |
| } |
| case ELF::R_MIPS_GOT_OFST: { |
| int64_t page = (Value + Addend + 0x8000) & ~0xffff; |
| return (Value + Addend - page) & 0xffff; |
| } |
| case ELF::R_MIPS_GPREL32: { |
| uint64_t GOTAddr = getSectionLoadAddress(SectionToGOTMap[SectionID]); |
| return Value + Addend - (GOTAddr + 0x7ff0); |
| } |
| case ELF::R_MIPS_PC16: { |
| uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset); |
| return ((Value + Addend - FinalAddress) >> 2) & 0xffff; |
| } |
| case ELF::R_MIPS_PC32: { |
| uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset); |
| return Value + Addend - FinalAddress; |
| } |
| case ELF::R_MIPS_PC18_S3: { |
| uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset); |
| return ((Value + Addend - (FinalAddress & ~0x7)) >> 3) & 0x3ffff; |
| } |
| case ELF::R_MIPS_PC19_S2: { |
| uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset); |
| return ((Value + Addend - (FinalAddress & ~0x3)) >> 2) & 0x7ffff; |
| } |
| case ELF::R_MIPS_PC21_S2: { |
| uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset); |
| return ((Value + Addend - FinalAddress) >> 2) & 0x1fffff; |
| } |
| case ELF::R_MIPS_PC26_S2: { |
| uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset); |
| return ((Value + Addend - FinalAddress) >> 2) & 0x3ffffff; |
| } |
| case ELF::R_MIPS_PCHI16: { |
| uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset); |
| return ((Value + Addend - FinalAddress + 0x8000) >> 16) & 0xffff; |
| } |
| case ELF::R_MIPS_PCLO16: { |
| uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset); |
| return (Value + Addend - FinalAddress) & 0xffff; |
| } |
| } |
| return 0; |
| } |
| |
| void RuntimeDyldELFMips::applyMIPSRelocation(uint8_t *TargetPtr, int64_t Value, |
| uint32_t Type) { |
| uint32_t Insn = readBytesUnaligned(TargetPtr, 4); |
| |
| switch (Type) { |
| default: |
| llvm_unreachable("Unknown relocation type!"); |
| break; |
| case ELF::R_MIPS_GPREL16: |
| case ELF::R_MIPS_HI16: |
| case ELF::R_MIPS_LO16: |
| case ELF::R_MIPS_HIGHER: |
| case ELF::R_MIPS_HIGHEST: |
| case ELF::R_MIPS_PC16: |
| case ELF::R_MIPS_PCHI16: |
| case ELF::R_MIPS_PCLO16: |
| case ELF::R_MIPS_CALL16: |
| case ELF::R_MIPS_GOT_DISP: |
| case ELF::R_MIPS_GOT_PAGE: |
| case ELF::R_MIPS_GOT_OFST: |
| Insn = (Insn & 0xffff0000) | (Value & 0x0000ffff); |
| writeBytesUnaligned(Insn, TargetPtr, 4); |
| break; |
| case ELF::R_MIPS_PC18_S3: |
| Insn = (Insn & 0xfffc0000) | (Value & 0x0003ffff); |
| writeBytesUnaligned(Insn, TargetPtr, 4); |
| break; |
| case ELF::R_MIPS_PC19_S2: |
| Insn = (Insn & 0xfff80000) | (Value & 0x0007ffff); |
| writeBytesUnaligned(Insn, TargetPtr, 4); |
| break; |
| case ELF::R_MIPS_PC21_S2: |
| Insn = (Insn & 0xffe00000) | (Value & 0x001fffff); |
| writeBytesUnaligned(Insn, TargetPtr, 4); |
| break; |
| case ELF::R_MIPS_26: |
| case ELF::R_MIPS_PC26_S2: |
| Insn = (Insn & 0xfc000000) | (Value & 0x03ffffff); |
| writeBytesUnaligned(Insn, TargetPtr, 4); |
| break; |
| case ELF::R_MIPS_32: |
| case ELF::R_MIPS_GPREL32: |
| case ELF::R_MIPS_PC32: |
| writeBytesUnaligned(Value & 0xffffffff, TargetPtr, 4); |
| break; |
| case ELF::R_MIPS_64: |
| case ELF::R_MIPS_SUB: |
| writeBytesUnaligned(Value, TargetPtr, 8); |
| break; |
| } |
| } |
| |
| void RuntimeDyldELFMips::resolveMIPSN32Relocation( |
| const SectionEntry &Section, uint64_t Offset, uint64_t Value, uint32_t Type, |
| int64_t Addend, uint64_t SymOffset, SID SectionID) { |
| int64_t CalculatedValue = evaluateMIPS64Relocation( |
| Section, Offset, Value, Type, Addend, SymOffset, SectionID); |
| applyMIPSRelocation(Section.getAddressWithOffset(Offset), CalculatedValue, |
| Type); |
| } |
| |
| void RuntimeDyldELFMips::resolveMIPSN64Relocation( |
| const SectionEntry &Section, uint64_t Offset, uint64_t Value, uint32_t Type, |
| int64_t Addend, uint64_t SymOffset, SID SectionID) { |
| uint32_t r_type = Type & 0xff; |
| uint32_t r_type2 = (Type >> 8) & 0xff; |
| uint32_t r_type3 = (Type >> 16) & 0xff; |
| |
| // RelType is used to keep information for which relocation type we are |
| // applying relocation. |
| uint32_t RelType = r_type; |
| int64_t CalculatedValue = evaluateMIPS64Relocation(Section, Offset, Value, |
| RelType, Addend, |
| SymOffset, SectionID); |
| if (r_type2 != ELF::R_MIPS_NONE) { |
| RelType = r_type2; |
| CalculatedValue = evaluateMIPS64Relocation(Section, Offset, 0, RelType, |
| CalculatedValue, SymOffset, |
| SectionID); |
| } |
| if (r_type3 != ELF::R_MIPS_NONE) { |
| RelType = r_type3; |
| CalculatedValue = evaluateMIPS64Relocation(Section, Offset, 0, RelType, |
| CalculatedValue, SymOffset, |
| SectionID); |
| } |
| applyMIPSRelocation(Section.getAddressWithOffset(Offset), CalculatedValue, |
| RelType); |
| } |
| |
| void RuntimeDyldELFMips::resolveMIPSO32Relocation(const SectionEntry &Section, |
| uint64_t Offset, |
| uint32_t Value, uint32_t Type, |
| int32_t Addend) { |
| uint8_t *TargetPtr = Section.getAddressWithOffset(Offset); |
| Value += Addend; |
| |
| LLVM_DEBUG(dbgs() << "resolveMIPSO32Relocation, LocalAddress: " |
| << Section.getAddressWithOffset(Offset) << " FinalAddress: " |
| << format("%p", Section.getLoadAddressWithOffset(Offset)) |
| << " Value: " << format("%x", Value) << " Type: " |
| << format("%x", Type) << " Addend: " << format("%x", Addend) |
| << " SymOffset: " << format("%x", Offset) << "\n"); |
| |
| Value = evaluateMIPS32Relocation(Section, Offset, Value, Type); |
| |
| applyMIPSRelocation(TargetPtr, Value, Type); |
| } |
