HexagonPLT.cpp revision f7ac0f19a1c8d0ad14bcf6456ce368b830fea886 
1//===- HexagonPLT.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 "HexagonPLT.h"
10#include "HexagonRelocationFunctions.h"
11
12#include <llvm/Support/ELF.h>
13#include <llvm/Support/Casting.h>
14
15#include <mcld/LD/LDSection.h>
16#include <mcld/LinkerConfig.h>
17#include <mcld/Support/MsgHandling.h>
18
19using namespace mcld;
20
21//===----------------------------------------------------------------------===//
22// PLT entry data
23//===----------------------------------------------------------------------===//
24HexagonPLT0::HexagonPLT0(SectionData& pParent)
25  : PLT::Entry<sizeof(hexagon_plt0)>(pParent)
26{
27}
28
29HexagonPLT1::HexagonPLT1(SectionData& pParent)
30  : PLT::Entry<sizeof(hexagon_plt1)>(pParent)
31{
32}
33
34//===----------------------------------------------------------------------===//
35// HexagonPLT
36//===----------------------------------------------------------------------===//
37HexagonPLT::HexagonPLT(LDSection& pSection,
38               HexagonGOTPLT &pGOTPLT,
39               const LinkerConfig& pConfig)
40  : PLT(pSection),
41    m_GOTPLT(pGOTPLT),
42    m_Config(pConfig)
43{
44  assert(LinkerConfig::DynObj == m_Config.codeGenType() ||
45         LinkerConfig::Exec   == m_Config.codeGenType() ||
46         LinkerConfig::Binary == m_Config.codeGenType());
47
48  m_PLT0 = hexagon_plt0;
49  m_PLT0Size = sizeof (hexagon_plt0);
50  // create PLT0
51  new HexagonPLT0(*m_SectionData);
52  m_Last = m_SectionData->begin();
53  pSection.setAlign(16);
54}
55
56HexagonPLT::~HexagonPLT()
57{
58}
59
60PLTEntryBase* HexagonPLT::getPLT0() const
61{
62  iterator first = m_SectionData->getFragmentList().begin();
63
64  assert(first != m_SectionData->getFragmentList().end() &&
65         "FragmentList is empty, getPLT0 failed!");
66
67  PLTEntryBase* plt0 = &(llvm::cast<PLTEntryBase>(*first));
68
69  return plt0;
70}
71
72void HexagonPLT::finalizeSectionSize()
73{
74  uint64_t size = 0;
75  // plt0 size
76  size = getPLT0()->size();
77
78  // get first plt1 entry
79  HexagonPLT::iterator it = begin();
80  ++it;
81  if (end() != it) {
82    // plt1 size
83    PLTEntryBase* plt1 = &(llvm::cast<PLTEntryBase>(*it));
84    size += (m_SectionData->size() - 1) * plt1->size();
85  }
86  m_Section.setSize(size);
87
88  uint32_t offset = 0;
89  SectionData::iterator frag, fragEnd = m_SectionData->end();
90  for (frag = m_SectionData->begin(); frag != fragEnd; ++frag) {
91    frag->setOffset(offset);
92    offset += frag->size();
93  }
94}
95
96bool HexagonPLT::hasPLT1() const
97{
98  return (m_SectionData->size() > 1);
99}
100
101void HexagonPLT::reserveEntry(size_t pNum)
102{
103  PLTEntryBase* plt1_entry = NULL;
104
105  for (size_t i = 0; i < pNum; ++i) {
106    plt1_entry = new HexagonPLT1(*m_SectionData);
107
108    if (NULL == plt1_entry)
109      fatal(diag::fail_allocate_memory_plt);
110  }
111}
112
113HexagonPLT1* HexagonPLT::consume()
114{
115  ++m_Last;
116  assert(m_Last != m_SectionData->end() &&
117         "The number of PLT Entries and ResolveInfo doesn't match");
118
119  return llvm::cast<HexagonPLT1>(&(*m_Last));
120}
121
122void HexagonPLT::applyPLT0()
123{
124  PLTEntryBase* plt0 = getPLT0();
125  uint64_t pltBase = m_Section.addr();
126
127  unsigned char* data = 0;
128  data = static_cast<unsigned char*>(malloc(plt0->size()));
129
130  if (!data)
131    fatal(diag::fail_allocate_memory_plt);
132
133  memcpy(data, m_PLT0, plt0->size());
134  uint32_t gotpltAddr = m_GOTPLT.addr();
135
136  int32_t *dest = (int32_t *)data;
137  int32_t result = ((gotpltAddr - pltBase ) >> 6);
138  *dest |= ApplyMask<int32_t>(0xfff3fff, result);
139  dest = dest + 1;
140  // Already calculated using pltBase
141  result = (gotpltAddr - pltBase);
142  *(dest) |= ApplyMask<int32_t>(0x1f80, result);
143
144  plt0->setValue(data);
145}
146
147void HexagonPLT::applyPLT1() {
148
149  uint64_t plt_base = m_Section.addr();
150  assert(plt_base && ".plt base address is NULL!");
151
152  uint64_t got_base = m_GOTPLT.addr();
153  assert(got_base && ".got base address is NULL!");
154
155  HexagonPLT::iterator it = m_SectionData->begin();
156  HexagonPLT::iterator ie = m_SectionData->end();
157  assert(it != ie && "FragmentList is empty, applyPLT1 failed!");
158
159  uint32_t GOTEntrySize = HexagonGOTEntry::EntrySize;
160  uint32_t GOTEntryAddress =
161    got_base +  GOTEntrySize * 4;
162
163  uint64_t PLTEntryAddress =
164    plt_base + HexagonPLT0::EntrySize; //Offset of PLT0
165
166  ++it; //skip PLT0
167  uint64_t PLT1EntrySize = HexagonPLT1::EntrySize;
168  HexagonPLT1* plt1 = NULL;
169
170  uint32_t* Out = NULL;
171  while (it != ie) {
172    plt1 = &(llvm::cast<HexagonPLT1>(*it));
173    Out = static_cast<uint32_t*>(malloc(HexagonPLT1::EntrySize));
174
175    if (!Out)
176      fatal(diag::fail_allocate_memory_plt);
177
178    memcpy(Out, hexagon_plt1, plt1->size());
179
180    int32_t *dest = (int32_t *)Out;
181    int32_t result = ((GOTEntryAddress - PLTEntryAddress ) >> 6);
182    *dest |= ApplyMask<int32_t>(0xfff3fff, result);
183    dest = dest + 1;
184    result = (GOTEntryAddress - PLTEntryAddress);
185    *(dest) |= ApplyMask<int32_t>(0x1f80, result);
186
187    // Address in the PLT entries point to the corresponding GOT entries
188    // TODO: Fixup plt to point to the corresponding GOTEntryAddress
189    // We need to borrow the same relocation code to fix the relocation
190    plt1->setValue(reinterpret_cast<unsigned char*>(Out));
191    ++it;
192
193    GOTEntryAddress += GOTEntrySize;
194    PLTEntryAddress += PLT1EntrySize;
195  }
196}
197
198uint64_t HexagonPLT::emit(MemoryRegion& pRegion)
199{
200  uint64_t result = 0x0;
201  iterator it = begin();
202
203  unsigned char* buffer = pRegion.getBuffer();
204  memcpy(buffer, llvm::cast<HexagonPLT0>((*it)).getValue(), HexagonPLT0::EntrySize);
205  result += HexagonPLT0::EntrySize;
206  ++it;
207
208  HexagonPLT1* plt1 = 0;
209  HexagonPLT::iterator ie = end();
210  while (it != ie) {
211    plt1 = &(llvm::cast<HexagonPLT1>(*it));
212    memcpy(buffer + result, plt1->getValue(), HexagonPLT1::EntrySize);
213    result += HexagonPLT1::EntrySize;
214    ++it;
215  }
216  return result;
217}
218
219