Coverage Report

Created: 2018-01-17 17:22

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/lld/ELF/Arch/PPC64.cpp
Line
Count
Source (jump to first uncovered line)
1
//===- PPC64.cpp ----------------------------------------------------------===//
2
//
3
//                             The LLVM Linker
4
//
5
// This file is distributed under the University of Illinois Open Source
6
// License. See LICENSE.TXT for details.
7
//
8
//===----------------------------------------------------------------------===//
9
10
#include "Symbols.h"
11
#include "SyntheticSections.h"
12
#include "Target.h"
13
#include "lld/Common/ErrorHandler.h"
14
#include "llvm/Support/Endian.h"
15
16
using namespace llvm;
17
using namespace llvm::support::endian;
18
using namespace llvm::ELF;
19
using namespace lld;
20
using namespace lld::elf;
21
22
static uint64_t PPC64TocOffset = 0x8000;
23
24
12
uint64_t elf::getPPC64TocBase() {
25
12
  // The TOC consists of sections .got, .toc, .tocbss, .plt in that order. The
26
12
  // TOC starts where the first of these sections starts. We always create a
27
12
  // .got when we see a relocation that uses it, so for us the start is always
28
12
  // the .got.
29
12
  uint64_t TocVA = InX::Got->getVA();
30
12
31
12
  // Per the ppc64-elf-linux ABI, The TOC base is TOC value plus 0x8000
32
12
  // thus permitting a full 64 Kbytes segment. Note that the glibc startup
33
12
  // code (crt1.o) assumes that you can get from the TOC base to the
34
12
  // start of the .toc section with only a single (signed) 16-bit relocation.
35
12
  return TocVA + PPC64TocOffset;
36
12
}
37
38
namespace {
39
class PPC64 final : public TargetInfo {
40
public:
41
  PPC64();
42
  RelExpr getRelExpr(RelType Type, const Symbol &S,
43
                     const uint8_t *Loc) const override;
44
  void writePlt(uint8_t *Buf, uint64_t GotPltEntryAddr, uint64_t PltEntryAddr,
45
                int32_t Index, unsigned RelOff) const override;
46
  void relocateOne(uint8_t *Loc, RelType Type, uint64_t Val) const override;
47
};
48
} // namespace
49
50
// Relocation masks following the #lo(value), #hi(value), #ha(value),
51
// #higher(value), #highera(value), #highest(value), and #highesta(value)
52
// macros defined in section 4.5.1. Relocation Types of the PPC-elf64abi
53
// document.
54
7
static uint16_t applyPPCLo(uint64_t V) { return V; }
55
2
static uint16_t applyPPCHi(uint64_t V) { return V >> 16; }
56
6
static uint16_t applyPPCHa(uint64_t V) { return (V + 0x8000) >> 16; }
57
1
static uint16_t applyPPCHigher(uint64_t V) { return V >> 32; }
58
1
static uint16_t applyPPCHighera(uint64_t V) { return (V + 0x8000) >> 32; }
59
1
static uint16_t applyPPCHighest(uint64_t V) { return V >> 48; }
60
1
static uint16_t applyPPCHighesta(uint64_t V) { return (V + 0x8000) >> 48; }
61
62
21
PPC64::PPC64() {
63
21
  PltRel = GotRel = R_PPC64_GLOB_DAT;
64
21
  RelativeRel = R_PPC64_RELATIVE;
65
21
  GotEntrySize = 8;
66
21
  GotPltEntrySize = 8;
67
21
  PltEntrySize = 32;
68
21
  PltHeaderSize = 0;
69
21
70
21
  // We need 64K pages (at least under glibc/Linux, the loader won't
71
21
  // set different permissions on a finer granularity than that).
72
21
  DefaultMaxPageSize = 65536;
73
21
74
21
  // The PPC64 ELF ABI v1 spec, says:
75
21
  //
76
21
  //   It is normally desirable to put segments with different characteristics
77
21
  //   in separate 256 Mbyte portions of the address space, to give the
78
21
  //   operating system full paging flexibility in the 64-bit address space.
79
21
  //
80
21
  // And because the lowest non-zero 256M boundary is 0x10000000, PPC64 linkers
81
21
  // use 0x10000000 as the starting address.
82
21
  DefaultImageBase = 0x10000000;
83
21
}
84
85
RelExpr PPC64::getRelExpr(RelType Type, const Symbol &S,
86
51
                          const uint8_t *Loc) const {
87
51
  switch (Type) {
88
51
  case R_PPC64_TOC16:
89
4
  case R_PPC64_TOC16_DS:
90
4
  case R_PPC64_TOC16_HA:
91
4
  case R_PPC64_TOC16_HI:
92
4
  case R_PPC64_TOC16_LO:
93
4
  case R_PPC64_TOC16_LO_DS:
94
4
    return R_GOTREL;
95
8
  case R_PPC64_TOC:
96
8
    return R_PPC_TOC;
97
11
  case R_PPC64_REL24:
98
11
    return R_PPC_PLT_OPD;
99
28
  default:
100
28
    return R_ABS;
101
0
  }
102
0
}
103
104
void PPC64::writePlt(uint8_t *Buf, uint64_t GotPltEntryAddr,
105
                     uint64_t PltEntryAddr, int32_t Index,
106
4
                     unsigned RelOff) const {
107
4
  uint64_t Off = GotPltEntryAddr - getPPC64TocBase();
108
4
109
4
  // FIXME: What we should do, in theory, is get the offset of the function
110
4
  // descriptor in the .opd section, and use that as the offset from %r2 (the
111
4
  // TOC-base pointer). Instead, we have the GOT-entry offset, and that will
112
4
  // be a pointer to the function descriptor in the .opd section. Using
113
4
  // this scheme is simpler, but requires an extra indirection per PLT dispatch.
114
4
115
4
  write32be(Buf, 0xf8410028);                       // std %r2, 40(%r1)
116
4
  write32be(Buf + 4, 0x3d620000 | applyPPCHa(Off)); // addis %r11, %r2, X@ha
117
4
  write32be(Buf + 8, 0xe98b0000 | applyPPCLo(Off)); // ld %r12, X@l(%r11)
118
4
  write32be(Buf + 12, 0xe96c0000);                  // ld %r11,0(%r12)
119
4
  write32be(Buf + 16, 0x7d6903a6);                  // mtctr %r11
120
4
  write32be(Buf + 20, 0xe84c0008);                  // ld %r2,8(%r12)
121
4
  write32be(Buf + 24, 0xe96c0010);                  // ld %r11,16(%r12)
122
4
  write32be(Buf + 28, 0x4e800420);                  // bctr
123
4
}
124
125
33
static std::pair<RelType, uint64_t> toAddr16Rel(RelType Type, uint64_t Val) {
126
33
  uint64_t V = Val - PPC64TocOffset;
127
33
  switch (Type) {
128
33
  case R_PPC64_TOC16:
129
0
    return {R_PPC64_ADDR16, V};
130
33
  case R_PPC64_TOC16_DS:
131
0
    return {R_PPC64_ADDR16_DS, V};
132
33
  case R_PPC64_TOC16_HA:
133
1
    return {R_PPC64_ADDR16_HA, V};
134
33
  case R_PPC64_TOC16_HI:
135
1
    return {R_PPC64_ADDR16_HI, V};
136
33
  case R_PPC64_TOC16_LO:
137
1
    return {R_PPC64_ADDR16_LO, V};
138
33
  case R_PPC64_TOC16_LO_DS:
139
1
    return {R_PPC64_ADDR16_LO_DS, V};
140
33
  default:
141
29
    return {Type, Val};
142
0
  }
143
0
}
144
145
33
void PPC64::relocateOne(uint8_t *Loc, RelType Type, uint64_t Val) const {
146
33
  // For a TOC-relative relocation, proceed in terms of the corresponding
147
33
  // ADDR16 relocation type.
148
33
  std::tie(Type, Val) = toAddr16Rel(Type, Val);
149
33
150
33
  switch (Type) {
151
33
  case R_PPC64_ADDR14: {
152
0
    checkAlignment<4>(Loc, Val, Type);
153
0
    // Preserve the AA/LK bits in the branch instruction
154
0
    uint8_t AALK = Loc[3];
155
0
    write16be(Loc + 2, (AALK & 3) | (Val & 0xfffc));
156
0
    break;
157
33
  }
158
33
  case R_PPC64_ADDR16:
159
1
    checkInt<16>(Loc, Val, Type);
160
1
    write16be(Loc, Val);
161
1
    break;
162
33
  case R_PPC64_ADDR16_DS:
163
0
    checkInt<16>(Loc, Val, Type);
164
0
    write16be(Loc, (read16be(Loc) & 3) | (Val & ~3));
165
0
    break;
166
33
  case R_PPC64_ADDR16_HA:
167
2
  case R_PPC64_REL16_HA:
168
2
    write16be(Loc, applyPPCHa(Val));
169
2
    break;
170
2
  case R_PPC64_ADDR16_HI:
171
2
  case R_PPC64_REL16_HI:
172
2
    write16be(Loc, applyPPCHi(Val));
173
2
    break;
174
2
  case R_PPC64_ADDR16_HIGHER:
175
1
    write16be(Loc, applyPPCHigher(Val));
176
1
    break;
177
2
  case R_PPC64_ADDR16_HIGHERA:
178
1
    write16be(Loc, applyPPCHighera(Val));
179
1
    break;
180
2
  case R_PPC64_ADDR16_HIGHEST:
181
1
    write16be(Loc, applyPPCHighest(Val));
182
1
    break;
183
2
  case R_PPC64_ADDR16_HIGHESTA:
184
1
    write16be(Loc, applyPPCHighesta(Val));
185
1
    break;
186
2
  case R_PPC64_ADDR16_LO:
187
2
    write16be(Loc, applyPPCLo(Val));
188
2
    break;
189
2
  case R_PPC64_ADDR16_LO_DS:
190
1
  case R_PPC64_REL16_LO:
191
1
    write16be(Loc, (read16be(Loc) & 3) | (applyPPCLo(Val) & ~3));
192
1
    break;
193
1
  case R_PPC64_ADDR32:
194
0
  case R_PPC64_REL32:
195
0
    checkInt<32>(Loc, Val, Type);
196
0
    write32be(Loc, Val);
197
0
    break;
198
10
  case R_PPC64_ADDR64:
199
10
  case R_PPC64_REL64:
200
10
  case R_PPC64_TOC:
201
10
    write64be(Loc, Val);
202
10
    break;
203
11
  case R_PPC64_REL24: {
204
11
    uint32_t Mask = 0x03FFFFFC;
205
11
    checkInt<24>(Loc, Val, Type);
206
11
    write32be(Loc, (read32be(Loc) & ~Mask) | (Val & Mask));
207
11
    break;
208
10
  }
209
10
  default:
210
0
    error(getErrorLocation(Loc) + "unrecognized reloc " + Twine(Type));
211
33
  }
212
33
}
213
214
21
TargetInfo *elf::getPPC64TargetInfo() {
215
21
  static PPC64 Target;
216
21
  return &Target;
217
21
}