1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
|
//===- HexagonRelocator.h ------------------------------------------------===//
//
// The MCLinker Project
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef HEXAGON_RELOCATION_FACTORY_H
#define HEXAGON_RELOCATION_FACTORY_H
#ifdef ENABLE_UNITTEST
#include <gtest.h>
#endif
#include <mcld/LD/Relocator.h>
#include <mcld/Target/GOT.h>
#include <mcld/Target/PLT.h>
#include <mcld/Target/KeyEntryMap.h>
#include "HexagonLDBackend.h"
namespace mcld {
class ResolveInfo;
class LinkerConfig;
/** \class HexagonRelocator
* \brief HexagonRelocator creates and destroys the Hexagon relocations.
*
*/
class HexagonRelocator : public Relocator
{
public:
typedef KeyEntryMap<ResolveInfo, PLTEntryBase> SymPLTMap;
typedef KeyEntryMap<ResolveInfo, HexagonGOTEntry> SymGOTMap;
typedef KeyEntryMap<ResolveInfo, HexagonGOTEntry> SymGOTPLTMap;
typedef KeyEntryMap<Relocation, Relocation> RelRelMap;
public:
/** \enum ReservedEntryType
* \brief The reserved entry type of reserved space in ResolveInfo.
*
* This is used for sacnRelocation to record what kinds of entries are
* reserved for this resolved symbol. In Hexagon, there are three kinds
* of entries, GOT, PLT, and dynamic relocation.
*
* bit: 3 2 1 0
* | | PLT | GOT | Rel |
*
* value Name - Description
*
* 0000 None - no reserved entry
* 0001 ReserveRel - reserve an dynamic relocation entry
* 0010 ReserveGOT - reserve an GOT entry
* 0100 ReservePLT - reserve an PLT entry and the corresponding GOT,
*
*/
enum ReservedEntryType {
None = 0,
ReserveRel = 1,
ReserveGOT = 2,
ReservePLT = 4,
};
/** \enum EntryValue
* \brief The value of the entries. The symbol value will be decided at after
* layout, so we mark the entry during scanRelocation and fill up the actual
* value when applying relocations.
*/
enum EntryValue {
Default = 0,
SymVal = 1
};
HexagonRelocator(HexagonLDBackend& pParent, const LinkerConfig& pConfig);
~HexagonRelocator();
Result applyRelocation(Relocation& pRelocation);
/// scanRelocation - determine the empty entries are needed or not and create
/// the empty entries if needed.
/// For Hexagon, following entries are check to create:
/// - GOT entry (for .got and .got.plt sections)
/// - PLT entry (for .plt section)
/// - dynamin relocation entries (for .rel.plt and .rel.dyn sections)
void scanRelocation(Relocation& pReloc,
IRBuilder& pBuilder,
Module& pModule,
LDSection& pSection,
Input& pInput);
// Handle partial linking
void partialScanRelocation(Relocation& pReloc,
Module& pModule,
const LDSection& pSection);
HexagonLDBackend& getTarget()
{ return m_Target; }
const HexagonLDBackend& getTarget() const
{ return m_Target; }
const char* getName(Relocation::Type pType) const;
Size getSize(Relocation::Type pType) const;
const SymPLTMap& getSymPLTMap() const { return m_SymPLTMap; }
SymPLTMap& getSymPLTMap() { return m_SymPLTMap; }
const SymGOTMap& getSymGOTMap() const { return m_SymGOTMap; }
SymGOTMap& getSymGOTMap() { return m_SymGOTMap; }
const SymGOTPLTMap& getSymGOTPLTMap() const { return m_SymGOTPLTMap; }
SymGOTPLTMap& getSymGOTPLTMap() { return m_SymGOTPLTMap; }
const RelRelMap& getRelRelMap() const { return m_RelRelMap; }
RelRelMap& getRelRelMap() { return m_RelRelMap; }
protected:
/// addCopyReloc - add a copy relocation into .rela.dyn for pSym
/// @param pSym - A resolved copy symbol that defined in BSS section
void addCopyReloc(ResolveInfo& pSym, HexagonLDBackend& pTarget);
/// defineSymbolforCopyReloc - allocate a space in BSS section and
/// and force define the copy of pSym to BSS section
/// @return the output LDSymbol of the copy symbol
LDSymbol& defineSymbolforCopyReloc(IRBuilder& pLinker,
const ResolveInfo& pSym,
HexagonLDBackend& pTarget);
private:
virtual void scanLocalReloc(Relocation& pReloc,
IRBuilder& pBuilder,
Module& pModule,
LDSection& pSection);
virtual void scanGlobalReloc(Relocation& pReloc,
IRBuilder& pBuilder,
Module& pModule,
LDSection& pSection);
HexagonLDBackend& m_Target;
SymPLTMap m_SymPLTMap;
SymGOTMap m_SymGOTMap;
SymGOTPLTMap m_SymGOTPLTMap;
RelRelMap m_RelRelMap;
};
} // namespace of mcld
#endif
|
