DiagnosticInfo.cpp | Explore in Territory

//===- llvm/IR/DiagnosticInfo.cpp - Diagnostic Definitions ------*- C++ -*-===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// This file defines the different classes involved in low level diagnostics.
//
// Diagnostics reporting is still done as part of the LLVMContext.
//===----------------------------------------------------------------------===//

#include "llvm/IR/DiagnosticInfo.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/Twine.h"
#include "llvm/ADT/iterator_range.h"
#include "llvm/Demangle/Demangle.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/DebugInfoMetadata.h"
#include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/DiagnosticPrinter.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/GlobalValue.h"
#include "llvm/IR/Instruction.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Metadata.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/Type.h"
#include "llvm/IR/Value.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/InstructionCost.h"
#include "llvm/Support/Path.h"
#include "llvm/Support/ScopedPrinter.h"
#include "llvm/Support/raw_ostream.h"
#include <atomic>
#include <string>

usingnamespacellvm;

int llvm::getNextAvailablePluginDiagnosticKind() { … }

const char *OptimizationRemarkAnalysis::AlwaysPrint = …;

DiagnosticInfoInlineAsm::DiagnosticInfoInlineAsm(const Instruction &I,
                                                 const Twine &MsgStr,
                                                 DiagnosticSeverity Severity)
    : … { … }

void DiagnosticInfoInlineAsm::print(DiagnosticPrinter &DP) const { … }

DiagnosticInfoResourceLimit::DiagnosticInfoResourceLimit(
    const Function &Fn, const char *ResourceName, uint64_t ResourceSize,
    uint64_t ResourceLimit, DiagnosticSeverity Severity, DiagnosticKind Kind)
    : … { … }

void DiagnosticInfoResourceLimit::print(DiagnosticPrinter &DP) const { … }

void DiagnosticInfoDebugMetadataVersion::print(DiagnosticPrinter &DP) const { … }

void DiagnosticInfoIgnoringInvalidDebugMetadata::print(
    DiagnosticPrinter &DP) const { … }

void DiagnosticInfoSampleProfile::print(DiagnosticPrinter &DP) const { … }

void DiagnosticInfoPGOProfile::print(DiagnosticPrinter &DP) const { … }

void DiagnosticInfo::anchor() { … }
void DiagnosticInfoStackSize::anchor() { … }
void DiagnosticInfoWithLocationBase::anchor() { … }
void DiagnosticInfoIROptimization::anchor() { … }

DiagnosticLocation::DiagnosticLocation(const DebugLoc &DL) { … }

DiagnosticLocation::DiagnosticLocation(const DISubprogram *SP) { … }

StringRef DiagnosticLocation::getRelativePath() const { … }

std::string DiagnosticLocation::getAbsolutePath() const { … }

std::string DiagnosticInfoWithLocationBase::getAbsolutePath() const { … }

void DiagnosticInfoWithLocationBase::getLocation(StringRef &RelativePath,
                                                 unsigned &Line,
                                                 unsigned &Column) const { … }

std::string DiagnosticInfoWithLocationBase::getLocationStr() const { … }

DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key,
                                                   const Value *V)
    : … { … }

DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, const Type *T)
    : … { … }

DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, StringRef S)
    : … { … }

DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, int N)
    : … { … }

DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, float N)
    : … { … }

DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, long N)
    : … { … }

DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, long long N)
    : … { … }

DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, unsigned N)
    : … { … }

DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key,
                                                   unsigned long N)
    : … { … }

DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key,
                                                   unsigned long long N)
    : … { … }

DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key,
                                                   ElementCount EC)
    : … { … }

DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key,
                                                   InstructionCost C)
    : … { … }

DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, DebugLoc Loc)
    : … { … }

void DiagnosticInfoOptimizationBase::print(DiagnosticPrinter &DP) const { … }

OptimizationRemark::OptimizationRemark(const char *PassName,
                                       StringRef RemarkName,
                                       const DiagnosticLocation &Loc,
                                       const Value *CodeRegion)
    : … { … }

OptimizationRemark::OptimizationRemark(const char *PassName,
                                       StringRef RemarkName,
                                       const Instruction *Inst)
    : … { … }

static const BasicBlock *getFirstFunctionBlock(const Function *Func) { … }

OptimizationRemark::OptimizationRemark(const char *PassName,
                                       StringRef RemarkName,
                                       const Function *Func)
    : … { … }

bool OptimizationRemark::isEnabled() const { … }

OptimizationRemarkMissed::OptimizationRemarkMissed(
    const char *PassName, StringRef RemarkName, const DiagnosticLocation &Loc,
    const Value *CodeRegion)
    : … { … }

OptimizationRemarkMissed::OptimizationRemarkMissed(const char *PassName,
                                                   StringRef RemarkName,
                                                   const Instruction *Inst)
    : … { … }

OptimizationRemarkMissed::OptimizationRemarkMissed(const char *PassName,
                                                   StringRef RemarkName,
                                                   const Function *Func)
    : … { … }

bool OptimizationRemarkMissed::isEnabled() const { … }

OptimizationRemarkAnalysis::OptimizationRemarkAnalysis(
    const char *PassName, StringRef RemarkName, const DiagnosticLocation &Loc,
    const Value *CodeRegion)
    : … { … }

OptimizationRemarkAnalysis::OptimizationRemarkAnalysis(const char *PassName,
                                                       StringRef RemarkName,
                                                       const Instruction *Inst)
    : … { … }

OptimizationRemarkAnalysis::OptimizationRemarkAnalysis(
    enum DiagnosticKind Kind, const char *PassName, StringRef RemarkName,
    const DiagnosticLocation &Loc, const Value *CodeRegion)
    : … { … }

OptimizationRemarkAnalysis::OptimizationRemarkAnalysis(const char *PassName,
                                                       StringRef RemarkName,
                                                       const Function *Func)
    : … { … }

bool OptimizationRemarkAnalysis::isEnabled() const { … }

void DiagnosticInfoMIRParser::print(DiagnosticPrinter &DP) const { … }

void DiagnosticInfoSrcMgr::print(DiagnosticPrinter &DP) const { … }

DiagnosticInfoOptimizationFailure::DiagnosticInfoOptimizationFailure(
    const char *PassName, StringRef RemarkName, const DiagnosticLocation &Loc,
    const Value *CodeRegion)
    : … { … }

bool DiagnosticInfoOptimizationFailure::isEnabled() const { … }

void DiagnosticInfoUnsupported::print(DiagnosticPrinter &DP) const { … }

void DiagnosticInfoInstrumentation::print(DiagnosticPrinter &DP) const { … }

void DiagnosticInfoISelFallback::print(DiagnosticPrinter &DP) const { … }

void DiagnosticInfoOptimizationBase::insert(StringRef S) { … }

void DiagnosticInfoOptimizationBase::insert(Argument A) { … }

void DiagnosticInfoOptimizationBase::insert(setIsVerbose V) { … }

void DiagnosticInfoOptimizationBase::insert(setExtraArgs EA) { … }

std::string DiagnosticInfoOptimizationBase::getMsg() const { … }

DiagnosticInfoMisExpect::DiagnosticInfoMisExpect(const Instruction *Inst,
                                                 Twine &Msg)
    : … { … }

void DiagnosticInfoMisExpect::print(DiagnosticPrinter &DP) const { … }

void OptimizationRemarkAnalysisFPCommute::anchor() { … }
void OptimizationRemarkAnalysisAliasing::anchor() { … }

void llvm::diagnoseDontCall(const CallInst &CI) { … }

void DiagnosticInfoDontCall::print(DiagnosticPrinter &DP) const { … }
llvm/llvm/lib/IR/DiagnosticInfo.cpp
