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
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
|
//===- ARMLDBackend.h -----------------------------------------------------===//
//
// The MCLinker Project
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef MCLD_ARM_LDBACKEND_H
#define MCLD_ARM_LDBACKEND_H
#include "ARMELFDynamic.h"
#include "ARMGOT.h"
#include "ARMPLT.h"
#include <mcld/LD/LDSection.h>
#include <mcld/Target/GNULDBackend.h>
#include <mcld/Target/OutputRelocSection.h>
namespace mcld {
class ARMELFAttributeData;
class LinkerConfig;
class GNUInfo;
//===----------------------------------------------------------------------===//
/// ARMGNULDBackend - linker backend of ARM target of GNU ELF format
///
class ARMGNULDBackend : public GNULDBackend
{
public:
// max branch offsets for ARM, THUMB, and THUMB2
// @ref gold/arm.cc:99
static const int32_t ARM_MAX_FWD_BRANCH_OFFSET = ((((1 << 23) - 1) << 2) + 8);
static const int32_t ARM_MAX_BWD_BRANCH_OFFSET = ((-((1 << 23) << 2)) + 8);
static const int32_t THM_MAX_FWD_BRANCH_OFFSET = ((1 << 22) -2 + 4);
static const int32_t THM_MAX_BWD_BRANCH_OFFSET = (-(1 << 22) + 4);
static const int32_t THM2_MAX_FWD_BRANCH_OFFSET = (((1 << 24) - 2) + 4);
static const int32_t THM2_MAX_BWD_BRANCH_OFFSET = (-(1 << 24) + 4);
public:
ARMGNULDBackend(const LinkerConfig& pConfig, GNUInfo* pInfo);
~ARMGNULDBackend();
public:
typedef std::vector<llvm::ELF::Elf32_Dyn*> ELF32DynList;
public:
/// initTargetSections - initialize target dependent sections in output.
void initTargetSections(Module& pModule, ObjectBuilder& pBuilder);
/// initTargetSymbols - initialize target dependent symbols in output.
void initTargetSymbols(IRBuilder& pBuilder, Module& pModule);
/// initRelocator - create and initialize Relocator.
bool initRelocator();
/// getRelocator - return relocator.
Relocator* getRelocator();
/// doPreLayout - Backend can do any needed modification before layout
void doPreLayout(IRBuilder& pBuilder);
/// doPostLayout -Backend can do any needed modification after layout
void doPostLayout(Module& pModule, IRBuilder& pBuilder);
/// dynamic - the dynamic section of the target machine.
/// Use co-variant return type to return its own dynamic section.
ARMELFDynamic& dynamic();
/// dynamic - the dynamic section of the target machine.
/// Use co-variant return type to return its own dynamic section.
const ARMELFDynamic& dynamic() const;
/// emitSectionData - write out the section data into the memory region.
/// When writers get a LDSection whose kind is LDFileFormat::Target, writers
/// call back target backend to emit the data.
///
/// Backends handle the target-special tables (plt, gp,...) by themselves.
/// Backend can put the data of the tables in SectionData directly
/// - LDSection.getSectionData can get the section data.
/// Or, backend can put the data into special data structure
/// - backend can maintain its own map<LDSection, table> to get the table
/// from given LDSection.
///
/// @param pSection - the given LDSection
/// @param pConfig - all options in the command line.
/// @param pRegion - the region to write out data
/// @return the size of the table in the file.
uint64_t emitSectionData(const LDSection& pSection,
MemoryRegion& pRegion) const;
ARMGOT& getGOT();
const ARMGOT& getGOT() const;
ARMPLT& getPLT();
const ARMPLT& getPLT() const;
OutputRelocSection& getRelDyn();
const OutputRelocSection& getRelDyn() const;
OutputRelocSection& getRelPLT();
const OutputRelocSection& getRelPLT() const;
ARMELFAttributeData& getAttributeData();
const ARMELFAttributeData& getAttributeData() const;
LDSymbol* getGOTSymbol() { return m_pGOTSymbol; }
const LDSymbol* getGOTSymbol() const { return m_pGOTSymbol; }
/// getTargetSectionOrder - compute the layout order of ARM target sections
unsigned int getTargetSectionOrder(const LDSection& pSectHdr) const;
/// finalizeTargetSymbols - finalize the symbol value
bool finalizeTargetSymbols();
/// mergeSection - merge target dependent sections
bool mergeSection(Module& pModule, const Input& pInput, LDSection& pSection);
/// setUpReachedSectionsForGC - set the reference from section XXX to
/// .ARM.exidx.XXX to make sure GC correctly handle section exidx
void setUpReachedSectionsForGC(const Module& pModule,
GarbageCollection::SectionReachedListMap& pSectReachedListMap) const;
/// readSection - read target dependent sections
bool readSection(Input& pInput, SectionData& pSD);
private:
void defineGOTSymbol(IRBuilder& pBuilder);
/// maxBranchOffset
/// FIXME: if we can handle arm attributes, we may refine this!
uint64_t maxBranchOffset() { return THM_MAX_FWD_BRANCH_OFFSET; }
/// mayRelax - Backends should override this function if they need relaxation
bool mayRelax() { return true; }
/// doRelax - Backend can orevride this function to add its relaxation
/// implementation. Return true if the output (e.g., .text) is "relaxed"
/// (i.e. layout is changed), and set pFinished to true if everything is fit,
/// otherwise set it to false.
bool doRelax(Module& pModule, IRBuilder& pBuilder, bool& pFinished);
/// initTargetStubs
bool initTargetStubs();
/// getRelEntrySize - the size in BYTE of rel type relocation
size_t getRelEntrySize()
{ return 8; }
/// getRelEntrySize - the size in BYTE of rela type relocation
size_t getRelaEntrySize()
{ assert(0 && "ARM backend with Rela type relocation\n"); return 12; }
/// doCreateProgramHdrs - backend can implement this function to create the
/// target-dependent segments
virtual void doCreateProgramHdrs(Module& pModule);
private:
Relocator* m_pRelocator;
ARMGOT* m_pGOT;
ARMPLT* m_pPLT;
/// m_RelDyn - dynamic relocation table of .rel.dyn
OutputRelocSection* m_pRelDyn;
/// m_RelPLT - dynamic relocation table of .rel.plt
OutputRelocSection* m_pRelPLT;
/// m_pAttrData - attribute data in public ("aeabi") attribute subsection
ARMELFAttributeData* m_pAttrData;
ARMELFDynamic* m_pDynamic;
LDSymbol* m_pGOTSymbol;
LDSymbol* m_pEXIDXStart;
LDSymbol* m_pEXIDXEnd;
// variable name : ELF
LDSection* m_pEXIDX; // .ARM.exidx
LDSection* m_pEXTAB; // .ARM.extab
LDSection* m_pAttributes; // .ARM.attributes
// LDSection* m_pPreemptMap; // .ARM.preemptmap
// LDSection* m_pDebugOverlay; // .ARM.debug_overlay
// LDSection* m_pOverlayTable; // .ARM.overlay_table
};
} // namespace of mcld
#endif
|
