Use R_X86_64_32S to handle Jump Table Index relocation entries. Hide TAI usage inside...
authorBruno Cardoso Lopes <bruno.cardoso@gmail.com>
Sat, 18 Jul 2009 23:24:01 +0000 (23:24 +0000)
committerBruno Cardoso Lopes <bruno.cardoso@gmail.com>
Sat, 18 Jul 2009 23:24:01 +0000 (23:24 +0000)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@76347 91177308-0d34-0410-b5e6-96231b3b80d8

include/llvm/Target/TargetELFWriterInfo.h
lib/CodeGen/ELFCodeEmitter.cpp
lib/CodeGen/ELFWriter.cpp
lib/CodeGen/ELFWriter.h
lib/Target/X86/X86ELFWriterInfo.cpp
lib/Target/X86/X86ELFWriterInfo.h

index 7eb53529af98b3dae2309623ce980a36509f843b..b583572cc907b6842b54043d2fda7959eaa167b6 100644 (file)
@@ -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;
index 6e502465942b265d536cbbf82818e81ad08d51f0..23210fcbc70c39e0c8d1912821e31c3a67e442e3 100644 (file)
@@ -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
index 69220f9aeaad9155d68834ee58d27b375017c781..527adb821e7bab79a934e2ff737dada1152c840a 100644 (file)
@@ -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();
       }
index 89ab00c397dbe3e7e4599b395294e04681bb623b..ec2e44ac2caf17ca7cd880bd40175fad7cb06e25 100644 (file)
@@ -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);
index 4e4b6f1d9177f835111aa094b5398cb54c344faa..9e44f97ca800d38802d780cfcb07f01f1dc65956 100644 (file)
@@ -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;
index 7782a5b12fb7d92d0eb709d19cf91569ad642408..e534e17f28ab734562a1cd63be6483659772c00a 100644 (file)
@@ -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;