• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
X86PLT0(llvm::MCSectionData * pParent,unsigned int pSize)47 X86PLT0::X86PLT0(llvm::MCSectionData* pParent, unsigned int pSize)
48   : PLTEntry(pSize, pParent) { }
49 
X86PLT1(llvm::MCSectionData * pParent,unsigned int pSize)50 X86PLT1::X86PLT1(llvm::MCSectionData* pParent, unsigned int pSize)
51   : PLTEntry(pSize, pParent) { }
52 
53 //===----------------------------------------------------------------------===//
54 // X86PLT
55 
X86PLT(LDSection & pSection,llvm::MCSectionData & pSectionData,X86GOT & pGOTPLT,const Output & pOutput)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 
~X86PLT()82 X86PLT::~X86PLT()
83 {
84 }
85 
reserveEntry(size_t pNum)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 
getPLTEntry(const ResolveInfo & pSymbol,bool & pExist)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 
getGOTPLTEntry(const ResolveInfo & pSymbol,bool & pExist)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 
getPLT0() const162 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.
applyPLT0()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.
applyPLT1()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