ELF: Allow thunks to change size. NFCI.

[pcc]

Summary

Depends on D44961

[ruiu]

lld/ELF/Thunks.cpp

146 ↗

(On Diff #140014)

auto -> Defined

346–349 ↗

(On Diff #140014)

Perhaps a personal preference, but I'd use a temporary variable like this

Defined *D = addSymbol(...);
D->StOther |= ...;

lld/ELF/Thunks.h

59 ↗

(On Diff #140014)

Can you add a comment somewhere why you could have more than one symbol for one thunk?

[peter.smith]

lld/ELF/Relocations.cpp

1361 ↗

(On Diff #140014)

With assignOffsets() this line may no longer be required. From memory it was used when a thunk was added in a later pass to a pre-existing ThunkSection and if there were no other thunk sections added we reported no addresses changed. It looks like assignOffsets() would catch this.

lld/ELF/Thunks.h

54 ↗

(On Diff #140014)

Perhaps getThunkTarget() or getThunkTargetSym() as this would reinforce the 1 target of the Thunk.

59 ↗

(On Diff #140014)

I think that the extra symbols are to account for the presence of Arm/Thumb mapping symbols. These are aids for disassembly and aren't part of the interface. There will only ever be one "Thunk Symbol". Perhaps the comment on addSymbols() should say something like "All thunks must define a symbol, known as the thunk symbol, so that we can redirect relocations to it. The thunk may define additional symbols, but these are never targets for relocations.

[pcc]

• Address review comments

[peter.smith]

Thanks, I'm happy with the changes.

[ruiu]

LGTM

lld/trunk/ELF/Relocations.cpp

std::pair<Thunk *, bool> ThunkCreator::getThunk(Symbol &Sym, RelType Type,
   if (auto *D = dyn_cast<Defined>(&Sym))
     if (!D->isInPlt() && D->Section)
       ThunkVec = &ThunkedSymbolsBySection[{D->Section->Repl, D->Value}];
   if (!ThunkVec)
     ThunkVec = &ThunkedSymbols[&Sym];
   // Check existing Thunks for Sym to see if they can be reused
   for (Thunk *ET : *ThunkVec)
     if (ET->isCompatibleWith(Type) &&
-        Target->inBranchRange(Type, Src, ET->ThunkSym->getVA()))
+        Target->inBranchRange(Type, Src, ET->getThunkTargetSym()->getVA()))
       return std::make_pair(ET, false);
   // No existing compatible Thunk in range, create a new one
   Thunk *T = addThunk(Type, Sym);
   ThunkVec->push_back(T);
   return std::make_pair(T, true);
 }
 
 // Call Fn on every executable InputSection accessed via the linker script
forEachInputSectionDescription(
 
             if (!Target->needsThunk(Rel.Expr, Rel.Type, IS->File, Src,
                                     *Rel.Sym))
               continue;
             Thunk *T;
             bool IsNew;
             std::tie(T, IsNew) = getThunk(*Rel.Sym, Rel.Type, Src);
             if (IsNew) {
-              AddressesChanged = true;
               // Find or create a ThunkSection for the new Thunk
               ThunkSection *TS;
               if (auto *TIS = T->getTargetInputSection())
                 TS = getISThunkSec(TIS);
               else
                 TS = getISDThunkSec(OS, IS, ISD, Rel.Type, Src);
               TS->addThunk(T);
-              Thunks[T->ThunkSym] = T;
+              Thunks[T->getThunkTargetSym()] = T;
             }
             // Redirect relocation to Thunk, we never go via the PLT to a Thunk
-            Rel.Sym = T->ThunkSym;
+            Rel.Sym = T->getThunkTargetSym();
             Rel.Expr = fromPlt(Rel.Expr);
           }
+        for (auto &P : ISD->ThunkSections)
+          AddressesChanged |= P.first->assignOffsets();
       });
+  for (auto &P : ThunkedSections)
+    AddressesChanged |= P.second->assignOffsets();
+
   // Merge all created synthetic ThunkSections back into OutputSection
   mergeThunks(OutputSections);
   ++Pass;
   return AddressesChanged;
 }
 
 template void elf::scanRelocations<ELF32LE>(InputSectionBase &);
 template void elf::scanRelocations<ELF32BE>(InputSectionBase &);
 template void elf::scanRelocations<ELF64LE>(InputSectionBase &);
 template void elf::scanRelocations<ELF64BE>(InputSectionBase &);

lld/trunk/ELF/SyntheticSections.h

 #include "GdbIndex.h"
 #include "InputSection.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/MC/StringTableBuilder.h"
 #include <functional>
 
 namespace lld {
 namespace elf {
+class Defined;
 class SharedSymbol;
 
 class SyntheticSection : public InputSection {
 public:
   SyntheticSection(uint64_t Flags, uint32_t Type, uint32_t Alignment,
                    StringRef Name)
       : InputSection(nullptr, Flags, Type, Alignment, {}, Name,
                      InputSectionBase::Synthetic) {
public:
   // Add a newly created Thunk to this container:
   // Thunk is given offset from start of this InputSection
   // Thunk defines a symbol in this InputSection that can be used as target
   // of a relocation
   void addThunk(Thunk *T);
   size_t getSize() const override { return Size; }
   void writeTo(uint8_t *Buf) override;
   InputSection *getTargetInputSection() const;
+  bool assignOffsets();
 
 private:
   std::vector<Thunk *> Thunks;
   size_t Size = 0;
 };
 
 InputSection *createInterpSection();
 MergeInputSection *createCommentSection();
 void decompressSections();
 void mergeSections();
 
-Symbol *addSyntheticLocal(StringRef Name, uint8_t Type, uint64_t Value,
+Defined *addSyntheticLocal(StringRef Name, uint8_t Type, uint64_t Value,
                            uint64_t Size, InputSectionBase &Section);
 
 // Linker generated sections which can be used as inputs.
 struct InX {
   static InputSection *ARMAttributes;
   static BssSection *Bss;
   static BssSection *BssRelRo;
   static BuildIdSection *BuildId;
   static EhFrameHeader *EhFrameHdr;

lld/trunk/ELF/SyntheticSections.cpp

InputSection *elf::createInterpSection() {
   ArrayRef<uint8_t> Contents = {(const uint8_t *)S.data(), S.size() + 1};
 
   auto *Sec = make<InputSection>(nullptr, SHF_ALLOC, SHT_PROGBITS, 1, Contents,
                                  ".interp");
   Sec->Live = true;
   return Sec;
 }
 
-Symbol *elf::addSyntheticLocal(StringRef Name, uint8_t Type, uint64_t Value,
+Defined *elf::addSyntheticLocal(StringRef Name, uint8_t Type, uint64_t Value,
                                 uint64_t Size, InputSectionBase &Section) {
   auto *S = make<Defined>(Section.File, Name, STB_LOCAL, STV_DEFAULT, Type,
                           Value, Size, &Section);
   if (InX::SymTab)
     InX::SymTab->addSymbol(S);
   return S;
 }
 
 static size_t getHashSize() {

 ThunkSection::ThunkSection(OutputSection *OS, uint64_t Off)
     : SyntheticSection(SHF_ALLOC | SHF_EXECINSTR, SHT_PROGBITS,
                        Config->Wordsize, ".text.thunk") {
   this->Parent = OS;
   this->OutSecOff = Off;
 }
 
 void ThunkSection::addThunk(Thunk *T) {
-  uint64_t Off = alignTo(Size, T->Alignment);
-  T->Offset = Off;
   Thunks.push_back(T);
   T->addSymbols(*this);
-  Size = Off + T->size();
 }
 
 void ThunkSection::writeTo(uint8_t *Buf) {
   for (Thunk *T : Thunks)
     T->writeTo(Buf + T->Offset);
 }
 
 InputSection *ThunkSection::getTargetInputSection() const {
   if (Thunks.empty())
     return nullptr;
   const Thunk *T = Thunks.front();
   return T->getTargetInputSection();
 }
 
+bool ThunkSection::assignOffsets() {
+  uint64_t Off = 0;
+  for (Thunk *T : Thunks) {
+    Off = alignTo(Off, T->Alignment);
+    T->setOffset(Off);
+    uint32_t Size = T->size();
+    T->getThunkTargetSym()->Size = Size;
+    Off += Size;
+  }
+  bool Changed = Off != Size;
+  Size = Off;
+  return Changed;
+}
+
 InputSection *InX::ARMAttributes;
 BssSection *InX::Bss;
 BssSection *InX::BssRelRo;
 BuildIdSection *InX::BuildId;
 EhFrameHeader *InX::EhFrameHdr;
 EhFrameSection *InX::EhFrame;
 SyntheticSection *InX::Dynamic;
 StringTableSection *InX::DynStrTab;

lld/trunk/ELF/Thunks.h

 //===- Thunks.h --------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_THUNKS_H
 #define LLD_ELF_THUNKS_H
 
 #include "Relocations.h"
 
 namespace lld {
 namespace elf {
+class Defined;
 class Symbol;
 class ThunkSection;
 // Class to describe an instance of a Thunk.
 // A Thunk is a code-sequence inserted by the linker in between a caller and
 // the callee. The relocation to the callee is redirected to the Thunk, which
 // after executing transfers control to the callee. Typical uses of Thunks
 // include transferring control from non-pi to pi and changing state on
 // targets like ARM.
 //
 // Thunks can be created for Defined, Shared and Undefined Symbols.
 // Thunks are assigned to synthetic ThunkSections
 class Thunk {
 public:
   Thunk(Symbol &Destination);
   virtual ~Thunk();
 
   virtual uint32_t size() = 0;
   virtual void writeTo(uint8_t *Buf) = 0;
 
-  // All Thunks must define at least one symbol ThunkSym so that we can
-  // redirect relocations to it.
+  // All Thunks must define at least one symbol, known as the thunk target
+  // symbol, so that we can redirect relocations to it. The thunk may define
+  // additional symbols, but these are never targets for relocations.
   virtual void addSymbols(ThunkSection &IS) = 0;
 
+  void setOffset(uint64_t Offset);
+  Defined *addSymbol(StringRef Name, uint8_t Type, uint64_t Value,
+                     InputSectionBase &Section);
+
   // Some Thunks must be placed immediately before their Target as they elide
   // a branch and fall through to the first Symbol in the Target.
   virtual InputSection *getTargetInputSection() const { return nullptr; }
 
   // To reuse a Thunk the caller as identified by the Type must be
   // compatible with it.
   virtual bool isCompatibleWith(RelType Type) const { return true; }
 
+  Defined *getThunkTargetSym() const { return Syms[0]; }
+
   // The alignment requirement for this Thunk, defaults to the size of the
   // typical code section alignment.
   Symbol &Destination;
-  Symbol *ThunkSym;
+  llvm::SmallVector<Defined *, 3> Syms;
   uint64_t Offset = 0;
   uint32_t Alignment = 4;
 };
 
 // For a Relocation to symbol S create a Thunk to be added to a synthetic
 // ThunkSection. At present there are implementations for ARM and Mips Thunks.
 Thunk *addThunk(RelType Type, Symbol &S);
 
 } // namespace elf
 } // namespace lld
 
 #endif

lld/trunk/ELF/Thunks.cpp

public:
   uint32_t size() override { return 12; }
   void writeTo(uint8_t *Buf) override;
   void addSymbols(ThunkSection &IS) override;
   InputSection *getTargetInputSection() const override;
 };
 
 } // end anonymous namespace
 
+Defined *Thunk::addSymbol(StringRef Name, uint8_t Type, uint64_t Value,
+                          InputSectionBase &Section) {
+  Defined *D = addSyntheticLocal(Name, Type, Value, /*Size=*/0, Section);
+  Syms.push_back(D);
+  return D;
+}
+
+void Thunk::setOffset(uint64_t NewOffset) {
+  for (Defined *D : Syms)
+    D->Value = D->Value - Offset + NewOffset;
+  Offset = NewOffset;
+}
+
 // AArch64 long range Thunks
 
 static uint64_t getAArch64ThunkDestVA(const Symbol &S) {
   uint64_t V = S.isInPlt() ? S.getPltVA() : S.getVA();
   return V;
 }
 
 void AArch64ABSLongThunk::writeTo(uint8_t *Buf) {
   const uint8_t Data[] = {
     0x50, 0x00, 0x00, 0x58, //     ldr x16, L0
     0x00, 0x02, 0x1f, 0xd6, //     br  x16
     0x00, 0x00, 0x00, 0x00, // L0: .xword S
     0x00, 0x00, 0x00, 0x00,
   };
   uint64_t S = getAArch64ThunkDestVA(Destination);
   memcpy(Buf, Data, sizeof(Data));
   Target->relocateOne(Buf + 8, R_AARCH64_ABS64, S);
 }
 
 void AArch64ABSLongThunk::addSymbols(ThunkSection &IS) {
-  ThunkSym = addSyntheticLocal(
-      Saver.save("__AArch64AbsLongThunk_" + Destination.getName()), STT_FUNC,
-      Offset, size(), IS);
-  addSyntheticLocal("$x", STT_NOTYPE, Offset, 0, IS);
-  addSyntheticLocal("$d", STT_NOTYPE, Offset + 8, 0, IS);
+  addSymbol(Saver.save("__AArch64AbsLongThunk_" + Destination.getName()),
+            STT_FUNC, 0, IS);
+  addSymbol("$x", STT_NOTYPE, 0, IS);
+  addSymbol("$d", STT_NOTYPE, 8, IS);
 }
 
 // This Thunk has a maximum range of 4Gb, this is sufficient for all programs
 // using the small code model, including pc-relative ones. At time of writing
 // clang and gcc do not support the large code model for position independent
 // code so it is safe to use this for position independent thunks without
 // worrying about the destination being more than 4Gb away.
 void AArch64ADRPThunk::writeTo(uint8_t *Buf) {
   const uint8_t Data[] = {
       0x10, 0x00, 0x00, 0x90, // adrp x16, Dest R_AARCH64_ADR_PREL_PG_HI21(Dest)
       0x10, 0x02, 0x00, 0x91, // add  x16, x16, R_AARCH64_ADD_ABS_LO12_NC(Dest)
       0x00, 0x02, 0x1f, 0xd6, // br   x16
   };
   uint64_t S = getAArch64ThunkDestVA(Destination);
-  uint64_t P = ThunkSym->getVA();
+  uint64_t P = getThunkTargetSym()->getVA();
   memcpy(Buf, Data, sizeof(Data));
   Target->relocateOne(Buf, R_AARCH64_ADR_PREL_PG_HI21,
                       getAArch64Page(S) - getAArch64Page(P));
   Target->relocateOne(Buf + 4, R_AARCH64_ADD_ABS_LO12_NC, S);
 }
 
-void AArch64ADRPThunk::addSymbols(ThunkSection &IS)
-{
-  ThunkSym = addSyntheticLocal(
-      Saver.save("__AArch64ADRPThunk_" + Destination.getName()), STT_FUNC,
-      Offset, size(), IS);
-  addSyntheticLocal("$x", STT_NOTYPE, Offset, 0, IS);
+void AArch64ADRPThunk::addSymbols(ThunkSection &IS) {
+  addSymbol(Saver.save("__AArch64ADRPThunk_" + Destination.getName()), STT_FUNC,
+            0, IS);
+  addSymbol("$x", STT_NOTYPE, 0, IS);
 }
 
 // ARM Target Thunks
 static uint64_t getARMThunkDestVA(const Symbol &S) {
   uint64_t V = S.isInPlt() ? S.getPltVA() : S.getVA();
   return SignExtend64<32>(V);
 }
 
 void ARMV7ABSLongThunk::writeTo(uint8_t *Buf) {
   const uint8_t Data[] = {
       0x00, 0xc0, 0x00, 0xe3, // movw         ip,:lower16:S
       0x00, 0xc0, 0x40, 0xe3, // movt         ip,:upper16:S
       0x1c, 0xff, 0x2f, 0xe1, // bx   ip
   };
   uint64_t S = getARMThunkDestVA(Destination);
   memcpy(Buf, Data, sizeof(Data));
   Target->relocateOne(Buf, R_ARM_MOVW_ABS_NC, S);
   Target->relocateOne(Buf + 4, R_ARM_MOVT_ABS, S);
 }
 
 void ARMV7ABSLongThunk::addSymbols(ThunkSection &IS) {
-  ThunkSym = addSyntheticLocal(
-      Saver.save("__ARMv7ABSLongThunk_" + Destination.getName()), STT_FUNC,
-      Offset, size(), IS);
-  addSyntheticLocal("$a", STT_NOTYPE, Offset, 0, IS);
+  addSymbol(Saver.save("__ARMv7ABSLongThunk_" + Destination.getName()),
+            STT_FUNC, 0, IS);
+  addSymbol("$a", STT_NOTYPE, 0, IS);
 }
 
 bool ARMV7ABSLongThunk::isCompatibleWith(RelType Type) const {
   // Thumb branch relocations can't use BLX
   return Type != R_ARM_THM_JUMP19 && Type != R_ARM_THM_JUMP24;
 }
 
 void ThumbV7ABSLongThunk::writeTo(uint8_t *Buf) {
   const uint8_t Data[] = {
       0x40, 0xf2, 0x00, 0x0c, // movw         ip, :lower16:S
       0xc0, 0xf2, 0x00, 0x0c, // movt         ip, :upper16:S
       0x60, 0x47,             // bx   ip
   };
   uint64_t S = getARMThunkDestVA(Destination);
   memcpy(Buf, Data, sizeof(Data));
   Target->relocateOne(Buf, R_ARM_THM_MOVW_ABS_NC, S);
   Target->relocateOne(Buf + 4, R_ARM_THM_MOVT_ABS, S);
 }
 
 void ThumbV7ABSLongThunk::addSymbols(ThunkSection &IS) {
-  ThunkSym = addSyntheticLocal(
-      Saver.save("__Thumbv7ABSLongThunk_" + Destination.getName()), STT_FUNC,
-      Offset | 0x1, size(), IS);
-  addSyntheticLocal("$t", STT_NOTYPE, Offset, 0, IS);
+  addSymbol(Saver.save("__Thumbv7ABSLongThunk_" + Destination.getName()),
+            STT_FUNC, 1, IS);
+  addSymbol("$t", STT_NOTYPE, 0, IS);
 }
 
 bool ThumbV7ABSLongThunk::isCompatibleWith(RelType Type) const {
   // ARM branch relocations can't use BLX
   return Type != R_ARM_JUMP24 && Type != R_ARM_PC24 && Type != R_ARM_PLT32;
 }
 
 void ARMV7PILongThunk::writeTo(uint8_t *Buf) {
   const uint8_t Data[] = {
       0xf0, 0xcf, 0x0f, 0xe3, // P:  movw ip,:lower16:S - (P + (L1-P) + 8)
       0x00, 0xc0, 0x40, 0xe3, //     movt ip,:upper16:S - (P + (L1-P) + 8)
       0x0f, 0xc0, 0x8c, 0xe0, // L1: add ip, ip, pc
       0x1c, 0xff, 0x2f, 0xe1, //     bx r12
   };
   uint64_t S = getARMThunkDestVA(Destination);
-  uint64_t P = ThunkSym->getVA();
+  uint64_t P = getThunkTargetSym()->getVA();
   uint64_t Offset = S - P - 16;
   memcpy(Buf, Data, sizeof(Data));
   Target->relocateOne(Buf, R_ARM_MOVW_PREL_NC, Offset);
   Target->relocateOne(Buf + 4, R_ARM_MOVT_PREL, Offset);
 }
 
 void ARMV7PILongThunk::addSymbols(ThunkSection &IS) {
-  ThunkSym = addSyntheticLocal(
-      Saver.save("__ARMV7PILongThunk_" + Destination.getName()), STT_FUNC,
-      Offset, size(), IS);
-  addSyntheticLocal("$a", STT_NOTYPE, Offset, 0, IS);
+  addSymbol(Saver.save("__ARMV7PILongThunk_" + Destination.getName()), STT_FUNC,
+            0, IS);
+  addSymbol("$a", STT_NOTYPE, 0, IS);
 }
 
 bool ARMV7PILongThunk::isCompatibleWith(RelType Type) const {
   // Thumb branch relocations can't use BLX
   return Type != R_ARM_THM_JUMP19 && Type != R_ARM_THM_JUMP24;
 }
 
 void ThumbV7PILongThunk::writeTo(uint8_t *Buf) {
   const uint8_t Data[] = {
       0x4f, 0xf6, 0xf4, 0x7c, // P:  movw ip,:lower16:S - (P + (L1-P) + 4)
       0xc0, 0xf2, 0x00, 0x0c, //     movt ip,:upper16:S - (P + (L1-P) + 4)
       0xfc, 0x44,             // L1: add  r12, pc
       0x60, 0x47,             //     bx   r12
   };
   uint64_t S = getARMThunkDestVA(Destination);
-  uint64_t P = ThunkSym->getVA() & ~0x1;
+  uint64_t P = getThunkTargetSym()->getVA() & ~0x1;
   uint64_t Offset = S - P - 12;
   memcpy(Buf, Data, sizeof(Data));
   Target->relocateOne(Buf, R_ARM_THM_MOVW_PREL_NC, Offset);
   Target->relocateOne(Buf + 4, R_ARM_THM_MOVT_PREL, Offset);
 }
 
 void ThumbV7PILongThunk::addSymbols(ThunkSection &IS) {
-  ThunkSym = addSyntheticLocal(
-      Saver.save("__ThumbV7PILongThunk_" + Destination.getName()), STT_FUNC,
-      Offset | 0x1, size(), IS);
-  addSyntheticLocal("$t", STT_NOTYPE, Offset, 0, IS);
+  addSymbol(Saver.save("__ThumbV7PILongThunk_" + Destination.getName()),
+            STT_FUNC, 1, IS);
+  addSymbol("$t", STT_NOTYPE, 0, IS);
 }
 
 bool ThumbV7PILongThunk::isCompatibleWith(RelType Type) const {
   // ARM branch relocations can't use BLX
   return Type != R_ARM_JUMP24 && Type != R_ARM_PC24 && Type != R_ARM_PLT32;
 }
 
 // Write MIPS LA25 thunk code to call PIC function from the non-PIC one.
 void MipsThunk::writeTo(uint8_t *Buf) {
   uint64_t S = Destination.getVA();
   write32(Buf, 0x3c190000); // lui   $25, %hi(func)
   write32(Buf + 4, 0x08000000 | (S >> 2)); // j     func
   write32(Buf + 8, 0x27390000); // addiu $25, $25, %lo(func)
   write32(Buf + 12, 0x00000000); // nop
   Target->relocateOne(Buf, R_MIPS_HI16, S);
   Target->relocateOne(Buf + 8, R_MIPS_LO16, S);
 }
 
 void MipsThunk::addSymbols(ThunkSection &IS) {
-  ThunkSym =
-      addSyntheticLocal(Saver.save("__LA25Thunk_" + Destination.getName()),
-                        STT_FUNC, Offset, size(), IS);
+  addSymbol(Saver.save("__LA25Thunk_" + Destination.getName()), STT_FUNC, 0,
+            IS);
 }
 
 InputSection *MipsThunk::getTargetInputSection() const {
   auto &DR = cast<Defined>(Destination);
   return dyn_cast<InputSection>(DR.Section);
 }
 
 // Write microMIPS R2-R5 LA25 thunk code
 // to call PIC function from the non-PIC one.
 void MicroMipsThunk::writeTo(uint8_t *Buf) {
   uint64_t S = Destination.getVA() | 1;
   write16(Buf, 0x41b9);       // lui   $25, %hi(func)
   write16(Buf + 4, 0xd400);   // j     func
   write16(Buf + 8, 0x3339);   // addiu $25, $25, %lo(func)
   write16(Buf + 12, 0x0c00);  // nop
   Target->relocateOne(Buf, R_MICROMIPS_HI16, S);
   Target->relocateOne(Buf + 4, R_MICROMIPS_26_S1, S);
   Target->relocateOne(Buf + 8, R_MICROMIPS_LO16, S);
 }
 
 void MicroMipsThunk::addSymbols(ThunkSection &IS) {
-  ThunkSym =
-      addSyntheticLocal(Saver.save("__microLA25Thunk_" + Destination.getName()),
-                        STT_FUNC, Offset, size(), IS);
-  ThunkSym->StOther |= STO_MIPS_MICROMIPS;
+  Defined *D = addSymbol(
+      Saver.save("__microLA25Thunk_" + Destination.getName()), STT_FUNC, 0, IS);
+  D->StOther |= STO_MIPS_MICROMIPS;
 }
 
 InputSection *MicroMipsThunk::getTargetInputSection() const {
   auto &DR = cast<Defined>(Destination);
   return dyn_cast<InputSection>(DR.Section);
 }
 
 // Write microMIPS R6 LA25 thunk code
 // to call PIC function from the non-PIC one.
 void MicroMipsR6Thunk::writeTo(uint8_t *Buf) {
   uint64_t S = Destination.getVA() | 1;
-  uint64_t P = ThunkSym->getVA();
+  uint64_t P = getThunkTargetSym()->getVA();
   write16(Buf, 0x1320);       // lui   $25, %hi(func)
   write16(Buf + 4, 0x3339);   // addiu $25, $25, %lo(func)
   write16(Buf + 8, 0x9400);   // bc    func
   Target->relocateOne(Buf, R_MICROMIPS_HI16, S);
   Target->relocateOne(Buf + 4, R_MICROMIPS_LO16, S);
   Target->relocateOne(Buf + 8, R_MICROMIPS_PC26_S1, S - P - 12);
 }
 
 void MicroMipsR6Thunk::addSymbols(ThunkSection &IS) {
-  ThunkSym =
-      addSyntheticLocal(Saver.save("__microLA25Thunk_" + Destination.getName()),
-                        STT_FUNC, Offset, size(), IS);
-  ThunkSym->StOther |= STO_MIPS_MICROMIPS;
+  Defined *D = addSymbol(
+      Saver.save("__microLA25Thunk_" + Destination.getName()), STT_FUNC, 0, IS);
+  D->StOther |= STO_MIPS_MICROMIPS;
 }
 
 InputSection *MicroMipsR6Thunk::getTargetInputSection() const {
   auto &DR = cast<Defined>(Destination);
   return dyn_cast<InputSection>(DR.Section);
 }
 
 Thunk::Thunk(Symbol &D) : Destination(D), Offset(0) {}