Coverage Report

Created: 2017-09-19 22:28

/Users/buildslave/jenkins/sharedspace/clang-stage2-coverage-R@2/llvm/tools/lld/lib/ReaderWriter/MachO/LayoutPass.cpp
Line
Count
Source (jump to first uncovered line)
1
//===-- ReaderWriter/MachO/LayoutPass.cpp - Layout atoms ------------------===//
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 "LayoutPass.h"
11
#include "lld/Core/Instrumentation.h"
12
#include "lld/Core/PassManager.h"
13
#include "lld/ReaderWriter/MachOLinkingContext.h"
14
#include "llvm/ADT/STLExtras.h"
15
#include "llvm/ADT/Twine.h"
16
#include "llvm/Support/Debug.h"
17
#include "llvm/Support/Parallel.h"
18
#include <algorithm>
19
#include <set>
20
#include <utility>
21
22
using namespace lld;
23
24
#define DEBUG_TYPE "LayoutPass"
25
26
namespace lld {
27
namespace mach_o {
28
29
static bool compareAtoms(const LayoutPass::SortKey &,
30
                         const LayoutPass::SortKey &,
31
                         LayoutPass::SortOverride customSorter);
32
33
#ifndef NDEBUG
34
// Return "reason (leftval, rightval)"
35
static std::string formatReason(StringRef reason, int leftVal, int rightVal) {
36
  return (Twine(reason) + " (" + Twine(leftVal) + ", " + Twine(rightVal) + ")")
37
      .str();
38
}
39
40
// Less-than relationship of two atoms must be transitive, which is, if a < b
41
// and b < c, a < c must be true. This function checks the transitivity by
42
// checking the sort results.
43
static void checkTransitivity(std::vector<LayoutPass::SortKey> &vec,
44
                              LayoutPass::SortOverride customSorter) {
45
  for (auto i = vec.begin(), e = vec.end(); (i + 1) != e; ++i) {
46
    for (auto j = i + 1; j != e; ++j) {
47
      assert(compareAtoms(*i, *j, customSorter));
48
      assert(!compareAtoms(*j, *i, customSorter));
49
    }
50
  }
51
}
52
53
// Helper functions to check follow-on graph.
54
typedef llvm::DenseMap<const DefinedAtom *, const DefinedAtom *> AtomToAtomT;
55
56
static std::string atomToDebugString(const Atom *atom) {
57
  const DefinedAtom *definedAtom = dyn_cast<DefinedAtom>(atom);
58
  std::string str;
59
  llvm::raw_string_ostream s(str);
60
  if (definedAtom->name().empty())
61
    s << "<anonymous " << definedAtom << ">";
62
  else
63
    s << definedAtom->name();
64
  s << " in ";
65
  if (definedAtom->customSectionName().empty())
66
    s << "<anonymous>";
67
  else
68
    s << definedAtom->customSectionName();
69
  s.flush();
70
  return str;
71
}
72
73
static void showCycleDetectedError(const Registry &registry,
74
                                   AtomToAtomT &followOnNexts,
75
                                   const DefinedAtom *atom) {
76
  const DefinedAtom *start = atom;
77
  llvm::dbgs() << "There's a cycle in a follow-on chain!\n";
78
  do {
79
    llvm::dbgs() << "  " << atomToDebugString(atom) << "\n";
80
    for (const Reference *ref : *atom) {
81
      StringRef kindValStr;
82
      if (!registry.referenceKindToString(ref->kindNamespace(), ref->kindArch(),
83
                                          ref->kindValue(), kindValStr)) {
84
        kindValStr = "<unknown>";
85
      }
86
      llvm::dbgs() << "    " << kindValStr
87
                   << ": " << atomToDebugString(ref->target()) << "\n";
88
    }
89
    atom = followOnNexts[atom];
90
  } while (atom != start);
91
  llvm::report_fatal_error("Cycle detected");
92
}
93
94
/// Exit if there's a cycle in a followon chain reachable from the
95
/// given root atom. Uses the tortoise and hare algorithm to detect a
96
/// cycle.
97
static void checkNoCycleInFollowonChain(const Registry &registry,
98
                                        AtomToAtomT &followOnNexts,
99
                                        const DefinedAtom *root) {
100
  const DefinedAtom *tortoise = root;
101
  const DefinedAtom *hare = followOnNexts[root];
102
  while (true) {
103
    if (!tortoise || !hare)
104
      return;
105
    if (tortoise == hare)
106
      showCycleDetectedError(registry, followOnNexts, tortoise);
107
    tortoise = followOnNexts[tortoise];
108
    hare = followOnNexts[followOnNexts[hare]];
109
  }
110
}
111
112
static void checkReachabilityFromRoot(AtomToAtomT &followOnRoots,
113
                                      const DefinedAtom *atom) {
114
  if (!atom) return;
115
  auto i = followOnRoots.find(atom);
116
  if (i == followOnRoots.end()) {
117
    llvm_unreachable(((Twine("Atom <") + atomToDebugString(atom) +
118
                       "> has no follow-on root!"))
119
                         .str()
120
                         .c_str());
121
  }
122
  const DefinedAtom *ap = i->second;
123
  while (true) {
124
    const DefinedAtom *next = followOnRoots[ap];
125
    if (!next) {
126
      llvm_unreachable((Twine("Atom <" + atomToDebugString(atom) +
127
                              "> is not reachable from its root!"))
128
                           .str()
129
                           .c_str());
130
    }
131
    if (next == ap)
132
      return;
133
    ap = next;
134
  }
135
}
136
137
static void printDefinedAtoms(const File::AtomRange<DefinedAtom> &atomRange) {
138
  for (const DefinedAtom *atom : atomRange) {
139
    llvm::dbgs() << "  file=" << atom->file().path()
140
                 << ", name=" << atom->name()
141
                 << ", size=" << atom->size()
142
                 << ", type=" << atom->contentType()
143
                 << ", ordinal=" << atom->ordinal()
144
                 << "\n";
145
  }
146
}
147
148
/// Verify that the followon chain is sane. Should not be called in
149
/// release binary.
150
void LayoutPass::checkFollowonChain(const File::AtomRange<DefinedAtom> &range) {
151
  ScopedTask task(getDefaultDomain(), "LayoutPass::checkFollowonChain");
152
153
  // Verify that there's no cycle in follow-on chain.
154
  std::set<const DefinedAtom *> roots;
155
  for (const auto &ai : _followOnRoots)
156
    roots.insert(ai.second);
157
  for (const DefinedAtom *root : roots)
158
    checkNoCycleInFollowonChain(_registry, _followOnNexts, root);
159
160
  // Verify that all the atoms in followOnNexts have references to
161
  // their roots.
162
  for (const auto &ai : _followOnNexts) {
163
    checkReachabilityFromRoot(_followOnRoots, ai.first);
164
    checkReachabilityFromRoot(_followOnRoots, ai.second);
165
  }
166
}
167
#endif // #ifndef NDEBUG
168
169
/// The function compares atoms by sorting atoms in the following order
170
/// a) Sorts atoms by their ordinal overrides (layout-after/ingroup)
171
/// b) Sorts atoms by their permissions
172
/// c) Sorts atoms by their content
173
/// d) Sorts atoms by custom sorter
174
/// e) Sorts atoms on how they appear using File Ordinality
175
/// f) Sorts atoms on how they appear within the File
176
static bool compareAtomsSub(const LayoutPass::SortKey &lc,
177
                            const LayoutPass::SortKey &rc,
178
                            LayoutPass::SortOverride customSorter,
179
1.28k
                            std::string &reason) {
180
1.28k
  const DefinedAtom *left = lc._atom.get();
181
1.28k
  const DefinedAtom *right = rc._atom.get();
182
1.28k
  if (
left == right1.28k
) {
183
44
    reason = "same";
184
44
    return false;
185
44
  }
186
1.24k
187
1.24k
  // Find the root of the chain if it is a part of a follow-on chain.
188
1.24k
  const DefinedAtom *leftRoot = lc._root;
189
1.24k
  const DefinedAtom *rightRoot = rc._root;
190
1.24k
191
1.24k
  // Sort atoms by their ordinal overrides only if they fall in the same
192
1.24k
  // chain.
193
1.24k
  if (
leftRoot == rightRoot1.24k
) {
194
4
    DEBUG(reason = formatReason("override", lc._override, rc._override));
195
4
    return lc._override < rc._override;
196
4
  }
197
1.23k
198
1.23k
  // Sort same permissions together.
199
1.23k
  DefinedAtom::ContentPermissions leftPerms = leftRoot->permissions();
200
1.23k
  DefinedAtom::ContentPermissions rightPerms = rightRoot->permissions();
201
1.23k
202
1.23k
  if (
leftPerms != rightPerms1.23k
) {
203
658
    DEBUG(reason =
204
658
              formatReason("contentPerms", (int)leftPerms, (int)rightPerms));
205
658
    return leftPerms < rightPerms;
206
658
  }
207
578
208
578
  // Sort same content types together.
209
578
  DefinedAtom::ContentType leftType = leftRoot->contentType();
210
578
  DefinedAtom::ContentType rightType = rightRoot->contentType();
211
578
212
578
  if (
leftType != rightType578
) {
213
280
    DEBUG(reason = formatReason("contentType", (int)leftType, (int)rightType));
214
280
    return leftType < rightType;
215
280
  }
216
298
217
298
  // Use custom sorter if supplied.
218
298
  
if (298
customSorter298
) {
219
298
    bool leftBeforeRight;
220
298
    if (customSorter(leftRoot, rightRoot, leftBeforeRight))
221
9
      return leftBeforeRight;
222
289
  }
223
289
224
289
  // Sort by .o order.
225
289
  const File *leftFile = &leftRoot->file();
226
289
  const File *rightFile = &rightRoot->file();
227
289
228
289
  if (
leftFile != rightFile289
) {
229
24
    DEBUG(reason = formatReason(".o order", (int)leftFile->ordinal(),
230
24
                                (int)rightFile->ordinal()));
231
24
    return leftFile->ordinal() < rightFile->ordinal();
232
24
  }
233
265
234
265
  // Sort by atom order with .o file.
235
265
  uint64_t leftOrdinal = leftRoot->ordinal();
236
265
  uint64_t rightOrdinal = rightRoot->ordinal();
237
265
238
265
  if (
leftOrdinal != rightOrdinal265
) {
239
265
    DEBUG(reason = formatReason("ordinal", (int)leftRoot->ordinal(),
240
265
                                (int)rightRoot->ordinal()));
241
265
    return leftOrdinal < rightOrdinal;
242
265
  }
243
0
244
0
  llvm::errs() << "Unordered: <" << left->name() << "> <"
245
0
               << right->name() << ">\n";
246
0
  llvm_unreachable("Atoms with Same Ordinal!");
247
1.28k
}
248
249
static bool compareAtoms(const LayoutPass::SortKey &lc,
250
                         const LayoutPass::SortKey &rc,
251
1.28k
                         LayoutPass::SortOverride customSorter) {
252
1.28k
  std::string reason;
253
1.28k
  bool result = compareAtomsSub(lc, rc, customSorter, reason);
254
1.28k
  DEBUG({
255
1.28k
    StringRef comp = result ? "<" : ">=";
256
1.28k
    llvm::dbgs() << "Layout: '" << lc._atom.get()->name()
257
1.28k
                 << "' " << comp << " '"
258
1.28k
                 << rc._atom.get()->name() << "' (" << reason << ")\n";
259
1.28k
  });
260
1.28k
  return result;
261
1.28k
}
262
263
LayoutPass::LayoutPass(const Registry &registry, SortOverride sorter)
264
168
    : _registry(registry), _customSorter(std::move(sorter)) {}
265
266
// Returns the atom immediately followed by the given atom in the followon
267
// chain.
268
const DefinedAtom *LayoutPass::findAtomFollowedBy(
269
0
    const DefinedAtom *targetAtom) {
270
0
  // Start from the beginning of the chain and follow the chain until
271
0
  // we find the targetChain.
272
0
  const DefinedAtom *atom = _followOnRoots[targetAtom];
273
0
  while (
true0
) {
274
0
    const DefinedAtom *prevAtom = atom;
275
0
    AtomToAtomT::iterator targetFollowOnAtomsIter = _followOnNexts.find(atom);
276
0
    // The target atom must be in the chain of its root.
277
0
    assert(targetFollowOnAtomsIter != _followOnNexts.end());
278
0
    atom = targetFollowOnAtomsIter->second;
279
0
    if (atom == targetAtom)
280
0
      return prevAtom;
281
0
  }
282
0
}
283
284
// Check if all the atoms followed by the given target atom are of size zero.
285
// When this method is called, an atom being added is not of size zero and
286
// will be added to the head of the followon chain. All the atoms between the
287
// atom and the targetAtom (specified by layout-after) need to be of size zero
288
// in this case. Otherwise the desired layout is impossible.
289
0
bool LayoutPass::checkAllPrevAtomsZeroSize(const DefinedAtom *targetAtom) {
290
0
  const DefinedAtom *atom = _followOnRoots[targetAtom];
291
0
  while (
true0
) {
292
0
    if (atom == targetAtom)
293
0
      return true;
294
0
    
if (0
atom->size() != 00
)
295
0
      // TODO: print warning that an impossible layout is being desired by the
296
0
      // user.
297
0
      return false;
298
0
    AtomToAtomT::iterator targetFollowOnAtomsIter = _followOnNexts.find(atom);
299
0
    // The target atom must be in the chain of its root.
300
0
    assert(targetFollowOnAtomsIter != _followOnNexts.end());
301
0
    atom = targetFollowOnAtomsIter->second;
302
0
  }
303
0
}
304
305
// Set the root of all atoms in targetAtom's chain to the given root.
306
void LayoutPass::setChainRoot(const DefinedAtom *targetAtom,
307
0
                              const DefinedAtom *root) {
308
0
  // Walk through the followon chain and override each node's root.
309
0
  while (
true0
) {
310
0
    _followOnRoots[targetAtom] = root;
311
0
    AtomToAtomT::iterator targetFollowOnAtomsIter =
312
0
        _followOnNexts.find(targetAtom);
313
0
    if (targetFollowOnAtomsIter == _followOnNexts.end())
314
0
      return;
315
0
    targetAtom = targetFollowOnAtomsIter->second;
316
0
  }
317
0
}
318
319
/// This pass builds the followon tables described by two DenseMaps
320
/// followOnRoots and followonNexts.
321
/// The followOnRoots map contains a mapping of a DefinedAtom to its root
322
/// The followOnNexts map contains a mapping of what DefinedAtom follows the
323
/// current Atom
324
/// The algorithm follows a very simple approach
325
/// a) If the atom is first seen, then make that as the root atom
326
/// b) The targetAtom which this Atom contains, has the root thats set to the
327
///    root of the current atom
328
/// c) If the targetAtom is part of a different tree and the root of the
329
///    targetAtom is itself, Chain all the atoms that are contained in the tree
330
///    to the current Tree
331
/// d) If the targetAtom is part of a different chain and the root of the
332
///    targetAtom until the targetAtom has all atoms of size 0, then chain the
333
///    targetAtoms and its tree to the current chain
334
168
void LayoutPass::buildFollowOnTable(const File::AtomRange<DefinedAtom> &range) {
335
168
  ScopedTask task(getDefaultDomain(), "LayoutPass::buildFollowOnTable");
336
168
  // Set the initial size of the followon and the followonNext hash to the
337
168
  // number of atoms that we have.
338
168
  _followOnRoots.reserve(range.size());
339
168
  _followOnNexts.reserve(range.size());
340
728
  for (const DefinedAtom *ai : range) {
341
596
    for (const Reference *r : *ai) {
342
596
      if (r->kindNamespace() != lld::Reference::KindNamespace::all ||
343
4
          r->kindValue() != lld::Reference::kindLayoutAfter)
344
592
        continue;
345
4
      const DefinedAtom *targetAtom = dyn_cast<DefinedAtom>(r->target());
346
4
      _followOnNexts[ai] = targetAtom;
347
4
348
4
      // If we find a followon for the first time, let's make that atom as the
349
4
      // root atom.
350
4
      if (_followOnRoots.count(ai) == 0)
351
3
        _followOnRoots[ai] = ai;
352
4
353
4
      auto iter = _followOnRoots.find(targetAtom);
354
4
      if (
iter == _followOnRoots.end()4
) {
355
4
        // If the targetAtom is not a root of any chain, let's make the root of
356
4
        // the targetAtom to the root of the current chain.
357
4
358
4
        // The expression m[i] = m[j] where m is a DenseMap and i != j is not
359
4
        // safe. m[j] returns a reference, which would be invalidated when a
360
4
        // rehashing occurs. If rehashing occurs to make room for m[i], m[j]
361
4
        // becomes invalid, and that invalid reference would be used as the RHS
362
4
        // value of the expression.
363
4
        // Copy the value to workaround.
364
4
        const DefinedAtom *tmp = _followOnRoots[ai];
365
4
        _followOnRoots[targetAtom] = tmp;
366
4
        continue;
367
4
      }
368
0
      
if (0
iter->second == targetAtom0
) {
369
0
        // If the targetAtom is the root of a chain, the chain becomes part of
370
0
        // the current chain. Rewrite the subchain's root to the current
371
0
        // chain's root.
372
0
        setChainRoot(targetAtom, _followOnRoots[ai]);
373
0
        continue;
374
0
      }
375
0
      // The targetAtom is already a part of a chain. If the current atom is
376
0
      // of size zero, we can insert it in the middle of the chain just
377
0
      // before the target atom, while not breaking other atom's followon
378
0
      // relationships. If it's not, we can only insert the current atom at
379
0
      // the beginning of the chain. All the atoms followed by the target
380
0
      // atom must be of size zero in that case to satisfy the followon
381
0
      // relationships.
382
0
      size_t currentAtomSize = ai->size();
383
0
      if (
currentAtomSize == 00
) {
384
0
        const DefinedAtom *targetPrevAtom = findAtomFollowedBy(targetAtom);
385
0
        _followOnNexts[targetPrevAtom] = ai;
386
0
        const DefinedAtom *tmp = _followOnRoots[targetPrevAtom];
387
0
        _followOnRoots[ai] = tmp;
388
0
        continue;
389
0
      }
390
0
      
if (0
!checkAllPrevAtomsZeroSize(targetAtom)0
)
391
0
        break;
392
0
      _followOnNexts[ai] = _followOnRoots[targetAtom];
393
0
      setChainRoot(_followOnRoots[targetAtom], _followOnRoots[ai]);
394
0
    }
395
728
  }
396
168
}
397
398
/// Build an ordinal override map by traversing the followon chain, and
399
/// assigning ordinals to each atom, if the atoms have their ordinals
400
/// already assigned skip the atom and move to the next. This is the
401
/// main map thats used to sort the atoms while comparing two atoms together
402
void
403
168
LayoutPass::buildOrdinalOverrideMap(const File::AtomRange<DefinedAtom> &range) {
404
168
  ScopedTask task(getDefaultDomain(), "LayoutPass::buildOrdinalOverrideMap");
405
168
  uint64_t index = 0;
406
728
  for (const DefinedAtom *ai : range) {
407
728
    const DefinedAtom *atom = ai;
408
728
    if (_ordinalOverrideMap.find(atom) != _ordinalOverrideMap.end())
409
4
      continue;
410
724
    AtomToAtomT::iterator start = _followOnRoots.find(atom);
411
724
    if (start == _followOnRoots.end())
412
721
      continue;
413
10
    
for (const DefinedAtom *nextAtom = start->second; 3
nextAtom10
;
414
7
         
nextAtom = _followOnNexts[nextAtom]7
) {
415
7
      AtomToOrdinalT::iterator pos = _ordinalOverrideMap.find(nextAtom);
416
7
      if (pos == _ordinalOverrideMap.end())
417
7
        _ordinalOverrideMap[nextAtom] = index++;
418
7
    }
419
728
  }
420
168
}
421
422
std::vector<LayoutPass::SortKey>
423
168
LayoutPass::decorate(File::AtomRange<DefinedAtom> &atomRange) const {
424
168
  std::vector<SortKey> ret;
425
728
  for (OwningAtomPtr<DefinedAtom> &atom : atomRange.owning_ptrs()) {
426
728
    auto ri = _followOnRoots.find(atom.get());
427
728
    auto oi = _ordinalOverrideMap.find(atom.get());
428
728
    const auto *root = (ri == _followOnRoots.end()) ? 
atom.get()721
:
ri->second7
;
429
728
    uint64_t override = (oi == _ordinalOverrideMap.end()) ? 
0721
:
oi->second7
;
430
728
    ret.push_back(SortKey(std::move(atom), root, override));
431
728
  }
432
168
  return ret;
433
168
}
434
435
void LayoutPass::undecorate(File::AtomRange<DefinedAtom> &atomRange,
436
168
                            std::vector<SortKey> &keys) const {
437
168
  size_t i = 0;
438
168
  for (SortKey &k : keys)
439
728
    atomRange[i++] = std::move(k._atom);
440
168
}
441
442
/// Perform the actual pass
443
168
llvm::Error LayoutPass::perform(SimpleFile &mergedFile) {
444
168
  DEBUG(llvm::dbgs() << "******** Laying out atoms:\n");
445
168
  // sort the atoms
446
168
  ScopedTask task(getDefaultDomain(), "LayoutPass");
447
168
  File::AtomRange<DefinedAtom> atomRange = mergedFile.defined();
448
168
449
168
  // Build follow on tables
450
168
  buildFollowOnTable(atomRange);
451
168
452
168
  // Check the structure of followon graph if running in debug mode.
453
168
  DEBUG(checkFollowonChain(atomRange));
454
168
455
168
  // Build override maps
456
168
  buildOrdinalOverrideMap(atomRange);
457
168
458
168
  DEBUG({
459
168
    llvm::dbgs() << "unsorted atoms:\n";
460
168
    printDefinedAtoms(atomRange);
461
168
  });
462
168
463
168
  std::vector<LayoutPass::SortKey> vec = decorate(atomRange);
464
168
  sort(llvm::parallel::par, vec.begin(), vec.end(),
465
1.28k
       [&](const LayoutPass::SortKey &l, const LayoutPass::SortKey &r) -> bool {
466
1.28k
         return compareAtoms(l, r, _customSorter);
467
1.28k
       });
468
168
  DEBUG(checkTransitivity(vec, _customSorter));
469
168
  undecorate(atomRange, vec);
470
168
471
168
  DEBUG({
472
168
    llvm::dbgs() << "sorted atoms:\n";
473
168
    printDefinedAtoms(atomRange);
474
168
  });
475
168
476
168
  DEBUG(llvm::dbgs() << "******** Finished laying out atoms\n");
477
168
  return llvm::Error::success();
478
168
}
479
480
168
void addLayoutPass(PassManager &pm, const MachOLinkingContext &ctx) {
481
168
  pm.add(llvm::make_unique<LayoutPass>(
482
168
      ctx.registry(), [&](const DefinedAtom * left, const DefinedAtom * right,
483
298
                          bool & leftBeforeRight) ->bool {
484
298
    return ctx.customAtomOrderer(left, right, leftBeforeRight);
485
298
  }));
486
168
}
487
488
} // namespace mach_o
489
} // namespace lld