[lld] [llvm] [llvm-objdump][ARM] Find ELF file PLT entries for arm, thumb (PR #130764)

[Peter Smith via llvm-commits]

================
@@ -431,6 +443,129 @@ class ARMMCInstrAnalysis : public MCInstrAnalysis {
   std::optional<uint64_t>
   evaluateMemoryOperandAddress(const MCInst &Inst, const MCSubtargetInfo *STI,
                                uint64_t Addr, uint64_t Size) const override;
+
+  std::vector<std::pair<uint64_t, uint64_t>>
+  findPltEntries(uint64_t PltSectionVA, ArrayRef<uint8_t> PltContents,
+                 const MCSubtargetInfo &STI) const override {
+    llvm::endianness DataEndianness = STI.getTargetTriple().isLittleEndian()
+                                          ? endianness::little
+                                          : endianness::big;
+    llvm::endianness InstrEndianness =
+        STI.checkFeatures("+big-endian-instructions") ? endianness::big
+                                                      : endianness::little;
+
+    // Do a lightweight parsing of PLT entries.
+    std::vector<std::pair<uint64_t, uint64_t>> Result;
+    if (STI.checkFeatures("+thumb-mode")) {
+      for (uint64_t Byte = 0, End = PltContents.size(); Byte + 12 < End;
+           Byte += 16) {
+        // Expected instruction sequence:
+        //
+        // movw ip, #lower16
+        // movt ip, #upper16
+        // add ip, pc
+        // ldr.w pc, [ip]
+        // b . -4
+
+        // Check for movw.
+        uint32_t MovwPart1 =
+            support::endian::read16(PltContents.data() + Byte, InstrEndianness);
+        if ((MovwPart1 & 0xffb0) != 0xf200)
+          continue;
+
+        uint32_t MovwPart2 = support::endian::read16(
+            PltContents.data() + Byte + 2, InstrEndianness);
+        if ((MovwPart2 & 0x8f00) != 0xc00)
+          continue;
+
+        uint64_t OffsetLower =
+            (MovwPart2 & 0xff) + ((MovwPart2 & 0x7000) >> 4) +
+            ((MovwPart1 & 0x400) << 1) + ((MovwPart1 & 0xf) << 12);
+
+        // Check for movt.
+        uint32_t MovtPart1 = support::endian::read16(
+            PltContents.data() + Byte + 4, InstrEndianness);
+        if ((MovtPart1 & 0xfbf0) != 0xf2c0)
+          continue;
+
+        uint32_t MovtPart2 = support::endian::read16(
+            PltContents.data() + Byte + 6, InstrEndianness);
+        if ((MovtPart2 & 0x8f00) != 0xc00)
+          continue;
+
+        uint64_t OffsetHigher =
+            ((MovtPart2 & 0xff) << 16) + ((MovtPart2 & 0x7000) << 12) +
+            ((MovtPart1 & 0x400) << 17) + ((MovtPart1 & 0xf) << 28);
+
+        const uint16_t Insns[] = {
+            0x44fc,         // add ip, pc
+            0xf8dc, 0xf000, // ldr.w pc, [ip]
+            0xe7fc,         // b . -4
+        };
+
+        if (instructionsAreMatching(Insns, PltContents.data() + Byte + 8,
+                                    InstrEndianness)) {
+          uint64_t Offset =
+              (PltSectionVA + Byte + 12) + OffsetLower + OffsetHigher;
+          Result.emplace_back(PltSectionVA + Byte, Offset);
+        }
+      }
+    } else {
+      const uint32_t LongEntryInsns[] = {
+          0xe59fc004, //     ldr ip, L2
+          0xe08cc00f, // L1: add ip, ip, pc
+          0xe59cf000, // ldr pc, [ip]
+      };
+
+      for (uint64_t Byte = 0, End = PltContents.size(); Byte + 12 < End;
+           Byte += 4) {
+        // Is it a long entry?
+        if (instructionsAreMatching(LongEntryInsns, PltContents.data() + Byte,
+                                    InstrEndianness)) {
+          // Expected instruction sequence:
+          //
+          //     ldr ip, L2
+          // L1: add ip, ip, pc
+          //     ldr pc, [ip]
+          // L2: .word   Offset(&(.got.plt) - L1 - 8
+
+          uint64_t Offset = (PltSectionVA + Byte + 12) +
+                            support::endian::read32(
+                                PltContents.data() + Byte + 12, DataEndianness);
+          Result.emplace_back(PltSectionVA + Byte, Offset);
+          Byte += 12;
+        } else {
+          // Expected instruction sequence:
+          //
+          // L1: add ip, pc,  #0x0NN00000  Offset(&(.got.plt) - L1 - 8
+          //     add ip, ip,  #0x000NN000  Offset(&(.got.plt) - L1 - 8
+          //     ldr pc, [ip, #0x00000NNN] Offset(&(.got.plt) - L1 - 8
+
+          // Check for first add.
+          uint32_t Add1 = support::endian::read32(PltContents.data() + Byte,
+                                                  InstrEndianness);
+          if ((Add1 & 0xe28fc600) != 0xe28fc600)
+            continue;
+          uint32_t Add2 = support::endian::read32(PltContents.data() + Byte + 4,
+                                                  InstrEndianness);
+          // Check for second add.
+          if ((Add2 & 0xe28cca00) != 0xe28cca00)
+            continue;
+          uint32_t Ldr = support::endian::read32(PltContents.data() + Byte + 8,
+                                                 InstrEndianness);
+          // Check for ldr.
+          if ((Ldr & 0xe5bcf000) != 0xe5bcf000)
+            continue;
+
+          uint64_t Offset = (PltSectionVA + Byte + 8) + ((Add1 & 0xff) << 20) +
----------------
smithp35 wrote:

Could we add a comment
// add ip, pc, #offset at Byte + 0 + arm-pc-bias = 8

https://github.com/llvm/llvm-project/pull/130764