1 //===- X86PLT.cpp -----------------------------------------------------------===// 2 // 3 // The MCLinker Project 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 #include "X86GOT.h" 10 #include "X86PLT.h" 11 #include <llvm/Support/raw_ostream.h> 12 #include <llvm/Support/ErrorHandling.h> 13 #include <llvm/Support/ELF.h> 14 #include <mcld/MC/MCLDOutput.h> 15 #include <new> 16 17 namespace { 18 19 const uint8_t x86_dyn_plt0[] = { 20 0xff, 0xb3, 0x04, 0, 0, 0, // pushl 0x4(%ebx) 21 0xff, 0xa3, 0x08, 0, 0, 0, // jmp *0x8(%ebx) 22 0xf, 0x1f, 0x4, 0 // nopl 0(%eax) 23 }; 24 25 const uint8_t x86_dyn_plt1[] = { 26 0xff, 0xa3, 0, 0, 0, 0, // jmp *sym@GOT(%ebx) 27 0x68, 0, 0, 0, 0, // pushl $offset 28 0xe9, 0, 0, 0, 0 // jmp plt0 29 }; 30 31 const uint8_t x86_exec_plt0[] = { 32 0xff, 0x35, 0, 0, 0, 0, // pushl .got + 4 33 0xff, 0x25, 0, 0, 0, 0, // jmp *(.got + 8) 34 0xf, 0x1f, 0x4, 0 // nopl 0(%eax) 35 }; 36 37 const uint8_t x86_exec_plt1[] = { 38 0xff, 0x25, 0, 0, 0, 0, // jmp *(sym in .got) 39 0x68, 0, 0, 0, 0, // pushl $offset 40 0xe9, 0, 0, 0, 0 // jmp plt0 41 }; 42 43 } 44 45 namespace mcld { 46 47 X86PLT0::X86PLT0(llvm::MCSectionData* pParent, unsigned int pSize) 48 : PLTEntry(pSize, pParent) { } 49 50 X86PLT1::X86PLT1(llvm::MCSectionData* pParent, unsigned int pSize) 51 : PLTEntry(pSize, pParent) { } 52 53 //===----------------------------------------------------------------------===// 54 // X86PLT 55 56 X86PLT::X86PLT(LDSection& pSection, 57 llvm::MCSectionData& pSectionData, 58 X86GOT &pGOTPLT, 59 const Output& pOutput) 60 : PLT(pSection, pSectionData), m_GOT(pGOTPLT), m_PLTEntryIterator() 61 { 62 assert (Output::DynObj == pOutput.type() || Output::Exec == pOutput.type()); 63 if (Output::DynObj == pOutput.type()) { 64 m_PLT0 = x86_dyn_plt0; 65 m_PLT1 = x86_dyn_plt1; 66 m_PLT0Size = sizeof (x86_dyn_plt0); 67 m_PLT1Size = sizeof (x86_dyn_plt1); 68 } 69 else { 70 m_PLT0 = x86_exec_plt0; 71 m_PLT1 = x86_exec_plt1; 72 m_PLT0Size = sizeof (x86_exec_plt0); 73 m_PLT1Size = sizeof (x86_exec_plt1); 74 } 75 X86PLT0* plt0_entry = new X86PLT0(&m_SectionData, m_PLT0Size); 76 77 m_Section.setSize(m_Section.size() + plt0_entry->getEntrySize()); 78 79 m_PLTEntryIterator = pSectionData.begin(); 80 } 81 82 X86PLT::~X86PLT() 83 { 84 } 85 86 void X86PLT::reserveEntry(size_t pNum) 87 { 88 X86PLT1* plt1_entry = 0; 89 GOTEntry* got_entry = 0; 90 91 for (size_t i = 0; i < pNum; ++i) { 92 plt1_entry = new (std::nothrow) X86PLT1(&m_SectionData, m_PLT1Size); 93 94 if (!plt1_entry) 95 llvm::report_fatal_error("Allocating new memory for X86PLT1 failed!"); 96 97 m_Section.setSize(m_Section.size() + plt1_entry->getEntrySize()); 98 99 got_entry= new (std::nothrow) GOTEntry(0, m_GOT.getEntrySize(), 100 &(m_GOT.m_SectionData)); 101 102 if (!got_entry) 103 llvm::report_fatal_error("Allocating new memory for GOT failed!"); 104 105 m_GOT.m_Section.setSize(m_GOT.m_Section.size() + m_GOT.f_EntrySize); 106 107 ++(m_GOT.m_GOTPLTNum); 108 ++(m_GOT.m_GeneralGOTIterator); 109 } 110 } 111 112 PLTEntry* X86PLT::getPLTEntry(const ResolveInfo& pSymbol, bool& pExist) 113 { 114 X86PLT1 *&PLTEntry = m_PLTEntryMap[&pSymbol]; 115 116 pExist = 1; 117 118 if (!PLTEntry) { 119 GOTEntry *&GOTPLTEntry = m_GOT.m_GOTPLTMap[&pSymbol]; 120 assert(!GOTPLTEntry && "PLT entry and got.plt entry doesn't match!"); 121 122 pExist = 0; 123 124 // This will skip PLT0. 125 ++m_PLTEntryIterator; 126 assert(m_PLTEntryIterator != m_SectionData.end() && 127 "The number of PLT Entries and ResolveInfo doesn't match"); 128 ++(m_GOT.m_GOTPLTIterator); 129 130 PLTEntry = llvm::cast<X86PLT1>(&(*m_PLTEntryIterator)); 131 GOTPLTEntry = llvm::cast<GOTEntry>(&(*(m_GOT.m_GOTPLTIterator))); 132 } 133 134 return PLTEntry; 135 } 136 137 GOTEntry* X86PLT::getGOTPLTEntry(const ResolveInfo& pSymbol, bool& pExist) 138 { 139 GOTEntry *&GOTPLTEntry = m_GOT.m_GOTPLTMap[&pSymbol]; 140 141 pExist = 1; 142 143 if (!GOTPLTEntry) { 144 X86PLT1 *&PLTEntry = m_PLTEntryMap[&pSymbol]; 145 assert(!PLTEntry && "PLT entry and got.plt entry doesn't match!"); 146 147 pExist = 0; 148 149 // This will skip PLT0. 150 ++m_PLTEntryIterator; 151 assert(m_PLTEntryIterator != m_SectionData.end() && 152 "The number of PLT Entries and ResolveInfo doesn't match"); 153 ++(m_GOT.m_GOTPLTIterator); 154 155 PLTEntry = llvm::cast<X86PLT1>(&(*m_PLTEntryIterator)); 156 GOTPLTEntry = llvm::cast<GOTEntry>(&(*(m_GOT.m_GOTPLTIterator))); 157 } 158 159 return GOTPLTEntry; 160 } 161 162 X86PLT0* X86PLT::getPLT0() const { 163 164 iterator first = m_SectionData.getFragmentList().begin(); 165 iterator end = m_SectionData.getFragmentList().end(); 166 167 assert(first!=end && "FragmentList is empty, getPLT0 failed!"); 168 169 X86PLT0* plt0 = &(llvm::cast<X86PLT0>(*first)); 170 171 return plt0; 172 } 173 174 // FIXME: It only works on little endian machine. 175 void X86PLT::applyPLT0() { 176 177 iterator first = m_SectionData.getFragmentList().begin(); 178 iterator end = m_SectionData.getFragmentList().end(); 179 180 assert(first!=end && "FragmentList is empty, applyPLT0 failed!"); 181 182 X86PLT0* plt0 = &(llvm::cast<X86PLT0>(*first)); 183 184 unsigned char* data = 0; 185 data = static_cast<unsigned char*>(malloc(plt0->getEntrySize())); 186 187 if (!data) 188 llvm::report_fatal_error("Allocating new memory for plt0 failed!"); 189 190 memcpy(data, m_PLT0, plt0->getEntrySize()); 191 192 if (m_PLT0 == x86_exec_plt0) { 193 uint64_t got_base = m_GOT.getSection().addr(); 194 assert(got_base && ".got base address is NULL!"); 195 uint32_t *offset = reinterpret_cast<uint32_t*>(data + 2); 196 *offset = got_base + 4; 197 offset = reinterpret_cast<uint32_t*>(data + 8); 198 *offset = got_base + 8; 199 } 200 201 plt0->setContent(data); 202 } 203 204 // FIXME: It only works on little endian machine. 205 void X86PLT::applyPLT1() { 206 207 uint64_t plt_base = m_Section.addr(); 208 assert(plt_base && ".plt base address is NULL!"); 209 210 uint64_t got_base = m_GOT.getSection().addr(); 211 assert(got_base && ".got base address is NULL!"); 212 213 X86PLT::iterator it = m_SectionData.begin(); 214 X86PLT::iterator ie = m_SectionData.end(); 215 assert(it!=ie && "FragmentList is empty, applyPLT1 failed!"); 216 217 uint64_t GOTEntrySize = m_GOT.getEntrySize(); 218 219 // Skip GOT0 220 uint64_t GOTEntryOffset = GOTEntrySize * X86GOT0Num; 221 222 //skip PLT0 223 uint64_t PLTEntryOffset = m_PLT0Size; 224 ++it; 225 226 X86PLT1* plt1 = 0; 227 228 uint64_t PLTRelOffset = 0; 229 230 while (it != ie) { 231 plt1 = &(llvm::cast<X86PLT1>(*it)); 232 unsigned char *data; 233 data = static_cast<unsigned char*>(malloc(plt1->getEntrySize())); 234 235 if (!data) 236 llvm::report_fatal_error("Allocating new memory for plt1 failed!"); 237 238 memcpy(data, m_PLT1, plt1->getEntrySize()); 239 240 uint32_t* offset; 241 242 offset = reinterpret_cast<uint32_t*>(data + 2); 243 *offset = GOTEntryOffset; 244 GOTEntryOffset += GOTEntrySize; 245 246 offset = reinterpret_cast<uint32_t*>(data + 7); 247 *offset = PLTRelOffset; 248 PLTRelOffset += sizeof (llvm::ELF::Elf32_Rel); 249 250 offset = reinterpret_cast<uint32_t*>(data + 12); 251 *offset = -(PLTEntryOffset + 12 + 4); 252 PLTEntryOffset += m_PLT1Size; 253 254 plt1->setContent(data); 255 ++it; 256 } 257 258 unsigned int GOTPLTNum = m_GOT.getGOTPLTNum(); 259 260 if (GOTPLTNum != 0) { 261 X86GOT::iterator gotplt_it = m_GOT.getLastGOT0(); 262 X86GOT::iterator list_ie = m_GOT.getSectionData().getFragmentList().end(); 263 264 ++gotplt_it; 265 uint64_t PLTEntryAddress = plt_base + m_PLT0Size; 266 for (unsigned int i = 0; i < GOTPLTNum; ++i) { 267 if (gotplt_it == list_ie) 268 llvm::report_fatal_error( 269 "The number of got.plt entries is inconsistent!"); 270 271 llvm::cast<GOTEntry>(*gotplt_it).setContent(PLTEntryAddress + 6); 272 PLTEntryAddress += m_PLT1Size; 273 ++gotplt_it; 274 } 275 } 276 } 277 278 } // end namespace mcld 279
