Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/lld/ELF/Arch/AMDGPU.cpp
Line
Count
Source (jump to first uncovered line)
1
//===- AMDGPU.cpp ---------------------------------------------------------===//
2
//
3
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8
9
#include "InputFiles.h"
10
#include "Symbols.h"
11
#include "Target.h"
12
#include "lld/Common/ErrorHandler.h"
13
#include "llvm/Object/ELF.h"
14
#include "llvm/Support/Endian.h"
15
16
using namespace llvm;
17
using namespace llvm::object;
18
using namespace llvm::support::endian;
19
using namespace llvm::ELF;
20
using namespace lld;
21
using namespace lld::elf;
22
23
namespace {
24
class AMDGPU final : public TargetInfo {
25
public:
26
  AMDGPU();
27
  uint32_t calcEFlags() const override;
28
  void relocateOne(uint8_t *loc, RelType type, uint64_t val) const override;
29
  RelExpr getRelExpr(RelType type, const Symbol &s,
30
                     const uint8_t *loc) const override;
31
  RelType getDynRel(RelType type) const override;
32
};
33
} // namespace
34
35
9
AMDGPU::AMDGPU() {
36
9
  relativeRel = R_AMDGPU_RELATIVE64;
37
9
  gotRel = R_AMDGPU_ABS64;
38
9
  noneRel = R_AMDGPU_NONE;
39
9
  symbolicRel = R_AMDGPU_ABS64;
40
9
}
41
42
12
static uint32_t getEFlags(InputFile *file) {
43
12
  return cast<ObjFile<ELF64LE>>(file)->getObj().getHeader()->e_flags;
44
12
}
45
46
9
uint32_t AMDGPU::calcEFlags() const {
47
9
  assert(!objectFiles.empty());
48
9
  uint32_t ret = getEFlags(objectFiles[0]);
49
9
50
9
  // Verify that all input files have the same e_flags.
51
9
  for (InputFile *f : makeArrayRef(objectFiles).slice(1)) {
52
3
    if (ret == getEFlags(f))
53
2
      continue;
54
1
    error("incompatible e_flags: " + toString(f));
55
1
    return 0;
56
1
  }
57
9
  
return ret8
;
58
9
}
59
60
24
void AMDGPU::relocateOne(uint8_t *loc, RelType type, uint64_t val) const {
61
24
  switch (type) {
62
24
  case R_AMDGPU_ABS32:
63
17
  case R_AMDGPU_GOTPCREL:
64
17
  case R_AMDGPU_GOTPCREL32_LO:
65
17
  case R_AMDGPU_REL32:
66
17
  case R_AMDGPU_REL32_LO:
67
17
    write32le(loc, val);
68
17
    break;
69
17
  case R_AMDGPU_ABS64:
70
1
  case R_AMDGPU_REL64:
71
1
    write64le(loc, val);
72
1
    break;
73
6
  case R_AMDGPU_GOTPCREL32_HI:
74
6
  case R_AMDGPU_REL32_HI:
75
6
    write32le(loc, val >> 32);
76
6
    break;
77
6
  default:
78
0
    llvm_unreachable("unknown relocation");
79
24
  }
80
24
}
81
82
RelExpr AMDGPU::getRelExpr(RelType type, const Symbol &s,
83
26
                           const uint8_t *loc) const {
84
26
  switch (type) {
85
26
  case R_AMDGPU_ABS32:
86
8
  case R_AMDGPU_ABS64:
87
8
    return R_ABS;
88
8
  case R_AMDGPU_REL32:
89
3
  case R_AMDGPU_REL32_LO:
90
3
  case R_AMDGPU_REL32_HI:
91
3
  case R_AMDGPU_REL64:
92
3
    return R_PC;
93
15
  case R_AMDGPU_GOTPCREL:
94
15
  case R_AMDGPU_GOTPCREL32_LO:
95
15
  case R_AMDGPU_GOTPCREL32_HI:
96
15
    return R_GOT_PC;
97
15
  default:
98
0
    error(getErrorLocation(loc) + "unknown relocation (" + Twine(type) +
99
0
          ") against symbol " + toString(s));
100
0
    return R_NONE;
101
26
  }
102
26
}
103
104
2
RelType AMDGPU::getDynRel(RelType type) const {
105
2
  if (type == R_AMDGPU_ABS64)
106
2
    return type;
107
0
  return R_AMDGPU_NONE;
108
0
}
109
110
18
TargetInfo *elf::getAMDGPUTargetInfo() {
111
18
  static AMDGPU target;
112
18
  return &target;
113
18
}