Coverage Report

Created: 2018-01-17 21:32

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/lld/lib/ReaderWriter/MachO/TLVPass.cpp
Line
Count
Source (jump to first uncovered line)
1
//===- lib/ReaderWriter/MachO/TLVPass.cpp -----------------------*- C++ -*-===//
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
/// \file
11
/// This linker pass transforms all TLV references to real references.
12
///
13
//===----------------------------------------------------------------------===//
14
15
#include "ArchHandler.h"
16
#include "File.h"
17
#include "MachOPasses.h"
18
#include "lld/Core/Simple.h"
19
#include "llvm/ADT/STLExtras.h"
20
#include "llvm/Support/Debug.h"
21
22
namespace lld {
23
namespace mach_o {
24
25
//
26
// TLVP Entry Atom created by the TLV pass.
27
//
28
class TLVPEntryAtom : public SimpleDefinedAtom {
29
public:
30
  TLVPEntryAtom(const File &file, bool is64, StringRef name)
31
0
      : SimpleDefinedAtom(file), _is64(is64), _name(name) {}
32
33
0
  ~TLVPEntryAtom() override = default;
34
35
0
  ContentType contentType() const override {
36
0
    return DefinedAtom::typeTLVInitializerPtr;
37
0
  }
38
39
0
  Alignment alignment() const override {
40
0
    return _is64 ? 8 : 4;
41
0
  }
42
43
0
  uint64_t size() const override {
44
0
    return _is64 ? 8 : 4;
45
0
  }
46
47
0
  ContentPermissions permissions() const override {
48
0
    return DefinedAtom::permRW_;
49
0
  }
50
51
0
  ArrayRef<uint8_t> rawContent() const override {
52
0
    static const uint8_t zeros[] =
53
0
      { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
54
0
    return llvm::makeArrayRef(zeros, size());
55
0
  }
56
57
0
  StringRef slotName() const {
58
0
    return _name;
59
0
  }
60
61
private:
62
  const bool _is64;
63
  StringRef _name;
64
};
65
66
class TLVPass : public Pass {
67
public:
68
  TLVPass(const MachOLinkingContext &context)
69
      : _ctx(context), _archHandler(_ctx.archHandler()),
70
50
        _file(*_ctx.make_file<MachOFile>("<mach-o TLV pass>")) {
71
50
    _file.setOrdinal(_ctx.getNextOrdinalAndIncrement());
72
50
  }
73
74
private:
75
50
  llvm::Error perform(SimpleFile &mergedFile) override {
76
50
    bool allowTLV = _ctx.minOS("10.7", "1.0");
77
50
78
275
    for (const DefinedAtom *atom : mergedFile.defined()) {
79
275
      for (const Reference *ref : *atom) {
80
198
        if (!_archHandler.isTLVAccess(*ref))
81
197
          continue;
82
1
83
1
        if (!allowTLV)
84
1
          return llvm::make_error<GenericError>(
85
1
            "targeted OS version does not support use of thread local "
86
1
            "variables in " + atom->name() + " for architecture " +
87
1
            _ctx.archName());
88
0
89
0
        const Atom *target = ref->target();
90
0
        assert(target != nullptr);
91
0
92
0
        const DefinedAtom *tlvpEntry = makeTLVPEntry(target);
93
0
        const_cast<Reference*>(ref)->setTarget(tlvpEntry);
94
0
        _archHandler.updateReferenceToTLV(ref);
95
0
      }
96
275
    }
97
50
98
50
    std::vector<const TLVPEntryAtom*> entries;
99
49
    entries.reserve(_targetToTLVP.size());
100
49
    for (auto &it : _targetToTLVP)
101
0
      entries.push_back(it.second);
102
49
    std::sort(entries.begin(), entries.end(),
103
49
              [](const TLVPEntryAtom *lhs, const TLVPEntryAtom *rhs) {
104
0
                return (lhs->slotName().compare(rhs->slotName()) < 0);
105
0
              });
106
49
107
49
    for (const TLVPEntryAtom *slot : entries)
108
0
      mergedFile.addAtom(*slot);
109
49
110
49
    return llvm::Error::success();
111
50
  }
112
113
0
  const DefinedAtom *makeTLVPEntry(const Atom *target) {
114
0
    auto pos = _targetToTLVP.find(target);
115
0
116
0
    if (pos != _targetToTLVP.end())
117
0
      return pos->second;
118
0
119
0
    auto *tlvpEntry = new (_file.allocator())
120
0
      TLVPEntryAtom(_file, _ctx.is64Bit(), target->name());
121
0
    _targetToTLVP[target] = tlvpEntry;
122
0
    const ArchHandler::ReferenceInfo &nlInfo =
123
0
      _archHandler.stubInfo().nonLazyPointerReferenceToBinder;
124
0
    tlvpEntry->addReference(Reference::KindNamespace::mach_o, nlInfo.arch,
125
0
                            nlInfo.kind, 0, target, 0);
126
0
    return tlvpEntry;
127
0
  }
128
129
  const MachOLinkingContext &_ctx;
130
  mach_o::ArchHandler &_archHandler;
131
  MachOFile           &_file;
132
  llvm::DenseMap<const Atom*, const TLVPEntryAtom*> _targetToTLVP;
133
};
134
135
50
void addTLVPass(PassManager &pm, const MachOLinkingContext &ctx) {
136
50
  assert(ctx.needsTLVPass());
137
50
  pm.add(llvm::make_unique<TLVPass>(ctx));
138
50
}
139
140
} // end namesapce mach_o
141
} // end namesapce lld