reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

    1
    2
    3
    4
    5
    6
    7
    8
    9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69

//===- ErrorCollector.cpp -------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===-----------------------------------------------------------------------===/

#include "ErrorCollector.h"
#include "llvm/Support/Errc.h"
#include "llvm/Support/Error.h"
#include "llvm/Support/WithColor.h"
#include "llvm/Support/raw_ostream.h"
#include <vector>

using namespace llvm;
using namespace llvm::elfabi;

void ErrorCollector::escalateToFatal() {
  ErrorsAreFatal = true;
}

void ErrorCollector::addError(Error &&Err, StringRef Tag) {
  if (Err) {
    Errors.push_back(std::move(Err));
    Tags.push_back(Tag.str());
  }
}

Error ErrorCollector::makeError() {
  // TODO: Make this return something (an AggregateError?) that gives more
  // individual control over each error and which might be of interest.
  Error JoinedErrors = Error::success();
  for (Error &E : Errors) {
    JoinedErrors = joinErrors(std::move(JoinedErrors), std::move(E));
  }
  Errors.clear();
  Tags.clear();
  return JoinedErrors;
}

void ErrorCollector::log(raw_ostream &OS) {
  OS << "Encountered multiple errors:\n";
  for (size_t i = 0; i < Errors.size(); ++i) {
    WithColor::error(OS) << "(" << Tags[i] << ") " << Errors[i];
    if (i != Errors.size() - 1)
      OS << "\n";
  }
}

bool ErrorCollector::allErrorsHandled() const {
  return Errors.empty();
}

ErrorCollector::~ErrorCollector() {
  if (ErrorsAreFatal && !allErrorsHandled())
    fatalUnhandledError();

  for (Error &E : Errors) {
    consumeError(std::move(E));
  }
}

LLVM_ATTRIBUTE_NORETURN void ErrorCollector::fatalUnhandledError() {
  errs() << "Program aborted due to unhandled Error(s):\n";
  log(errs());
  errs() << "\n";
  abort();
}