/build/llvm-toolchain-snapshot-7~svn338205/tools/lld/include/lld/Core/PassManager.h

Bug Summary

File:	tools/lld/include/lld/Core/PassManager.h
Warning:	line 37, column 28 Use of memory after it is freed

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name DarwinLdDriver.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-eagerly-assume -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -mrelocation-model pic -pic-level 2 -mthread-model posix -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-7/lib/clang/7.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/lld/lib/Driver -I /build/llvm-toolchain-snapshot-7~svn338205/tools/lld/lib/Driver -I /build/llvm-toolchain-snapshot-7~svn338205/tools/lld/include -I /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/lld/include -I /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn338205/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/x86_64-linux-gnu/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/x86_64-linux-gnu/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8/backward -internal-isystem /usr/include/clang/7.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.0.0/include -internal-externc-isystem /usr/lib/gcc/x86_64-linux-gnu/8/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/lld/lib/Driver -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-07-29-043837-17923-1 -x c++ /build/llvm-toolchain-snapshot-7~svn338205/tools/lld/lib/Driver/DarwinLdDriver.cpp -faddrsig

/build/llvm-toolchain-snapshot-7~svn338205/tools/lld/lib/Driver/DarwinLdDriver.cpp

→

1//===- lib/Driver/DarwinLdDriver.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/// \file
11///
12/// Concrete instance of the Driver for darwin's ld.
13///
14//===----------------------------------------------------------------------===//

16#include "lld/Common/Args.h"
17#include "lld/Common/ErrorHandler.h"
18#include "lld/Common/LLVM.h"
19#include "lld/Core/ArchiveLibraryFile.h"
20#include "lld/Core/Error.h"
21#include "lld/Core/File.h"
22#include "lld/Core/Instrumentation.h"
23#include "lld/Core/LinkingContext.h"
24#include "lld/Core/Node.h"
25#include "lld/Core/PassManager.h"
26#include "lld/Core/Resolver.h"
27#include "lld/Core/SharedLibraryFile.h"
28#include "lld/Core/Simple.h"
29#include "lld/ReaderWriter/MachOLinkingContext.h"
30#include "llvm/ADT/ArrayRef.h"
31#include "llvm/ADT/Optional.h"
32#include "llvm/ADT/STLExtras.h"
33#include "llvm/ADT/SmallString.h"
34#include "llvm/ADT/StringExtras.h"
35#include "llvm/ADT/StringRef.h"
36#include "llvm/ADT/Twine.h"
37#include "llvm/BinaryFormat/MachO.h"
38#include "llvm/Option/Arg.h"
39#include "llvm/Option/ArgList.h"
40#include "llvm/Option/OptTable.h"
41#include "llvm/Option/Option.h"
42#include "llvm/Support/Casting.h"
43#include "llvm/Support/CommandLine.h"
44#include "llvm/Support/Error.h"
45#include "llvm/Support/ErrorOr.h"
46#include "llvm/Support/Format.h"
47#include "llvm/Support/MathExtras.h"
48#include "llvm/Support/MemoryBuffer.h"
49#include "llvm/Support/Path.h"
50#include "llvm/Support/raw_ostream.h"
51#include <algorithm>
52#include <cstdint>
53#include <memory>
54#include <string>
55#include <system_error>
56#include <utility>
57#include <vector>

59using namespace lld;

61namespace {

63// Create enum with OPT_xxx values for each option in DarwinLdOptions.td
64enum {
OPT_INVALID = 0,
66#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
             HELP, META, VALUES)                                             \
OPT_##ID,
69#include "DarwinLdOptions.inc"
70#undef OPTION
71};

73// Create prefix string literals used in DarwinLdOptions.td
74#define PREFIX(NAME, VALUE) const char *const NAME[] = VALUE;
75#include "DarwinLdOptions.inc"
76#undef PREFIX

78// Create table mapping all options defined in DarwinLdOptions.td
79static const llvm::opt::OptTable::Info InfoTable[] = {
80#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
             HELPTEXT, METAVAR, VALUES)                                      \
{PREFIX,      NAME,      HELPTEXT,                                           \
 METAVAR,     OPT_##ID,  llvm::opt::Option::KIND##Class,                     \
 PARAM,       FLAGS,     OPT_##GROUP,                                        \
 OPT_##ALIAS, ALIASARGS, VALUES},
86#include "DarwinLdOptions.inc"
87#undef OPTION
88};

90// Create OptTable class for parsing actual command line arguments
91class DarwinLdOptTable : public llvm::opt::OptTable {
92public:
DarwinLdOptTable() : OptTable(InfoTable) {}
94};

96static std::vector<std::unique_ptr<File>>
97makeErrorFile(StringRef path, std::error_code ec) {
std::vector<std::unique_ptr<File>> result;
result.push_back(llvm::make_unique<ErrorFile>(path, ec));
return result;
101}

103static std::vector<std::unique_ptr<File>>
104parseMemberFiles(std::unique_ptr<File> file) {
std::vector<std::unique_ptr<File>> members;
if (auto *archive = dyn_cast<ArchiveLibraryFile>(file.get())) {
  if (std::error_code ec = archive->parseAllMembers(members))
    return makeErrorFile(file->path(), ec);
} else {
  members.push_back(std::move(file));
}
return members;
113}

115std::vector<std::unique_ptr<File>> loadFile(MachOLinkingContext &ctx,
                                          StringRef path, bool wholeArchive,
                                          bool upwardDylib) {
if (ctx.logInputFiles())
  message(path);

ErrorOr<std::unique_ptr<MemoryBuffer>> mbOrErr = ctx.getMemoryBuffer(path);
if (std::error_code ec = mbOrErr.getError())
  return makeErrorFile(path, ec);
ErrorOr<std::unique_ptr<File>> fileOrErr =
    ctx.registry().loadFile(std::move(mbOrErr.get()));
if (std::error_code ec = fileOrErr.getError())
  return makeErrorFile(path, ec);
std::unique_ptr<File> &file = fileOrErr.get();

// If file is a dylib, inform LinkingContext about it.
if (SharedLibraryFile *shl = dyn_cast<SharedLibraryFile>(file.get())) {
  if (std::error_code ec = shl->parse())
    return makeErrorFile(path, ec);
  ctx.registerDylib(reinterpret_cast<mach_o::MachODylibFile *>(shl),
                    upwardDylib);
}
if (wholeArchive)
  return parseMemberFiles(std::move(file));
std::vector<std::unique_ptr<File>> files;
files.push_back(std::move(file));
return files;
142}

144} // end anonymous namespace

146// Test may be running on Windows. Canonicalize the path
147// separator to '/' to get consistent outputs for tests.
148static std::string canonicalizePath(StringRef path) {
char sep = llvm::sys::path::get_separator().front();
if (sep != '/') {
  std::string fixedPath = path;
  std::replace(fixedPath.begin(), fixedPath.end(), sep, '/');
  return fixedPath;
} else {
  return path;
}
157}

159static void addFile(StringRef path, MachOLinkingContext &ctx,
                  bool loadWholeArchive, bool upwardDylib) {
std::vector<std::unique_ptr<File>> files =
    loadFile(ctx, path, loadWholeArchive, upwardDylib);
for (std::unique_ptr<File> &file : files)
  ctx.getNodes().push_back(llvm::make_unique<FileNode>(std::move(file)));
165}

167// Export lists are one symbol per line.  Blank lines are ignored.
168// Trailing comments start with #.
169static std::error_code parseExportsList(StringRef exportFilePath,
                                      MachOLinkingContext &ctx) {
// Map in export list file.
ErrorOr<std::unique_ptr<MemoryBuffer>> mb =
                                 MemoryBuffer::getFileOrSTDIN(exportFilePath);
if (std::error_code ec = mb.getError())
  return ec;
ctx.addInputFileDependency(exportFilePath);
StringRef buffer = mb->get()->getBuffer();
while (!buffer.empty()) {
  // Split off each line in the file.
  std::pair<StringRef, StringRef> lineAndRest = buffer.split('\n');
  StringRef line = lineAndRest.first;
  // Ignore trailing # comments.
  std::pair<StringRef, StringRef> symAndComment = line.split('#');
  StringRef sym = symAndComment.first.trim();
  if (!sym.empty())
    ctx.addExportSymbol(sym);
  buffer = lineAndRest.second;
}
return std::error_code();
190}

192/// Order files are one symbol per line. Blank lines are ignored.
193/// Trailing comments start with #. Symbol names can be prefixed with an
194/// architecture name and/or .o leaf name.  Examples:
195///     _foo
196///     bar.o:_bar
197///     libfrob.a(bar.o):_bar
198///     x86_64:_foo64
199static std::error_code parseOrderFile(StringRef orderFilePath,
                                    MachOLinkingContext &ctx) {
// Map in order file.
ErrorOr<std::unique_ptr<MemoryBuffer>> mb =
                                 MemoryBuffer::getFileOrSTDIN(orderFilePath);
if (std::error_code ec = mb.getError())
  return ec;
ctx.addInputFileDependency(orderFilePath);
StringRef buffer = mb->get()->getBuffer();
while (!buffer.empty()) {
  // Split off each line in the file.
  std::pair<StringRef, StringRef> lineAndRest = buffer.split('\n');
  StringRef line = lineAndRest.first;
  buffer = lineAndRest.second;
  // Ignore trailing # comments.
  std::pair<StringRef, StringRef> symAndComment = line.split('#');
  if (symAndComment.first.empty())
    continue;
  StringRef sym = symAndComment.first.trim();
  if (sym.empty())
    continue;
  // Check for prefix.
  StringRef prefix;
  std::pair<StringRef, StringRef> prefixAndSym = sym.split(':');
  if (!prefixAndSym.second.empty()) {
    sym = prefixAndSym.second;
    prefix = prefixAndSym.first;
    if (!prefix.endswith(".o") && !prefix.endswith(".o)")) {
      // If arch name prefix does not match arch being linked, ignore symbol.
      if (!ctx.archName().equals(prefix))
        continue;
      prefix = "";
    }
  } else
   sym = prefixAndSym.first;
  if (!sym.empty()) {
    ctx.appendOrderedSymbol(sym, prefix);
    //llvm::errs() << sym << ", prefix=" << prefix << "\n";
  }
}
return std::error_code();
240}

242//
243// There are two variants of the  -filelist option:
244//
245//   -filelist <path>
246// In this variant, the path is to a text file which contains one file path
247// per line.  There are no comments or trimming of whitespace.
248//
249//   -fileList <path>,<dir>
250// In this variant, the path is to a text file which contains a partial path
251// per line. The <dir> prefix is prepended to each partial path.
252//
253static llvm::Error loadFileList(StringRef fileListPath,
                              MachOLinkingContext &ctx, bool forceLoad) {
// If there is a comma, split off <dir>.
std::pair<StringRef, StringRef> opt = fileListPath.split(',');
StringRef filePath = opt.first;
StringRef dirName = opt.second;
ctx.addInputFileDependency(filePath);
// Map in file list file.
ErrorOr<std::unique_ptr<MemoryBuffer>> mb =
                                      MemoryBuffer::getFileOrSTDIN(filePath);
if (std::error_code ec = mb.getError())
  return llvm::errorCodeToError(ec);
StringRef buffer = mb->get()->getBuffer();
while (!buffer.empty()) {
  // Split off each line in the file.
  std::pair<StringRef, StringRef> lineAndRest = buffer.split('\n');
  StringRef line = lineAndRest.first;
  StringRef path;
  if (!dirName.empty()) {
    // If there is a <dir> then prepend dir to each line.
    SmallString<256> fullPath;
    fullPath.assign(dirName);
    llvm::sys::path::append(fullPath, Twine(line));
    path = ctx.copy(fullPath.str());
  } else {
    // No <dir> use whole line as input file path.
    path = ctx.copy(line);
  }
  if (!ctx.pathExists(path)) {
    return llvm::make_error<GenericError>(Twine("File not found '")
                                          + path
                                          + "'");
  }
  if (ctx.testingFileUsage()) {
    message("Found filelist entry " + canonicalizePath(path));
  }
  addFile(path, ctx, forceLoad, false);
  buffer = lineAndRest.second;
}
return llvm::Error::success();
293}

295/// Parse number assuming it is base 16, but allow 0x prefix.
296static bool parseNumberBase16(StringRef numStr, uint64_t &baseAddress) {
if (numStr.startswith_lower("0x"))
  numStr = numStr.drop_front(2);
return numStr.getAsInteger(16, baseAddress);
300}

302static void parseLLVMOptions(const LinkingContext &ctx) {
// Honor -mllvm
if (!ctx.llvmOptions().empty()) {
  unsigned numArgs = ctx.llvmOptions().size();
  auto **args = new const char *[numArgs + 2];
  args[0] = "lld (LLVM option parsing)";
  for (unsigned i = 0; i != numArgs; ++i)
    args[i + 1] = ctx.llvmOptions()[i];
  args[numArgs + 1] = nullptr;
  llvm::cl::ParseCommandLineOptions(numArgs + 1, args);
}
313}

315namespace lld {
316namespace mach_o {

318bool parse(llvm::ArrayRef<const char *> args, MachOLinkingContext &ctx) {
// Parse command line options using DarwinLdOptions.td
DarwinLdOptTable table;
unsigned missingIndex;
unsigned missingCount;
llvm::opt::InputArgList parsedArgs =
    table.ParseArgs(args.slice(1), missingIndex, missingCount);
if (missingCount) {
  error("missing arg value for '" +
        Twine(parsedArgs.getArgString(missingIndex)) + "' expected " +
        Twine(missingCount) + " argument(s).");
  return false;
}

for (auto unknownArg : parsedArgs.filtered(OPT_UNKNOWN)) {
  warn("ignoring unknown argument: " +
       Twine(unknownArg->getAsString(parsedArgs)));
}

errorHandler().Verbose = parsedArgs.hasArg(OPT_v);
errorHandler().ErrorLimit = args::getInteger(parsedArgs, OPT_error_limit, 20);

// Figure out output kind ( -dylib, -r, -bundle, -preload, or -static )
llvm::MachO::HeaderFileType fileType = llvm::MachO::MH_EXECUTE;
bool isStaticExecutable = false;
if (llvm::opt::Arg *kind = parsedArgs.getLastArg(
        OPT_dylib, OPT_relocatable, OPT_bundle, OPT_static, OPT_preload)) {
  switch (kind->getOption().getID()) {
  case OPT_dylib:
    fileType = llvm::MachO::MH_DYLIB;
    break;
  case OPT_relocatable:
    fileType = llvm::MachO::MH_OBJECT;
    break;
  case OPT_bundle:
    fileType = llvm::MachO::MH_BUNDLE;
    break;
  case OPT_static:
    fileType = llvm::MachO::MH_EXECUTE;
    isStaticExecutable = true;
    break;
  case OPT_preload:
    fileType = llvm::MachO::MH_PRELOAD;
    break;
  }
}

// Handle -arch xxx
MachOLinkingContext::Arch arch = MachOLinkingContext::arch_unknown;
if (llvm::opt::Arg *archStr = parsedArgs.getLastArg(OPT_arch)) {
  arch = MachOLinkingContext::archFromName(archStr->getValue());
  if (arch == MachOLinkingContext::arch_unknown) {
    error("unknown arch named '" + Twine(archStr->getValue()) + "'");
    return false;
  }
}
// If no -arch specified, scan input files to find first non-fat .o file.
if (arch == MachOLinkingContext::arch_unknown) {
  for (auto &inFile : parsedArgs.filtered(OPT_INPUT)) {
    // This is expensive because it opens and maps the file.  But that is
    // ok because no -arch is rare.
    if (MachOLinkingContext::isThinObjectFile(inFile->getValue(), arch))
      break;
  }
  if (arch == MachOLinkingContext::arch_unknown &&
      !parsedArgs.getLastArg(OPT_test_file_usage)) {
    // If no -arch and no options at all, print usage message.
    if (parsedArgs.size() == 0)
      table.PrintHelp(llvm::outs(), args[0], "LLVM Linker", false);
    else
      error("-arch not specified and could not be inferred");
    return false;
  }
}

// Handle -macosx_version_min or -ios_version_min
MachOLinkingContext::OS os = MachOLinkingContext::OS::unknown;
uint32_t minOSVersion = 0;
if (llvm::opt::Arg *minOS =
        parsedArgs.getLastArg(OPT_macosx_version_min, OPT_ios_version_min,
                              OPT_ios_simulator_version_min)) {
  switch (minOS->getOption().getID()) {
  case OPT_macosx_version_min:
    os = MachOLinkingContext::OS::macOSX;
    if (MachOLinkingContext::parsePackedVersion(minOS->getValue(),
                                                minOSVersion)) {
      error("malformed macosx_version_min value");
      return false;
    }
    break;
  case OPT_ios_version_min:
    os = MachOLinkingContext::OS::iOS;
    if (MachOLinkingContext::parsePackedVersion(minOS->getValue(),
                                                minOSVersion)) {
      error("malformed ios_version_min value");
      return false;
    }
    break;
  case OPT_ios_simulator_version_min:
    os = MachOLinkingContext::OS::iOS_simulator;
    if (MachOLinkingContext::parsePackedVersion(minOS->getValue(),
                                                minOSVersion)) {
      error("malformed ios_simulator_version_min value");
      return false;
    }
    break;
  }
} else {
  // No min-os version on command line, check environment variables
}

// Handle export_dynamic
// FIXME: Should we warn when this applies to something other than a static
// executable or dylib?  Those are the only cases where this has an effect.
// Note, this has to come before ctx.configure() so that we get the correct
// value for _globalsAreDeadStripRoots.
bool exportDynamicSymbols = parsedArgs.hasArg(OPT_export_dynamic);

// Now that there's enough information parsed in, let the linking context
// set up default values.
ctx.configure(fileType, arch, os, minOSVersion, exportDynamicSymbols);

// Handle -e xxx
if (llvm::opt::Arg *entry = parsedArgs.getLastArg(OPT_entry))
  ctx.setEntrySymbolName(entry->getValue());

// Handle -o xxx
if (llvm::opt::Arg *outpath = parsedArgs.getLastArg(OPT_output))
  ctx.setOutputPath(outpath->getValue());
else
  ctx.setOutputPath("a.out");

// Handle -image_base XXX and -seg1addr XXXX
if (llvm::opt::Arg *imageBase = parsedArgs.getLastArg(OPT_image_base)) {
  uint64_t baseAddress;
  if (parseNumberBase16(imageBase->getValue(), baseAddress)) {
    error("image_base expects a hex number");
    return false;
  } else if (baseAddress < ctx.pageZeroSize()) {
    error("image_base overlaps with __PAGEZERO");
    return false;
  } else if (baseAddress % ctx.pageSize()) {
    error("image_base must be a multiple of page size (0x" +
          llvm::utohexstr(ctx.pageSize()) + ")");
    return false;
  }

  ctx.setBaseAddress(baseAddress);
}

// Handle -dead_strip
if (parsedArgs.getLastArg(OPT_dead_strip))
  ctx.setDeadStripping(true);

bool globalWholeArchive = false;
// Handle -all_load
if (parsedArgs.getLastArg(OPT_all_load))
  globalWholeArchive = true;

// Handle -install_name
if (llvm::opt::Arg *installName = parsedArgs.getLastArg(OPT_install_name))
  ctx.setInstallName(installName->getValue());
else
  ctx.setInstallName(ctx.outputPath());

// Handle -mark_dead_strippable_dylib
if (parsedArgs.getLastArg(OPT_mark_dead_strippable_dylib))
  ctx.setDeadStrippableDylib(true);

// Handle -compatibility_version and -current_version
if (llvm::opt::Arg *vers = parsedArgs.getLastArg(OPT_compatibility_version)) {
  if (ctx.outputMachOType() != llvm::MachO::MH_DYLIB) {
    error("-compatibility_version can only be used with -dylib");
    return false;
  }
  uint32_t parsedVers;
  if (MachOLinkingContext::parsePackedVersion(vers->getValue(), parsedVers)) {
    error("-compatibility_version value is malformed");
    return false;
  }
  ctx.setCompatibilityVersion(parsedVers);
}

if (llvm::opt::Arg *vers = parsedArgs.getLastArg(OPT_current_version)) {
  if (ctx.outputMachOType() != llvm::MachO::MH_DYLIB) {
    error("-current_version can only be used with -dylib");
    return false;
  }
  uint32_t parsedVers;
  if (MachOLinkingContext::parsePackedVersion(vers->getValue(), parsedVers)) {
    error("-current_version value is malformed");
    return false;
  }
  ctx.setCurrentVersion(parsedVers);
}

// Handle -bundle_loader
if (llvm::opt::Arg *loader = parsedArgs.getLastArg(OPT_bundle_loader))
  ctx.setBundleLoader(loader->getValue());

// Handle -sectalign segname sectname align
for (auto &alignArg : parsedArgs.filtered(OPT_sectalign)) {
  const char* segName   = alignArg->getValue(0);
  const char* sectName  = alignArg->getValue(1);
  const char* alignStr  = alignArg->getValue(2);
  if ((alignStr[0] == '0') && (alignStr[1] == 'x'))
    alignStr += 2;
  unsigned long long alignValue;
  if (llvm::getAsUnsignedInteger(alignStr, 16, alignValue)) {
    error("-sectalign alignment value '" + Twine(alignStr) +
          "' not a valid number");
    return false;
  }
  uint16_t align = 1 << llvm::countTrailingZeros(alignValue);
  if (!llvm::isPowerOf2_64(alignValue)) {
    std::string Msg;
    llvm::raw_string_ostream OS(Msg);
    OS << "alignment for '-sectalign " << segName << " " << sectName
       << llvm::format(" 0x%llX", alignValue)
       << "' is not a power of two, using " << llvm::format("0x%08X", align);
    OS.flush();
    warn(Msg);
  }
  ctx.addSectionAlignment(segName, sectName, align);
}

// Handle -mllvm
for (auto &llvmArg : parsedArgs.filtered(OPT_mllvm)) {
  ctx.appendLLVMOption(llvmArg->getValue());
}

// Handle -print_atoms
if (parsedArgs.getLastArg(OPT_print_atoms))
  ctx.setPrintAtoms();

// Handle -t (trace) option.
if (parsedArgs.getLastArg(OPT_t))
  ctx.setLogInputFiles(true);

// Handle -demangle option.
if (parsedArgs.getLastArg(OPT_demangle))
  ctx.setDemangleSymbols(true);

// Handle -keep_private_externs
if (parsedArgs.getLastArg(OPT_keep_private_externs)) {
  ctx.setKeepPrivateExterns(true);
  if (ctx.outputMachOType() != llvm::MachO::MH_OBJECT)
    warn("-keep_private_externs only used in -r mode");
}

// Handle -dependency_info <path> used by Xcode.
if (llvm::opt::Arg *depInfo = parsedArgs.getLastArg(OPT_dependency_info))
  if (std::error_code ec = ctx.createDependencyFile(depInfo->getValue()))
    warn(ec.message() + ", processing '-dependency_info " +
         depInfo->getValue());

// In -test_file_usage mode, we'll be given an explicit list of paths that
// exist. We'll also be expected to print out information about how we located
// libraries and so on that the user specified, but not to actually do any
// linking.
if (parsedArgs.getLastArg(OPT_test_file_usage)) {
  ctx.setTestingFileUsage();

  // With paths existing by fiat, linking is not going to end well.
  ctx.setDoNothing(true);

  // Only bother looking for an existence override if we're going to use it.
  for (auto existingPath : parsedArgs.filtered(OPT_path_exists)) {
    ctx.addExistingPathForDebug(existingPath->getValue());
  }
}

// Register possible input file parsers.
if (!ctx.doNothing()) {
  ctx.registry().addSupportMachOObjects(ctx);
  ctx.registry().addSupportArchives(ctx.logInputFiles());
  ctx.registry().addSupportYamlFiles();
}

// Now construct the set of library search directories, following ld64's
// baroque set of accumulated hacks. Mostly, the algorithm constructs
//     { syslibroots } x { libpaths }
//
// Unfortunately, there are numerous exceptions:
//   1. Only absolute paths get modified by syslibroot options.
//   2. If there is just 1 -syslibroot, system paths not found in it are
//      skipped.
//   3. If the last -syslibroot is "/", all of them are ignored entirely.
//   4. If { syslibroots } x path ==  {}, the original path is kept.
std::vector<StringRef> sysLibRoots;
for (auto syslibRoot : parsedArgs.filtered(OPT_syslibroot)) {
  sysLibRoots.push_back(syslibRoot->getValue());
}
if (!sysLibRoots.empty()) {
  // Ignore all if last -syslibroot is "/".
  if (sysLibRoots.back() != "/")
    ctx.setSysLibRoots(sysLibRoots);
}

// Paths specified with -L come first, and are not considered system paths for
// the case where there is precisely 1 -syslibroot.
for (auto libPath : parsedArgs.filtered(OPT_L)) {
  ctx.addModifiedSearchDir(libPath->getValue());
}

// Process -F directories (where to look for frameworks).
for (auto fwPath : parsedArgs.filtered(OPT_F)) {
  ctx.addFrameworkSearchDir(fwPath->getValue());
}

// -Z suppresses the standard search paths.
if (!parsedArgs.hasArg(OPT_Z)) {
  ctx.addModifiedSearchDir("/usr/lib", true);
  ctx.addModifiedSearchDir("/usr/local/lib", true);
  ctx.addFrameworkSearchDir("/Library/Frameworks", true);
  ctx.addFrameworkSearchDir("/System/Library/Frameworks", true);
}

// Now that we've constructed the final set of search paths, print out those
// search paths in verbose mode.
if (errorHandler().Verbose) {
  message("Library search paths:");
  for (auto path : ctx.searchDirs()) {
    message("    " + path);
  }
  message("Framework search paths:");
  for (auto path : ctx.frameworkDirs()) {
    message("    " + path);
  }
}

// Handle -exported_symbols_list <file>
for (auto expFile : parsedArgs.filtered(OPT_exported_symbols_list)) {
  if (ctx.exportMode() == MachOLinkingContext::ExportMode::blackList) {
    error("-exported_symbols_list cannot be combined with "
          "-unexported_symbol[s_list]");
    return false;
  }
  ctx.setExportMode(MachOLinkingContext::ExportMode::whiteList);
  if (std::error_code ec = parseExportsList(expFile->getValue(), ctx)) {
    error(ec.message() + ", processing '-exported_symbols_list " +
          expFile->getValue());
    return false;
  }
}

// Handle -exported_symbol <symbol>
for (auto symbol : parsedArgs.filtered(OPT_exported_symbol)) {
  if (ctx.exportMode() == MachOLinkingContext::ExportMode::blackList) {
    error("-exported_symbol cannot be combined with "
          "-unexported_symbol[s_list]");
    return false;
  }
  ctx.setExportMode(MachOLinkingContext::ExportMode::whiteList);
  ctx.addExportSymbol(symbol->getValue());
}

// Handle -unexported_symbols_list <file>
for (auto expFile : parsedArgs.filtered(OPT_unexported_symbols_list)) {
  if (ctx.exportMode() == MachOLinkingContext::ExportMode::whiteList) {
    error("-unexported_symbols_list cannot be combined with "
          "-exported_symbol[s_list]");
    return false;
  }
  ctx.setExportMode(MachOLinkingContext::ExportMode::blackList);
  if (std::error_code ec = parseExportsList(expFile->getValue(), ctx)) {
    error(ec.message() + ", processing '-unexported_symbols_list " +
          expFile->getValue());
    return false;
  }
}

// Handle -unexported_symbol <symbol>
for (auto symbol : parsedArgs.filtered(OPT_unexported_symbol)) {
  if (ctx.exportMode() == MachOLinkingContext::ExportMode::whiteList) {
    error("-unexported_symbol cannot be combined with "
          "-exported_symbol[s_list]");
    return false;
  }
  ctx.setExportMode(MachOLinkingContext::ExportMode::blackList);
  ctx.addExportSymbol(symbol->getValue());
}

// Handle obosolete -multi_module and -single_module
if (llvm::opt::Arg *mod =
        parsedArgs.getLastArg(OPT_multi_module, OPT_single_module)) {
  if (mod->getOption().getID() == OPT_multi_module)
    warn("-multi_module is obsolete and being ignored");
  else if (ctx.outputMachOType() != llvm::MachO::MH_DYLIB)
    warn("-single_module being ignored. It is only for use when producing a "
         "dylib");
}

// Handle obsolete ObjC options: -objc_gc_compaction, -objc_gc, -objc_gc_only
if (parsedArgs.getLastArg(OPT_objc_gc_compaction)) {
  error("-objc_gc_compaction is not supported");
  return false;
}

if (parsedArgs.getLastArg(OPT_objc_gc)) {
  error("-objc_gc is not supported");
  return false;
}

if (parsedArgs.getLastArg(OPT_objc_gc_only)) {
  error("-objc_gc_only is not supported");
  return false;
}

// Handle -pie or -no_pie
if (llvm::opt::Arg *pie = parsedArgs.getLastArg(OPT_pie, OPT_no_pie)) {
  switch (ctx.outputMachOType()) {
  case llvm::MachO::MH_EXECUTE:
    switch (ctx.os()) {
    case MachOLinkingContext::OS::macOSX:
      if ((minOSVersion < 0x000A0500) &&
          (pie->getOption().getID() == OPT_pie)) {
        error("-pie can only be used when targeting Mac OS X 10.5 or later");
        return false;
      }
      break;
    case MachOLinkingContext::OS::iOS:
      if ((minOSVersion < 0x00040200) &&
          (pie->getOption().getID() == OPT_pie)) {
        error("-pie can only be used when targeting iOS 4.2 or later");
        return false;
      }
      break;
    case MachOLinkingContext::OS::iOS_simulator:
      if (pie->getOption().getID() == OPT_no_pie) {
        error("iOS simulator programs must be built PIE");
        return false;
      }
      break;
    case MachOLinkingContext::OS::unknown:
      break;
    }
    ctx.setPIE(pie->getOption().getID() == OPT_pie);
    break;
  case llvm::MachO::MH_PRELOAD:
    break;
  case llvm::MachO::MH_DYLIB:
  case llvm::MachO::MH_BUNDLE:
    warn(pie->getSpelling() +
         " being ignored. It is only used when linking main executables");
    break;
  default:
    error(pie->getSpelling() +
          " can only used when linking main executables");
    return false;
  }
}

// Handle -version_load_command or -no_version_load_command
{
  bool flagOn = false;
  bool flagOff = false;
  if (auto *arg = parsedArgs.getLastArg(OPT_version_load_command,
                                        OPT_no_version_load_command)) {
    flagOn = arg->getOption().getID() == OPT_version_load_command;
    flagOff = arg->getOption().getID() == OPT_no_version_load_command;
  }

  // default to adding version load command for dynamic code,
  // static code must opt-in
  switch (ctx.outputMachOType()) {
    case llvm::MachO::MH_OBJECT:
      ctx.setGenerateVersionLoadCommand(false);
      break;
    case llvm::MachO::MH_EXECUTE:
      // dynamic executables default to generating a version load command,
      // while static exectuables only generate it if required.
      if (isStaticExecutable) {
        if (flagOn)
          ctx.setGenerateVersionLoadCommand(true);
      } else {
        if (!flagOff)
          ctx.setGenerateVersionLoadCommand(true);
      }
      break;
    case llvm::MachO::MH_PRELOAD:
    case llvm::MachO::MH_KEXT_BUNDLE:
      if (flagOn)
        ctx.setGenerateVersionLoadCommand(true);
      break;
    case llvm::MachO::MH_DYLINKER:
    case llvm::MachO::MH_DYLIB:
    case llvm::MachO::MH_BUNDLE:
      if (!flagOff)
        ctx.setGenerateVersionLoadCommand(true);
      break;
    case llvm::MachO::MH_FVMLIB:
    case llvm::MachO::MH_DYLDLINK:
    case llvm::MachO::MH_DYLIB_STUB:
    case llvm::MachO::MH_DSYM:
      // We don't generate load commands for these file types, even if
      // forced on.
      break;
  }
}

// Handle -function_starts or -no_function_starts
{
  bool flagOn = false;
  bool flagOff = false;
  if (auto *arg = parsedArgs.getLastArg(OPT_function_starts,
                                        OPT_no_function_starts)) {
    flagOn = arg->getOption().getID() == OPT_function_starts;
    flagOff = arg->getOption().getID() == OPT_no_function_starts;
  }

  // default to adding functions start for dynamic code, static code must
  // opt-in
  switch (ctx.outputMachOType()) {
    case llvm::MachO::MH_OBJECT:
      ctx.setGenerateFunctionStartsLoadCommand(false);
      break;
    case llvm::MachO::MH_EXECUTE:
      // dynamic executables default to generating a version load command,
      // while static exectuables only generate it if required.
      if (isStaticExecutable) {
        if (flagOn)
          ctx.setGenerateFunctionStartsLoadCommand(true);
      } else {
        if (!flagOff)
          ctx.setGenerateFunctionStartsLoadCommand(true);
      }
      break;
    case llvm::MachO::MH_PRELOAD:
    case llvm::MachO::MH_KEXT_BUNDLE:
      if (flagOn)
        ctx.setGenerateFunctionStartsLoadCommand(true);
      break;
    case llvm::MachO::MH_DYLINKER:
    case llvm::MachO::MH_DYLIB:
    case llvm::MachO::MH_BUNDLE:
      if (!flagOff)
        ctx.setGenerateFunctionStartsLoadCommand(true);
      break;
    case llvm::MachO::MH_FVMLIB:
    case llvm::MachO::MH_DYLDLINK:
    case llvm::MachO::MH_DYLIB_STUB:
    case llvm::MachO::MH_DSYM:
      // We don't generate load commands for these file types, even if
      // forced on.
      break;
  }
}

// Handle -data_in_code_info or -no_data_in_code_info
{
  bool flagOn = false;
  bool flagOff = false;
  if (auto *arg = parsedArgs.getLastArg(OPT_data_in_code_info,
                                        OPT_no_data_in_code_info)) {
    flagOn = arg->getOption().getID() == OPT_data_in_code_info;
    flagOff = arg->getOption().getID() == OPT_no_data_in_code_info;
  }

  // default to adding data in code for dynamic code, static code must
  // opt-in
  switch (ctx.outputMachOType()) {
    case llvm::MachO::MH_OBJECT:
      if (!flagOff)
        ctx.setGenerateDataInCodeLoadCommand(true);
      break;
    case llvm::MachO::MH_EXECUTE:
      // dynamic executables default to generating a version load command,
      // while static exectuables only generate it if required.
      if (isStaticExecutable) {
        if (flagOn)
          ctx.setGenerateDataInCodeLoadCommand(true);
      } else {
        if (!flagOff)
          ctx.setGenerateDataInCodeLoadCommand(true);
      }
      break;
    case llvm::MachO::MH_PRELOAD:
    case llvm::MachO::MH_KEXT_BUNDLE:
      if (flagOn)
        ctx.setGenerateDataInCodeLoadCommand(true);
      break;
    case llvm::MachO::MH_DYLINKER:
    case llvm::MachO::MH_DYLIB:
    case llvm::MachO::MH_BUNDLE:
      if (!flagOff)
        ctx.setGenerateDataInCodeLoadCommand(true);
      break;
    case llvm::MachO::MH_FVMLIB:
    case llvm::MachO::MH_DYLDLINK:
    case llvm::MachO::MH_DYLIB_STUB:
    case llvm::MachO::MH_DSYM:
      // We don't generate load commands for these file types, even if
      // forced on.
      break;
  }
}

// Handle sdk_version
if (llvm::opt::Arg *arg = parsedArgs.getLastArg(OPT_sdk_version)) {
  uint32_t sdkVersion = 0;
  if (MachOLinkingContext::parsePackedVersion(arg->getValue(),
                                              sdkVersion)) {
    error("malformed sdkVersion value");
    return false;
  }
  ctx.setSdkVersion(sdkVersion);
} else if (ctx.generateVersionLoadCommand()) {
  // If we don't have an sdk version, but were going to emit a load command
  // with min_version, then we need to give an warning as we have no sdk
  // version to put in that command.
  // FIXME: We need to decide whether to make this an error.
  warn("-sdk_version is required when emitting min version load command.  "
       "Setting sdk version to match provided min version");
  ctx.setSdkVersion(ctx.osMinVersion());
}

// Handle source_version
if (llvm::opt::Arg *arg = parsedArgs.getLastArg(OPT_source_version)) {
  uint64_t version = 0;
  if (MachOLinkingContext::parsePackedVersion(arg->getValue(),
                                              version)) {
    error("malformed source_version value");
    return false;
  }
  ctx.setSourceVersion(version);
}

// Handle stack_size
if (llvm::opt::Arg *stackSize = parsedArgs.getLastArg(OPT_stack_size)) {
  uint64_t stackSizeVal;
  if (parseNumberBase16(stackSize->getValue(), stackSizeVal)) {
    error("stack_size expects a hex number");
    return false;
  }
  if ((stackSizeVal % ctx.pageSize()) != 0) {
    error("stack_size must be a multiple of page size (0x" +
          llvm::utohexstr(ctx.pageSize()) + ")");
    return false;
  }

  ctx.setStackSize(stackSizeVal);
}

// Handle debug info handling options: -S
if (parsedArgs.hasArg(OPT_S))
  ctx.setDebugInfoMode(MachOLinkingContext::DebugInfoMode::noDebugMap);

// Handle -order_file <file>
for (auto orderFile : parsedArgs.filtered(OPT_order_file)) {
  if (std::error_code ec = parseOrderFile(orderFile->getValue(), ctx)) {
    error(ec.message() + ", processing '-order_file " + orderFile->getValue()
          + "'");
    return false;
  }
}

// Handle -flat_namespace.
if (llvm::opt::Arg *ns =
        parsedArgs.getLastArg(OPT_flat_namespace, OPT_twolevel_namespace)) {
  if (ns->getOption().getID() == OPT_flat_namespace)
    ctx.setUseFlatNamespace(true);
}

// Handle -undefined
if (llvm::opt::Arg *undef = parsedArgs.getLastArg(OPT_undefined)) {
  MachOLinkingContext::UndefinedMode UndefMode;
  if (StringRef(undef->getValue()).equals("error"))
    UndefMode = MachOLinkingContext::UndefinedMode::error;
  else if (StringRef(undef->getValue()).equals("warning"))
    UndefMode = MachOLinkingContext::UndefinedMode::warning;
  else if (StringRef(undef->getValue()).equals("suppress"))
    UndefMode = MachOLinkingContext::UndefinedMode::suppress;
  else if (StringRef(undef->getValue()).equals("dynamic_lookup"))
    UndefMode = MachOLinkingContext::UndefinedMode::dynamicLookup;
  else {
    error("invalid option to -undefined [ warning | error | suppress | "
          "dynamic_lookup ]");
    return false;
  }

  if (ctx.useFlatNamespace()) {
    // If we're using -flat_namespace then 'warning', 'suppress' and
    // 'dynamic_lookup' are all equivalent, so map them to 'suppress'.
    if (UndefMode != MachOLinkingContext::UndefinedMode::error)
      UndefMode = MachOLinkingContext::UndefinedMode::suppress;
  } else {
    // If we're using -twolevel_namespace then 'warning' and 'suppress' are
    // illegal. Emit a diagnostic if they've been (mis)used.
    if (UndefMode == MachOLinkingContext::UndefinedMode::warning ||
        UndefMode == MachOLinkingContext::UndefinedMode::suppress) {
      error("can't use -undefined warning or suppress with "
            "-twolevel_namespace");
      return false;
    }
  }

  ctx.setUndefinedMode(UndefMode);
}

// Handle -no_objc_category_merging.
if (parsedArgs.getLastArg(OPT_no_objc_category_merging))
  ctx.setMergeObjCCategories(false);

// Handle -rpath <path>
if (parsedArgs.hasArg(OPT_rpath)) {
  switch (ctx.outputMachOType()) {
    case llvm::MachO::MH_EXECUTE:
    case llvm::MachO::MH_DYLIB:
    case llvm::MachO::MH_BUNDLE:
      if (!ctx.minOS("10.5", "2.0")) {
        if (ctx.os() == MachOLinkingContext::OS::macOSX)
          error("-rpath can only be used when targeting OS X 10.5 or later");
        else
          error("-rpath can only be used when targeting iOS 2.0 or later");
        return false;
      }
      break;
    default:
      error("-rpath can only be used when creating a dynamic final linked "
            "image");
      return false;
  }

  for (auto rPath : parsedArgs.filtered(OPT_rpath)) {
    ctx.addRpath(rPath->getValue());
  }
}

// Parse the LLVM options before we process files in case the file handling
// makes use of things like LLVM_DEBUG().
parseLLVMOptions(ctx);

// Handle input files and sectcreate.
for (auto &arg : parsedArgs) {
  bool upward;
  llvm::Optional<StringRef> resolvedPath;
  switch (arg->getOption().getID()) {
  default:
    continue;
  case OPT_INPUT:
    addFile(arg->getValue(), ctx, globalWholeArchive, false);
    break;
  case OPT_upward_library:
    addFile(arg->getValue(), ctx, false, true);
    break;
  case OPT_force_load:
    addFile(arg->getValue(), ctx, true, false);
    break;
  case OPT_l:
  case OPT_upward_l:
    upward = (arg->getOption().getID() == OPT_upward_l);
    resolvedPath = ctx.searchLibrary(arg->getValue());
    if (!resolvedPath) {
      error("Unable to find library for " + arg->getSpelling() +
            arg->getValue());
      return false;
    } else if (ctx.testingFileUsage()) {
      message(Twine("Found ") + (upward ? "upward " : " ") + "library " +
              canonicalizePath(resolvedPath.getValue()));
    }
    addFile(resolvedPath.getValue(), ctx, globalWholeArchive, upward);
    break;
  case OPT_framework:
  case OPT_upward_framework:
    upward = (arg->getOption().getID() == OPT_upward_framework);
    resolvedPath = ctx.findPathForFramework(arg->getValue());
    if (!resolvedPath) {
      error("Unable to find framework for " + arg->getSpelling() + " " +
            arg->getValue());
      return false;
    } else if (ctx.testingFileUsage()) {
      message(Twine("Found ") + (upward ? "upward " : " ") + "framework " +
              canonicalizePath(resolvedPath.getValue()));
    }
    addFile(resolvedPath.getValue(), ctx, globalWholeArchive, upward);
    break;
  case OPT_filelist:
    if (auto ec = loadFileList(arg->getValue(), ctx, globalWholeArchive)) {
      handleAllErrors(std::move(ec), [&](const llvm::ErrorInfoBase &EI) {
        error(EI.message() + ", processing '-filelist " + arg->getValue());
      });
      return false;
    }
    break;
  case OPT_sectcreate: {
      const char* seg  = arg->getValue(0);
      const char* sect = arg->getValue(1);
      const char* fileName = arg->getValue(2);

      ErrorOr<std::unique_ptr<MemoryBuffer>> contentOrErr =
        MemoryBuffer::getFile(fileName);

      if (!contentOrErr) {
        error("can't open -sectcreate file " + Twine(fileName));
        return false;
      }

      ctx.addSectCreateSection(seg, sect, std::move(*contentOrErr));
    }
    break;
  }
}

if (ctx.getNodes().empty()) {
  error("No input files");
  return false;
}

// Validate the combination of options used.
return ctx.validate();
1129}

1131static void createFiles(MachOLinkingContext &ctx, bool Implicit) {
std::vector<std::unique_ptr<File>> Files;
if (Implicit)
  ctx.createImplicitFiles(Files);
else
  ctx.createInternalFiles(Files);
for (auto i = Files.rbegin(), e = Files.rend(); i != e; ++i) {
  auto &members = ctx.getNodes();
  members.insert(members.begin(), llvm::make_unique<FileNode>(std::move(*i)));
}
1141}

1143/// This is where the link is actually performed.
1144bool link(llvm::ArrayRef<const char *> args, bool CanExitEarly,
        raw_ostream &Error) {
errorHandler().LogName = llvm::sys::path::filename(args[0]);
errorHandler().ErrorLimitExceededMsg =
    "too many errors emitted, stopping now (use "
    "'-error-limit 0' to see all errors)";
errorHandler().ErrorOS = &Error;
errorHandler().ExitEarly = CanExitEarly;
errorHandler().ColorDiagnostics = Error.has_colors();

MachOLinkingContext ctx;
if (!parse(args, ctx))
1
Assuming the condition is false→
2
←
Taking false branch→
  return false;
if (ctx.doNothing())
3
←
Assuming the condition is false→
4
←
Taking false branch→
  return true;
if (ctx.getNodes().empty())
5
←
Assuming the condition is false→
6
←
Taking false branch→
  return false;

for (std::unique_ptr<Node> &ie : ctx.getNodes())
  if (FileNode *node = dyn_cast<FileNode>(ie.get()))
    node->getFile()->parse();

createFiles(ctx, false /* Implicit */);

// Give target a chance to add files
createFiles(ctx, true /* Implicit */);

// Give target a chance to postprocess input files.
// Mach-O uses this chance to move all object files before library files.
ctx.finalizeInputFiles();

// Do core linking.
ScopedTask resolveTask(getDefaultDomain(), "Resolve");
Resolver resolver(ctx);
if (!resolver.resolve())
7
←
Assuming the condition is false→
8
←
Taking false branch→
  return false;
SimpleFile *merged = nullptr;
{
  std::unique_ptr<SimpleFile> mergedFile = resolver.resultFile();
  merged = mergedFile.get();
  auto &members = ctx.getNodes();
  members.insert(members.begin(),
                 llvm::make_unique<FileNode>(std::move(mergedFile)));
9
←
Calling 'make_unique<lld::FileNode, std::unique_ptr<lld::SimpleFile, std::default_delete<lld::SimpleFile> >>'→
17
←
Returning; memory was released→
}
resolveTask.end();

// Run passes on linked atoms.
ScopedTask passTask(getDefaultDomain(), "Passes");
PassManager pm;
ctx.addPasses(pm);
if (auto ec = pm.runOnFile(*merged)) {
18
←
Calling 'PassManager::runOnFile'→
  // FIXME: This should be passed to logAllUnhandledErrors but it needs
  // to be passed a Twine instead of a string.
  *errorHandler().ErrorOS << "Failed to run passes on file '"
                          << ctx.outputPath() << "': ";
  logAllUnhandledErrors(std::move(ec), *errorHandler().ErrorOS,
                        std::string());
  return false;
}

passTask.end();

// Give linked atoms to Writer to generate output file.
ScopedTask writeTask(getDefaultDomain(), "Write");
if (auto ec = ctx.writeFile(*merged)) {
  // FIXME: This should be passed to logAllUnhandledErrors but it needs
  // to be passed a Twine instead of a string.
  *errorHandler().ErrorOS << "Failed to write file '" << ctx.outputPath()
                          << "': ";
  logAllUnhandledErrors(std::move(ec), *errorHandler().ErrorOS,
                        std::string());
  return false;
}

// Call exit() if we can to avoid calling destructors.
if (CanExitEarly)
  exitLld(errorCount() ? 1 : 0);


return true;
1224}

1226} // end namespace mach_o
1227} // end namespace lld

←

/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/ADT/STLExtras.h

→

1//===- llvm/ADT/STLExtras.h - Useful STL related functions ------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file contains some templates that are useful if you are working with the
11// STL at all.
12//
13// No library is required when using these functions.
14//
15//===----------------------------------------------------------------------===//
16 
17#ifndef LLVM_ADT_STLEXTRAS_H
18#define LLVM_ADT_STLEXTRAS_H
19 
20#include "llvm/ADT/Optional.h"
21#include "llvm/ADT/SmallVector.h"
22#include "llvm/ADT/iterator.h"
23#include "llvm/ADT/iterator_range.h"
24#include "llvm/Support/ErrorHandling.h"
25#include <algorithm>
26#include <cassert>
27#include <cstddef>
28#include <cstdint>
29#include <cstdlib>
30#include <functional>
31#include <initializer_list>
32#include <iterator>
33#include <limits>
34#include <memory>
35#include <tuple>
36#include <type_traits>
37#include <utility>
38 
39#ifdef EXPENSIVE_CHECKS
40#include <random> // for std::mt19937
41#endif
42 
43namespace llvm {
44 
45// Only used by compiler if both template types are the same.  Useful when
46// using SFINAE to test for the existence of member functions.
47template <typename T, T> struct SameType;
48 
49namespace detail {
50 
51template <typename RangeT>
52using IterOfRange = decltype(std::begin(std::declval<RangeT &>()));
53 
54template <typename RangeT>
55using ValueOfRange = typename std::remove_reference<decltype(
56    *std::begin(std::declval<RangeT &>()))>::type;
57 
58} // end namespace detail
59 
60//===----------------------------------------------------------------------===//
61//     Extra additions to <type_traits>
62//===----------------------------------------------------------------------===//
63 
64template <typename T>
65struct negation : std::integral_constant<bool, !bool(T::value)> {};
66 
67template <typename...> struct conjunction : std::true_type {};
68template <typename B1> struct conjunction<B1> : B1 {};
69template <typename B1, typename... Bn>
70struct conjunction<B1, Bn...>
71    : std::conditional<bool(B1::value), conjunction<Bn...>, B1>::type {};
72 
73//===----------------------------------------------------------------------===//
74//     Extra additions to <functional>
75//===----------------------------------------------------------------------===//
76 
77template <class Ty> struct identity {
78  using argument_type = Ty;
79 
80  Ty &operator()(Ty &self) const {
81    return self;
82  }
83  const Ty &operator()(const Ty &self) const {
84    return self;
85  }
86};
87 
88template <class Ty> struct less_ptr {
89  bool operator()(const Ty* left, const Ty* right) const {
90    return *left < *right;
91  }
92};
93 
94template <class Ty> struct greater_ptr {
95  bool operator()(const Ty* left, const Ty* right) const {
96    return *right < *left;
97  }
98};
99 
100/// An efficient, type-erasing, non-owning reference to a callable. This is
101/// intended for use as the type of a function parameter that is not used
102/// after the function in question returns.
103///
104/// This class does not own the callable, so it is not in general safe to store
105/// a function_ref.
106template<typename Fn> class function_ref;
107 
108template<typename Ret, typename ...Params>
109class function_ref<Ret(Params...)> {
110  Ret (*callback)(intptr_t callable, Params ...params) = nullptr;
111  intptr_t callable;
112 
113  template<typename Callable>
114  static Ret callback_fn(intptr_t callable, Params ...params) {
115    return (*reinterpret_cast<Callable*>(callable))(
116        std::forward<Params>(params)...);
117  }
118 
119public:
120  function_ref() = default;
121  function_ref(std::nullptr_t) {}
122 
123  template <typename Callable>
124  function_ref(Callable &&callable,
125               typename std::enable_if<
126                   !std::is_same<typename std::remove_reference<Callable>::type,
127                                 function_ref>::value>::type * = nullptr)
128      : callback(callback_fn<typename std::remove_reference<Callable>::type>),
129        callable(reinterpret_cast<intptr_t>(&callable)) {}
130 
131  Ret operator()(Params ...params) const {
132    return callback(callable, std::forward<Params>(params)...);
133  }
134 
135  operator bool() const { return callback; }
136};
137 
138// deleter - Very very very simple method that is used to invoke operator
139// delete on something.  It is used like this:
140//
141//   for_each(V.begin(), B.end(), deleter<Interval>);
142template <class T>
143inline void deleter(T *Ptr) {
144  delete Ptr;
145}
146 
147//===----------------------------------------------------------------------===//
148//     Extra additions to <iterator>
149//===----------------------------------------------------------------------===//
150 
151namespace adl_detail {
152 
153using std::begin;
154 
155template <typename ContainerTy>
156auto adl_begin(ContainerTy &&container)
157    -> decltype(begin(std::forward<ContainerTy>(container))) {
158  return begin(std::forward<ContainerTy>(container));
159}
160 
161using std::end;
162 
163template <typename ContainerTy>
164auto adl_end(ContainerTy &&container)
165    -> decltype(end(std::forward<ContainerTy>(container))) {
166  return end(std::forward<ContainerTy>(container));
167}
168 
169using std::swap;
170 
171template <typename T>
172void adl_swap(T &&lhs, T &&rhs) noexcept(noexcept(swap(std::declval<T>(),
173                                                       std::declval<T>()))) {
174  swap(std::forward<T>(lhs), std::forward<T>(rhs));
175}
176 
177} // end namespace adl_detail
178 
179template <typename ContainerTy>
180auto adl_begin(ContainerTy &&container)
181    -> decltype(adl_detail::adl_begin(std::forward<ContainerTy>(container))) {
182  return adl_detail::adl_begin(std::forward<ContainerTy>(container));
183}
184 
185template <typename ContainerTy>
186auto adl_end(ContainerTy &&container)
187    -> decltype(adl_detail::adl_end(std::forward<ContainerTy>(container))) {
188  return adl_detail::adl_end(std::forward<ContainerTy>(container));
189}
190 
191template <typename T>
192void adl_swap(T &&lhs, T &&rhs) noexcept(
193    noexcept(adl_detail::adl_swap(std::declval<T>(), std::declval<T>()))) {
194  adl_detail::adl_swap(std::forward<T>(lhs), std::forward<T>(rhs));
195}
196 
197// mapped_iterator - This is a simple iterator adapter that causes a function to
198// be applied whenever operator* is invoked on the iterator.
199 
200template <typename ItTy, typename FuncTy,
201          typename FuncReturnTy =
202            decltype(std::declval<FuncTy>()(*std::declval<ItTy>()))>
203class mapped_iterator
204    : public iterator_adaptor_base<
205             mapped_iterator<ItTy, FuncTy>, ItTy,
206             typename std::iterator_traits<ItTy>::iterator_category,
207             typename std::remove_reference<FuncReturnTy>::type> {
208public:
209  mapped_iterator(ItTy U, FuncTy F)
210    : mapped_iterator::iterator_adaptor_base(std::move(U)), F(std::move(F)) {}
211 
212  ItTy getCurrent() { return this->I; }
213 
214  FuncReturnTy operator*() { return F(*this->I); }
215 
216private:
217  FuncTy F;
218};
219 
220// map_iterator - Provide a convenient way to create mapped_iterators, just like
221// make_pair is useful for creating pairs...
222template <class ItTy, class FuncTy>
223inline mapped_iterator<ItTy, FuncTy> map_iterator(ItTy I, FuncTy F) {
224  return mapped_iterator<ItTy, FuncTy>(std::move(I), std::move(F));
225}
226 
227/// Helper to determine if type T has a member called rbegin().
228template <typename Ty> class has_rbegin_impl {
229  using yes = char[1];
230  using no = char[2];
231 
232  template <typename Inner>
233  static yes& test(Inner *I, decltype(I->rbegin()) * = nullptr);
234 
235  template <typename>
236  static no& test(...);
237 
238public:
239  static const bool value = sizeof(test<Ty>(nullptr)) == sizeof(yes);
240};
241 
242/// Metafunction to determine if T& or T has a member called rbegin().
243template <typename Ty>
244struct has_rbegin : has_rbegin_impl<typename std::remove_reference<Ty>::type> {
245};
246 
247// Returns an iterator_range over the given container which iterates in reverse.
248// Note that the container must have rbegin()/rend() methods for this to work.
249template <typename ContainerTy>
250auto reverse(ContainerTy &&C,
251             typename std::enable_if<has_rbegin<ContainerTy>::value>::type * =
252                 nullptr) -> decltype(make_range(C.rbegin(), C.rend())) {
253  return make_range(C.rbegin(), C.rend());
254}
255 
256// Returns a std::reverse_iterator wrapped around the given iterator.
257template <typename IteratorTy>
258std::reverse_iterator<IteratorTy> make_reverse_iterator(IteratorTy It) {
259  return std::reverse_iterator<IteratorTy>(It);
260}
261 
262// Returns an iterator_range over the given container which iterates in reverse.
263// Note that the container must have begin()/end() methods which return
264// bidirectional iterators for this to work.
265template <typename ContainerTy>
266auto reverse(
267    ContainerTy &&C,
268    typename std::enable_if<!has_rbegin<ContainerTy>::value>::type * = nullptr)
269    -> decltype(make_range(llvm::make_reverse_iterator(std::end(C)),
270                           llvm::make_reverse_iterator(std::begin(C)))) {
271  return make_range(llvm::make_reverse_iterator(std::end(C)),
272                    llvm::make_reverse_iterator(std::begin(C)));
273}
274 
275/// An iterator adaptor that filters the elements of given inner iterators.
276///
277/// The predicate parameter should be a callable object that accepts the wrapped
278/// iterator's reference type and returns a bool. When incrementing or
279/// decrementing the iterator, it will call the predicate on each element and
280/// skip any where it returns false.
281///
282/// \code
283///   int A[] = { 1, 2, 3, 4 };
284///   auto R = make_filter_range(A, [](int N) { return N % 2 == 1; });
285///   // R contains { 1, 3 }.
286/// \endcode
287///
288/// Note: filter_iterator_base implements support for forward iteration.
289/// filter_iterator_impl exists to provide support for bidirectional iteration,
290/// conditional on whether the wrapped iterator supports it.
291template <typename WrappedIteratorT, typename PredicateT, typename IterTag>
292class filter_iterator_base
293    : public iterator_adaptor_base<
294          filter_iterator_base<WrappedIteratorT, PredicateT, IterTag>,
295          WrappedIteratorT,
296          typename std::common_type<
297              IterTag, typename std::iterator_traits<
298                           WrappedIteratorT>::iterator_category>::type> {
299  using BaseT = iterator_adaptor_base<
300      filter_iterator_base<WrappedIteratorT, PredicateT, IterTag>,
301      WrappedIteratorT,
302      typename std::common_type<
303          IterTag, typename std::iterator_traits<
304                       WrappedIteratorT>::iterator_category>::type>;
305 
306protected:
307  WrappedIteratorT End;
308  PredicateT Pred;
309 
310  void findNextValid() {
311    while (this->I != End && !Pred(*this->I))
312      BaseT::operator++();
313  }
314 
315  // Construct the iterator. The begin iterator needs to know where the end
316  // is, so that it can properly stop when it gets there. The end iterator only
317  // needs the predicate to support bidirectional iteration.
318  filter_iterator_base(WrappedIteratorT Begin, WrappedIteratorT End,
319                       PredicateT Pred)
320      : BaseT(Begin), End(End), Pred(Pred) {
321    findNextValid();
322  }
323 
324public:
325  using BaseT::operator++;
326 
327  filter_iterator_base &operator++() {
328    BaseT::operator++();
329    findNextValid();
330    return *this;
331  }
332};
333 
334/// Specialization of filter_iterator_base for forward iteration only.
335template <typename WrappedIteratorT, typename PredicateT,
336          typename IterTag = std::forward_iterator_tag>
337class filter_iterator_impl
338    : public filter_iterator_base<WrappedIteratorT, PredicateT, IterTag> {
339  using BaseT = filter_iterator_base<WrappedIteratorT, PredicateT, IterTag>;
340 
341public:
342  filter_iterator_impl(WrappedIteratorT Begin, WrappedIteratorT End,
343                       PredicateT Pred)
344      : BaseT(Begin, End, Pred) {}
345};
346 
347/// Specialization of filter_iterator_base for bidirectional iteration.
348template <typename WrappedIteratorT, typename PredicateT>
349class filter_iterator_impl<WrappedIteratorT, PredicateT,
350                           std::bidirectional_iterator_tag>
351    : public filter_iterator_base<WrappedIteratorT, PredicateT,
352                                  std::bidirectional_iterator_tag> {
353  using BaseT = filter_iterator_base<WrappedIteratorT, PredicateT,
354                                     std::bidirectional_iterator_tag>;
355  void findPrevValid() {
356    while (!this->Pred(*this->I))
357      BaseT::operator--();
358  }
359 
360public:
361  using BaseT::operator--;
362 
363  filter_iterator_impl(WrappedIteratorT Begin, WrappedIteratorT End,
364                       PredicateT Pred)
365      : BaseT(Begin, End, Pred) {}
366 
367  filter_iterator_impl &operator--() {
368    BaseT::operator--();
369    findPrevValid();
370    return *this;
371  }
372};
373 
374namespace detail {
375 
376template <bool is_bidirectional> struct fwd_or_bidi_tag_impl {
377  using type = std::forward_iterator_tag;
378};
379 
380template <> struct fwd_or_bidi_tag_impl<true> {
381  using type = std::bidirectional_iterator_tag;
382};
383 
384/// Helper which sets its type member to forward_iterator_tag if the category
385/// of \p IterT does not derive from bidirectional_iterator_tag, and to
386/// bidirectional_iterator_tag otherwise.
387template <typename IterT> struct fwd_or_bidi_tag {
388  using type = typename fwd_or_bidi_tag_impl<std::is_base_of<
389      std::bidirectional_iterator_tag,
390      typename std::iterator_traits<IterT>::iterator_category>::value>::type;
391};
392 
393} // namespace detail
394 
395/// Defines filter_iterator to a suitable specialization of
396/// filter_iterator_impl, based on the underlying iterator's category.
397template <typename WrappedIteratorT, typename PredicateT>
398using filter_iterator = filter_iterator_impl<
399    WrappedIteratorT, PredicateT,
400    typename detail::fwd_or_bidi_tag<WrappedIteratorT>::type>;
401 
402/// Convenience function that takes a range of elements and a predicate,
403/// and return a new filter_iterator range.
404///
405/// FIXME: Currently if RangeT && is a rvalue reference to a temporary, the
406/// lifetime of that temporary is not kept by the returned range object, and the
407/// temporary is going to be dropped on the floor after the make_iterator_range
408/// full expression that contains this function call.
409template <typename RangeT, typename PredicateT>
410iterator_range<filter_iterator<detail::IterOfRange<RangeT>, PredicateT>>
411make_filter_range(RangeT &&Range, PredicateT Pred) {
412  using FilterIteratorT =
413      filter_iterator<detail::IterOfRange<RangeT>, PredicateT>;
414  return make_range(
415      FilterIteratorT(std::begin(std::forward<RangeT>(Range)),
416                      std::end(std::forward<RangeT>(Range)), Pred),
417      FilterIteratorT(std::end(std::forward<RangeT>(Range)),
418                      std::end(std::forward<RangeT>(Range)), Pred));
419}
420 
421// forward declarations required by zip_shortest/zip_first
422template <typename R, typename UnaryPredicate>
423bool all_of(R &&range, UnaryPredicate P);
424 
425template <size_t... I> struct index_sequence;
426 
427template <class... Ts> struct index_sequence_for;
428 
429namespace detail {
430 
431using std::declval;
432 
433// We have to alias this since inlining the actual type at the usage site
434// in the parameter list of iterator_facade_base<> below ICEs MSVC 2017.
435template<typename... Iters> struct ZipTupleType {
436  using type = std::tuple<decltype(*declval<Iters>())...>;
437};
438 
439template <typename ZipType, typename... Iters>
440using zip_traits = iterator_facade_base<
441    ZipType, typename std::common_type<std::bidirectional_iterator_tag,
442                                       typename std::iterator_traits<
443                                           Iters>::iterator_category...>::type,
444    // ^ TODO: Implement random access methods.
445    typename ZipTupleType<Iters...>::type,
446    typename std::iterator_traits<typename std::tuple_element<
447        0, std::tuple<Iters...>>::type>::difference_type,
448    // ^ FIXME: This follows boost::make_zip_iterator's assumption that all
449    // inner iterators have the same difference_type. It would fail if, for
450    // instance, the second field's difference_type were non-numeric while the
451    // first is.
452    typename ZipTupleType<Iters...>::type *,
453    typename ZipTupleType<Iters...>::type>;
454 
455template <typename ZipType, typename... Iters>
456struct zip_common : public zip_traits<ZipType, Iters...> {
457  using Base = zip_traits<ZipType, Iters...>;
458  using value_type = typename Base::value_type;
459 
460  std::tuple<Iters...> iterators;
461 
462protected:
463  template <size_t... Ns> value_type deref(index_sequence<Ns...>) const {
464    return value_type(*std::get<Ns>(iterators)...);
465  }
466 
467  template <size_t... Ns>
468  decltype(iterators) tup_inc(index_sequence<Ns...>) const {
469    return std::tuple<Iters...>(std::next(std::get<Ns>(iterators))...);
470  }
471 
472  template <size_t... Ns>
473  decltype(iterators) tup_dec(index_sequence<Ns...>) const {
474    return std::tuple<Iters...>(std::prev(std::get<Ns>(iterators))...);
475  }
476 
477public:
478  zip_common(Iters &&... ts) : iterators(std::forward<Iters>(ts)...) {}
479 
480  value_type operator*() { return deref(index_sequence_for<Iters...>{}); }
481 
482  const value_type operator*() const {
483    return deref(index_sequence_for<Iters...>{});
484  }
485 
486  ZipType &operator++() {
487    iterators = tup_inc(index_sequence_for<Iters...>{});
488    return *reinterpret_cast<ZipType *>(this);
489  }
490 
491  ZipType &operator--() {
492    static_assert(Base::IsBidirectional,
493                  "All inner iterators must be at least bidirectional.");
494    iterators = tup_dec(index_sequence_for<Iters...>{});
495    return *reinterpret_cast<ZipType *>(this);
496  }
497};
498 
499template <typename... Iters>
500struct zip_first : public zip_common<zip_first<Iters...>, Iters...> {
501  using Base = zip_common<zip_first<Iters...>, Iters...>;
502 
503  bool operator==(const zip_first<Iters...> &other) const {
504    return std::get<0>(this->iterators) == std::get<0>(other.iterators);
505  }
506 
507  zip_first(Iters &&... ts) : Base(std::forward<Iters>(ts)...) {}
508};
509 
510template <typename... Iters>
511class zip_shortest : public zip_common<zip_shortest<Iters...>, Iters...> {
512  template <size_t... Ns>
513  bool test(const zip_shortest<Iters...> &other, index_sequence<Ns...>) const {
514    return all_of(std::initializer_list<bool>{std::get<Ns>(this->iterators) !=
515                                              std::get<Ns>(other.iterators)...},
516                  identity<bool>{});
517  }
518 
519public:
520  using Base = zip_common<zip_shortest<Iters...>, Iters...>;
521 
522  zip_shortest(Iters &&... ts) : Base(std::forward<Iters>(ts)...) {}
523 
524  bool operator==(const zip_shortest<Iters...> &other) const {
525    return !test(other, index_sequence_for<Iters...>{});
526  }
527};
528 
529template <template <typename...> class ItType, typename... Args> class zippy {
530public:
531  using iterator = ItType<decltype(std::begin(std::declval<Args>()))...>;
532  using iterator_category = typename iterator::iterator_category;
533  using value_type = typename iterator::value_type;
534  using difference_type = typename iterator::difference_type;
535  using pointer = typename iterator::pointer;
536  using reference = typename iterator::reference;
537 
538private:
539  std::tuple<Args...> ts;
540 
541  template <size_t... Ns> iterator begin_impl(index_sequence<Ns...>) const {
542    return iterator(std::begin(std::get<Ns>(ts))...);
543  }
544  template <size_t... Ns> iterator end_impl(index_sequence<Ns...>) const {
545    return iterator(std::end(std::get<Ns>(ts))...);
546  }
547 
548public:
549  zippy(Args &&... ts_) : ts(std::forward<Args>(ts_)...) {}
550 
551  iterator begin() const { return begin_impl(index_sequence_for<Args...>{}); }
552  iterator end() const { return end_impl(index_sequence_for<Args...>{}); }
553};
554 
555} // end namespace detail
556 
557/// zip iterator for two or more iteratable types.
558template <typename T, typename U, typename... Args>
559detail::zippy<detail::zip_shortest, T, U, Args...> zip(T &&t, U &&u,
560                                                       Args &&... args) {
561  return detail::zippy<detail::zip_shortest, T, U, Args...>(
562      std::forward<T>(t), std::forward<U>(u), std::forward<Args>(args)...);
563}
564 
565/// zip iterator that, for the sake of efficiency, assumes the first iteratee to
566/// be the shortest.
567template <typename T, typename U, typename... Args>
568detail::zippy<detail::zip_first, T, U, Args...> zip_first(T &&t, U &&u,
569                                                          Args &&... args) {
570  return detail::zippy<detail::zip_first, T, U, Args...>(
571      std::forward<T>(t), std::forward<U>(u), std::forward<Args>(args)...);
572}
573 
574/// Iterator wrapper that concatenates sequences together.
575///
576/// This can concatenate different iterators, even with different types, into
577/// a single iterator provided the value types of all the concatenated
578/// iterators expose `reference` and `pointer` types that can be converted to
579/// `ValueT &` and `ValueT *` respectively. It doesn't support more
580/// interesting/customized pointer or reference types.
581///
582/// Currently this only supports forward or higher iterator categories as
583/// inputs and always exposes a forward iterator interface.
584template <typename ValueT, typename... IterTs>
585class concat_iterator
586    : public iterator_facade_base<concat_iterator<ValueT, IterTs...>,
587                                  std::forward_iterator_tag, ValueT> {
588  using BaseT = typename concat_iterator::iterator_facade_base;
589 
590  /// We store both the current and end iterators for each concatenated
591  /// sequence in a tuple of pairs.
592  ///
593  /// Note that something like iterator_range seems nice at first here, but the
594  /// range properties are of little benefit and end up getting in the way
595  /// because we need to do mutation on the current iterators.
596  std::tuple<std::pair<IterTs, IterTs>...> IterPairs;
597 
598  /// Attempts to increment a specific iterator.
599  ///
600  /// Returns true if it was able to increment the iterator. Returns false if
601  /// the iterator is already at the end iterator.
602  template <size_t Index> bool incrementHelper() {
603    auto &IterPair = std::get<Index>(IterPairs);
604    if (IterPair.first == IterPair.second)
605      return false;
606 
607    ++IterPair.first;
608    return true;
609  }
610 
611  /// Increments the first non-end iterator.
612  ///
613  /// It is an error to call this with all iterators at the end.
614  template <size_t... Ns> void increment(index_sequence<Ns...>) {
615    // Build a sequence of functions to increment each iterator if possible.
616    bool (concat_iterator::*IncrementHelperFns[])() = {
617        &concat_iterator::incrementHelper<Ns>...};
618 
619    // Loop over them, and stop as soon as we succeed at incrementing one.
620    for (auto &IncrementHelperFn : IncrementHelperFns)
621      if ((this->*IncrementHelperFn)())
622        return;
623 
624    llvm_unreachable("Attempted to increment an end concat iterator!")::llvm::llvm_unreachable_internal("Attempted to increment an end concat iterator!"
, "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/ADT/STLExtras.h"
, 624);
625  }
626 
627  /// Returns null if the specified iterator is at the end. Otherwise,
628  /// dereferences the iterator and returns the address of the resulting
629  /// reference.
630  template <size_t Index> ValueT *getHelper() const {
631    auto &IterPair = std::get<Index>(IterPairs);
632    if (IterPair.first == IterPair.second)
633      return nullptr;
634 
635    return &*IterPair.first;
636  }
637 
638  /// Finds the first non-end iterator, dereferences, and returns the resulting
639  /// reference.
640  ///
641  /// It is an error to call this with all iterators at the end.
642  template <size_t... Ns> ValueT &get(index_sequence<Ns...>) const {
643    // Build a sequence of functions to get from iterator if possible.
644    ValueT *(concat_iterator::*GetHelperFns[])() const = {
645        &concat_iterator::getHelper<Ns>...};
646 
647    // Loop over them, and return the first result we find.
648    for (auto &GetHelperFn : GetHelperFns)
649      if (ValueT *P = (this->*GetHelperFn)())
650        return *P;
651 
652    llvm_unreachable("Attempted to get a pointer from an end concat iterator!")::llvm::llvm_unreachable_internal("Attempted to get a pointer from an end concat iterator!"
, "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/ADT/STLExtras.h"
, 652);
653  }
654 
655public:
656  /// Constructs an iterator from a squence of ranges.
657  ///
658  /// We need the full range to know how to switch between each of the
659  /// iterators.
660  template <typename... RangeTs>
661  explicit concat_iterator(RangeTs &&... Ranges)
662      : IterPairs({std::begin(Ranges), std::end(Ranges)}...) {}
663 
664  using BaseT::operator++;
665 
666  concat_iterator &operator++() {
667    increment(index_sequence_for<IterTs...>());
668    return *this;
669  }
670 
671  ValueT &operator*() const { return get(index_sequence_for<IterTs...>()); }
672 
673  bool operator==(const concat_iterator &RHS) const {
674    return IterPairs == RHS.IterPairs;
675  }
676};
677 
678namespace detail {
679 
680/// Helper to store a sequence of ranges being concatenated and access them.
681///
682/// This is designed to facilitate providing actual storage when temporaries
683/// are passed into the constructor such that we can use it as part of range
684/// based for loops.
685template <typename ValueT, typename... RangeTs> class concat_range {
686public:
687  using iterator =
688      concat_iterator<ValueT,
689                      decltype(std::begin(std::declval<RangeTs &>()))...>;
690 
691private:
692  std::tuple<RangeTs...> Ranges;
693 
694  template <size_t... Ns> iterator begin_impl(index_sequence<Ns...>) {
695    return iterator(std::get<Ns>(Ranges)...);
696  }
697  template <size_t... Ns> iterator end_impl(index_sequence<Ns...>) {
698    return iterator(make_range(std::end(std::get<Ns>(Ranges)),
699                               std::end(std::get<Ns>(Ranges)))...);
700  }
701 
702public:
703  concat_range(RangeTs &&... Ranges)
704      : Ranges(std::forward<RangeTs>(Ranges)...) {}
705 
706  iterator begin() { return begin_impl(index_sequence_for<RangeTs...>{}); }
707  iterator end() { return end_impl(index_sequence_for<RangeTs...>{}); }
708};
709 
710} // end namespace detail
711 
712/// Concatenated range across two or more ranges.
713///
714/// The desired value type must be explicitly specified.
715template <typename ValueT, typename... RangeTs>
716detail::concat_range<ValueT, RangeTs...> concat(RangeTs &&... Ranges) {
717  static_assert(sizeof...(RangeTs) > 1,
718                "Need more than one range to concatenate!");
719  return detail::concat_range<ValueT, RangeTs...>(
720      std::forward<RangeTs>(Ranges)...);
721}
722 
723//===----------------------------------------------------------------------===//
724//     Extra additions to <utility>
725//===----------------------------------------------------------------------===//
726 
727/// Function object to check whether the first component of a std::pair
728/// compares less than the first component of another std::pair.
729struct less_first {
730  template <typename T> bool operator()(const T &lhs, const T &rhs) const {
731    return lhs.first < rhs.first;
732  }
733};
734 
735/// Function object to check whether the second component of a std::pair
736/// compares less than the second component of another std::pair.
737struct less_second {
738  template <typename T> bool operator()(const T &lhs, const T &rhs) const {
739    return lhs.second < rhs.second;
740  }
741};
742 
743// A subset of N3658. More stuff can be added as-needed.
744 
745/// Represents a compile-time sequence of integers.
746template <class T, T... I> struct integer_sequence {
747  using value_type = T;
748 
749  static constexpr size_t size() { return sizeof...(I); }
750};
751 
752/// Alias for the common case of a sequence of size_ts.
753template <size_t... I>
754struct index_sequence : integer_sequence<std::size_t, I...> {};
755 
756template <std::size_t N, std::size_t... I>
757struct build_index_impl : build_index_impl<N - 1, N - 1, I...> {};
758template <std::size_t... I>
759struct build_index_impl<0, I...> : index_sequence<I...> {};
760 
761/// Creates a compile-time integer sequence for a parameter pack.
762template <class... Ts>
763struct index_sequence_for : build_index_impl<sizeof...(Ts)> {};
764 
765/// Utility type to build an inheritance chain that makes it easy to rank
766/// overload candidates.
767template <int N> struct rank : rank<N - 1> {};
768template <> struct rank<0> {};
769 
770/// traits class for checking whether type T is one of any of the given
771/// types in the variadic list.
772template <typename T, typename... Ts> struct is_one_of {
773  static const bool value = false;
774};
775 
776template <typename T, typename U, typename... Ts>
777struct is_one_of<T, U, Ts...> {
778  static const bool value =
779      std::is_same<T, U>::value || is_one_of<T, Ts...>::value;
780};
781 
782/// traits class for checking whether type T is a base class for all
783///  the given types in the variadic list.
784template <typename T, typename... Ts> struct are_base_of {
785  static const bool value = true;
786};
787 
788template <typename T, typename U, typename... Ts>
789struct are_base_of<T, U, Ts...> {
790  static const bool value =
791      std::is_base_of<T, U>::value && are_base_of<T, Ts...>::value;
792};
793 
794//===----------------------------------------------------------------------===//
795//     Extra additions for arrays
796//===----------------------------------------------------------------------===//
797 
798/// Find the length of an array.
799template <class T, std::size_t N>
800constexpr inline size_t array_lengthof(T (&)[N]) {
801  return N;
802}
803 
804/// Adapt std::less<T> for array_pod_sort.
805template<typename T>
806inline int array_pod_sort_comparator(const void *P1, const void *P2) {
807  if (std::less<T>()(*reinterpret_cast<const T*>(P1),
808                     *reinterpret_cast<const T*>(P2)))
809    return -1;
810  if (std::less<T>()(*reinterpret_cast<const T*>(P2),
811                     *reinterpret_cast<const T*>(P1)))
812    return 1;
813  return 0;
814}
815 
816/// get_array_pod_sort_comparator - This is an internal helper function used to
817/// get type deduction of T right.
818template<typename T>
819inline int (*get_array_pod_sort_comparator(const T &))
820             (const void*, const void*) {
821  return array_pod_sort_comparator<T>;
822}
823 
824/// array_pod_sort - This sorts an array with the specified start and end
825/// extent.  This is just like std::sort, except that it calls qsort instead of
826/// using an inlined template.  qsort is slightly slower than std::sort, but
827/// most sorts are not performance critical in LLVM and std::sort has to be
828/// template instantiated for each type, leading to significant measured code
829/// bloat.  This function should generally be used instead of std::sort where
830/// possible.
831///
832/// This function assumes that you have simple POD-like types that can be
833/// compared with std::less and can be moved with memcpy.  If this isn't true,
834/// you should use std::sort.
835///
836/// NOTE: If qsort_r were portable, we could allow a custom comparator and
837/// default to std::less.
838template<class IteratorTy>
839inline void array_pod_sort(IteratorTy Start, IteratorTy End) {
840  // Don't inefficiently call qsort with one element or trigger undefined
841  // behavior with an empty sequence.
842  auto NElts = End - Start;
843  if (NElts <= 1) return;
844#ifdef EXPENSIVE_CHECKS
845  std::mt19937 Generator(std::random_device{}());
846  std::shuffle(Start, End, Generator);
847#endif
848  qsort(&*Start, NElts, sizeof(*Start), get_array_pod_sort_comparator(*Start));
849}
850 
851template <class IteratorTy>
852inline void array_pod_sort(
853    IteratorTy Start, IteratorTy End,
854    int (*Compare)(
855        const typename std::iterator_traits<IteratorTy>::value_type *,
856        const typename std::iterator_traits<IteratorTy>::value_type *)) {
857  // Don't inefficiently call qsort with one element or trigger undefined
858  // behavior with an empty sequence.
859  auto NElts = End - Start;
860  if (NElts <= 1) return;
861#ifdef EXPENSIVE_CHECKS
862  std::mt19937 Generator(std::random_device{}());
863  std::shuffle(Start, End, Generator);
864#endif
865  qsort(&*Start, NElts, sizeof(*Start),
866        reinterpret_cast<int (*)(const void *, const void *)>(Compare));
867}
868 
869// Provide wrappers to std::sort which shuffle the elements before sorting
870// to help uncover non-deterministic behavior (PR35135).
871template <typename IteratorTy>
872inline void sort(IteratorTy Start, IteratorTy End) {
873#ifdef EXPENSIVE_CHECKS
874  std::mt19937 Generator(std::random_device{}());
875  std::shuffle(Start, End, Generator);
876#endif
877  std::sort(Start, End);
878}
879 
880template <typename IteratorTy, typename Compare>
881inline void sort(IteratorTy Start, IteratorTy End, Compare Comp) {
882#ifdef EXPENSIVE_CHECKS
883  std::mt19937 Generator(std::random_device{}());
884  std::shuffle(Start, End, Generator);
885#endif
886  std::sort(Start, End, Comp);
887}
888 
889//===----------------------------------------------------------------------===//
890//     Extra additions to <algorithm>
891//===----------------------------------------------------------------------===//
892 
893/// For a container of pointers, deletes the pointers and then clears the
894/// container.
895template<typename Container>
896void DeleteContainerPointers(Container &C) {
897  for (auto V : C)
898    delete V;
899  C.clear();
900}
901 
902/// In a container of pairs (usually a map) whose second element is a pointer,
903/// deletes the second elements and then clears the container.
904template<typename Container>
905void DeleteContainerSeconds(Container &C) {
906  for (auto &V : C)
907    delete V.second;
908  C.clear();
909}
910 
911/// Provide wrappers to std::for_each which take ranges instead of having to
912/// pass begin/end explicitly.
913template <typename R, typename UnaryPredicate>
914UnaryPredicate for_each(R &&Range, UnaryPredicate P) {
915  return std::for_each(adl_begin(Range), adl_end(Range), P);
916}
917 
918/// Provide wrappers to std::all_of which take ranges instead of having to pass
919/// begin/end explicitly.
920template <typename R, typename UnaryPredicate>
921bool all_of(R &&Range, UnaryPredicate P) {
922  return std::all_of(adl_begin(Range), adl_end(Range), P);
923}
924 
925/// Provide wrappers to std::any_of which take ranges instead of having to pass
926/// begin/end explicitly.
927template <typename R, typename UnaryPredicate>
928bool any_of(R &&Range, UnaryPredicate P) {
929  return std::any_of(adl_begin(Range), adl_end(Range), P);
930}
931 
932/// Provide wrappers to std::none_of which take ranges instead of having to pass
933/// begin/end explicitly.
934template <typename R, typename UnaryPredicate>
935bool none_of(R &&Range, UnaryPredicate P) {
936  return std::none_of(adl_begin(Range), adl_end(Range), P);
937}
938 
939/// Provide wrappers to std::find which take ranges instead of having to pass
940/// begin/end explicitly.
941template <typename R, typename T>
942auto find(R &&Range, const T &Val) -> decltype(adl_begin(Range)) {
943  return std::find(adl_begin(Range), adl_end(Range), Val);
944}
945 
946/// Provide wrappers to std::find_if which take ranges instead of having to pass
947/// begin/end explicitly.
948template <typename R, typename UnaryPredicate>
949auto find_if(R &&Range, UnaryPredicate P) -> decltype(adl_begin(Range)) {
950  return std::find_if(adl_begin(Range), adl_end(Range), P);
951}
952 
953template <typename R, typename UnaryPredicate>
954auto find_if_not(R &&Range, UnaryPredicate P) -> decltype(adl_begin(Range)) {
955  return std::find_if_not(adl_begin(Range), adl_end(Range), P);
956}
957 
958/// Provide wrappers to std::remove_if which take ranges instead of having to
959/// pass begin/end explicitly.
960template <typename R, typename UnaryPredicate>
961auto remove_if(R &&Range, UnaryPredicate P) -> decltype(adl_begin(Range)) {
962  return std::remove_if(adl_begin(Range), adl_end(Range), P);
963}
964 
965/// Provide wrappers to std::copy_if which take ranges instead of having to
966/// pass begin/end explicitly.
967template <typename R, typename OutputIt, typename UnaryPredicate>
968OutputIt copy_if(R &&Range, OutputIt Out, UnaryPredicate P) {
969  return std::copy_if(adl_begin(Range), adl_end(Range), Out, P);
970}
971 
972template <typename R, typename OutputIt>
973OutputIt copy(R &&Range, OutputIt Out) {
974  return std::copy(adl_begin(Range), adl_end(Range), Out);
975}
976 
977/// Wrapper function around std::find to detect if an element exists
978/// in a container.
979template <typename R, typename E>
980bool is_contained(R &&Range, const E &Element) {
981  return std::find(adl_begin(Range), adl_end(Range), Element) != adl_end(Range);
982}
983 
984/// Wrapper function around std::count to count the number of times an element
985/// \p Element occurs in the given range \p Range.
986template <typename R, typename E>
987auto count(R &&Range, const E &Element) ->
988    typename std::iterator_traits<decltype(adl_begin(Range))>::difference_type {
989  return std::count(adl_begin(Range), adl_end(Range), Element);
990}
991 
992/// Wrapper function around std::count_if to count the number of times an
993/// element satisfying a given predicate occurs in a range.
994template <typename R, typename UnaryPredicate>
995auto count_if(R &&Range, UnaryPredicate P) ->
996    typename std::iterator_traits<decltype(adl_begin(Range))>::difference_type {
997  return std::count_if(adl_begin(Range), adl_end(Range), P);
998}
999 
1000/// Wrapper function around std::transform to apply a function to a range and
1001/// store the result elsewhere.
1002template <typename R, typename OutputIt, typename UnaryPredicate>
1003OutputIt transform(R &&Range, OutputIt d_first, UnaryPredicate P) {
1004  return std::transform(adl_begin(Range), adl_end(Range), d_first, P);
1005}
1006 
1007/// Provide wrappers to std::partition which take ranges instead of having to
1008/// pass begin/end explicitly.
1009template <typename R, typename UnaryPredicate>
1010auto partition(R &&Range, UnaryPredicate P) -> decltype(adl_begin(Range)) {
1011  return std::partition(adl_begin(Range), adl_end(Range), P);
1012}
1013 
1014/// Provide wrappers to std::lower_bound which take ranges instead of having to
1015/// pass begin/end explicitly.
1016template <typename R, typename ForwardIt>
1017auto lower_bound(R &&Range, ForwardIt I) -> decltype(adl_begin(Range)) {
1018  return std::lower_bound(adl_begin(Range), adl_end(Range), I);
1019}
1020 
1021/// Given a range of type R, iterate the entire range and return a
1022/// SmallVector with elements of the vector.  This is useful, for example,
1023/// when you want to iterate a range and then sort the results.
1024template <unsigned Size, typename R>
1025SmallVector<typename std::remove_const<detail::ValueOfRange<R>>::type, Size>
1026to_vector(R &&Range) {
1027  return {adl_begin(Range), adl_end(Range)};
1028}
1029 
1030/// Provide a container algorithm similar to C++ Library Fundamentals v2's
1031/// `erase_if` which is equivalent to:
1032///
1033///   C.erase(remove_if(C, pred), C.end());
1034///
1035/// This version works for any container with an erase method call accepting
1036/// two iterators.
1037template <typename Container, typename UnaryPredicate>
1038void erase_if(Container &C, UnaryPredicate P) {
1039  C.erase(remove_if(C, P), C.end());
1040}
1041 
1042/// Get the size of a range. This is a wrapper function around std::distance
1043/// which is only enabled when the operation is O(1).
1044template <typename R>
1045auto size(R &&Range, typename std::enable_if<
1046                         std::is_same<typename std::iterator_traits<decltype(
1047                                          Range.begin())>::iterator_category,
1048                                      std::random_access_iterator_tag>::value,
1049                         void>::type * = nullptr)
1050    -> decltype(std::distance(Range.begin(), Range.end())) {
1051  return std::distance(Range.begin(), Range.end());
1052}
1053 
1054//===----------------------------------------------------------------------===//
1055//     Extra additions to <memory>
1056//===----------------------------------------------------------------------===//
1057 
1058// Implement make_unique according to N3656.
1059 
1060/// Constructs a `new T()` with the given args and returns a
1061///        `unique_ptr<T>` which owns the object.
1062///
1063/// Example:
1064///
1065///     auto p = make_unique<int>();
1066///     auto p = make_unique<std::tuple<int, int>>(0, 1);
1067template <class T, class... Args>
1068typename std::enable_if<!std::is_array<T>::value, std::unique_ptr<T>>::type
1069make_unique(Args &&... args) {
1070  return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
10
←
Calling '~unique_ptr'→
16
←
Returning from '~unique_ptr'→
1071}
1072 
1073/// Constructs a `new T[n]` with the given args and returns a
1074///        `unique_ptr<T[]>` which owns the object.
1075///
1076/// \param n size of the new array.
1077///
1078/// Example:
1079///
1080///     auto p = make_unique<int[]>(2); // value-initializes the array with 0's.
1081template <class T>
1082typename std::enable_if<std::is_array<T>::value && std::extent<T>::value == 0,
1083                        std::unique_ptr<T>>::type
1084make_unique(size_t n) {
1085  return std::unique_ptr<T>(new typename std::remove_extent<T>::type[n]());
1086}
1087 
1088/// This function isn't used and is only here to provide better compile errors.
1089template <class T, class... Args>
1090typename std::enable_if<std::extent<T>::value != 0>::type
1091make_unique(Args &&...) = delete;
1092 
1093struct FreeDeleter {
1094  void operator()(void* v) {
1095    ::free(v);
1096  }
1097};
1098 
1099template<typename First, typename Second>
1100struct pair_hash {
1101  size_t operator()(const std::pair<First, Second> &P) const {
1102    return std::hash<First>()(P.first) * 31 + std::hash<Second>()(P.second);
1103  }
1104};
1105 
1106/// A functor like C++14's std::less<void> in its absence.
1107struct less {
1108  template <typename A, typename B> bool operator()(A &&a, B &&b) const {
1109    return std::forward<A>(a) < std::forward<B>(b);
1110  }
1111};
1112 
1113/// A functor like C++14's std::equal<void> in its absence.
1114struct equal {
1115  template <typename A, typename B> bool operator()(A &&a, B &&b) const {
1116    return std::forward<A>(a) == std::forward<B>(b);
1117  }
1118};
1119 
1120/// Binary functor that adapts to any other binary functor after dereferencing
1121/// operands.
1122template <typename T> struct deref {
1123  T func;
1124 
1125  // Could be further improved to cope with non-derivable functors and
1126  // non-binary functors (should be a variadic template member function
1127  // operator()).
1128  template <typename A, typename B>
1129  auto operator()(A &lhs, B &rhs) const -> decltype(func(*lhs, *rhs)) {
1130    assert(lhs)(static_cast <bool> (lhs) ? void (0) : __assert_fail ("lhs"
, "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/ADT/STLExtras.h"
, 1130, __extension__ __PRETTY_FUNCTION__));
1131    assert(rhs)(static_cast <bool> (rhs) ? void (0) : __assert_fail ("rhs"
, "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/ADT/STLExtras.h"
, 1131, __extension__ __PRETTY_FUNCTION__));
1132    return func(*lhs, *rhs);
1133  }
1134};
1135 
1136namespace detail {
1137 
1138template <typename R> class enumerator_iter;
1139 
1140template <typename R> struct result_pair {
1141  friend class enumerator_iter<R>;
1142 
1143  result_pair() = default;
1144  result_pair(std::size_t Index, IterOfRange<R> Iter)
1145      : Index(Index), Iter(Iter) {}
1146 
1147  result_pair<R> &operator=(const result_pair<R> &Other) {
1148    Index = Other.Index;
1149    Iter = Other.Iter;
1150    return *this;
1151  }
1152 
1153  std::size_t index() const { return Index; }
1154  const ValueOfRange<R> &value() const { return *Iter; }
1155  ValueOfRange<R> &value() { return *Iter; }
1156 
1157private:
1158  std::size_t Index = std::numeric_limits<std::size_t>::max();
1159  IterOfRange<R> Iter;
1160};
1161 
1162template <typename R>
1163class enumerator_iter
1164    : public iterator_facade_base<
1165          enumerator_iter<R>, std::forward_iterator_tag, result_pair<R>,
1166          typename std::iterator_traits<IterOfRange<R>>::difference_type,
1167          typename std::iterator_traits<IterOfRange<R>>::pointer,
1168          typename std::iterator_traits<IterOfRange<R>>::reference> {
1169  using result_type = result_pair<R>;
1170 
1171public:
1172  explicit enumerator_iter(IterOfRange<R> EndIter)
1173      : Result(std::numeric_limits<size_t>::max(), EndIter) {}
1174 
1175  enumerator_iter(std::size_t Index, IterOfRange<R> Iter)
1176      : Result(Index, Iter) {}
1177 
1178  result_type &operator*() { return Result; }
1179  const result_type &operator*() const { return Result; }
1180 
1181  enumerator_iter<R> &operator++() {
1182    assert(Result.Index != std::numeric_limits<size_t>::max())(static_cast <bool> (Result.Index != std::numeric_limits
<size_t>::max()) ? void (0) : __assert_fail ("Result.Index != std::numeric_limits<size_t>::max()"
, "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/ADT/STLExtras.h"
, 1182, __extension__ __PRETTY_FUNCTION__));
1183    ++Result.Iter;
1184    ++Result.Index;
1185    return *this;
1186  }
1187 
1188  bool operator==(const enumerator_iter<R> &RHS) const {
1189    // Don't compare indices here, only iterators.  It's possible for an end
1190    // iterator to have different indices depending on whether it was created
1191    // by calling std::end() versus incrementing a valid iterator.
1192    return Result.Iter == RHS.Result.Iter;
1193  }
1194 
1195  enumerator_iter<R> &operator=(const enumerator_iter<R> &Other) {
1196    Result = Other.Result;
1197    return *this;
1198  }
1199 
1200private:
1201  result_type Result;
1202};
1203 
1204template <typename R> class enumerator {
1205public:
1206  explicit enumerator(R &&Range) : TheRange(std::forward<R>(Range)) {}
1207 
1208  enumerator_iter<R> begin() {
1209    return enumerator_iter<R>(0, std::begin(TheRange));
1210  }
1211 
1212  enumerator_iter<R> end() {
1213    return enumerator_iter<R>(std::end(TheRange));
1214  }
1215 
1216private:
1217  R TheRange;
1218};
1219 
1220} // end namespace detail
1221 
1222/// Given an input range, returns a new range whose values are are pair (A,B)
1223/// such that A is the 0-based index of the item in the sequence, and B is
1224/// the value from the original sequence.  Example:
1225///
1226/// std::vector<char> Items = {'A', 'B', 'C', 'D'};
1227/// for (auto X : enumerate(Items)) {
1228///   printf("Item %d - %c\n", X.index(), X.value());
1229/// }
1230///
1231/// Output:
1232///   Item 0 - A
1233///   Item 1 - B
1234///   Item 2 - C
1235///   Item 3 - D
1236///
1237template <typename R> detail::enumerator<R> enumerate(R &&TheRange) {
1238  return detail::enumerator<R>(std::forward<R>(TheRange));
1239}
1240 
1241namespace detail {
1242 
1243template <typename F, typename Tuple, std::size_t... I>
1244auto apply_tuple_impl(F &&f, Tuple &&t, index_sequence<I...>)
1245    -> decltype(std::forward<F>(f)(std::get<I>(std::forward<Tuple>(t))...)) {
1246  return std::forward<F>(f)(std::get<I>(std::forward<Tuple>(t))...);
1247}
1248 
1249} // end namespace detail
1250 
1251/// Given an input tuple (a1, a2, ..., an), pass the arguments of the
1252/// tuple variadically to f as if by calling f(a1, a2, ..., an) and
1253/// return the result.
1254template <typename F, typename Tuple>
1255auto apply_tuple(F &&f, Tuple &&t) -> decltype(detail::apply_tuple_impl(
1256    std::forward<F>(f), std::forward<Tuple>(t),
1257    build_index_impl<
1258        std::tuple_size<typename std::decay<Tuple>::type>::value>{})) {
1259  using Indices = build_index_impl<
1260      std::tuple_size<typename std::decay<Tuple>::type>::value>;
1261 
1262  return detail::apply_tuple_impl(std::forward<F>(f), std::forward<Tuple>(t),
1263                                  Indices{});
1264}
1265 
1266} // end namespace llvm
1267 
1268#endif // LLVM_ADT_STLEXTRAS_H

←

/usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8/bits/unique_ptr.h

→

1// unique_ptr implementation -*- C++ -*-

3// Copyright (C) 2008-2018 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library.  This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.

11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14// GNU General Public License for more details.

16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.

20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23// <http://www.gnu.org/licenses/>.

25/** @file bits/unique_ptr.h
*  This is an internal header file, included by other library headers.
*  Do not attempt to use it directly. @headername{memory}
*/

30#ifndef _UNIQUE_PTR_H1
31#define _UNIQUE_PTR_H1 1

33#include <bits/c++config.h>
34#include <debug/assertions.h>
35#include <type_traits>
36#include <utility>
37#include <tuple>
38#include <bits/stl_function.h>
39#include <bits/functional_hash.h>

41namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
42{
43_GLIBCXX_BEGIN_NAMESPACE_VERSION

/**
 * @addtogroup pointer_abstractions
 * @{
 */

50#if _GLIBCXX_USE_DEPRECATED1
51#pragma GCC diagnostic push
52#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
template<typename> class auto_ptr;
54#pragma GCC diagnostic pop
55#endif

/// Primary template of default_delete, used by unique_ptr
template<typename _Tp>
  struct default_delete
  {
    /// Default constructor
    constexpr default_delete() noexcept = default;

    /** @brief Converting constructor.
     *
     * Allows conversion from a deleter for arrays of another type, @p _Up,
     * only if @p _Up* is convertible to @p _Tp*.
     */
    template<typename _Up, typename = typename
      enable_if<is_convertible<_Up*, _Tp*>::value>::type>
      default_delete(const default_delete<_Up>&) noexcept { }

    /// Calls @c delete @p __ptr
    void
    operator()(_Tp* __ptr) const
    {
static_assert(!is_void<_Tp>::value,
      "can't delete pointer to incomplete type");
static_assert(sizeof(_Tp)>0,
      "can't delete pointer to incomplete type");
delete __ptr;
14
←
Memory is released→
    }
  };

// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 740 - omit specialization for array objects with a compile time length
/// Specialization for arrays, default_delete.
template<typename _Tp>
  struct default_delete<_Tp[]>
  {
  public:
    /// Default constructor
    constexpr default_delete() noexcept = default;

    /** @brief Converting constructor.
     *
     * Allows conversion from a deleter for arrays of another type, such as
     * a const-qualified version of @p _Tp.
     *
     * Conversions from types derived from @c _Tp are not allowed because
     * it is unsafe to @c delete[] an array of derived types through a
     * pointer to the base type.
     */
    template<typename _Up, typename = typename
      enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value>::type>
      default_delete(const default_delete<_Up[]>&) noexcept { }

    /// Calls @c delete[] @p __ptr
    template<typename _Up>
    typename enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value>::type
operator()(_Up* __ptr) const
    {
static_assert(sizeof(_Tp)>0,
      "can't delete pointer to incomplete type");
delete [] __ptr;
    }
  };

template <typename _Tp, typename _Dp>
  class __uniq_ptr_impl
  {
    template <typename _Up, typename _Ep, typename = void>
struct _Ptr
{
 using type = _Up*;
};

    template <typename _Up, typename _Ep>
struct
_Ptr<_Up, _Ep, __void_t<typename remove_reference<_Ep>::type::pointer>>
{
 using type = typename remove_reference<_Ep>::type::pointer;
};

  public:
    using _DeleterConstraint = enable_if<
      __and_<__not_<is_pointer<_Dp>>,
      is_default_constructible<_Dp>>::value>;

    using pointer = typename _Ptr<_Tp, _Dp>::type;

    __uniq_ptr_impl() = default;
    __uniq_ptr_impl(pointer __p) : _M_t() { _M_ptr() = __p; }

    template<typename _Del>
    __uniq_ptr_impl(pointer __p, _Del&& __d)
: _M_t(__p, std::forward<_Del>(__d)) { }

    pointer&   _M_ptr() { return std::get<0>(_M_t); }
    pointer    _M_ptr() const { return std::get<0>(_M_t); }
    _Dp&       _M_deleter() { return std::get<1>(_M_t); }
    const _Dp& _M_deleter() const { return std::get<1>(_M_t); }

  private:
    tuple<pointer, _Dp> _M_t;
  };

/// 20.7.1.2 unique_ptr for single objects.
template <typename _Tp, typename _Dp = default_delete<_Tp>>
  class unique_ptr
  {
    template <class _Up>
    using _DeleterConstraint =
typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;

    __uniq_ptr_impl<_Tp, _Dp> _M_t;

  public:
    using pointer	  = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
    using element_type  = _Tp;
    using deleter_type  = _Dp;

    // helper template for detecting a safe conversion from another
    // unique_ptr
    template<typename _Up, typename _Ep>
using __safe_conversion_up = __and_<
       is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>,
              __not_<is_array<_Up>>,
              __or_<__and_<is_reference<deleter_type>,
                           is_same<deleter_type, _Ep>>,
                    __and_<__not_<is_reference<deleter_type>>,
                           is_convertible<_Ep, deleter_type>>
              >
            >;

    // Constructors.

    /// Default constructor, creates a unique_ptr that owns nothing.
    template <typename _Up = _Dp,
typename = _DeleterConstraint<_Up>>
constexpr unique_ptr() noexcept
: _M_t()
      { }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an object of @c element_type
     *
     * The deleter will be value-initialized.
     */
    template <typename _Up = _Dp,
typename = _DeleterConstraint<_Up>>
explicit
unique_ptr(pointer __p) noexcept
: _M_t(__p)
      { }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an object of @c element_type
     * @param __d  A reference to a deleter.
     *
     * The deleter will be initialized with @p __d
     */
    unique_ptr(pointer __p,
 typename conditional<is_reference<deleter_type>::value,
   deleter_type, const deleter_type&>::type __d) noexcept
    : _M_t(__p, __d) { }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an object of @c element_type
     * @param __d  An rvalue reference to a deleter.
     *
     * The deleter will be initialized with @p std::move(__d)
     */
    unique_ptr(pointer __p,
 typename remove_reference<deleter_type>::type&& __d) noexcept
    : _M_t(std::move(__p), std::move(__d))
    { static_assert(!std::is_reference<deleter_type>::value,
      "rvalue deleter bound to reference"); }

    /// Creates a unique_ptr that owns nothing.
    template <typename _Up = _Dp,
typename = _DeleterConstraint<_Up>>
constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }

    // Move constructors.

    /// Move constructor.
    unique_ptr(unique_ptr&& __u) noexcept
    : _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }

    /** @brief Converting constructor from another type
     *
     * Requires that the pointer owned by @p __u is convertible to the
     * type of pointer owned by this object, @p __u does not own an array,
     * and @p __u has a compatible deleter type.
     */
    template<typename _Up, typename _Ep, typename = _Require<
             __safe_conversion_up<_Up, _Ep>,
      typename conditional<is_reference<_Dp>::value,
		    is_same<_Ep, _Dp>,
		    is_convertible<_Ep, _Dp>>::type>>
unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
: _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
{ }

259#if _GLIBCXX_USE_DEPRECATED1
260#pragma GCC diagnostic push
261#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
    /// Converting constructor from @c auto_ptr
    template<typename _Up, typename = _Require<
      is_convertible<_Up*, _Tp*>, is_same<_Dp, default_delete<_Tp>>>>
unique_ptr(auto_ptr<_Up>&& __u) noexcept;
266#pragma GCC diagnostic pop
267#endif

    /// Destructor, invokes the deleter if the stored pointer is not null.
    ~unique_ptr() noexcept
    {
auto& __ptr = _M_t._M_ptr();
if (__ptr != nullptr)
11
←
Assuming the condition is true→
12
←
Taking true branch→
 get_deleter()(__ptr);
13
←
Calling 'default_delete::operator()'→
15
←
Returning; memory was released via 2nd parameter→
__ptr = pointer();
    }

    // Assignment.

    /** @brief Move assignment operator.
     *
     * @param __u  The object to transfer ownership from.
     *
     * Invokes the deleter first if this object owns a pointer.
     */
    unique_ptr&
    operator=(unique_ptr&& __u) noexcept
    {
reset(__u.release());
get_deleter() = std::forward<deleter_type>(__u.get_deleter());
return *this;
    }

    /** @brief Assignment from another type.
     *
     * @param __u  The object to transfer ownership from, which owns a
     *             convertible pointer to a non-array object.
     *
     * Invokes the deleter first if this object owns a pointer.
     */
    template<typename _Up, typename _Ep>
      typename enable_if< __and_<
        __safe_conversion_up<_Up, _Ep>,
        is_assignable<deleter_type&, _Ep&&>
        >::value,
        unique_ptr&>::type
operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
{
 reset(__u.release());
 get_deleter() = std::forward<_Ep>(__u.get_deleter());
 return *this;
}

    /// Reset the %unique_ptr to empty, invoking the deleter if necessary.
    unique_ptr&
    operator=(nullptr_t) noexcept
    {
reset();
return *this;
    }

    // Observers.

    /// Dereference the stored pointer.
    typename add_lvalue_reference<element_type>::type
    operator*() const
    {
__glibcxx_assert(get() != pointer());
return *get();
    }

    /// Return the stored pointer.
    pointer
    operator->() const noexcept
    {
_GLIBCXX_DEBUG_PEDASSERT(get() != pointer());
return get();
    }

    /// Return the stored pointer.
    pointer
    get() const noexcept
    { return _M_t._M_ptr(); }

    /// Return a reference to the stored deleter.
    deleter_type&
    get_deleter() noexcept
    { return _M_t._M_deleter(); }

    /// Return a reference to the stored deleter.
    const deleter_type&
    get_deleter() const noexcept
    { return _M_t._M_deleter(); }

    /// Return @c true if the stored pointer is not null.
    explicit operator bool() const noexcept
    { return get() == pointer() ? false : true; }

    // Modifiers.

    /// Release ownership of any stored pointer.
    pointer
    release() noexcept
    {
pointer __p = get();
_M_t._M_ptr() = pointer();
return __p;
    }

    /** @brief Replace the stored pointer.
     *
     * @param __p  The new pointer to store.
     *
     * The deleter will be invoked if a pointer is already owned.
     */
    void
    reset(pointer __p = pointer()) noexcept
    {
using std::swap;
swap(_M_t._M_ptr(), __p);
if (__p != pointer())
 get_deleter()(__p);
    }

    /// Exchange the pointer and deleter with another object.
    void
    swap(unique_ptr& __u) noexcept
    {
using std::swap;
swap(_M_t, __u._M_t);
    }

    // Disable copy from lvalue.
    unique_ptr(const unique_ptr&) = delete;
    unique_ptr& operator=(const unique_ptr&) = delete;
};

/// 20.7.1.3 unique_ptr for array objects with a runtime length
// [unique.ptr.runtime]
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 740 - omit specialization for array objects with a compile time length
template<typename _Tp, typename _Dp>
  class unique_ptr<_Tp[], _Dp>
  {
    template <typename _Up>
    using _DeleterConstraint =
typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;

    __uniq_ptr_impl<_Tp, _Dp> _M_t;

    template<typename _Up>
using __remove_cv = typename remove_cv<_Up>::type;

    // like is_base_of<_Tp, _Up> but false if unqualified types are the same
    template<typename _Up>
using __is_derived_Tp
 = __and_< is_base_of<_Tp, _Up>,
    __not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;

  public:
    using pointer	  = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
    using element_type  = _Tp;
    using deleter_type  = _Dp;

    // helper template for detecting a safe conversion from another
    // unique_ptr
    template<typename _Up, typename _Ep,
             typename _Up_up = unique_ptr<_Up, _Ep>,
      typename _Up_element_type = typename _Up_up::element_type>
using __safe_conversion_up = __and_<
        is_array<_Up>,
        is_same<pointer, element_type*>,
        is_same<typename _Up_up::pointer, _Up_element_type*>,
        is_convertible<_Up_element_type(*)[], element_type(*)[]>,
        __or_<__and_<is_reference<deleter_type>, is_same<deleter_type, _Ep>>,
              __and_<__not_<is_reference<deleter_type>>,
                     is_convertible<_Ep, deleter_type>>>
      >;

    // helper template for detecting a safe conversion from a raw pointer
    template<typename _Up>
      using __safe_conversion_raw = __and_<
        __or_<__or_<is_same<_Up, pointer>,
                    is_same<_Up, nullptr_t>>,
              __and_<is_pointer<_Up>,
                     is_same<pointer, element_type*>,
                     is_convertible<
                       typename remove_pointer<_Up>::type(*)[],
                       element_type(*)[]>
              >
        >
      >;

    // Constructors.

    /// Default constructor, creates a unique_ptr that owns nothing.
    template <typename _Up = _Dp,
typename = _DeleterConstraint<_Up>>
constexpr unique_ptr() noexcept
: _M_t()
      { }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an array of a type safely convertible
     * to an array of @c element_type
     *
     * The deleter will be value-initialized.
     */
    template<typename _Up,
      typename _Vp = _Dp,
      typename = _DeleterConstraint<_Vp>,
      typename = typename enable_if<
               __safe_conversion_raw<_Up>::value, bool>::type>
explicit
unique_ptr(_Up __p) noexcept
: _M_t(__p)
      { }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an array of a type safely convertible
     * to an array of @c element_type
     * @param __d  A reference to a deleter.
     *
     * The deleter will be initialized with @p __d
     */
    template<typename _Up,
             typename = typename enable_if<
               __safe_conversion_raw<_Up>::value, bool>::type>
    unique_ptr(_Up __p,
               typename conditional<is_reference<deleter_type>::value,
               deleter_type, const deleter_type&>::type __d) noexcept
    : _M_t(__p, __d) { }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an array of a type safely convertible
     * to an array of @c element_type
     * @param __d  A reference to a deleter.
     *
     * The deleter will be initialized with @p std::move(__d)
     */
    template<typename _Up,
             typename = typename enable_if<
               __safe_conversion_raw<_Up>::value, bool>::type>
    unique_ptr(_Up __p, typename
 remove_reference<deleter_type>::type&& __d) noexcept
    : _M_t(std::move(__p), std::move(__d))
    { static_assert(!is_reference<deleter_type>::value,
      "rvalue deleter bound to reference"); }

    /// Move constructor.
    unique_ptr(unique_ptr&& __u) noexcept
    : _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }

    /// Creates a unique_ptr that owns nothing.
    template <typename _Up = _Dp,
typename = _DeleterConstraint<_Up>>
constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }

    template<typename _Up, typename _Ep,
      typename = _Require<__safe_conversion_up<_Up, _Ep>>>
unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
: _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
{ }

    /// Destructor, invokes the deleter if the stored pointer is not null.
    ~unique_ptr()
    {
auto& __ptr = _M_t._M_ptr();
if (__ptr != nullptr)
 get_deleter()(__ptr);
__ptr = pointer();
    }

    // Assignment.

    /** @brief Move assignment operator.
     *
     * @param __u  The object to transfer ownership from.
     *
     * Invokes the deleter first if this object owns a pointer.
     */
    unique_ptr&
    operator=(unique_ptr&& __u) noexcept
    {
reset(__u.release());
get_deleter() = std::forward<deleter_type>(__u.get_deleter());
return *this;
    }

    /** @brief Assignment from another type.
     *
     * @param __u  The object to transfer ownership from, which owns a
     *             convertible pointer to an array object.
     *
     * Invokes the deleter first if this object owns a pointer.
     */
    template<typename _Up, typename _Ep>
typename
enable_if<__and_<__safe_conversion_up<_Up, _Ep>,
                       is_assignable<deleter_type&, _Ep&&>
                >::value,
                unique_ptr&>::type
operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
{
 reset(__u.release());
 get_deleter() = std::forward<_Ep>(__u.get_deleter());
 return *this;
}

    /// Reset the %unique_ptr to empty, invoking the deleter if necessary.
    unique_ptr&
    operator=(nullptr_t) noexcept
    {
reset();
return *this;
    }

    // Observers.

    /// Access an element of owned array.
    typename std::add_lvalue_reference<element_type>::type
    operator[](size_t __i) const
    {
__glibcxx_assert(get() != pointer());
return get()[__i];
    }

    /// Return the stored pointer.
    pointer
    get() const noexcept
    { return _M_t._M_ptr(); }

    /// Return a reference to the stored deleter.
    deleter_type&
    get_deleter() noexcept
    { return _M_t._M_deleter(); }

    /// Return a reference to the stored deleter.
    const deleter_type&
    get_deleter() const noexcept
    { return _M_t._M_deleter(); }

    /// Return @c true if the stored pointer is not null.
    explicit operator bool() const noexcept
    { return get() == pointer() ? false : true; }

    // Modifiers.

    /// Release ownership of any stored pointer.
    pointer
    release() noexcept
    {
pointer __p = get();
_M_t._M_ptr() = pointer();
return __p;
    }

    /** @brief Replace the stored pointer.
     *
     * @param __p  The new pointer to store.
     *
     * The deleter will be invoked if a pointer is already owned.
     */
    template <typename _Up,
              typename = _Require<
                __or_<is_same<_Up, pointer>,
                      __and_<is_same<pointer, element_type*>,
                             is_pointer<_Up>,
                             is_convertible<
                               typename remove_pointer<_Up>::type(*)[],
                               element_type(*)[]
                             >
                      >
                >
             >>
    void
    reset(_Up __p) noexcept
    {
pointer __ptr = __p;
using std::swap;
swap(_M_t._M_ptr(), __ptr);
if (__ptr != nullptr)
 get_deleter()(__ptr);
    }

    void reset(nullptr_t = nullptr) noexcept
    {
      reset(pointer());
    }

    /// Exchange the pointer and deleter with another object.
    void
    swap(unique_ptr& __u) noexcept
    {
using std::swap;
swap(_M_t, __u._M_t);
    }

    // Disable copy from lvalue.
    unique_ptr(const unique_ptr&) = delete;
    unique_ptr& operator=(const unique_ptr&) = delete;
  };

template<typename _Tp, typename _Dp>
  inline
669#if __cplusplus201103L > 201402L || !defined(__STRICT_ANSI__1) // c++1z or gnu++11
  // Constrained free swap overload, see p0185r1
  typename enable_if<__is_swappable<_Dp>::value>::type
672#else
  void
674#endif
  swap(unique_ptr<_Tp, _Dp>& __x,
unique_ptr<_Tp, _Dp>& __y) noexcept
  { __x.swap(__y); }

679#if __cplusplus201103L > 201402L || !defined(__STRICT_ANSI__1) // c++1z or gnu++11
template<typename _Tp, typename _Dp>
  typename enable_if<!__is_swappable<_Dp>::value>::type
  swap(unique_ptr<_Tp, _Dp>&,
unique_ptr<_Tp, _Dp>&) = delete;
684#endif

template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  inline bool
  operator==(const unique_ptr<_Tp, _Dp>& __x,
      const unique_ptr<_Up, _Ep>& __y)
  { return __x.get() == __y.get(); }

template<typename _Tp, typename _Dp>
  inline bool
  operator==(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
  { return !__x; }

template<typename _Tp, typename _Dp>
  inline bool
  operator==(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
  { return !__x; }

template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  inline bool
  operator!=(const unique_ptr<_Tp, _Dp>& __x,
      const unique_ptr<_Up, _Ep>& __y)
  { return __x.get() != __y.get(); }

template<typename _Tp, typename _Dp>
  inline bool
  operator!=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
  { return (bool)__x; }

template<typename _Tp, typename _Dp>
  inline bool
  operator!=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
  { return (bool)__x; }

template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  inline bool
  operator<(const unique_ptr<_Tp, _Dp>& __x,
     const unique_ptr<_Up, _Ep>& __y)
  {
    typedef typename
std::common_type<typename unique_ptr<_Tp, _Dp>::pointer,
                typename unique_ptr<_Up, _Ep>::pointer>::type _CT;
    return std::less<_CT>()(__x.get(), __y.get());
  }

template<typename _Tp, typename _Dp>
  inline bool
  operator<(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
  { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
						 nullptr); }

template<typename _Tp, typename _Dp>
  inline bool
  operator<(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
  { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
						 __x.get()); }

template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  inline bool
  operator<=(const unique_ptr<_Tp, _Dp>& __x,
      const unique_ptr<_Up, _Ep>& __y)
  { return !(__y < __x); }

template<typename _Tp, typename _Dp>
  inline bool
  operator<=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
  { return !(nullptr < __x); }

template<typename _Tp, typename _Dp>
  inline bool
  operator<=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
  { return !(__x < nullptr); }

template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  inline bool
  operator>(const unique_ptr<_Tp, _Dp>& __x,
     const unique_ptr<_Up, _Ep>& __y)
  { return (__y < __x); }

template<typename _Tp, typename _Dp>
  inline bool
  operator>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
  { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
						 __x.get()); }

template<typename _Tp, typename _Dp>
  inline bool
  operator>(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
  { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
						 nullptr); }

template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  inline bool
  operator>=(const unique_ptr<_Tp, _Dp>& __x,
      const unique_ptr<_Up, _Ep>& __y)
  { return !(__x < __y); }

template<typename _Tp, typename _Dp>
  inline bool
  operator>=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
  { return !(__x < nullptr); }

template<typename _Tp, typename _Dp>
  inline bool
  operator>=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
  { return !(nullptr < __x); }

/// std::hash specialization for unique_ptr.
template<typename _Tp, typename _Dp>
  struct hash<unique_ptr<_Tp, _Dp>>
  : public __hash_base<size_t, unique_ptr<_Tp, _Dp>>,
  private __poison_hash<typename unique_ptr<_Tp, _Dp>::pointer>
  {
    size_t
    operator()(const unique_ptr<_Tp, _Dp>& __u) const noexcept
    {
typedef unique_ptr<_Tp, _Dp> _UP;
return std::hash<typename _UP::pointer>()(__u.get());
    }
  };

811#if __cplusplus201103L > 201103L

813#define __cpp_lib_make_unique 201304

template<typename _Tp>
  struct _MakeUniq
  { typedef unique_ptr<_Tp> __single_object; };

template<typename _Tp>
  struct _MakeUniq<_Tp[]>
  { typedef unique_ptr<_Tp[]> __array; };

template<typename _Tp, size_t _Bound>
  struct _MakeUniq<_Tp[_Bound]>
  { struct __invalid_type { }; };

/// std::make_unique for single objects
template<typename _Tp, typename... _Args>
  inline typename _MakeUniq<_Tp>::__single_object
  make_unique(_Args&&... __args)
  { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }

/// std::make_unique for arrays of unknown bound
template<typename _Tp>
  inline typename _MakeUniq<_Tp>::__array
  make_unique(size_t __num)
  { return unique_ptr<_Tp>(new remove_extent_t<_Tp>[__num]()); }

/// Disable std::make_unique for arrays of known bound
template<typename _Tp, typename... _Args>
  inline typename _MakeUniq<_Tp>::__invalid_type
  make_unique(_Args&&...) = delete;
843#endif

// @} group pointer_abstractions

847_GLIBCXX_END_NAMESPACE_VERSION
848} // namespace

850#endif /* _UNIQUE_PTR_H */

←

/build/llvm-toolchain-snapshot-7~svn338205/tools/lld/include/lld/Core/PassManager.h

1//===- lld/Core/PassManager.h - Manage linker passes ----------------------===//
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#ifndef LLD_CORE_PASS_MANAGER_H
11#define LLD_CORE_PASS_MANAGER_H
12 
13#include "lld/Common/LLVM.h"
14#include "lld/Core/Pass.h"
15#include "llvm/Support/Error.h"
16#include <memory>
17#include <vector>
18 
19namespace lld {
20class SimpleFile;
21class Pass;
22 
23/// Owns and runs a collection of passes.
24///
25/// This class is currently just a container for passes and a way to run them.
26///
27/// In the future this should handle timing pass runs, running parallel passes,
28/// and validate/satisfy pass dependencies.
29class PassManager {
30public:
31  void add(std::unique_ptr<Pass> pass) {
32    _passes.push_back(std::move(pass));
33  }
34 
35  llvm::Error runOnFile(SimpleFile &file) {
36    for (std::unique_ptr<Pass> &pass : _passes)
37      if (llvm::Error EC = pass->perform(file))
19
←
Use of memory after it is freed
38        return EC;
39    return llvm::Error::success();
40  }
41 
42private:
43  /// Passes in the order they should run.
44  std::vector<std::unique_ptr<Pass>> _passes;
45};
46} // end namespace lld
47 
48#endif