/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp

Bug Summary

File:	tools/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp
Warning:	line 1178, column 1 Potential memory leak

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 ClangDiagnosticsEmitter.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 -relaxed-aliasing -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~svn329677/build-llvm/tools/clang/utils/TableGen -I /build/llvm-toolchain-snapshot-7~svn329677/tools/clang/utils/TableGen -I /build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn329677/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/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/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-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/tools/clang/utils/TableGen -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-04-11-031539-24776-1 -x c++ /build/llvm-toolchain-snapshot-7~svn329677/tools/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp

/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp

→

1//=- ClangDiagnosticsEmitter.cpp - Generate Clang diagnostics tables -*- 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// These tablegen backends emit Clang diagnostics tables.
11//
12//===----------------------------------------------------------------------===//

14#include "llvm/ADT/DenseSet.h"
15#include "llvm/ADT/Optional.h"
16#include "llvm/ADT/PointerUnion.h"
17#include "llvm/ADT/SmallPtrSet.h"
18#include "llvm/ADT/SmallString.h"
19#include "llvm/ADT/SmallVector.h"
20#include "llvm/ADT/StringMap.h"
21#include "llvm/ADT/STLExtras.h"
22#include "llvm/ADT/Twine.h"
23#include "llvm/TableGen/Error.h"
24#include "llvm/TableGen/Record.h"
25#include "llvm/TableGen/StringToOffsetTable.h"
26#include "llvm/TableGen/TableGenBackend.h"
27#include <algorithm>
28#include <cctype>
29#include <functional>
30#include <map>
31#include <set>
32using namespace llvm;

34//===----------------------------------------------------------------------===//
35// Diagnostic category computation code.
36//===----------------------------------------------------------------------===//

38namespace {
39class DiagGroupParentMap {
RecordKeeper &Records;
std::map<const Record*, std::vector<Record*> > Mapping;
42public:
DiagGroupParentMap(RecordKeeper &records) : Records(records) {
  std::vector<Record*> DiagGroups
    = Records.getAllDerivedDefinitions("DiagGroup");
  for (unsigned i = 0, e = DiagGroups.size(); i != e; ++i) {
    std::vector<Record*> SubGroups =
      DiagGroups[i]->getValueAsListOfDefs("SubGroups");
    for (unsigned j = 0, e = SubGroups.size(); j != e; ++j)
      Mapping[SubGroups[j]].push_back(DiagGroups[i]);
  }
}

const std::vector<Record*> &getParents(const Record *Group) {
  return Mapping[Group];
}
57};
58} // end anonymous namespace.

60static std::string
61getCategoryFromDiagGroup(const Record *Group,
                       DiagGroupParentMap &DiagGroupParents) {
// If the DiagGroup has a category, return it.
std::string CatName = Group->getValueAsString("CategoryName");
if (!CatName.empty()) return CatName;

// The diag group may the subgroup of one or more other diagnostic groups,
// check these for a category as well.
const std::vector<Record*> &Parents = DiagGroupParents.getParents(Group);
for (unsigned i = 0, e = Parents.size(); i != e; ++i) {
  CatName = getCategoryFromDiagGroup(Parents[i], DiagGroupParents);
  if (!CatName.empty()) return CatName;
}
return "";
75}

77/// getDiagnosticCategory - Return the category that the specified diagnostic
78/// lives in.
79static std::string getDiagnosticCategory(const Record *R,
                                       DiagGroupParentMap &DiagGroupParents) {
// If the diagnostic is in a group, and that group has a category, use it.
if (DefInit *Group = dyn_cast<DefInit>(R->getValueInit("Group"))) {
  // Check the diagnostic's diag group for a category.
  std::string CatName = getCategoryFromDiagGroup(Group->getDef(),
                                                 DiagGroupParents);
  if (!CatName.empty()) return CatName;
}

// If the diagnostic itself has a category, get it.
return R->getValueAsString("CategoryName");
91}

93namespace {
class DiagCategoryIDMap {
  RecordKeeper &Records;
  StringMap<unsigned> CategoryIDs;
  std::vector<std::string> CategoryStrings;
public:
  DiagCategoryIDMap(RecordKeeper &records) : Records(records) {
    DiagGroupParentMap ParentInfo(Records);

    // The zero'th category is "".
    CategoryStrings.push_back("");
    CategoryIDs[""] = 0;

    std::vector<Record*> Diags =
    Records.getAllDerivedDefinitions("Diagnostic");
    for (unsigned i = 0, e = Diags.size(); i != e; ++i) {
      std::string Category = getDiagnosticCategory(Diags[i], ParentInfo);
      if (Category.empty()) continue;  // Skip diags with no category.

      unsigned &ID = CategoryIDs[Category];
      if (ID != 0) continue;  // Already seen.

      ID = CategoryStrings.size();
      CategoryStrings.push_back(Category);
    }
  }

  unsigned getID(StringRef CategoryString) {
    return CategoryIDs[CategoryString];
  }

  typedef std::vector<std::string>::const_iterator const_iterator;
  const_iterator begin() const { return CategoryStrings.begin(); }
  const_iterator end() const { return CategoryStrings.end(); }
};

struct GroupInfo {
  std::vector<const Record*> DiagsInGroup;
  std::vector<std::string> SubGroups;
  unsigned IDNo;

  const Record *ExplicitDef;

  GroupInfo() : ExplicitDef(nullptr) {}
};
138} // end anonymous namespace.

140static bool beforeThanCompare(const Record *LHS, const Record *RHS) {
assert(!LHS->getLoc().empty() && !RHS->getLoc().empty())(static_cast <bool> (!LHS->getLoc().empty() &&
 !RHS->getLoc().empty()) ? void (0) : __assert_fail ("!LHS->getLoc().empty() && !RHS->getLoc().empty()"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp"
, 141, __extension__ __PRETTY_FUNCTION__));
return
  LHS->getLoc().front().getPointer() < RHS->getLoc().front().getPointer();
144}

146static bool diagGroupBeforeByName(const Record *LHS, const Record *RHS) {
return LHS->getValueAsString("GroupName") <
       RHS->getValueAsString("GroupName");
149}

151static bool beforeThanCompareGroups(const GroupInfo *LHS, const GroupInfo *RHS){
assert(!LHS->DiagsInGroup.empty() && !RHS->DiagsInGroup.empty())(static_cast <bool> (!LHS->DiagsInGroup.empty() &&
 !RHS->DiagsInGroup.empty()) ? void (0) : __assert_fail ("!LHS->DiagsInGroup.empty() && !RHS->DiagsInGroup.empty()"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp"
, 152, __extension__ __PRETTY_FUNCTION__));
return beforeThanCompare(LHS->DiagsInGroup.front(),
                         RHS->DiagsInGroup.front());
155}

157/// \brief Invert the 1-[0/1] mapping of diags to group into a one to many
158/// mapping of groups to diags in the group.
159static void groupDiagnostics(const std::vector<Record*> &Diags,
                           const std::vector<Record*> &DiagGroups,
                           std::map<std::string, GroupInfo> &DiagsInGroup) {

for (unsigned i = 0, e = Diags.size(); i != e; ++i) {
  const Record *R = Diags[i];
  DefInit *DI = dyn_cast<DefInit>(R->getValueInit("Group"));
  if (!DI)
    continue;
  assert(R->getValueAsDef("Class")->getName() != "CLASS_NOTE" &&(static_cast <bool> (R->getValueAsDef("Class")->getName
() != "CLASS_NOTE" && "Note can't be in a DiagGroup")
 ? void (0) : __assert_fail ("R->getValueAsDef(\"Class\")->getName() != \"CLASS_NOTE\" && \"Note can't be in a DiagGroup\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp"
, 169, __extension__ __PRETTY_FUNCTION__))
         "Note can't be in a DiagGroup")(static_cast <bool> (R->getValueAsDef("Class")->getName
() != "CLASS_NOTE" && "Note can't be in a DiagGroup")
 ? void (0) : __assert_fail ("R->getValueAsDef(\"Class\")->getName() != \"CLASS_NOTE\" && \"Note can't be in a DiagGroup\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp"
, 169, __extension__ __PRETTY_FUNCTION__));
  std::string GroupName = DI->getDef()->getValueAsString("GroupName");
  DiagsInGroup[GroupName].DiagsInGroup.push_back(R);
}

typedef SmallPtrSet<GroupInfo *, 16> GroupSetTy;
GroupSetTy ImplicitGroups;

// Add all DiagGroup's to the DiagsInGroup list to make sure we pick up empty
// groups (these are warnings that GCC supports that clang never produces).
for (unsigned i = 0, e = DiagGroups.size(); i != e; ++i) {
  Record *Group = DiagGroups[i];
  GroupInfo &GI = DiagsInGroup[Group->getValueAsString("GroupName")];
  if (Group->isAnonymous()) {
    if (GI.DiagsInGroup.size() > 1)
      ImplicitGroups.insert(&GI);
  } else {
    if (GI.ExplicitDef)
      assert(GI.ExplicitDef == Group)(static_cast <bool> (GI.ExplicitDef == Group) ? void (0
) : __assert_fail ("GI.ExplicitDef == Group", "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp"
, 187, __extension__ __PRETTY_FUNCTION__));
    else
      GI.ExplicitDef = Group;
  }

  std::vector<Record*> SubGroups = Group->getValueAsListOfDefs("SubGroups");
  for (unsigned j = 0, e = SubGroups.size(); j != e; ++j)
    GI.SubGroups.push_back(SubGroups[j]->getValueAsString("GroupName"));
}

// Assign unique ID numbers to the groups.
unsigned IDNo = 0;
for (std::map<std::string, GroupInfo>::iterator
     I = DiagsInGroup.begin(), E = DiagsInGroup.end(); I != E; ++I, ++IDNo)
  I->second.IDNo = IDNo;

// Sort the implicit groups, so we can warn about them deterministically.
SmallVector<GroupInfo *, 16> SortedGroups(ImplicitGroups.begin(),
                                          ImplicitGroups.end());
for (SmallVectorImpl<GroupInfo *>::iterator I = SortedGroups.begin(),
                                            E = SortedGroups.end();
     I != E; ++I) {
  MutableArrayRef<const Record *> GroupDiags = (*I)->DiagsInGroup;
  llvm::sort(GroupDiags.begin(), GroupDiags.end(), beforeThanCompare);
}
llvm::sort(SortedGroups.begin(), SortedGroups.end(), beforeThanCompareGroups);

// Warn about the same group being used anonymously in multiple places.
for (SmallVectorImpl<GroupInfo *>::const_iterator I = SortedGroups.begin(),
                                                  E = SortedGroups.end();
     I != E; ++I) {
  ArrayRef<const Record *> GroupDiags = (*I)->DiagsInGroup;

  if ((*I)->ExplicitDef) {
    std::string Name = (*I)->ExplicitDef->getValueAsString("GroupName");
    for (ArrayRef<const Record *>::const_iterator DI = GroupDiags.begin(),
                                                  DE = GroupDiags.end();
         DI != DE; ++DI) {
      const DefInit *GroupInit = cast<DefInit>((*DI)->getValueInit("Group"));
      const Record *NextDiagGroup = GroupInit->getDef();
      if (NextDiagGroup == (*I)->ExplicitDef)
        continue;

      SrcMgr.PrintMessage((*DI)->getLoc().front(),
                          SourceMgr::DK_Error,
                          Twine("group '") + Name +
                            "' is referred to anonymously");
      SrcMgr.PrintMessage((*I)->ExplicitDef->getLoc().front(),
                          SourceMgr::DK_Note, "group defined here");
    }
  } else {
    // If there's no existing named group, we should just warn once and use
    // notes to list all the other cases.
    ArrayRef<const Record *>::const_iterator DI = GroupDiags.begin(),
                                             DE = GroupDiags.end();
    assert(DI != DE && "We only care about groups with multiple uses!")(static_cast <bool> (DI != DE && "We only care about groups with multiple uses!"
) ? void (0) : __assert_fail ("DI != DE && \"We only care about groups with multiple uses!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp"
, 242, __extension__ __PRETTY_FUNCTION__));

    const DefInit *GroupInit = cast<DefInit>((*DI)->getValueInit("Group"));
    const Record *NextDiagGroup = GroupInit->getDef();
    std::string Name = NextDiagGroup->getValueAsString("GroupName");

    SrcMgr.PrintMessage((*DI)->getLoc().front(),
                        SourceMgr::DK_Error,
                        Twine("group '") + Name +
                          "' is referred to anonymously");

    for (++DI; DI != DE; ++DI) {
      SrcMgr.PrintMessage((*DI)->getLoc().front(),
                          SourceMgr::DK_Note, "also referenced here");
    }
  }
}
259}

261//===----------------------------------------------------------------------===//
262// Infer members of -Wpedantic.
263//===----------------------------------------------------------------------===//

265typedef std::vector<const Record *> RecordVec;
266typedef llvm::DenseSet<const Record *> RecordSet;
267typedef llvm::PointerUnion<RecordVec*, RecordSet*> VecOrSet;

269namespace {
270class InferPedantic {
typedef llvm::DenseMap<const Record*,
                       std::pair<unsigned, Optional<unsigned> > > GMap;

DiagGroupParentMap &DiagGroupParents;
const std::vector<Record*> &Diags;
const std::vector<Record*> DiagGroups;
std::map<std::string, GroupInfo> &DiagsInGroup;
llvm::DenseSet<const Record*> DiagsSet;
GMap GroupCount;
280public:
InferPedantic(DiagGroupParentMap &DiagGroupParents,
              const std::vector<Record*> &Diags,
              const std::vector<Record*> &DiagGroups,
              std::map<std::string, GroupInfo> &DiagsInGroup)
: DiagGroupParents(DiagGroupParents),
Diags(Diags),
DiagGroups(DiagGroups),
DiagsInGroup(DiagsInGroup) {}

/// Compute the set of diagnostics and groups that are immediately
/// in -Wpedantic.
void compute(VecOrSet DiagsInPedantic,
             VecOrSet GroupsInPedantic);

295private:
/// Determine whether a group is a subgroup of another group.
bool isSubGroupOfGroup(const Record *Group,
                       llvm::StringRef RootGroupName);

/// Determine if the diagnostic is an extension.
bool isExtension(const Record *Diag);

/// Determine if the diagnostic is off by default.
bool isOffByDefault(const Record *Diag);

/// Increment the count for a group, and transitively marked
/// parent groups when appropriate.
void markGroup(const Record *Group);

/// Return true if the diagnostic is in a pedantic group.
bool groupInPedantic(const Record *Group, bool increment = false);
312};
313} // end anonymous namespace

315bool InferPedantic::isSubGroupOfGroup(const Record *Group,
                                    llvm::StringRef GName) {

const std::string &GroupName = Group->getValueAsString("GroupName");
if (GName == GroupName)
  return true;

const std::vector<Record*> &Parents = DiagGroupParents.getParents(Group);
for (unsigned i = 0, e = Parents.size(); i != e; ++i)
  if (isSubGroupOfGroup(Parents[i], GName))
    return true;

return false;
328}

330/// Determine if the diagnostic is an extension.
331bool InferPedantic::isExtension(const Record *Diag) {
const std::string &ClsName = Diag->getValueAsDef("Class")->getName();
return ClsName == "CLASS_EXTENSION";
334}

336bool InferPedantic::isOffByDefault(const Record *Diag) {
const std::string &DefSeverity =
    Diag->getValueAsDef("DefaultSeverity")->getValueAsString("Name");
return DefSeverity == "Ignored";
340}

342bool InferPedantic::groupInPedantic(const Record *Group, bool increment) {
GMap::mapped_type &V = GroupCount[Group];
// Lazily compute the threshold value for the group count.
if (!V.second.hasValue()) {
  const GroupInfo &GI = DiagsInGroup[Group->getValueAsString("GroupName")];
  V.second = GI.SubGroups.size() + GI.DiagsInGroup.size();
}

if (increment)
  ++V.first;

// Consider a group in -Wpendatic IFF if has at least one diagnostic
// or subgroup AND all of those diagnostics and subgroups are covered
// by -Wpedantic via our computation.
return V.first != 0 && V.first == V.second.getValue();
357}

359void InferPedantic::markGroup(const Record *Group) {
// If all the diagnostics and subgroups have been marked as being
// covered by -Wpedantic, increment the count of parent groups.  Once the
// group's count is equal to the number of subgroups and diagnostics in
// that group, we can safely add this group to -Wpedantic.
if (groupInPedantic(Group, /* increment */ true)) {
  const std::vector<Record*> &Parents = DiagGroupParents.getParents(Group);
  for (unsigned i = 0, e = Parents.size(); i != e; ++i)
    markGroup(Parents[i]);
}
369}

371void InferPedantic::compute(VecOrSet DiagsInPedantic,
                          VecOrSet GroupsInPedantic) {
// All extensions that are not on by default are implicitly in the
// "pedantic" group.  For those that aren't explicitly included in -Wpedantic,
// mark them for consideration to be included in -Wpedantic directly.
for (unsigned i = 0, e = Diags.size(); i != e; ++i) {
  Record *R = Diags[i];
  if (isExtension(R) && isOffByDefault(R)) {
    DiagsSet.insert(R);
    if (DefInit *Group = dyn_cast<DefInit>(R->getValueInit("Group"))) {
      const Record *GroupRec = Group->getDef();
      if (!isSubGroupOfGroup(GroupRec, "pedantic")) {
        markGroup(GroupRec);
      }
    }
  }
}

// Compute the set of diagnostics that are directly in -Wpedantic.  We
// march through Diags a second time to ensure the results are emitted
// in deterministic order.
for (unsigned i = 0, e = Diags.size(); i != e; ++i) {
  Record *R = Diags[i];
  if (!DiagsSet.count(R))
    continue;
  // Check if the group is implicitly in -Wpedantic.  If so,
  // the diagnostic should not be directly included in the -Wpedantic
  // diagnostic group.
  if (DefInit *Group = dyn_cast<DefInit>(R->getValueInit("Group")))
    if (groupInPedantic(Group->getDef()))
      continue;

  // The diagnostic is not included in a group that is (transitively) in
  // -Wpedantic.  Include it in -Wpedantic directly.
  if (RecordVec *V = DiagsInPedantic.dyn_cast<RecordVec*>())
    V->push_back(R);
  else {
    DiagsInPedantic.get<RecordSet*>()->insert(R);
  }
}

if (!GroupsInPedantic)
  return;

// Compute the set of groups that are directly in -Wpedantic.  We
// march through the groups to ensure the results are emitted
/// in a deterministc order.
for (unsigned i = 0, ei = DiagGroups.size(); i != ei; ++i) {
  Record *Group = DiagGroups[i];
  if (!groupInPedantic(Group))
    continue;

  unsigned ParentsInPedantic = 0;
  const std::vector<Record*> &Parents = DiagGroupParents.getParents(Group);
  for (unsigned j = 0, ej = Parents.size(); j != ej; ++j) {
    if (groupInPedantic(Parents[j]))
      ++ParentsInPedantic;
  }
  // If all the parents are in -Wpedantic, this means that this diagnostic
  // group will be indirectly included by -Wpedantic already.  In that
  // case, do not add it directly to -Wpedantic.  If the group has no
  // parents, obviously it should go into -Wpedantic.
  if (Parents.size() > 0 && ParentsInPedantic == Parents.size())
    continue;

  if (RecordVec *V = GroupsInPedantic.dyn_cast<RecordVec*>())
    V->push_back(Group);
  else {
    GroupsInPedantic.get<RecordSet*>()->insert(Group);
  }
}
442}

444//===----------------------------------------------------------------------===//
445// Warning Tables (.inc file) generation.
446//===----------------------------------------------------------------------===//

448static bool isError(const Record &Diag) {
const std::string &ClsName = Diag.getValueAsDef("Class")->getName();
return ClsName == "CLASS_ERROR";
451}

453static bool isRemark(const Record &Diag) {
const std::string &ClsName = Diag.getValueAsDef("Class")->getName();
return ClsName == "CLASS_REMARK";
456}

458/// ClangDiagsDefsEmitter - The top-level class emits .def files containing
459/// declarations of Clang diagnostics.
460namespace clang {
461void EmitClangDiagsDefs(RecordKeeper &Records, raw_ostream &OS,
                      const std::string &Component) {
// Write the #if guard
if (!Component.empty()) {
  std::string ComponentName = StringRef(Component).upper();
  OS << "#ifdef " << ComponentName << "START\n";
  OS << "__" << ComponentName << "START = DIAG_START_" << ComponentName
     << ",\n";
  OS << "#undef " << ComponentName << "START\n";
  OS << "#endif\n\n";
}

const std::vector<Record*> &Diags =
  Records.getAllDerivedDefinitions("Diagnostic");

std::vector<Record*> DiagGroups
  = Records.getAllDerivedDefinitions("DiagGroup");

std::map<std::string, GroupInfo> DiagsInGroup;
groupDiagnostics(Diags, DiagGroups, DiagsInGroup);

DiagCategoryIDMap CategoryIDs(Records);
DiagGroupParentMap DGParentMap(Records);

// Compute the set of diagnostics that are in -Wpedantic.
RecordSet DiagsInPedantic;
InferPedantic inferPedantic(DGParentMap, Diags, DiagGroups, DiagsInGroup);
inferPedantic.compute(&DiagsInPedantic, (RecordVec*)nullptr);

for (unsigned i = 0, e = Diags.size(); i != e; ++i) {
  const Record &R = *Diags[i];

  // Check if this is an error that is accidentally in a warning
  // group.
  if (isError(R)) {
    if (DefInit *Group = dyn_cast<DefInit>(R.getValueInit("Group"))) {
      const Record *GroupRec = Group->getDef();
      const std::string &GroupName = GroupRec->getValueAsString("GroupName");
      PrintFatalError(R.getLoc(), "Error " + R.getName() +
                    " cannot be in a warning group [" + GroupName + "]");
    }
  }

  // Check that all remarks have an associated diagnostic group.
  if (isRemark(R)) {
    if (!isa<DefInit>(R.getValueInit("Group"))) {
      PrintFatalError(R.getLoc(), "Error " + R.getName() +
                                      " not in any diagnostic group");
    }
  }

  // Filter by component.
  if (!Component.empty() && Component != R.getValueAsString("Component"))
    continue;

  OS << "DIAG(" << R.getName() << ", ";
  OS << R.getValueAsDef("Class")->getName();
  OS << ", (unsigned)diag::Severity::"
     << R.getValueAsDef("DefaultSeverity")->getValueAsString("Name");

  // Description string.
  OS << ", \"";
  OS.write_escaped(R.getValueAsString("Text")) << '"';

  // Warning associated with the diagnostic. This is stored as an index into
  // the alphabetically sorted warning table.
  if (DefInit *DI = dyn_cast<DefInit>(R.getValueInit("Group"))) {
    std::map<std::string, GroupInfo>::iterator I =
        DiagsInGroup.find(DI->getDef()->getValueAsString("GroupName"));
    assert(I != DiagsInGroup.end())(static_cast <bool> (I != DiagsInGroup.end()) ? void (0
) : __assert_fail ("I != DiagsInGroup.end()", "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp"
, 530, __extension__ __PRETTY_FUNCTION__));
    OS << ", " << I->second.IDNo;
  } else if (DiagsInPedantic.count(&R)) {
    std::map<std::string, GroupInfo>::iterator I =
      DiagsInGroup.find("pedantic");
    assert(I != DiagsInGroup.end() && "pedantic group not defined")(static_cast <bool> (I != DiagsInGroup.end() &&
 "pedantic group not defined") ? void (0) : __assert_fail ("I != DiagsInGroup.end() && \"pedantic group not defined\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp"
, 535, __extension__ __PRETTY_FUNCTION__));
    OS << ", " << I->second.IDNo;
  } else {
    OS << ", 0";
  }

  // SFINAE response.
  OS << ", " << R.getValueAsDef("SFINAE")->getName();

  // Default warning has no Werror bit.
  if (R.getValueAsBit("WarningNoWerror"))
    OS << ", true";
  else
    OS << ", false";

  if (R.getValueAsBit("ShowInSystemHeader"))
    OS << ", true";
  else
    OS << ", false";

  // Category number.
  OS << ", " << CategoryIDs.getID(getDiagnosticCategory(&R, DGParentMap));
  OS << ")\n";
}
559}
560} // end namespace clang

562//===----------------------------------------------------------------------===//
563// Warning Group Tables generation
564//===----------------------------------------------------------------------===//

566static std::string getDiagCategoryEnum(llvm::StringRef name) {
if (name.empty())
  return "DiagCat_None";
SmallString<256> enumName = llvm::StringRef("DiagCat_");
for (llvm::StringRef::iterator I = name.begin(), E = name.end(); I != E; ++I)
  enumName += isalnum(*I) ? *I : '_';
return enumName.str();
573}

575/// \brief Emit the array of diagnostic subgroups.
576///
577/// The array of diagnostic subgroups contains for each group a list of its
578/// subgroups. The individual lists are separated by '-1'. Groups with no
579/// subgroups are skipped.
580///
581/// \code
582///   static const int16_t DiagSubGroups[] = {
583///     /* Empty */ -1,
584///     /* DiagSubGroup0 */ 142, -1,
585///     /* DiagSubGroup13 */ 265, 322, 399, -1
586///   }
587/// \endcode
588///
589static void emitDiagSubGroups(std::map<std::string, GroupInfo> &DiagsInGroup,
                            RecordVec &GroupsInPedantic, raw_ostream &OS) {
OS << "static const int16_t DiagSubGroups[] = {\n"
   << "  /* Empty */ -1,\n";
for (auto const &I : DiagsInGroup) {
  const bool IsPedantic = I.first == "pedantic";

  const std::vector<std::string> &SubGroups = I.second.SubGroups;
  if (!SubGroups.empty() || (IsPedantic && !GroupsInPedantic.empty())) {
    OS << "  /* DiagSubGroup" << I.second.IDNo << " */ ";
    for (auto const &SubGroup : SubGroups) {
      std::map<std::string, GroupInfo>::const_iterator RI =
          DiagsInGroup.find(SubGroup);
      assert(RI != DiagsInGroup.end() && "Referenced without existing?")(static_cast <bool> (RI != DiagsInGroup.end() &&
 "Referenced without existing?") ? void (0) : __assert_fail (
"RI != DiagsInGroup.end() && \"Referenced without existing?\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp"
, 602, __extension__ __PRETTY_FUNCTION__));
      OS << RI->second.IDNo << ", ";
    }
    // Emit the groups implicitly in "pedantic".
    if (IsPedantic) {
      for (auto const &Group : GroupsInPedantic) {
        const std::string &GroupName = Group->getValueAsString("GroupName");
        std::map<std::string, GroupInfo>::const_iterator RI =
            DiagsInGroup.find(GroupName);
        assert(RI != DiagsInGroup.end() && "Referenced without existing?")(static_cast <bool> (RI != DiagsInGroup.end() &&
 "Referenced without existing?") ? void (0) : __assert_fail (
"RI != DiagsInGroup.end() && \"Referenced without existing?\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp"
, 611, __extension__ __PRETTY_FUNCTION__));
        OS << RI->second.IDNo << ", ";
      }
    }

    OS << "-1,\n";
  }
}
OS << "};\n\n";
620}

622/// \brief Emit the list of diagnostic arrays.
623///
624/// This data structure is a large array that contains itself arrays of varying
625/// size. Each array represents a list of diagnostics. The different arrays are
626/// separated by the value '-1'.
627///
628/// \code
629///   static const int16_t DiagArrays[] = {
630///     /* Empty */ -1,
631///     /* DiagArray1 */ diag::warn_pragma_message,
632///                      -1,
633///     /* DiagArray2 */ diag::warn_abs_too_small,
634///                      diag::warn_unsigned_abs,
635///                      diag::warn_wrong_absolute_value_type,
636///                      -1
637///   };
638/// \endcode
639///
640static void emitDiagArrays(std::map<std::string, GroupInfo> &DiagsInGroup,
                         RecordVec &DiagsInPedantic, raw_ostream &OS) {
OS << "static const int16_t DiagArrays[] = {\n"
   << "  /* Empty */ -1,\n";
for (auto const &I : DiagsInGroup) {
  const bool IsPedantic = I.first == "pedantic";

  const std::vector<const Record *> &V = I.second.DiagsInGroup;
  if (!V.empty() || (IsPedantic && !DiagsInPedantic.empty())) {
    OS << "  /* DiagArray" << I.second.IDNo << " */ ";
    for (auto *Record : V)
      OS << "diag::" << Record->getName() << ", ";
    // Emit the diagnostics implicitly in "pedantic".
    if (IsPedantic) {
      for (auto const &Diag : DiagsInPedantic)
        OS << "diag::" << Diag->getName() << ", ";
    }
    OS << "-1,\n";
  }
}
OS << "};\n\n";
661}

663/// \brief Emit a list of group names.
664///
665/// This creates a long string which by itself contains a list of pascal style
666/// strings, which consist of a length byte directly followed by the string.
667///
668/// \code
669///   static const char DiagGroupNames[] = {
670///     \000\020#pragma-messages\t#warnings\020CFString-literal"
671///   };
672/// \endcode
673static void emitDiagGroupNames(StringToOffsetTable &GroupNames,
                             raw_ostream &OS) {
OS << "static const char DiagGroupNames[] = {\n";
GroupNames.EmitString(OS);
OS << "};\n\n";
678}

680/// \brief Emit diagnostic arrays and related data structures.
681///
682/// This creates the actual diagnostic array, an array of diagnostic subgroups
683/// and an array of subgroup names.
684///
685/// \code
686///  #ifdef GET_DIAG_ARRAYS
687///     static const int16_t DiagArrays[];
688///     static const int16_t DiagSubGroups[];
689///     static const char DiagGroupNames[];
690///  #endif
691///  \endcode
692static void emitAllDiagArrays(std::map<std::string, GroupInfo> &DiagsInGroup,
                            RecordVec &DiagsInPedantic,
                            RecordVec &GroupsInPedantic,
                            StringToOffsetTable &GroupNames,
                            raw_ostream &OS) {
OS << "\n#ifdef GET_DIAG_ARRAYS\n";
emitDiagArrays(DiagsInGroup, DiagsInPedantic, OS);
emitDiagSubGroups(DiagsInGroup, GroupsInPedantic, OS);
emitDiagGroupNames(GroupNames, OS);
OS << "#endif // GET_DIAG_ARRAYS\n\n";
702}

704/// \brief Emit diagnostic table.
705///
706/// The table is sorted by the name of the diagnostic group. Each element
707/// consists of the name of the diagnostic group (given as offset in the
708/// group name table), a reference to a list of diagnostics (optional) and a
709/// reference to a set of subgroups (optional).
710///
711/// \code
712/// #ifdef GET_DIAG_TABLE
713///  {/* abi */              159, /* DiagArray11 */ 19, /* Empty */          0},
714///  {/* aggregate-return */ 180, /* Empty */        0, /* Empty */          0},
715///  {/* all */              197, /* Empty */        0, /* DiagSubGroup13 */ 3},
716///  {/* deprecated */       1981,/* DiagArray1 */ 348, /* DiagSubGroup3 */  9},
717/// #endif
718/// \endcode
719static void emitDiagTable(std::map<std::string, GroupInfo> &DiagsInGroup,
                        RecordVec &DiagsInPedantic,
                        RecordVec &GroupsInPedantic,
                        StringToOffsetTable &GroupNames, raw_ostream &OS) {
unsigned MaxLen = 0;

for (auto const &I: DiagsInGroup)
  MaxLen = std::max(MaxLen, (unsigned)I.first.size());

OS << "\n#ifdef GET_DIAG_TABLE\n";
unsigned SubGroupIndex = 1, DiagArrayIndex = 1;
for (auto const &I: DiagsInGroup) {
  // Group option string.
  OS << "  { /* ";
  if (I.first.find_first_not_of("abcdefghijklmnopqrstuvwxyz"
                                 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                                 "0123456789!@#$%^*-+=:?") !=
      std::string::npos)
    PrintFatalError("Invalid character in diagnostic group '" + I.first +
                    "'");
  OS << I.first << " */ " << std::string(MaxLen - I.first.size(), ' ');
  // Store a pascal-style length byte at the beginning of the string.
  std::string Name = char(I.first.size()) + I.first;
  OS << GroupNames.GetOrAddStringOffset(Name, false) << ", ";

  // Special handling for 'pedantic'.
  const bool IsPedantic = I.first == "pedantic";

  // Diagnostics in the group.
  const std::vector<const Record *> &V = I.second.DiagsInGroup;
  const bool hasDiags =
      !V.empty() || (IsPedantic && !DiagsInPedantic.empty());
  if (hasDiags) {
    OS << "/* DiagArray" << I.second.IDNo << " */ " << DiagArrayIndex
       << ", ";
    if (IsPedantic)
      DiagArrayIndex += DiagsInPedantic.size();
    DiagArrayIndex += V.size() + 1;
  } else {
    OS << "/* Empty */     0, ";
  }

  // Subgroups.
  const std::vector<std::string> &SubGroups = I.second.SubGroups;
  const bool hasSubGroups =
      !SubGroups.empty() || (IsPedantic && !GroupsInPedantic.empty());
  if (hasSubGroups) {
    OS << "/* DiagSubGroup" << I.second.IDNo << " */ " << SubGroupIndex;
    if (IsPedantic)
      SubGroupIndex += GroupsInPedantic.size();
    SubGroupIndex += SubGroups.size() + 1;
  } else {
    OS << "/* Empty */         0";
  }

  OS << " },\n";
}
OS << "#endif // GET_DIAG_TABLE\n\n";
777}

779/// \brief Emit the table of diagnostic categories.
780///
781/// The table has the form of macro calls that have two parameters. The
782/// category's name as well as an enum that represents the category. The
783/// table can be used by defining the macro 'CATEGORY' and including this
784/// table right after.
785///
786/// \code
787/// #ifdef GET_CATEGORY_TABLE
788///   CATEGORY("Semantic Issue", DiagCat_Semantic_Issue)
789///   CATEGORY("Lambda Issue", DiagCat_Lambda_Issue)
790/// #endif
791/// \endcode
792static void emitCategoryTable(RecordKeeper &Records, raw_ostream &OS) {
DiagCategoryIDMap CategoriesByID(Records);
OS << "\n#ifdef GET_CATEGORY_TABLE\n";
for (auto const &C : CategoriesByID)
  OS << "CATEGORY(\"" << C << "\", " << getDiagCategoryEnum(C) << ")\n";
OS << "#endif // GET_CATEGORY_TABLE\n\n";
798}

800namespace clang {
801void EmitClangDiagGroups(RecordKeeper &Records, raw_ostream &OS) {
// Compute a mapping from a DiagGroup to all of its parents.
DiagGroupParentMap DGParentMap(Records);

std::vector<Record *> Diags = Records.getAllDerivedDefinitions("Diagnostic");

std::vector<Record *> DiagGroups =
    Records.getAllDerivedDefinitions("DiagGroup");

std::map<std::string, GroupInfo> DiagsInGroup;
groupDiagnostics(Diags, DiagGroups, DiagsInGroup);

// All extensions are implicitly in the "pedantic" group.  Record the
// implicit set of groups in the "pedantic" group, and use this information
// later when emitting the group information for Pedantic.
RecordVec DiagsInPedantic;
RecordVec GroupsInPedantic;
InferPedantic inferPedantic(DGParentMap, Diags, DiagGroups, DiagsInGroup);
inferPedantic.compute(&DiagsInPedantic, &GroupsInPedantic);

StringToOffsetTable GroupNames;
for (std::map<std::string, GroupInfo>::const_iterator
         I = DiagsInGroup.begin(),
         E = DiagsInGroup.end();
     I != E; ++I) {
  // Store a pascal-style length byte at the beginning of the string.
  std::string Name = char(I->first.size()) + I->first;
  GroupNames.GetOrAddStringOffset(Name, false);
}

emitAllDiagArrays(DiagsInGroup, DiagsInPedantic, GroupsInPedantic, GroupNames,
                  OS);
emitDiagTable(DiagsInGroup, DiagsInPedantic, GroupsInPedantic, GroupNames,
              OS);
emitCategoryTable(Records, OS);
836}
837} // end namespace clang

839//===----------------------------------------------------------------------===//
840// Diagnostic name index generation
841//===----------------------------------------------------------------------===//

843namespace {
844struct RecordIndexElement
845{
RecordIndexElement() {}
explicit RecordIndexElement(Record const &R):
  Name(R.getName()) {}

std::string Name;
851};
852} // end anonymous namespace.

854namespace clang {
855void EmitClangDiagsIndexName(RecordKeeper &Records, raw_ostream &OS) {
const std::vector<Record*> &Diags =
  Records.getAllDerivedDefinitions("Diagnostic");

std::vector<RecordIndexElement> Index;
Index.reserve(Diags.size());
for (unsigned i = 0, e = Diags.size(); i != e; ++i) {
  const Record &R = *(Diags[i]);
  Index.push_back(RecordIndexElement(R));
}

llvm::sort(Index.begin(), Index.end(),
           [](const RecordIndexElement &Lhs, const RecordIndexElement &Rhs) {
             return Lhs.Name < Rhs.Name;
          });

for (unsigned i = 0, e = Index.size(); i != e; ++i) {
  const RecordIndexElement &R = Index[i];

  OS << "DIAG_NAME_INDEX(" << R.Name << ")\n";
}
876}

878//===----------------------------------------------------------------------===//
879// Diagnostic documentation generation
880//===----------------------------------------------------------------------===//

882namespace docs {
883namespace {

885/// Diagnostic text, parsed into pieces.
886struct DiagText {
struct Piece {
  // This type and its derived classes are move-only.
  Piece() {}
  Piece(Piece &&O) {}
  Piece &operator=(Piece &&O) { return *this; }

  virtual void print(std::vector<std::string> &RST) = 0;
  virtual ~Piece() {}
};
struct TextPiece : Piece {
  StringRef Role;
  std::string Text;
  void print(std::vector<std::string> &RST) override;
};
struct PlaceholderPiece : Piece {
  int Index;
  void print(std::vector<std::string> &RST) override;
};
struct SelectPiece : Piece {
  SelectPiece() {}
  SelectPiece(SelectPiece &&O) noexcept : Options(std::move(O.Options)) {}
  std::vector<DiagText> Options;
  void print(std::vector<std::string> &RST) override;
};

std::vector<std::unique_ptr<Piece>> Pieces;

DiagText();
DiagText(DiagText &&O) noexcept : Pieces(std::move(O.Pieces)) {}

DiagText(StringRef Text);
DiagText(StringRef Kind, StringRef Text);

template<typename P> void add(P Piece) {
  Pieces.push_back(llvm::make_unique<P>(std::move(Piece)));
}
void print(std::vector<std::string> &RST);
924};

926DiagText parseDiagText(StringRef &Text, bool Nested = false) {
DiagText Parsed;

while (!Text.empty()) {
  size_t End = (size_t)-2;
  do
    End = Nested ? Text.find_first_of("%|}", End + 2)
                 : Text.find_first_of('%', End + 2);
  while (End < Text.size() - 1 && Text[End] == '%' && Text[End + 1] == '%');

  if (End) {
    DiagText::TextPiece Piece;
    Piece.Role = "diagtext";
    Piece.Text = Text.slice(0, End);
    Parsed.add(std::move(Piece));
    Text = Text.slice(End, StringRef::npos);
    if (Text.empty()) break;
  }

  if (Text[0] == '|' || Text[0] == '}')
    break;

  // Drop the '%'.
  Text = Text.drop_front();

  // Extract the (optional) modifier.
  size_t ModLength = Text.find_first_of("0123456789{");
  StringRef Modifier = Text.slice(0, ModLength);
  Text = Text.slice(ModLength, StringRef::npos);

  // FIXME: Handle %ordinal here.
  if (Modifier == "select" || Modifier == "plural") {
    DiagText::SelectPiece Select;
    do {
      Text = Text.drop_front();
      if (Modifier == "plural")
        while (Text[0] != ':')
          Text = Text.drop_front();
      Select.Options.push_back(parseDiagText(Text, true));
      assert(!Text.empty() && "malformed %select")(static_cast <bool> (!Text.empty() && "malformed %select"
) ? void (0) : __assert_fail ("!Text.empty() && \"malformed %select\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp"
, 965, __extension__ __PRETTY_FUNCTION__));
    } while (Text.front() == '|');
    Parsed.add(std::move(Select));

    // Drop the trailing '}n'.
    Text = Text.drop_front(2);
    continue;
  }

  // For %diff, just take the second alternative (tree diagnostic). It would
  // be preferable to take the first one, and replace the $ with the suitable
  // placeholders.
  if (Modifier == "diff") {
    Text = Text.drop_front(); // '{'
    parseDiagText(Text, true);
    Text = Text.drop_front(); // '|'

    DiagText D = parseDiagText(Text, true);
    for (auto &P : D.Pieces)
      Parsed.Pieces.push_back(std::move(P));

    Text = Text.drop_front(4); // '}n,m'
    continue;
  }

  if (Modifier == "s") {
    Text = Text.drop_front();
    DiagText::SelectPiece Select;
    Select.Options.push_back(DiagText(""));
    Select.Options.push_back(DiagText("s"));
    Parsed.add(std::move(Select));
    continue;
  }

  assert(!Text.empty() && isdigit(Text[0]) && "malformed placeholder")(static_cast <bool> (!Text.empty() && isdigit(Text
[0]) && "malformed placeholder") ? void (0) : __assert_fail
 ("!Text.empty() && isdigit(Text[0]) && \"malformed placeholder\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp"
, 999, __extension__ __PRETTY_FUNCTION__));
  DiagText::PlaceholderPiece Placeholder;
  Placeholder.Index = Text[0] - '0';
  Parsed.add(std::move(Placeholder));
  Text = Text.drop_front();
  continue;
}
return Parsed;
1007}

1009DiagText::DiagText() {}

1011DiagText::DiagText(StringRef Text) : DiagText(parseDiagText(Text, false)) {}

1013DiagText::DiagText(StringRef Kind, StringRef Text) : DiagText(parseDiagText(Text, false)) {
TextPiece Prefix;
Prefix.Role = Kind;
Prefix.Text = Kind;
Prefix.Text += ": ";
Pieces.insert(Pieces.begin(),
              llvm::make_unique<TextPiece>(std::move(Prefix)));
1020}

1022void escapeRST(StringRef Str, std::string &Out) {
for (auto K : Str) {
  if (StringRef("`*|_[]\\").count(K))
    Out.push_back('\\');
  Out.push_back(K);
}
1028}

1030template<typename It> void padToSameLength(It Begin, It End) {
size_t Width = 0;
for (It I = Begin; I != End; ++I)
  Width = std::max(Width, I->size());
for (It I = Begin; I != End; ++I)
  (*I) += std::string(Width - I->size(), ' ');
1036}

1038template<typename It> void makeTableRows(It Begin, It End) {
if (Begin == End) return;
padToSameLength(Begin, End);
for (It I = Begin; I != End; ++I)
  *I = "|" + *I + "|";
1043}

1045void makeRowSeparator(std::string &Str) {
for (char &K : Str)
  K = (K == '|' ? '+' : '-');
1048}

1050void DiagText::print(std::vector<std::string> &RST) {
if (Pieces.empty()) {
  RST.push_back("");
  return;
}

if (Pieces.size() == 1)
  return Pieces[0]->print(RST);

std::string EmptyLinePrefix;
size_t Start = RST.size();
bool HasMultipleLines = true;
for (auto &P : Pieces) {
  std::vector<std::string> Lines;
  P->print(Lines);
  if (Lines.empty())
    continue;

  // We need a vertical separator if either this or the previous piece is a
  // multi-line piece, or this is the last piece.
  const char *Separator = (Lines.size() > 1 || HasMultipleLines) ? "|" : "";
  HasMultipleLines = Lines.size() > 1;

  if (Start + Lines.size() > RST.size())
    RST.resize(Start + Lines.size(), EmptyLinePrefix);

  padToSameLength(Lines.begin(), Lines.end());
  for (size_t I = 0; I != Lines.size(); ++I)
    RST[Start + I] += Separator + Lines[I];
  std::string Empty(Lines[0].size(), ' ');
  for (size_t I = Start + Lines.size(); I != RST.size(); ++I)
    RST[I] += Separator + Empty;
  EmptyLinePrefix += Separator + Empty;
}
for (size_t I = Start; I != RST.size(); ++I)
  RST[I] += "|";
EmptyLinePrefix += "|";

makeRowSeparator(EmptyLinePrefix);
RST.insert(RST.begin() + Start, EmptyLinePrefix);
RST.insert(RST.end(), EmptyLinePrefix);
1091}

1093void DiagText::TextPiece::print(std::vector<std::string> &RST) {
RST.push_back("");
auto &S = RST.back();

StringRef T = Text;
while (!T.empty() && T.front() == ' ') {
  RST.back() += " |nbsp| ";
  T = T.drop_front();
}

std::string Suffix;
while (!T.empty() && T.back() == ' ') {
  Suffix += " |nbsp| ";
  T = T.drop_back();
}

if (!T.empty()) {
  S += ':';
  S += Role;
  S += ":`";
  escapeRST(T, S);
  S += '`';
}

S += Suffix;
1118}

1120void DiagText::PlaceholderPiece::print(std::vector<std::string> &RST) {
RST.push_back(std::string(":placeholder:`") + char('A' + Index) + "`");
1122}

1124void DiagText::SelectPiece::print(std::vector<std::string> &RST) {
std::vector<size_t> SeparatorIndexes;
SeparatorIndexes.push_back(RST.size());
RST.emplace_back();
for (auto &O : Options) {
  O.print(RST);
  SeparatorIndexes.push_back(RST.size());
  RST.emplace_back();
}

makeTableRows(RST.begin() + SeparatorIndexes.front(),
              RST.begin() + SeparatorIndexes.back() + 1);
for (size_t I : SeparatorIndexes)
  makeRowSeparator(RST[I]);
1138}

1140bool isRemarkGroup(const Record *DiagGroup,
                 const std::map<std::string, GroupInfo> &DiagsInGroup) {
bool AnyRemarks = false, AnyNonRemarks = false;

std::function<void(StringRef)> Visit = [&](StringRef GroupName) {
  auto &GroupInfo = DiagsInGroup.find(GroupName)->second;
  for (const Record *Diag : GroupInfo.DiagsInGroup)
    (isRemark(*Diag) ? AnyRemarks : AnyNonRemarks) = true;
  for (const auto &Name : GroupInfo.SubGroups)
    Visit(Name);
};
Visit(DiagGroup->getValueAsString("GroupName"));

if (AnyRemarks && AnyNonRemarks)
  PrintFatalError(
      DiagGroup->getLoc(),
      "Diagnostic group contains both remark and non-remark diagnostics");
return AnyRemarks;
1158}

1160std::string getDefaultSeverity(const Record *Diag) {
return Diag->getValueAsDef("DefaultSeverity")->getValueAsString("Name");
1162}

1164std::set<std::string>
1165getDefaultSeverities(const Record *DiagGroup,
                   const std::map<std::string, GroupInfo> &DiagsInGroup) {
std::set<std::string> States;

std::function<void(StringRef)> Visit = [&](StringRef GroupName) {
7
←
Calling constructor for 'function'→
14
←
Returning from constructor for 'function'→
  auto &GroupInfo = DiagsInGroup.find(GroupName)->second;
  for (const Record *Diag : GroupInfo.DiagsInGroup)
    States.insert(getDefaultSeverity(Diag));
  for (const auto &Name : GroupInfo.SubGroups)
    Visit(Name);
};
Visit(DiagGroup->getValueAsString("GroupName"));
return States;
1178}
15
←
Potential memory leak

1180void writeHeader(StringRef Str, raw_ostream &OS, char Kind = '-') {
OS << Str << "\n" << std::string(Str.size(), Kind) << "\n";
1182}

1184void writeDiagnosticText(StringRef Role, StringRef Text, raw_ostream &OS) {
if (Text == "%0")
  OS << "The text of this diagnostic is not controlled by Clang.\n\n";
else {
  std::vector<std::string> Out;
  DiagText(Role, Text).print(Out);
  for (auto &Line : Out)
    OS << Line << "\n";
  OS << "\n";
}
1194}

1196}  // namespace
1197}  // namespace docs

1199void EmitClangDiagDocs(RecordKeeper &Records, raw_ostream &OS) {
using namespace docs;

// Get the documentation introduction paragraph.
const Record *Documentation = Records.getDef("GlobalDocumentation");
if (!Documentation) {
1
Assuming 'Documentation' is non-null→
2
←
Taking false branch→
  PrintFatalError("The Documentation top-level definition is missing, "
                  "no documentation will be generated.");
  return;
}

OS << Documentation->getValueAsString("Intro") << "\n";

std::vector<Record*> Diags =
    Records.getAllDerivedDefinitions("Diagnostic");
std::vector<Record*> DiagGroups =
    Records.getAllDerivedDefinitions("DiagGroup");
llvm::sort(DiagGroups.begin(), DiagGroups.end(), diagGroupBeforeByName);

DiagGroupParentMap DGParentMap(Records);

std::map<std::string, GroupInfo> DiagsInGroup;
groupDiagnostics(Diags, DiagGroups, DiagsInGroup);

// Compute the set of diagnostics that are in -Wpedantic.
{
  RecordSet DiagsInPedanticSet;
  RecordSet GroupsInPedanticSet;
  InferPedantic inferPedantic(DGParentMap, Diags, DiagGroups, DiagsInGroup);
  inferPedantic.compute(&DiagsInPedanticSet, &GroupsInPedanticSet);
  auto &PedDiags = DiagsInGroup["pedantic"];
  // Put the diagnostics into a deterministic order.
  RecordVec DiagsInPedantic(DiagsInPedanticSet.begin(),
                            DiagsInPedanticSet.end());
  RecordVec GroupsInPedantic(GroupsInPedanticSet.begin(),
                             GroupsInPedanticSet.end());
  llvm::sort(DiagsInPedantic.begin(), DiagsInPedantic.end(),
             beforeThanCompare);
  llvm::sort(GroupsInPedantic.begin(), GroupsInPedantic.end(),
             beforeThanCompare);
  PedDiags.DiagsInGroup.insert(PedDiags.DiagsInGroup.end(),
                               DiagsInPedantic.begin(),
                               DiagsInPedantic.end());
  for (auto *Group : GroupsInPedantic)
    PedDiags.SubGroups.push_back(Group->getValueAsString("GroupName"));
}

// FIXME: Write diagnostic categories and link to diagnostic groups in each.

// Write out the diagnostic groups.
for (const Record *G : DiagGroups) {
  bool IsRemarkGroup = isRemarkGroup(G, DiagsInGroup);
  auto &GroupInfo = DiagsInGroup[G->getValueAsString("GroupName")];
  bool IsSynonym = GroupInfo.DiagsInGroup.empty() &&
3
←
Assuming the condition is false→
                   GroupInfo.SubGroups.size() == 1;

  writeHeader(((IsRemarkGroup ? "-R" : "-W") +
4
←
'?' condition is false→
                  G->getValueAsString("GroupName")).str(),
              OS);

  if (!IsSynonym) {
5
←
Taking true branch→
    // FIXME: Ideally, all the diagnostics in a group should have the same
    // default state, but that is not currently the case.
    auto DefaultSeverities = getDefaultSeverities(G, DiagsInGroup);
6
←
Calling 'getDefaultSeverities'→
    if (!DefaultSeverities.empty() && !DefaultSeverities.count("Ignored")) {
      bool AnyNonErrors = DefaultSeverities.count("Warning") ||
                          DefaultSeverities.count("Remark");
      if (!AnyNonErrors)
        OS << "This diagnostic is an error by default, but the flag ``-Wno-"
           << G->getValueAsString("GroupName") << "`` can be used to disable "
           << "the error.\n\n";
      else
        OS << "This diagnostic is enabled by default.\n\n";
    } else if (DefaultSeverities.size() > 1) {
      OS << "Some of the diagnostics controlled by this flag are enabled "
         << "by default.\n\n";
    }
  }

  if (!GroupInfo.SubGroups.empty()) {
    if (IsSynonym)
      OS << "Synonym for ";
    else if (GroupInfo.DiagsInGroup.empty())
      OS << "Controls ";
    else
      OS << "Also controls ";

    bool First = true;
    llvm::sort(GroupInfo.SubGroups.begin(), GroupInfo.SubGroups.end());
    for (const auto &Name : GroupInfo.SubGroups) {
      if (!First) OS << ", ";
      OS << "`" << (IsRemarkGroup ? "-R" : "-W") << Name << "`_";
      First = false;
    }
    OS << ".\n\n";
  }

  if (!GroupInfo.DiagsInGroup.empty()) {
    OS << "**Diagnostic text:**\n\n";
    for (const Record *D : GroupInfo.DiagsInGroup) {
      auto Severity = getDefaultSeverity(D);
      Severity[0] = tolower(Severity[0]);
      if (Severity == "ignored")
        Severity = IsRemarkGroup ? "remark" : "warning";
      writeDiagnosticText(Severity, D->getValueAsString("Text"), OS);
    }
  }

  auto Doc = G->getValueAsString("Documentation");
  if (!Doc.empty())
    OS << Doc;
  else if (GroupInfo.SubGroups.empty() && GroupInfo.DiagsInGroup.empty())
    OS << "This diagnostic flag exists for GCC compatibility, and has no "
          "effect in Clang.\n";
  OS << "\n";
}
1315}

1317} // end namespace clang

←

/usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/bits/std_function.h

1// Implementation of std::function -*- C++ -*-

3// Copyright (C) 2004-2017 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 include/bits/function.h
*  This is an internal header file, included by other library headers.
*  Do not attempt to use it directly. @headername{functional}
*/

30#ifndef _GLIBCXX_STD_FUNCTION_H1
31#define _GLIBCXX_STD_FUNCTION_H1 1

33#pragma GCC system_header

35#if __cplusplus201103L < 201103L
36# include <bits/c++0x_warning.h>
37#else

39#if __cpp_rtti199711
40# include <typeinfo>
41#endif
42#include <bits/stl_function.h>
43#include <bits/invoke.h>
44#include <bits/refwrap.h>
45#include <bits/functexcept.h>

47namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
48{
49_GLIBCXX_BEGIN_NAMESPACE_VERSION

/**
 * Derives from @c unary_function or @c binary_function, or perhaps
 * nothing, depending on the number of arguments provided. The
 * primary template is the basis case, which derives nothing.
 */
template<typename _Res, typename... _ArgTypes>
  struct _Maybe_unary_or_binary_function { };

/// Derives from @c unary_function, as appropriate.
template<typename _Res, typename _T1>
  struct _Maybe_unary_or_binary_function<_Res, _T1>
  : std::unary_function<_T1, _Res> { };

/// Derives from @c binary_function, as appropriate.
template<typename _Res, typename _T1, typename _T2>
  struct _Maybe_unary_or_binary_function<_Res, _T1, _T2>
  : std::binary_function<_T1, _T2, _Res> { };


/**
 *  @brief Exception class thrown when class template function's
 *  operator() is called with an empty target.
 *  @ingroup exceptions
 */
class bad_function_call : public std::exception
{
public:
  virtual ~bad_function_call() noexcept;

  const char* what() const noexcept;
};

/**
 *  Trait identifying "location-invariant" types, meaning that the
 *  address of the object (or any of its members) will not escape.
 *  Trivially copyable types are location-invariant and users can
 *  specialize this trait for other types.
 */
template<typename _Tp>
  struct __is_location_invariant
  : is_trivially_copyable<_Tp>::type
  { };

class _Undefined_class;

union _Nocopy_types
{
  void*       _M_object;
  const void* _M_const_object;
  void (*_M_function_pointer)();
  void (_Undefined_class::*_M_member_pointer)();
};

union [[gnu::may_alias]] _Any_data
{
  void*       _M_access()       { return &_M_pod_data[0]; }
  const void* _M_access() const { return &_M_pod_data[0]; }

  template<typename _Tp>
    _Tp&
    _M_access()
    { return *static_cast<_Tp*>(_M_access()); }

  template<typename _Tp>
    const _Tp&
    _M_access() const
    { return *static_cast<const _Tp*>(_M_access()); }

  _Nocopy_types _M_unused;
  char _M_pod_data[sizeof(_Nocopy_types)];
};

enum _Manager_operation
{
  __get_type_info,
  __get_functor_ptr,
  __clone_functor,
  __destroy_functor
};

// Simple type wrapper that helps avoid annoying const problems
// when casting between void pointers and pointers-to-pointers.
template<typename _Tp>
  struct _Simple_type_wrapper
  {
    _Simple_type_wrapper(_Tp __value) : __value(__value) { }

    _Tp __value;
  };

template<typename _Tp>
  struct __is_location_invariant<_Simple_type_wrapper<_Tp> >
  : __is_location_invariant<_Tp>
  { };

template<typename _Signature>
  class function;

/// Base class of all polymorphic function object wrappers.
class _Function_base
{
public:
  static const std::size_t _M_max_size = sizeof(_Nocopy_types);
  static const std::size_t _M_max_align = __alignof__(_Nocopy_types);

  template<typename _Functor>
    class _Base_manager
    {
    protected:
static const bool __stored_locally =
(__is_location_invariant<_Functor>::value
&& sizeof(_Functor) <= _M_max_size
&& __alignof__(_Functor) <= _M_max_align
&& (_M_max_align % __alignof__(_Functor) == 0));

typedef integral_constant<bool, __stored_locally> _Local_storage;

// Retrieve a pointer to the function object
static _Functor*
_M_get_pointer(const _Any_data& __source)
{
 const _Functor* __ptr =
   __stored_locally? std::__addressof(__source._M_access<_Functor>())
   /* have stored a pointer */ : __source._M_access<_Functor*>();
 return const_cast<_Functor*>(__ptr);
}

// Clone a location-invariant function object that fits within
// an _Any_data structure.
static void
_M_clone(_Any_data& __dest, const _Any_data& __source, true_type)
{
 ::new (__dest._M_access()) _Functor(__source._M_access<_Functor>());
}

// Clone a function object that is not location-invariant or
// that cannot fit into an _Any_data structure.
static void
_M_clone(_Any_data& __dest, const _Any_data& __source, false_type)
{
 __dest._M_access<_Functor*>() =
   new _Functor(*__source._M_access<_Functor*>());
}

// Destroying a location-invariant object may still require
// destruction.
static void
_M_destroy(_Any_data& __victim, true_type)
{
 __victim._M_access<_Functor>().~_Functor();
}

// Destroying an object located on the heap.
static void
_M_destroy(_Any_data& __victim, false_type)
{
 delete __victim._M_access<_Functor*>();
}

    public:
static bool
_M_manager(_Any_data& __dest, const _Any_data& __source,
   _Manager_operation __op)
{
 switch (__op)
   {
217#if __cpp_rtti199711
   case __get_type_info:
     __dest._M_access<const type_info*>() = &typeid(_Functor);
     break;
221#endif
   case __get_functor_ptr:
     __dest._M_access<_Functor*>() = _M_get_pointer(__source);
     break;

   case __clone_functor:
     _M_clone(__dest, __source, _Local_storage());
     break;

   case __destroy_functor:
     _M_destroy(__dest, _Local_storage());
     break;
   }
 return false;
}

static void
_M_init_functor(_Any_data& __functor, _Functor&& __f)
{ _M_init_functor(__functor, std::move(__f), _Local_storage()); }
10
←
Calling '_Base_manager::_M_init_functor'→
12
←
Returned allocated memory→

template<typename _Signature>
 static bool
 _M_not_empty_function(const function<_Signature>& __f)
 { return static_cast<bool>(__f); }

template<typename _Tp>
 static bool
 _M_not_empty_function(_Tp* __fp)
 { return __fp != nullptr; }

template<typename _Class, typename _Tp>
 static bool
 _M_not_empty_function(_Tp _Class::* __mp)
 { return __mp != nullptr; }

template<typename _Tp>
 static bool
 _M_not_empty_function(const _Tp&)
 { return true; }

    private:
static void
_M_init_functor(_Any_data& __functor, _Functor&& __f, true_type)
{ ::new (__functor._M_access()) _Functor(std::move(__f)); }

static void
_M_init_functor(_Any_data& __functor, _Functor&& __f, false_type)
{ __functor._M_access<_Functor*>() = new _Functor(std::move(__f)); }
11
←
Memory is allocated→
    };

  _Function_base() : _M_manager(nullptr) { }

  ~_Function_base()
  {
    if (_M_manager)
_M_manager(_M_functor, _M_functor, __destroy_functor);
  }

  bool _M_empty() const { return !_M_manager; }

  typedef bool (*_Manager_type)(_Any_data&, const _Any_data&,
		  _Manager_operation);

  _Any_data     _M_functor;
  _Manager_type _M_manager;
};

template<typename _Signature, typename _Functor>
  class _Function_handler;

template<typename _Res, typename _Functor, typename... _ArgTypes>
  class _Function_handler<_Res(_ArgTypes...), _Functor>
  : public _Function_base::_Base_manager<_Functor>
  {
    typedef _Function_base::_Base_manager<_Functor> _Base;

  public:
    static _Res
    _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
    {
return (*_Base::_M_get_pointer(__functor))(
   std::forward<_ArgTypes>(__args)...);
    }
  };

template<typename _Functor, typename... _ArgTypes>
  class _Function_handler<void(_ArgTypes...), _Functor>
  : public _Function_base::_Base_manager<_Functor>
  {
    typedef _Function_base::_Base_manager<_Functor> _Base;

   public:
    static void
    _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
    {
(*_Base::_M_get_pointer(__functor))(
   std::forward<_ArgTypes>(__args)...);
    }
  };

template<typename _Class, typename _Member, typename _Res,
  typename... _ArgTypes>
  class _Function_handler<_Res(_ArgTypes...), _Member _Class::*>
  : public _Function_handler<void(_ArgTypes...), _Member _Class::*>
  {
    typedef _Function_handler<void(_ArgTypes...), _Member _Class::*>
_Base;

   public:
    static _Res
    _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
    {
return std::__invoke(_Base::_M_get_pointer(__functor)->__value,
	     std::forward<_ArgTypes>(__args)...);
    }
  };

template<typename _Class, typename _Member, typename... _ArgTypes>
  class _Function_handler<void(_ArgTypes...), _Member _Class::*>
  : public _Function_base::_Base_manager<
 _Simple_type_wrapper< _Member _Class::* > >
  {
    typedef _Member _Class::* _Functor;
    typedef _Simple_type_wrapper<_Functor> _Wrapper;
    typedef _Function_base::_Base_manager<_Wrapper> _Base;

  public:
    static bool
    _M_manager(_Any_data& __dest, const _Any_data& __source,
 _Manager_operation __op)
    {
switch (__op)
 {
354#if __cpp_rtti199711
 case __get_type_info:
   __dest._M_access<const type_info*>() = &typeid(_Functor);
   break;
358#endif
 case __get_functor_ptr:
   __dest._M_access<_Functor*>() =
     &_Base::_M_get_pointer(__source)->__value;
   break;

 default:
   _Base::_M_manager(__dest, __source, __op);
 }
return false;
    }

    static void
    _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
    {
std::__invoke(_Base::_M_get_pointer(__functor)->__value,
      std::forward<_ArgTypes>(__args)...);
    }
  };

template<typename _From, typename _To>
  using __check_func_return_type
    = __or_<is_void<_To>, is_same<_From, _To>, is_convertible<_From, _To>>;

/**
 *  @brief Primary class template for std::function.
 *  @ingroup functors
 *
 *  Polymorphic function wrapper.
 */
template<typename _Res, typename... _ArgTypes>
  class function<_Res(_ArgTypes...)>
  : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>,
    private _Function_base
  {
    template<typename _Func,
      typename _Res2 = typename result_of<_Func&(_ArgTypes...)>::type>
struct _Callable : __check_func_return_type<_Res2, _Res> { };

    // Used so the return type convertibility checks aren't done when
    // performing overload resolution for copy construction/assignment.
    template<typename _Tp>
struct _Callable<function, _Tp> : false_type { };

    template<typename _Cond, typename _Tp>
using _Requires = typename enable_if<_Cond::value, _Tp>::type;

  public:
    typedef _Res result_type;

    // [3.7.2.1] construct/copy/destroy

    /**
     *  @brief Default construct creates an empty function call wrapper.
     *  @post @c !(bool)*this
     */
    function() noexcept
    : _Function_base() { }

    /**
     *  @brief Creates an empty function call wrapper.
     *  @post @c !(bool)*this
     */
    function(nullptr_t) noexcept
    : _Function_base() { }

    /**
     *  @brief %Function copy constructor.
     *  @param __x A %function object with identical call signature.
     *  @post @c bool(*this) == bool(__x)
     *
     *  The newly-created %function contains a copy of the target of @a
     *  __x (if it has one).
     */
    function(const function& __x);

    /**
     *  @brief %Function move constructor.
     *  @param __x A %function object rvalue with identical call signature.
     *
     *  The newly-created %function contains the target of @a __x
     *  (if it has one).
     */
    function(function&& __x) noexcept : _Function_base()
    {
__x.swap(*this);
    }

    /**
     *  @brief Builds a %function that targets a copy of the incoming
     *  function object.
     *  @param __f A %function object that is callable with parameters of
     *  type @c T1, @c T2, ..., @c TN and returns a value convertible
     *  to @c Res.
     *
     *  The newly-created %function object will target a copy of
     *  @a __f. If @a __f is @c reference_wrapper<F>, then this function
     *  object will contain a reference to the function object @c
     *  __f.get(). If @a __f is a NULL function pointer or NULL
     *  pointer-to-member, the newly-created object will be empty.
     *
     *  If @a __f is a non-NULL function pointer or an object of type @c
     *  reference_wrapper<F>, this function will not throw.
     */
    template<typename _Functor,
      typename = _Requires<__not_<is_same<_Functor, function>>, void>,
      typename = _Requires<_Callable<_Functor>, void>>
function(_Functor);

    /**
     *  @brief %Function assignment operator.
     *  @param __x A %function with identical call signature.
     *  @post @c (bool)*this == (bool)x
     *  @returns @c *this
     *
     *  The target of @a __x is copied to @c *this. If @a __x has no
     *  target, then @c *this will be empty.
     *
     *  If @a __x targets a function pointer or a reference to a function
     *  object, then this operation will not throw an %exception.
     */
    function&
    operator=(const function& __x)
    {
function(__x).swap(*this);
return *this;
    }

    /**
     *  @brief %Function move-assignment operator.
     *  @param __x A %function rvalue with identical call signature.
     *  @returns @c *this
     *
     *  The target of @a __x is moved to @c *this. If @a __x has no
     *  target, then @c *this will be empty.
     *
     *  If @a __x targets a function pointer or a reference to a function
     *  object, then this operation will not throw an %exception.
     */
    function&
    operator=(function&& __x) noexcept
    {
function(std::move(__x)).swap(*this);
return *this;
    }

    /**
     *  @brief %Function assignment to zero.
     *  @post @c !(bool)*this
     *  @returns @c *this
     *
     *  The target of @c *this is deallocated, leaving it empty.
     */
    function&
    operator=(nullptr_t) noexcept
    {
if (_M_manager)
 {
   _M_manager(_M_functor, _M_functor, __destroy_functor);
   _M_manager = nullptr;
   _M_invoker = nullptr;
 }
return *this;
    }

    /**
     *  @brief %Function assignment to a new target.
     *  @param __f A %function object that is callable with parameters of
     *  type @c T1, @c T2, ..., @c TN and returns a value convertible
     *  to @c Res.
     *  @return @c *this
     *
     *  This  %function object wrapper will target a copy of @a
     *  __f. If @a __f is @c reference_wrapper<F>, then this function
     *  object will contain a reference to the function object @c
     *  __f.get(). If @a __f is a NULL function pointer or NULL
     *  pointer-to-member, @c this object will be empty.
     *
     *  If @a __f is a non-NULL function pointer or an object of type @c
     *  reference_wrapper<F>, this function will not throw.
     */
    template<typename _Functor>
_Requires<_Callable<typename decay<_Functor>::type>, function&>
operator=(_Functor&& __f)
{
 function(std::forward<_Functor>(__f)).swap(*this);
 return *this;
}

    /// @overload
    template<typename _Functor>
function&
operator=(reference_wrapper<_Functor> __f) noexcept
{
 function(__f).swap(*this);
 return *this;
}

    // [3.7.2.2] function modifiers

    /**
     *  @brief Swap the targets of two %function objects.
     *  @param __x A %function with identical call signature.
     *
     *  Swap the targets of @c this function object and @a __f. This
     *  function will not throw an %exception.
     */
    void swap(function& __x) noexcept
    {
std::swap(_M_functor, __x._M_functor);
std::swap(_M_manager, __x._M_manager);
std::swap(_M_invoker, __x._M_invoker);
    }

    // [3.7.2.3] function capacity

    /**
     *  @brief Determine if the %function wrapper has a target.
     *
     *  @return @c true when this %function object contains a target,
     *  or @c false when it is empty.
     *
     *  This function will not throw an %exception.
     */
    explicit operator bool() const noexcept
    { return !_M_empty(); }

    // [3.7.2.4] function invocation

    /**
     *  @brief Invokes the function targeted by @c *this.
     *  @returns the result of the target.
     *  @throws bad_function_call when @c !(bool)*this
     *
     *  The function call operator invokes the target function object
     *  stored by @c this.
     */
    _Res operator()(_ArgTypes... __args) const;

597#if __cpp_rtti199711
    // [3.7.2.5] function target access
    /**
     *  @brief Determine the type of the target of this function object
     *  wrapper.
     *
     *  @returns the type identifier of the target function object, or
     *  @c typeid(void) if @c !(bool)*this.
     *
     *  This function will not throw an %exception.
     */
    const type_info& target_type() const noexcept;

    /**
     *  @brief Access the stored target function object.
     *
     *  @return Returns a pointer to the stored target function object,
     *  if @c typeid(_Functor).equals(target_type()); otherwise, a NULL
     *  pointer.
     *
     * This function does not throw exceptions.
     *
     * @{
     */
    template<typename _Functor>       _Functor* target() noexcept;

    template<typename _Functor> const _Functor* target() const noexcept;
    // @}
625#endif

  private:
    using _Invoker_type = _Res (*)(const _Any_data&, _ArgTypes&&...);
    _Invoker_type _M_invoker;
};

632#if __cpp_deduction_guides >= 201606
template<typename>
  struct __function_guide_helper
  { };

template<typename _Res, typename _Tp, bool _Nx, typename... _Args>
  struct __function_guide_helper<
    _Res (_Tp::*) (_Args...) noexcept(_Nx)
  >
  { using type = _Res(_Args...); };

template<typename _Res, typename _Tp, bool _Nx, typename... _Args>
  struct __function_guide_helper<
    _Res (_Tp::*) (_Args...) & noexcept(_Nx)
  >
  { using type = _Res(_Args...); };

template<typename _Res, typename _Tp, bool _Nx, typename... _Args>
  struct __function_guide_helper<
    _Res (_Tp::*) (_Args...) const noexcept(_Nx)
  >
  { using type = _Res(_Args...); };

template<typename _Res, typename _Tp, bool _Nx, typename... _Args>
  struct __function_guide_helper<
    _Res (_Tp::*) (_Args...) const & noexcept(_Nx)
  >
  { using type = _Res(_Args...); };

template<typename _Res, typename... _ArgTypes>
  function(_Res(*)(_ArgTypes...)) -> function<_Res(_ArgTypes...)>;

template<typename _Functor, typename _Signature = typename
  __function_guide_helper<decltype(&_Functor::operator())>::type>
  function(_Functor) -> function<_Signature>;
667#endif

// Out-of-line member definitions.
template<typename _Res, typename... _ArgTypes>
  function<_Res(_ArgTypes...)>::
  function(const function& __x)
  : _Function_base()
  {
    if (static_cast<bool>(__x))
{
 __x._M_manager(_M_functor, __x._M_functor, __clone_functor);
 _M_invoker = __x._M_invoker;
 _M_manager = __x._M_manager;
}
  }

template<typename _Res, typename... _ArgTypes>
  template<typename _Functor, typename, typename>
    function<_Res(_ArgTypes...)>::
    function(_Functor __f)
    : _Function_base()
    {
typedef _Function_handler<_Res(_ArgTypes...), _Functor> _My_handler;

if (_My_handler::_M_not_empty_function(__f))
8
←
Taking true branch→
 {
   _My_handler::_M_init_functor(_M_functor, std::move(__f));
9
←
Calling '_Base_manager::_M_init_functor'→
13
←
Returned allocated memory→
   _M_invoker = &_My_handler::_M_invoke;
   _M_manager = &_My_handler::_M_manager;
 }
    }

template<typename _Res, typename... _ArgTypes>
  _Res
  function<_Res(_ArgTypes...)>::
  operator()(_ArgTypes... __args) const
  {
    if (_M_empty())
__throw_bad_function_call();
    return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...);
  }

709#if __cpp_rtti199711
template<typename _Res, typename... _ArgTypes>
  const type_info&
  function<_Res(_ArgTypes...)>::
  target_type() const noexcept
  {
    if (_M_manager)
{
 _Any_data __typeinfo_result;
 _M_manager(__typeinfo_result, _M_functor, __get_type_info);
 return *__typeinfo_result._M_access<const type_info*>();
}
    else
return typeid(void);
  }

template<typename _Res, typename... _ArgTypes>
  template<typename _Functor>
    _Functor*
    function<_Res(_ArgTypes...)>::
    target() noexcept
    {
const function* __const_this = this;
const _Functor* __func = __const_this->template target<_Functor>();
return const_cast<_Functor*>(__func);
    }

template<typename _Res, typename... _ArgTypes>
  template<typename _Functor>
    const _Functor*
    function<_Res(_ArgTypes...)>::
    target() const noexcept
    {
if (typeid(_Functor) == target_type() && _M_manager)
 {
   _Any_data __ptr;
   _M_manager(__ptr, _M_functor, __get_functor_ptr);
   return __ptr._M_access<const _Functor*>();
 }
else
 return nullptr;
    }
751#endif

// [20.7.15.2.6] null pointer comparisons

/**
 *  @brief Compares a polymorphic function object wrapper against 0
 *  (the NULL pointer).
 *  @returns @c true if the wrapper has no target, @c false otherwise
 *
 *  This function will not throw an %exception.
 */
template<typename _Res, typename... _Args>
  inline bool
  operator==(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
  { return !static_cast<bool>(__f); }

/// @overload
template<typename _Res, typename... _Args>
  inline bool
  operator==(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
  { return !static_cast<bool>(__f); }

/**
 *  @brief Compares a polymorphic function object wrapper against 0
 *  (the NULL pointer).
 *  @returns @c false if the wrapper has no target, @c true otherwise
 *
 *  This function will not throw an %exception.
 */
template<typename _Res, typename... _Args>
  inline bool
  operator!=(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
  { return static_cast<bool>(__f); }

/// @overload
template<typename _Res, typename... _Args>
  inline bool
  operator!=(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
  { return static_cast<bool>(__f); }


// [20.7.15.2.7] specialized algorithms

/**
 *  @brief Swap the targets of two polymorphic function object wrappers.
 *
 *  This function will not throw an %exception.
 */
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 2062. Effect contradictions w/o no-throw guarantee of std::function swaps
template<typename _Res, typename... _Args>
  inline void
  swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y) noexcept
  { __x.swap(__y); }

806_GLIBCXX_END_NAMESPACE_VERSION
807} // namespace std

809#endif // C++11

811#endif // _GLIBCXX_STD_FUNCTION_H