arm-mc-elf-s07-tew

lib/CodeGen/ELFWriter.cpp

 //===-- ELFWriter.cpp - Target-independent ELF Writer code ----------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the target-independent ELF writer.  This file writes out
@@ skipping 58 matching lines @@
     is64Bit(TM.getTargetData()->getPointerSizeInBits() == 64),
     isLittleEndian(TM.getTargetData()->isLittleEndian()),
     ElfHdr(isLittleEndian, is64Bit) {
 
   MAI = TM.getMCAsmInfo();
   TEW = TM.getELFWriterInfo();
 
   // Create the object code emitter object for this target.
   ElfCE = new ELFCodeEmitter(*this);
 
+  // Create the arch-specific relocation helper
+  TERH = TEW->getRelocHelper();
+
   // Inital number of sections
   NumSections = 0;
 }
 
 ELFWriter::~ELFWriter() {
   delete ElfCE;
   delete &OutContext;
 
   while(!SymbolList.empty()) {
     delete SymbolList.back(); 
@@ skipping 625 matching lines @@
 
   // Dump the sections and section table to the .o file.
   OutputSectionsAndSectionTable();
 
   return false;
 }
 
 // RelocateField - Patch relocatable field with 'Offset' in 'BO'
 // using a 'Value' of known 'Size'
 void ELFWriter::RelocateField(BinaryObject &BO, uint32_t Offset,
-                              int64_t Value, unsigned Size) {
+                              int64_t Value, unsigned Size,
+                              const MachineRelocation &MR) {
   if (Size == 32)
     BO.fixWord32(Value, Offset);
   else if (Size == 64)
     BO.fixWord64(Value, Offset);
-  else
-    llvm_unreachable("don't know howto patch relocatable field");
+  else {
+    TERH->RelocateField(BO, Offset, Value, Size, MR);
+  }
 }
 
 /// EmitRelocations - Emit relocations
 void ELFWriter::EmitRelocations() {
 
   // True if the target uses the relocation entry to hold the addend,
   // otherwise the addend is written directly to the relocatable field.
   bool HasRelA = TEW->hasRelocationAddend();
 
   // Create Relocation sections for each section which needs it.
@@ skipping 53 matching lines @@
         SymIdx = SectionList[SectionIdx]->getSymbolTableIndex();
 
         // The symbol offset inside the section
         int64_t SymOffset = (int64_t)MR.getResultPointer();
 
         // For pc relative relocations where symbols are defined in the same
         // section they are referenced, ignore the relocation entry and patch
         // the relocatable field with the symbol offset directly.
         if (S.SectionIdx == SectionIdx && TEW->isPCRelativeRel(RelType)) {
           int64_t Value = TEW->computeRelocation(SymOffset, RelOffset, RelType);
-          RelocateField(S, RelOffset, Value, RelTySize);
+          RelocateField(S, RelOffset, Value, RelTySize, MR);
           continue;
         }
 
         Addend = TEW->getDefaultAddendForRelTy(RelType, SymOffset);
       }
 
       // The target without addend on the relocation symbol must be
       // patched in the relocation place itself to contain the addend
       // otherwise write zeros to make sure there is no garbage there
-      RelocateField(S, RelOffset, HasRelA ? 0 : Addend, RelTySize);
+      RelocateField(S, RelOffset, HasRelA ? 0 : Addend, RelTySize, MR);
 
       // Get the relocation entry and emit to the relocation section
       ELFRelocation Rel(RelOffset, SymIdx, RelType, HasRelA, Addend);
       EmitRelocation(RelSec, Rel, HasRelA);
     }
   }
 }
 
 /// EmitRelocation - Write relocation 'Rel' to the relocation section 'Rel'
 void ELFWriter::EmitRelocation(BinaryObject &RelSec, ELFRelocation &Rel,
@@ skipping 256 matching lines @@
   }
 
   // Align output for the section table.
   for (size_t NewFileOff = (FileOff+TableAlign-1) & ~(TableAlign-1);
        FileOff != NewFileOff; ++FileOff)
     O << (char)0xAB;
 
   // Emit the section table itself.
   O.write((char *)&SHdrTable.getData()[0], SHdrTable.size());
 }