Use R_X86_64_32S to handle Jump Table Index relocation entries. Hide TAI usage inside getSection* functions

llvm-svn: 76347

include/llvm/Target/TargetELFWriterInfo.h

@@ -89,6 +89,14 @@ namespace llvm {
                      : (hasRelocationAddend() ? 12 : 8);
     }
 
+    /// hasCustomJumpTableIndexRelTy - Returns true if the target has a
+    /// specific relocation type for a jump table index.
+    virtual bool hasCustomJumpTableIndexRelTy() const { return false; }
+
+    /// getJumpTableIndexRelTy - Returns the target specific relocation type
+    /// for a jump table index.
+    virtual unsigned getJumpTableIndexRelTy() const { return 0; }
+
     /// getRelocationType - Returns the target specific ELF Relocation type.
     /// 'MachineRelTy' contains the object code independent relocation type
     virtual unsigned getRelocationType(unsigned MachineRelTy) const = 0;

lib/CodeGen/ELFCodeEmitter.cpp

@@ -101,8 +101,8 @@ bool ELFCodeEmitter::finishFunction(MachineFunction &MF) {
       MR.setResultPointer((void*)Addr);
     } else if (MR.isJumpTableIndex()) {
       Addr = getJumpTableEntryAddress(MR.getJumpTableIndex());
-      MR.setResultPointer((void*)Addr);
       MR.setConstantVal(JumpTableSectionIdx);
+      MR.setResultPointer((void*)Addr);
     } else {
       llvm_unreachable("Unhandled relocation type");
     }
@@ -128,25 +128,19 @@ void ELFCodeEmitter::emitConstantPool(MachineConstantPool *MCP) {
   assert(TM.getRelocationModel() != Reloc::PIC_ &&
          "PIC codegen not yet handled for elf constant pools!");
 
-  const TargetAsmInfo *TAI = TM.getTargetAsmInfo();
   for (unsigned i = 0, e = CP.size(); i != e; ++i) {
     MachineConstantPoolEntry CPE = CP[i];
 
-    // Get the right ELF Section for this constant pool entry
-    std::string CstPoolName =
-      TAI->SelectSectionForMachineConst(CPE.getType())->getName();
-    ELFSection &CstPoolSection =
-      EW.getConstantPoolSection(CstPoolName, CPE.getAlignment());
-
     // Record the constant pool location and the section index
-    CPLocations.push_back(CstPoolSection.size());
-    CPSections.push_back(CstPoolSection.SectionIdx);
+    ELFSection &CstPool = EW.getConstantPoolSection(CPE);
+    CPLocations.push_back(CstPool.size());
+    CPSections.push_back(CstPool.SectionIdx);
 
     if (CPE.isMachineConstantPoolEntry())
       assert("CPE.isMachineConstantPoolEntry not supported yet");
 
     // Emit the constant to constant pool section
-    EW.EmitGlobalConstant(CPE.Val.ConstVal, CstPoolSection);
+    EW.EmitGlobalConstant(CPE.Val.ConstVal, CstPool);
   }
 }
 
@@ -160,13 +154,10 @@ void ELFCodeEmitter::emitJumpTables(MachineJumpTableInfo *MJTI) {
   assert(TM.getRelocationModel() != Reloc::PIC_ &&
          "PIC codegen not yet handled for elf jump tables!");
 
-  const TargetAsmInfo *TAI = TM.getTargetAsmInfo();
   const TargetELFWriterInfo *TEW = TM.getELFWriterInfo();
 
   // Get the ELF Section to emit the jump table
-  unsigned Align = TM.getTargetData()->getPointerABIAlignment();
-  std::string JTName(TAI->getJumpTableDataSection());
-  ELFSection &JTSection = EW.getJumpTableSection(JTName, Align);
+  ELFSection &JTSection = EW.getJumpTableSection();
   JumpTableSectionIdx = JTSection.SectionIdx;
 
   // Entries in the JT Section are relocated against the text section

lib/CodeGen/ELFWriter.cpp

@@ -145,6 +145,24 @@ bool ELFWriter::doInitialization(Module &M) {
   return false;
 }
 
+/// Get jump table section on the section name returned by TAI
+ELFSection &ELFWriter::getJumpTableSection() {
+  unsigned Align = TM.getTargetData()->getPointerABIAlignment();
+  return getSection(TAI->getJumpTableDataSection(),
+                    ELFSection::SHT_PROGBITS,
+                    ELFSection::SHF_ALLOC, Align);
+}
+
+///  Get a constant pool section based on the section name returned by TAI
+ELFSection &ELFWriter::getConstantPoolSection(MachineConstantPoolEntry &CPE) {
+  std::string CstPoolName =
+    TAI->SelectSectionForMachineConst(CPE.getType())->getName();
+  return getSection(CstPoolName,
+                    ELFSection::SHT_PROGBITS,
+                    ELFSection::SHF_MERGE | ELFSection::SHF_ALLOC,
+                    CPE.getAlignment());
+}
+
 // getGlobalELFVisibility - Returns the ELF specific visibility type
 unsigned ELFWriter::getGlobalELFVisibility(const GlobalValue *GV) {
   switch (GV->getVisibility()) {
@@ -513,9 +531,14 @@ void ELFWriter::EmitRelocations() {
           Addend = TEW->getDefaultAddendForRelTy(RelType);
         }
       } else {
-        // Get the symbol index for the section symbol referenced
-        // by the relocation
+        // Get the symbol index for the section symbol
         unsigned SectionIdx = MR.getConstantVal();
+
+        // Handle Jump Table Index relocation
+        if ((SectionIdx == getJumpTableSection().SectionIdx) &&
+            TEW->hasCustomJumpTableIndexRelTy())
+          RelType = TEW->getJumpTableIndexRelTy();
+
         SymIdx = SectionList[SectionIdx]->getSymbolTableIndex();
         Addend = (uint64_t)MR.getResultPointer();
       }

lib/CodeGen/ELFWriter.h

@@ -29,6 +29,7 @@ namespace llvm {
   class GlobalVariable;
   class Mangler;
   class MachineCodeEmitter;
+  class MachineConstantPoolEntry;
   class ObjectCodeEmitter;
   class TargetAsmInfo;
   class TargetELFWriterInfo;
@@ -170,18 +171,6 @@ namespace llvm {
                         ELFSection::SHF_EXECINSTR | ELFSection::SHF_ALLOC);
     }
 
-    /// Get jump table section on the section name returned by TAI
-    ELFSection &getJumpTableSection(std::string SName, unsigned Align) {
-      return getSection(SName, ELFSection::SHT_PROGBITS,
-                        ELFSection::SHF_ALLOC, Align);
-    }
-
-    /// Get a constant pool section based on the section name returned by TAI
-    ELFSection &getConstantPoolSection(std::string SName, unsigned Align) {
-      return getSection(SName, ELFSection::SHT_PROGBITS,
-                        ELFSection::SHF_MERGE | ELFSection::SHF_ALLOC, Align);
-    }
-
     /// Return the relocation section of section 'S'. 'RelA' is true
     /// if the relocation section contains entries with addends.
     ELFSection &getRelocSection(std::string SName, bool RelA, unsigned Align) {
@@ -224,6 +213,9 @@ namespace llvm {
       return getSection("", ELFSection::SHT_NULL, 0);
     }
 
+    ELFSection &getJumpTableSection();
+    ELFSection &getConstantPoolSection(MachineConstantPoolEntry &CPE);
+
     // Helpers for obtaining ELF specific info.
     unsigned getGlobalELFBinding(const GlobalValue *GV);
     unsigned getGlobalELFType(const GlobalValue *GV);

lib/Target/X86/X86ELFWriterInfo.cpp

@@ -84,6 +84,7 @@ unsigned X86ELFWriterInfo::getRelocationTySize(unsigned RelTy) const {
     switch(RelTy) {
       case R_X86_64_PC32:
       case R_X86_64_32:
+      case R_X86_64_32S:
         return 32;
       case R_X86_64_64:
         return 64;

lib/Target/X86/X86ELFWriterInfo.h

@@ -49,6 +49,16 @@ namespace llvm {
     /// ELF relocation entry.
     virtual bool hasRelocationAddend() const { return is64Bit ? true : false; }
 
+    /// hasCustomJumpTableIndexRelTy - Returns true if the target has a
+    /// specific relocation type for a jump table index.
+    virtual bool hasCustomJumpTableIndexRelTy() const {
+      return is64Bit ? true : false;
+    }
+
+    /// getJumpTableIndexRelTy - Returns the target specific relocation type
+    /// for a jump table index.
+    virtual unsigned getJumpTableIndexRelTy() const { return R_X86_64_32S; }
+
     /// getAddendForRelTy - Gets the addend value for an ELF relocation entry
     /// based on the target relocation type
     virtual long int getDefaultAddendForRelTy(unsigned RelTy) const;