Coverage Report

Created: 2018-10-20 12:32

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/lld/ELF/Target.cpp
Line
Count
Source (jump to first uncovered line)
1
//===- Target.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
// Machine-specific things, such as applying relocations, creation of
11
// GOT or PLT entries, etc., are handled in this file.
12
//
13
// Refer the ELF spec for the single letter variables, S, A or P, used
14
// in this file.
15
//
16
// Some functions defined in this file has "relaxTls" as part of their names.
17
// They do peephole optimization for TLS variables by rewriting instructions.
18
// They are not part of the ABI but optional optimization, so you can skip
19
// them if you are not interested in how TLS variables are optimized.
20
// See the following paper for the details.
21
//
22
//   Ulrich Drepper, ELF Handling For Thread-Local Storage
23
//   http://www.akkadia.org/drepper/tls.pdf
24
//
25
//===----------------------------------------------------------------------===//
26
27
#include "Target.h"
28
#include "InputFiles.h"
29
#include "OutputSections.h"
30
#include "SymbolTable.h"
31
#include "Symbols.h"
32
#include "lld/Common/ErrorHandler.h"
33
#include "llvm/Object/ELF.h"
34
35
using namespace llvm;
36
using namespace llvm::object;
37
using namespace llvm::ELF;
38
using namespace lld;
39
using namespace lld::elf;
40
41
TargetInfo *elf::Target;
42
43
1.90k
std::string lld::toString(RelType Type) {
44
1.90k
  StringRef S = getELFRelocationTypeName(elf::Config->EMachine, Type);
45
1.90k
  if (S == "Unknown")
46
1
    return ("Unknown (" + Twine(Type) + ")").str();
47
1.90k
  return S;
48
1.90k
}
49
50
2.41k
TargetInfo *elf::getTarget() {
51
2.41k
  switch (Config->EMachine) {
52
2.41k
  case EM_386:
53
127
  case EM_IAMCU:
54
127
    return getX86TargetInfo();
55
127
  case EM_AARCH64:
56
97
    return getAArch64TargetInfo();
57
127
  case EM_AMDGPU:
58
7
    return getAMDGPUTargetInfo();
59
141
  case EM_ARM:
60
141
    return getARMTargetInfo();
61
127
  case EM_AVR:
62
0
    return getAVRTargetInfo();
63
127
  case EM_HEXAGON:
64
4
    return getHexagonTargetInfo();
65
181
  case EM_MIPS:
66
181
    switch (Config->EKind) {
67
181
    case ELF32LEKind:
68
17
      return getMipsTargetInfo<ELF32LE>();
69
181
    case ELF32BEKind:
70
117
      return getMipsTargetInfo<ELF32BE>();
71
181
    case ELF64LEKind:
72
2
      return getMipsTargetInfo<ELF64LE>();
73
181
    case ELF64BEKind:
74
45
      return getMipsTargetInfo<ELF64BE>();
75
181
    default:
76
0
      fatal("unsupported MIPS target");
77
0
    }
78
3
  case EM_PPC:
79
3
    return getPPCTargetInfo();
80
134
  case EM_PPC64:
81
134
    return getPPC64TargetInfo();
82
0
  case EM_RISCV:
83
0
    return getRISCVTargetInfo();
84
1
  case EM_SPARCV9:
85
1
    return getSPARCV9TargetInfo();
86
1.71k
  case EM_X86_64:
87
1.71k
    if (Config->EKind == ELF32LEKind)
88
3
      return getX32TargetInfo();
89
1.71k
    return getX86_64TargetInfo();
90
0
  }
91
0
  fatal("unknown target machine");
92
0
}
93
94
1.86k
template <class ELFT> static ErrorPlace getErrPlace(const uint8_t *Loc) {
95
1.93k
  for (InputSectionBase *D : InputSections) {
96
1.93k
    auto *IS = cast<InputSection>(D);
97
1.93k
    if (!IS->getParent())
98
2
      continue;
99
1.93k
100
1.93k
    uint8_t *ISLoc = IS->getParent()->Loc + IS->OutSecOff;
101
1.93k
    if (ISLoc <= Loc && Loc < ISLoc + IS->getSize())
102
1.86k
      return {IS, IS->template getLocation<ELFT>(Loc - ISLoc) + ": "};
103
1.93k
  }
104
1.86k
  
return {}2
;
105
1.86k
}
Target.cpp:lld::elf::ErrorPlace getErrPlace<llvm::object::ELFType<(llvm::support::endianness)1, false> >(unsigned char const*)
Line
Count
Source
94
3
template <class ELFT> static ErrorPlace getErrPlace(const uint8_t *Loc) {
95
3
  for (InputSectionBase *D : InputSections) {
96
3
    auto *IS = cast<InputSection>(D);
97
3
    if (!IS->getParent())
98
0
      continue;
99
3
100
3
    uint8_t *ISLoc = IS->getParent()->Loc + IS->OutSecOff;
101
3
    if (ISLoc <= Loc && Loc < ISLoc + IS->getSize())
102
3
      return {IS, IS->template getLocation<ELFT>(Loc - ISLoc) + ": "};
103
3
  }
104
3
  
return {}0
;
105
3
}
Target.cpp:lld::elf::ErrorPlace getErrPlace<llvm::object::ELFType<(llvm::support::endianness)0, false> >(unsigned char const*)
Line
Count
Source
94
1
template <class ELFT> static ErrorPlace getErrPlace(const uint8_t *Loc) {
95
1
  for (InputSectionBase *D : InputSections) {
96
1
    auto *IS = cast<InputSection>(D);
97
1
    if (!IS->getParent())
98
0
      continue;
99
1
100
1
    uint8_t *ISLoc = IS->getParent()->Loc + IS->OutSecOff;
101
1
    if (ISLoc <= Loc && Loc < ISLoc + IS->getSize())
102
1
      return {IS, IS->template getLocation<ELFT>(Loc - ISLoc) + ": "};
103
1
  }
104
1
  
return {}0
;
105
1
}
Target.cpp:lld::elf::ErrorPlace getErrPlace<llvm::object::ELFType<(llvm::support::endianness)1, true> >(unsigned char const*)
Line
Count
Source
94
43
template <class ELFT> static ErrorPlace getErrPlace(const uint8_t *Loc) {
95
108
  for (InputSectionBase *D : InputSections) {
96
108
    auto *IS = cast<InputSection>(D);
97
108
    if (!IS->getParent())
98
2
      continue;
99
106
100
106
    uint8_t *ISLoc = IS->getParent()->Loc + IS->OutSecOff;
101
106
    if (ISLoc <= Loc && Loc < ISLoc + IS->getSize())
102
41
      return {IS, IS->template getLocation<ELFT>(Loc - ISLoc) + ": "};
103
106
  }
104
43
  
return {}2
;
105
43
}
Target.cpp:lld::elf::ErrorPlace getErrPlace<llvm::object::ELFType<(llvm::support::endianness)0, true> >(unsigned char const*)
Line
Count
Source
94
1.82k
template <class ELFT> static ErrorPlace getErrPlace(const uint8_t *Loc) {
95
1.82k
  for (InputSectionBase *D : InputSections) {
96
1.82k
    auto *IS = cast<InputSection>(D);
97
1.82k
    if (!IS->getParent())
98
0
      continue;
99
1.82k
100
1.82k
    uint8_t *ISLoc = IS->getParent()->Loc + IS->OutSecOff;
101
1.82k
    if (ISLoc <= Loc && Loc < ISLoc + IS->getSize())
102
1.82k
      return {IS, IS->template getLocation<ELFT>(Loc - ISLoc) + ": "};
103
1.82k
  }
104
1.82k
  
return {}0
;
105
1.82k
}
106
107
1.86k
ErrorPlace elf::getErrorPlace(const uint8_t *Loc) {
108
1.86k
  switch (Config->EKind) {
109
1.86k
  case ELF32LEKind:
110
3
    return getErrPlace<ELF32LE>(Loc);
111
1.86k
  case ELF32BEKind:
112
1
    return getErrPlace<ELF32BE>(Loc);
113
1.86k
  case ELF64LEKind:
114
43
    return getErrPlace<ELF64LE>(Loc);
115
1.86k
  case ELF64BEKind:
116
1.82k
    return getErrPlace<ELF64BE>(Loc);
117
1.86k
  default:
118
0
    llvm_unreachable("unknown ELF type");
119
1.86k
  }
120
1.86k
}
121
122
2.41k
TargetInfo::~TargetInfo() {}
123
124
2
int64_t TargetInfo::getImplicitAddend(const uint8_t *Buf, RelType Type) const {
125
2
  return 0;
126
2
}
127
128
175
bool TargetInfo::usesOnlyLowPageBits(RelType Type) const { return false; }
129
130
bool TargetInfo::needsThunk(RelExpr Expr, RelType Type, const InputFile *File,
131
0
                            uint64_t BranchAddr, const Symbol &S) const {
132
0
  return false;
133
0
}
134
135
bool TargetInfo::adjustPrologueForCrossSplitStack(uint8_t *Loc, uint8_t *End,
136
0
                                                  uint8_t StOther) const {
137
0
  llvm_unreachable("Target doesn't support split stacks.");
138
0
}
139
140
117
bool TargetInfo::inBranchRange(RelType Type, uint64_t Src, uint64_t Dst) const {
141
117
  return true;
142
117
}
143
144
21
void TargetInfo::writeIgotPlt(uint8_t *Buf, const Symbol &S) const {
145
21
  writeGotPlt(Buf, S);
146
21
}
147
148
RelExpr TargetInfo::adjustRelaxExpr(RelType Type, const uint8_t *Data,
149
3
                                    RelExpr Expr) const {
150
3
  return Expr;
151
3
}
152
153
0
void TargetInfo::relaxGot(uint8_t *Loc, uint64_t Val) const {
154
0
  llvm_unreachable("Should not have claimed to be relaxable");
155
0
}
156
157
void TargetInfo::relaxTlsGdToLe(uint8_t *Loc, RelType Type,
158
0
                                uint64_t Val) const {
159
0
  llvm_unreachable("Should not have claimed to be relaxable");
160
0
}
161
162
void TargetInfo::relaxTlsGdToIe(uint8_t *Loc, RelType Type,
163
0
                                uint64_t Val) const {
164
0
  llvm_unreachable("Should not have claimed to be relaxable");
165
0
}
166
167
void TargetInfo::relaxTlsIeToLe(uint8_t *Loc, RelType Type,
168
0
                                uint64_t Val) const {
169
0
  llvm_unreachable("Should not have claimed to be relaxable");
170
0
}
171
172
void TargetInfo::relaxTlsLdToLe(uint8_t *Loc, RelType Type,
173
0
                                uint64_t Val) const {
174
0
  llvm_unreachable("Should not have claimed to be relaxable");
175
0
}
176
177
2.43k
uint64_t TargetInfo::getImageBase() {
178
2.43k
  // Use -image-base if set. Fall back to the target default if not.
179
2.43k
  if (Config->ImageBase)
180
11
    return *Config->ImageBase;
181
2.42k
  return Config->Pic ? 
01.01k
:
DefaultImageBase1.40k
;
182
2.42k
}