return DefaultMaxUsesToExplore;
}
-CaptureTracker::~CaptureTracker() {}
+CaptureTracker::~CaptureTracker() = default;
bool CaptureTracker::shouldExplore(const Use *U) { return true; }
//===--------------------------------------------------------------------===//
// DDGNode implementation
//===--------------------------------------------------------------------===//
-DDGNode::~DDGNode() {}
+DDGNode::~DDGNode() = default;
bool DDGNode::collectInstructions(
llvm::function_ref<bool(Instruction *)> const &Pred,
/// should provide this much alignment at least, but this makes it clear we
/// specifically rely on this amount of alignment.
struct alignas(8) AlignedMap {
- AlignedMap() {}
- AlignedMap(const AlignedMap &Arg) : Map(Arg.Map) {}
+ AlignedMap() = default;
+ AlignedMap(const AlignedMap &Arg) = default;
GlobalInfoMapType Map;
};
"Insufficient low bits to store our flag and ModRef info.");
public:
- FunctionInfo() {}
+ FunctionInfo() = default;
~FunctionInfo() {
delete Info.getPointer();
}
}
}
-GlobalsAAResult::~GlobalsAAResult() {}
+GlobalsAAResult::~GlobalsAAResult() = default;
/*static*/ GlobalsAAResult GlobalsAAResult::analyzeModule(
Module &M, std::function<const TargetLibraryInfo &(Function &F)> GetTLI,
friend class InstVisitor<CallAnalyzer, bool>;
protected:
- virtual ~CallAnalyzer() {}
+ virtual ~CallAnalyzer() = default;
/// The TargetTransformInfo available for this compilation.
const TargetTransformInfo &TTI;
return None;
}
- virtual ~InlineCostCallAnalyzer() {}
+ virtual ~InlineCostCallAnalyzer() = default;
int getThreshold() const { return Threshold; }
int getCost() const { return Cost; }
Optional<CostBenefitPair> getCostBenefitPair() { return CostBenefit; }
namespace llvm {
class TFModelEvaluator {};
} // namespace llvm
-InlineSizeEstimatorAnalysis::InlineSizeEstimatorAnalysis() {}
+InlineSizeEstimatorAnalysis::InlineSizeEstimatorAnalysis() = default;
InlineSizeEstimatorAnalysis ::InlineSizeEstimatorAnalysis(
InlineSizeEstimatorAnalysis &&) {}
-InlineSizeEstimatorAnalysis::~InlineSizeEstimatorAnalysis() {}
+InlineSizeEstimatorAnalysis::~InlineSizeEstimatorAnalysis() = default;
InlineSizeEstimatorAnalysis::Result
InlineSizeEstimatorAnalysis::run(const Function &F,
FunctionAnalysisManager &FAM) {
struct generic_def_path_iterator
: public iterator_facade_base<generic_def_path_iterator<T, Walker>,
std::forward_iterator_tag, T *> {
- generic_def_path_iterator() {}
+ generic_def_path_iterator() = default;
generic_def_path_iterator(Walker *W, ListIndex N) : W(W), N(N) {}
T &operator*() const { return curNode(); }
[&](const BasicBlock &BB) { LoopPO.appendBlock(BB); });
}
-SyncDependenceAnalysis::~SyncDependenceAnalysis() {}
+SyncDependenceAnalysis::~SyncDependenceAnalysis() = default;
// divergence propagator for reducible CFGs
struct DivergencePropagator {
TargetTransformInfo::TargetTransformInfo(const DataLayout &DL)
: TTIImpl(new Model<NoTTIImpl>(NoTTIImpl(DL))) {}
-TargetTransformInfo::~TargetTransformInfo() {}
+TargetTransformInfo::~TargetTransformInfo() = default;
TargetTransformInfo::TargetTransformInfo(TargetTransformInfo &&Arg)
: TTIImpl(std::move(Arg.TTIImpl)) {}
}
}
-TargetTransformInfo::Concept::~Concept() {}
+TargetTransformInfo::Concept::~Concept() = default;
TargetIRAnalysis::TargetIRAnalysis() : TTICallback(&getDefaultTTI) {}
return false;
}
-AddressesMap::~AddressesMap() {}
+AddressesMap::~AddressesMap() = default;
-DwarfEmitter::~DwarfEmitter() {}
+DwarfEmitter::~DwarfEmitter() = default;
static Optional<StringRef> StripTemplateParameters(StringRef Name) {
// We are looking for template parameters to strip from Name. e.g.
ContinuationRecordBuilder::ContinuationRecordBuilder()
: SegmentWriter(Buffer), Mapping(SegmentWriter) {}
-ContinuationRecordBuilder::~ContinuationRecordBuilder() {}
+ContinuationRecordBuilder::~ContinuationRecordBuilder() = default;
void ContinuationRecordBuilder::begin(ContinuationRecordKind RecordKind) {
assert(!Kind.hasValue());
using namespace llvm::codeview;
-DebugSubsectionRef::~DebugSubsectionRef() {}
+DebugSubsectionRef::~DebugSubsectionRef() = default;
-DebugSubsection::~DebugSubsection() {}
+DebugSubsection::~DebugSubsection() = default;
SimpleTypeSerializer::SimpleTypeSerializer() : ScratchBuffer(MaxRecordLength) {}
-SimpleTypeSerializer::~SimpleTypeSerializer() {}
+SimpleTypeSerializer::~SimpleTypeSerializer() = default;
template <typename T>
ArrayRef<uint8_t> SimpleTypeSerializer::serialize(T &Record) {
Layout.Mod = ModIndex;
}
-DbiModuleDescriptorBuilder::~DbiModuleDescriptorBuilder() {}
+DbiModuleDescriptorBuilder::~DbiModuleDescriptorBuilder() = default;
uint16_t DbiModuleDescriptorBuilder::getStreamIndex() const {
return Layout.ModDiStream;
PdbDllVersion(0), PdbDllRbld(0), Flags(0), MachineType(PDB_Machine::x86),
Header(nullptr) {}
-DbiStreamBuilder::~DbiStreamBuilder() {}
+DbiStreamBuilder::~DbiStreamBuilder() = default;
void DbiStreamBuilder::setVersionHeader(PdbRaw_DbiVer V) { VerHeader = V; }
: Msf(Msf), PSH(std::make_unique<GSIHashStreamBuilder>()),
GSH(std::make_unique<GSIHashStreamBuilder>()) {}
-GSIStreamBuilder::~GSIStreamBuilder() {}
+GSIStreamBuilder::~GSIStreamBuilder() = default;
uint32_t GSIStreamBuilder::calculatePublicsHashStreamSize() const {
uint32_t Size = 0;
: NativeRawSymbol(Session, PDB_SymType::Function, Id), Sym(Sym),
RecordOffset(Offset) {}
-NativeFunctionSymbol::~NativeFunctionSymbol() {}
+NativeFunctionSymbol::~NativeFunctionSymbol() = default;
void NativeFunctionSymbol::dump(raw_ostream &OS, int Indent,
PdbSymbolIdField ShowIdFields,
: NativeRawSymbol(Session, PDB_SymType::InlineSite, Id), Sym(Sym),
ParentAddr(ParentAddr) {}
-NativeInlineSiteSymbol::~NativeInlineSiteSymbol() {}
+NativeInlineSiteSymbol::~NativeInlineSiteSymbol() = default;
void NativeInlineSiteSymbol::dump(raw_ostream &OS, int Indent,
PdbSymbolIdField ShowIdFields,
const codeview::PublicSym32 &Sym)
: NativeRawSymbol(Session, PDB_SymType::PublicSymbol, Id), Sym(Sym) {}
-NativePublicSymbol::~NativePublicSymbol() {}
+NativePublicSymbol::~NativePublicSymbol() = default;
void NativePublicSymbol::dump(raw_ostream &OS, int Indent,
PdbSymbolIdField ShowIdFields,
: NativeRawSymbol(Session, PDB_SymType::Data, Id), Parent(Parent),
Record(std::move(Record)) {}
-NativeSymbolEnumerator::~NativeSymbolEnumerator() {}
+NativeSymbolEnumerator::~NativeSymbolEnumerator() = default;
void NativeSymbolEnumerator::dump(raw_ostream &OS, int Indent,
PdbSymbolIdField ShowIdFields,
codeview::ArrayRecord Record)
: NativeRawSymbol(Session, PDB_SymType::ArrayType, Id), Record(Record),
Index(TI) {}
-NativeTypeArray::~NativeTypeArray() {}
+NativeTypeArray::~NativeTypeArray() = default;
void NativeTypeArray::dump(raw_ostream &OS, int Indent,
PdbSymbolIdField ShowIdFields,
: NativeRawSymbol(PDBSession, PDB_SymType::BuiltinType, Id),
Session(PDBSession), Mods(Mods), Type(T), Length(L) {}
-NativeTypeBuiltin::~NativeTypeBuiltin() {}
+NativeTypeBuiltin::~NativeTypeBuiltin() = default;
void NativeTypeBuiltin::dump(raw_ostream &OS, int Indent,
PdbSymbolIdField ShowIdFields,
: NativeRawSymbol(Session, PDB_SymType::Enum, Id),
UnmodifiedType(&UnmodifiedType), Modifiers(std::move(Modifier)) {}
-NativeTypeEnum::~NativeTypeEnum() {}
+NativeTypeEnum::~NativeTypeEnum() = default;
void NativeTypeEnum::dump(raw_ostream &OS, int Indent,
PdbSymbolIdField ShowIdFields,
}
}
-NativeTypeFunctionSig::~NativeTypeFunctionSig() {}
+NativeTypeFunctionSig::~NativeTypeFunctionSig() = default;
void NativeTypeFunctionSig::initializeArgList(codeview::TypeIndex ArgListTI) {
TpiStream &Tpi = cantFail(Session.getPDBFile().getPDBTpiStream());
: NativeRawSymbol(Session, PDB_SymType::PointerType, Id), TI(TI),
Record(std::move(Record)) {}
-NativeTypePointer::~NativeTypePointer() {}
+NativeTypePointer::~NativeTypePointer() = default;
void NativeTypePointer::dump(raw_ostream &OS, int Indent,
PdbSymbolIdField ShowIdFields,
: NativeRawSymbol(Session, PDB_SymType::Typedef, Id),
Record(std::move(Typedef)) {}
-NativeTypeTypedef::~NativeTypeTypedef() {}
+NativeTypeTypedef::~NativeTypeTypedef() = default;
void NativeTypeTypedef::dump(raw_ostream &OS, int Indent,
PdbSymbolIdField ShowIdFields,
: NativeRawSymbol(Session, PDB_SymType::UDT, Id),
UnmodifiedType(&UnmodifiedType), Modifiers(std::move(Modifier)) {}
-NativeTypeUDT::~NativeTypeUDT() {}
+NativeTypeUDT::~NativeTypeUDT() = default;
void NativeTypeUDT::dump(raw_ostream &OS, int Indent,
PdbSymbolIdField ShowIdFields,
: NativeRawSymbol(Session, PDB_SymType::VTableShape, Id), TI(TI),
Record(std::move(SR)) {}
-NativeTypeVTShape::~NativeTypeVTShape() {}
+NativeTypeVTShape::~NativeTypeVTShape() = default;
void NativeTypeVTShape::dump(raw_ostream &OS, int Indent,
PdbSymbolIdField ShowIdFields,
: Allocator(Allocator), InjectedSourceHashTraits(Strings),
InjectedSourceTable(2) {}
-PDBFileBuilder::~PDBFileBuilder() {}
+PDBFileBuilder::~PDBFileBuilder() = default;
Error PDBFileBuilder::initialize(uint32_t BlockSize) {
auto ExpectedMsf = MSFBuilder::create(Allocator, BlockSize);
SymbolStream::SymbolStream(std::unique_ptr<MappedBlockStream> Stream)
: Stream(std::move(Stream)) {}
-SymbolStream::~SymbolStream() {}
+SymbolStream::~SymbolStream() = default;
Error SymbolStream::reload() {
BinaryStreamReader Reader(*Stream);
}
struct RegisteredObjectInfo {
- RegisteredObjectInfo() {}
+ RegisteredObjectInfo() = default;
RegisteredObjectInfo(std::size_t Size, jit_code_entry *Entry,
OwningBinary<ObjectFile> Obj)
public:
/// Instantiates the JIT service.
- GDBJITRegistrationListener() {}
+ GDBJITRegistrationListener() = default;
/// Unregisters each object that was previously registered and releases all
/// internal resources.
std::vector<void *> Allocations;
public:
- AllocaHolder() {}
+ AllocaHolder() = default;
// Make this type move-only.
AllocaHolder(AllocaHolder &&) = default;
return Error::success();
}
-EHFrameRegistrar::~EHFrameRegistrar() {}
+EHFrameRegistrar::~EHFrameRegistrar() = default;
Error InProcessEHFrameRegistrar::registerEHFrames(
orc::ExecutorAddrRange EHFrameSection) {
StringRef ELFLinkGraphBuilderBase::CommonSectionName(".common");
ArrayRef<const char *> ELFLinkGraphBuilderBase::DwarfSectionNames = DWSecNames;
-ELFLinkGraphBuilderBase::~ELFLinkGraphBuilderBase() {}
+ELFLinkGraphBuilderBase::~ELFLinkGraphBuilderBase() = default;
} // end namespace jitlink
} // end namespace llvm
void JITLinkAsyncLookupContinuation::anchor() {}
-JITLinkContext::~JITLinkContext() {}
+JITLinkContext::~JITLinkContext() = default;
bool JITLinkContext::shouldAddDefaultTargetPasses(const Triple &TT) const {
return true;
namespace llvm {
namespace jitlink {
-JITLinkerBase::~JITLinkerBase() {}
+JITLinkerBase::~JITLinkerBase() = default;
void JITLinkerBase::linkPhase1(std::unique_ptr<JITLinkerBase> Self) {
SimpleSegmentAlloc::SimpleSegmentAlloc(SimpleSegmentAlloc &&) = default;
SimpleSegmentAlloc &
SimpleSegmentAlloc::operator=(SimpleSegmentAlloc &&) = default;
-SimpleSegmentAlloc::~SimpleSegmentAlloc() {}
+SimpleSegmentAlloc::~SimpleSegmentAlloc() = default;
SimpleSegmentAlloc::SegmentInfo SimpleSegmentAlloc::getSegInfo(AllocGroup AG) {
auto I = ContentBlocks.find(AG);
namespace llvm {
namespace jitlink {
-MachOLinkGraphBuilder::~MachOLinkGraphBuilder() {}
+MachOLinkGraphBuilder::~MachOLinkGraphBuilder() = default;
Expected<std::unique_ptr<LinkGraph>> MachOLinkGraphBuilder::buildGraph() {
class OwningModuleContainer {
public:
- OwningModuleContainer() {
- }
+ OwningModuleContainer() = default;
~OwningModuleContainer() {
freeModulePtrSet(AddedModules);
freeModulePtrSet(LoadedModules);
JDAndFlag.store(Val);
}
-ResourceManager::~ResourceManager() {}
+ResourceManager::~ResourceManager() = default;
ResourceTrackerDefunct::ResourceTrackerDefunct(ResourceTrackerSP RT)
: RT(std::move(RT)) {}
LookupSet(std::move(LookupSet)), RequiredState(RequiredState) {
DefGeneratorCandidates = this->LookupSet;
}
- virtual ~InProgressLookupState() {}
+ virtual ~InProgressLookupState() = default;
virtual void complete(std::unique_ptr<InProgressLookupState> IPLS) = 0;
virtual void fail(Error Err) = 0;
ES.OL_applyQueryPhase1(std::move(IPLS), std::move(Err));
}
-DefinitionGenerator::~DefinitionGenerator() {}
+DefinitionGenerator::~DefinitionGenerator() = default;
JITDylib::~JITDylib() {
LLVM_DEBUG(dbgs() << "Destroying JITDylib " << getName() << "\n");
}
}
-Platform::~Platform() {}
+Platform::~Platform() = default;
Expected<DenseMap<JITDylib *, SymbolMap>> Platform::lookupInitSymbols(
ExecutionSession &ES,
public:
virtual void setTargetMemoryRange(SectionRange Range) = 0;
virtual void dump(raw_ostream &OS, StringRef Name) {}
- virtual ~DebugObjectSection() {}
+ virtual ~DebugObjectSection() = default;
};
template <typename ELFT>
MachODebugObjectSynthesizerBase(LinkGraph &G, ExecutorAddr RegisterActionAddr)
: G(G), RegisterActionAddr(RegisterActionAddr) {}
- virtual ~MachODebugObjectSynthesizerBase() {}
+ virtual ~MachODebugObjectSynthesizerBase() = default;
Error preserveDebugSections() {
if (G.findSectionByName(SynthDebugSectionName)) {
namespace llvm {
namespace orc {
-EPCIndirectionUtils::ABISupport::~ABISupport() {}
+EPCIndirectionUtils::ABISupport::~ABISupport() = default;
Expected<std::unique_ptr<EPCIndirectionUtils>>
EPCIndirectionUtils::Create(ExecutorProcessControl &EPC) {
namespace llvm {
namespace orc {
-ExecutorProcessControl::MemoryAccess::~MemoryAccess() {}
+ExecutorProcessControl::MemoryAccess::~MemoryAccess() = default;
-ExecutorProcessControl::~ExecutorProcessControl() {}
+ExecutorProcessControl::~ExecutorProcessControl() = default;
SelfExecutorProcessControl::SelfExecutorProcessControl(
std::shared_ptr<SymbolStringPool> SSP, std::unique_ptr<TaskDispatcher> D,
namespace llvm {
namespace orc {
-IRCompileLayer::IRCompiler::~IRCompiler() {}
+IRCompileLayer::IRCompiler::~IRCompiler() = default;
IRCompileLayer::IRCompileLayer(ExecutionSession &ES, ObjectLayer &BaseLayer,
std::unique_ptr<IRCompiler> Compile)
namespace llvm {
namespace orc {
-TrampolinePool::~TrampolinePool() {}
+TrampolinePool::~TrampolinePool() = default;
void IndirectStubsManager::anchor() {}
Expected<JITTargetAddress>
J.InitHelperTransformLayer->setTransform(std::move(T));
}
-LLJIT::PlatformSupport::~PlatformSupport() {}
+LLJIT::PlatformSupport::~PlatformSupport() = default;
Error LLJITBuilderState::prepareForConstruction() {
namespace llvm {
namespace orc {
-IRLayer::~IRLayer() {}
+IRLayer::~IRLayer() = default;
Error IRLayer::add(ResourceTrackerSP RT, ThreadSafeModule TSM) {
assert(RT && "RT can not be null");
ObjectLayer::ObjectLayer(ExecutionSession &ES) : ES(ES) {}
-ObjectLayer::~ObjectLayer() {}
+ObjectLayer::~ObjectLayer() = default;
Error ObjectLayer::add(ResourceTrackerSP RT, std::unique_ptr<MemoryBuffer> O,
MaterializationUnit::Interface I) {
DenseMap<SymbolStringPtr, SymbolNameSet> InternalNamedSymbolDeps;
};
-ObjectLinkingLayer::Plugin::~Plugin() {}
+ObjectLinkingLayer::Plugin::~Plugin() = default;
char ObjectLinkingLayer::ID;
} // end namespace SimpleRemoteEPCDefaultBootstrapSymbolNames
-SimpleRemoteEPCTransportClient::~SimpleRemoteEPCTransportClient() {}
-SimpleRemoteEPCTransport::~SimpleRemoteEPCTransport() {}
+SimpleRemoteEPCTransportClient::~SimpleRemoteEPCTransportClient() = default;
+SimpleRemoteEPCTransport::~SimpleRemoteEPCTransport() = default;
Expected<std::unique_ptr<FDSimpleRemoteEPCTransport>>
FDSimpleRemoteEPCTransport::Create(SimpleRemoteEPCTransportClient &C, int InFD,
namespace llvm {
namespace orc {
-ExecutorBootstrapService::~ExecutorBootstrapService() {}
+ExecutorBootstrapService::~ExecutorBootstrapService() = default;
-SimpleRemoteEPCServer::Dispatcher::~Dispatcher() {}
+SimpleRemoteEPCServer::Dispatcher::~Dispatcher() = default;
#if LLVM_ENABLE_THREADS
void SimpleRemoteEPCServer::ThreadDispatcher::dispatch(
const char *GenericNamedTask::DefaultDescription = "Generic Task";
void Task::anchor() {}
-TaskDispatcher::~TaskDispatcher() {}
+TaskDispatcher::~TaskDispatcher() = default;
void InPlaceTaskDispatcher::dispatch(std::unique_ptr<Task> T) { T->run(); }
namespace llvm {
-RTDyldMemoryManager::~RTDyldMemoryManager() {}
+RTDyldMemoryManager::~RTDyldMemoryManager() = default;
#if defined(HAVE_REGISTER_FRAME) && defined(HAVE_DEREGISTER_FRAME) && \
!defined(__SEH__) && !defined(__USING_SJLJ_EXCEPTIONS__)
}
// Empty out-of-line virtual destructor as the key function.
-RuntimeDyldImpl::~RuntimeDyldImpl() {}
+RuntimeDyldImpl::~RuntimeDyldImpl() = default;
// Pin LoadedObjectInfo's vtables to this file.
void RuntimeDyld::LoadedObjectInfo::anchor() {}
ProcessAllSections = false;
}
-RuntimeDyld::~RuntimeDyld() {}
+RuntimeDyld::~RuntimeDyld() = default;
static std::unique_ptr<RuntimeDyldCOFF>
createRuntimeDyldCOFF(
std::move(GetGOTInfo), Endianness, Disassembler, InstPrinter,
ErrStream)) {}
-RuntimeDyldChecker::~RuntimeDyldChecker() {}
+RuntimeDyldChecker::~RuntimeDyldChecker() = default;
bool RuntimeDyldChecker::check(StringRef CheckExpr) const {
return Impl->check(CheckExpr);
RuntimeDyldELF::RuntimeDyldELF(RuntimeDyld::MemoryManager &MemMgr,
JITSymbolResolver &Resolver)
: RuntimeDyldImpl(MemMgr, Resolver), GOTSectionID(0), CurrentGOTIndex(0) {}
-RuntimeDyldELF::~RuntimeDyldELF() {}
+RuntimeDyldELF::~RuntimeDyldELF() = default;
void RuntimeDyldELF::registerEHFrames() {
for (int i = 0, e = UnregisteredEHFrameSections.size(); i != e; ++i) {
}
}
-SectionMemoryManager::MemoryMapper::~MemoryMapper() {}
+SectionMemoryManager::MemoryMapper::~MemoryMapper() = default;
void SectionMemoryManager::anchor() {}
OS << '>';
}
-AbstractSlotTrackerStorage::~AbstractSlotTrackerStorage() {}
+AbstractSlotTrackerStorage::~AbstractSlotTrackerStorage() = default;
namespace llvm {
/// prints a Metadata as operand.
virtual void onWriteMetadataAsOperand(const Metadata *) {}
- virtual ~AsmWriterContext() {}
+ virtual ~AsmWriterContext() = default;
};
} // end anonymous namespace
// folding and other libcall simplification. The nobuiltin attribute on the
// callsite has the same effect.
struct StrictFPUpgradeVisitor : public InstVisitor<StrictFPUpgradeVisitor> {
- StrictFPUpgradeVisitor() {}
+ StrictFPUpgradeVisitor() = default;
void visitCallBase(CallBase &Call) {
if (!Call.isStrictFP())
/// while introducing only minor runtime overhead.
class ShadowStackGC : public GCStrategy {
public:
- ShadowStackGC() {}
+ ShadowStackGC() = default;
};
/// A GCStrategy which serves as an example for the usage of a statepoint based
#include "llvm/IR/GVMaterializer.h"
using namespace llvm;
-GVMaterializer::~GVMaterializer() {}
+GVMaterializer::~GVMaterializer() = default;
return CreateAlignmentAssumptionHelper(DL, PtrValue, Alignment, OffsetValue);
}
-IRBuilderDefaultInserter::~IRBuilderDefaultInserter() {}
-IRBuilderCallbackInserter::~IRBuilderCallbackInserter() {}
-IRBuilderFolder::~IRBuilderFolder() {}
+IRBuilderDefaultInserter::~IRBuilderDefaultInserter() = default;
+IRBuilderCallbackInserter::~IRBuilderCallbackInserter() = default;
+IRBuilderFolder::~IRBuilderFolder() = default;
void ConstantFolder::anchor() {}
void NoFolder::anchor() {}
PM->add(this);
}
-legacy::PassManagerBase::~PassManagerBase() {}
+legacy::PassManagerBase::~PassManagerBase() = default;
: Conf(Conf), CombinedIndex(CombinedIndex),
ModuleToDefinedGVSummaries(ModuleToDefinedGVSummaries) {}
- virtual ~ThinBackendProc() {}
+ virtual ~ThinBackendProc() = default;
virtual Error start(
unsigned Task, BitcodeModule BM,
const FunctionImporter::ImportMapTy &ImportList,
};
}
-LTOCodeGenerator::~LTOCodeGenerator() {}
+LTOCodeGenerator::~LTOCodeGenerator() = default;
void LTOCodeGenerator::setAsmUndefinedRefs(LTOModule *Mod) {
for (const StringRef &Undef : Mod->getAsmUndefinedRefs())
SymTab.addModule(Mod.get());
}
-LTOModule::~LTOModule() {}
+LTOModule::~LTOModule() = default;
/// isBitcodeFile - Returns 'true' if the file (or memory contents) is LLVM
/// bitcode.
return std::string();
}
-LineEditor::CompleterConcept::~CompleterConcept() {}
-LineEditor::ListCompleterConcept::~ListCompleterConcept() {}
+LineEditor::CompleterConcept::~CompleterConcept() = default;
+LineEditor::ListCompleterConcept::~ListCompleterConcept() = default;
std::string LineEditor::ListCompleterConcept::getCommonPrefix(
const std::vector<Completion> &Comps) {
using namespace llvm;
using namespace llvm::codeview;
-CodeViewContext::CodeViewContext() {}
+CodeViewContext::CodeViewContext() = default;
CodeViewContext::~CodeViewContext() {
// If someone inserted strings into the string table but never actually
/* MultiSymbolsAllowed */ true, ".dwmac", XCOFF::SSUBTYP_DWMAC);
}
-MCObjectFileInfo::~MCObjectFileInfo() {}
+MCObjectFileInfo::~MCObjectFileInfo() = default;
void MCObjectFileInfo::initMCObjectFileInfo(MCContext &MCCtx, bool PIC,
bool LargeCodeModel) {
setAllowAutoPadding(Assembler->getBackend().allowAutoPadding());
}
-MCObjectStreamer::~MCObjectStreamer() {}
+MCObjectStreamer::~MCObjectStreamer() = default;
// AssemblerPtr is used for evaluation of expressions and causes
// difference between asm and object outputs. Return nullptr to in
}
public:
- GOFFAsmParser() {}
+ GOFFAsmParser() = default;
void Initialize(MCAsmParser &Parser) override {
// Call the base implementation.
"asm-macro-max-nesting-depth", cl::init(20), cl::Hidden,
cl::desc("The maximum nesting depth allowed for assembly macros."));
-MCAsmParser::MCAsmParser() {}
+MCAsmParser::MCAsmParser() = default;
MCAsmParser::~MCAsmParser() = default;
}
public:
- XCOFFAsmParser() {}
+ XCOFFAsmParser() = default;
void Initialize(MCAsmParser &P) override {
Parser = &P;
SectionStack.push_back(std::pair<MCSectionSubPair, MCSectionSubPair>());
}
-MCStreamer::~MCStreamer() {}
+MCStreamer::~MCStreamer() = default;
void MCStreamer::reset() {
DwarfFrameInfos.clear();
namespace llvm {
namespace WinEH {
-UnwindEmitter::~UnwindEmitter() {}
+UnwindEmitter::~UnwindEmitter() = default;
}
}
Index = UninitializedIndex;
}
- virtual ~SectionEntry() {}
+ virtual ~SectionEntry() = default;
};
// Represents the data related to a section excluding the csects that make up
Group->clear();
}
- virtual ~CsectSectionEntry() {}
+ virtual ~CsectSectionEntry() = default;
};
struct DwarfSectionEntry : public SectionEntry {
DwarfSectionEntry(DwarfSectionEntry &&s) = default;
- virtual ~DwarfSectionEntry() {}
+ virtual ~DwarfSectionEntry() = default;
};
class XCOFFObjectWriter : public MCObjectWriter {
namespace llvm {
namespace mca {
-CustomBehaviour::~CustomBehaviour() {}
+CustomBehaviour::~CustomBehaviour() = default;
unsigned CustomBehaviour::checkCustomHazard(ArrayRef<InstRef> IssuedInst,
const InstRef &IR) {
}
}
-LSUnitBase::~LSUnitBase() {}
+LSUnitBase::~LSUnitBase() = default;
void LSUnitBase::cycleEvent() {
for (const std::pair<unsigned, std::unique_ptr<MemoryGroup>> &G : Groups)
SymTab.addModule(M.get());
}
-IRObjectFile::~IRObjectFile() {}
+IRObjectFile::~IRObjectFile() = default;
static ModuleSymbolTable::Symbol getSym(DataRefImpl &Symb) {
return *reinterpret_cast<ModuleSymbolTable::Symbol *>(Symb.p);
Out << formatv("*** IR Pass {0} on {1} ignored ***\n", PassID, Name);
}
-IRChangedPrinter::~IRChangedPrinter() {}
+IRChangedPrinter::~IRChangedPrinter() = default;
void IRChangedPrinter::registerCallbacks(PassInstrumentationCallbacks &PIC) {
if (PrintChanged == ChangePrinter::PrintChangedVerbose ||
});
}
-InLineChangePrinter::~InLineChangePrinter() {}
+InLineChangePrinter::~InLineChangePrinter() = default;
void InLineChangePrinter::generateIRRepresentation(Any IR, StringRef PassID,
IRDataT<EmptyData> &D) {
static sys::SmartMutex<true> OutputMutex;
-CodeGenCoverage::CodeGenCoverage() {}
+CodeGenCoverage::CodeGenCoverage() = default;
void CodeGenCoverage::setCovered(uint64_t RuleID) {
if (RuleCoverage.size() <= RuleID)
public:
explicit HelpPrinter(bool showHidden) : ShowHidden(showHidden) {}
- virtual ~HelpPrinter() {}
+ virtual ~HelpPrinter() = default;
// Invoke the printer.
void operator=(bool Value) {
static void installExceptionOrSignalHandlers();
static void uninstallExceptionOrSignalHandlers();
-CrashRecoveryContextCleanup::~CrashRecoveryContextCleanup() {}
+CrashRecoveryContextCleanup::~CrashRecoveryContextCleanup() = default;
CrashRecoveryContext::CrashRecoveryContext() {
// On Windows, if abort() was previously triggered (and caught by a previous
#include <set>
using namespace llvm;
-DeltaAlgorithm::~DeltaAlgorithm() {
-}
+DeltaAlgorithm::~DeltaAlgorithm() = default;
bool DeltaAlgorithm::GetTestResult(const changeset_ty &Changes) {
if (FailedTestsCache.count(Changes))
// MemoryBuffer implementation itself.
//===----------------------------------------------------------------------===//
-MemoryBuffer::~MemoryBuffer() { }
+MemoryBuffer::~MemoryBuffer() = default;
/// init - Initialize this MemoryBuffer as a reference to externally allocated
/// memory, memory that we know is already null terminated.
return MemoryBufferRef(Data, Identifier);
}
-SmallVectorMemoryBuffer::~SmallVectorMemoryBuffer() {}
+SmallVectorMemoryBuffer::~SmallVectorMemoryBuffer() = default;
return true;
}
-SpecialCaseList::~SpecialCaseList() {}
+SpecialCaseList::~SpecialCaseList() = default;
bool SpecialCaseList::inSection(StringRef Section, StringRef Prefix,
StringRef Query, StringRef Category) const {
InitializeCOMRAII::InitializeCOMRAII(COMThreadingMode Threading,
bool SpeedOverMemory) {}
-InitializeCOMRAII::~InitializeCOMRAII() {}
+InitializeCOMRAII::~InitializeCOMRAII() = default;
}
}
void dump() const;
- RecordsEntry() {}
+ RecordsEntry() = default;
RecordsEntry(std::unique_ptr<Record> Rec) : Rec(std::move(Rec)) {}
RecordsEntry(std::unique_ptr<ForeachLoop> Loop)
: Loop(std::move(Loop)) {}
ShuffleVectorPseudo(unsigned Opc, Register Dst,
std::initializer_list<SrcOp> SrcOps)
: Opc(Opc), Dst(Dst), SrcOps(SrcOps){};
- ShuffleVectorPseudo() {}
+ ShuffleVectorPseudo() = default;
};
/// Check if a vector shuffle corresponds to a REV instruction with the
class ExportClustering : public ScheduleDAGMutation {
public:
- ExportClustering() {}
+ ExportClustering() = default;
void apply(ScheduleDAGInstrs *DAG) override;
};
class MetadataStreamer {
public:
- virtual ~MetadataStreamer(){};
+ virtual ~MetadataStreamer() = default;
virtual bool emitTo(AMDGPUTargetStreamer &TargetStreamer) = 0;
class AMDGPULibFuncImpl : public AMDGPULibFuncBase {
public:
- AMDGPULibFuncImpl() {}
- virtual ~AMDGPULibFuncImpl() {}
+ AMDGPULibFuncImpl() = default;
+ virtual ~AMDGPULibFuncImpl() = default;
/// Get unmangled name for mangled library function and name for unmangled
/// library function.
class AMDGPUMIRFormatter final : public MIRFormatter {
public:
- AMDGPUMIRFormatter() {}
+ AMDGPUMIRFormatter() = default;
virtual ~AMDGPUMIRFormatter() = default;
/// Implement target specific parsing of target custom pseudo source value.
/// \p WavefrontSize.
AMDGPUDwarfFlavour getAMDGPUDwarfFlavour() const;
- virtual ~AMDGPUSubtarget() {}
+ virtual ~AMDGPUSubtarget() = default;
};
} // end namespace llvm
AMDGPUInstrPostProcess(const MCSubtargetInfo &STI, const MCInstrInfo &MCII)
: InstrPostProcess(STI, MCII) {}
- ~AMDGPUInstrPostProcess() {}
+ ~AMDGPUInstrPostProcess() = default;
void postProcessInstruction(std::unique_ptr<Instruction> &Inst,
const MCInst &MCI) override;
AMDGPUCustomBehaviour(const MCSubtargetInfo &STI,
const mca::SourceMgr &SrcMgr, const MCInstrInfo &MCII);
- ~AMDGPUCustomBehaviour() {}
+ ~AMDGPUCustomBehaviour() = default;
/// This method is used to determine if an instruction
/// should be allowed to be dispatched. The return value is
/// how many cycles until the instruction can be dispatched.
unsigned LgkmCnt = ~0u;
unsigned VsCnt = ~0u;
- Waitcnt() {}
+ Waitcnt() = default;
Waitcnt(unsigned VmCnt, unsigned ExpCnt, unsigned LgkmCnt, unsigned VsCnt)
: VmCnt(VmCnt), ExpCnt(ExpCnt), LgkmCnt(LgkmCnt), VsCnt(VsCnt) {}
void ARMRegisterInfo::anchor() { }
-ARMRegisterInfo::ARMRegisterInfo() {}
+ARMRegisterInfo::ARMRegisterInfo() = default;
using namespace llvm;
-ThumbRegisterInfo::ThumbRegisterInfo() {}
+ThumbRegisterInfo::ThumbRegisterInfo() = default;
const TargetRegisterClass *
ThumbRegisterInfo::getLargestLegalSuperClass(const TargetRegisterClass *RC,
public:
AVRDisassembler(const MCSubtargetInfo &STI, MCContext &Ctx)
: MCDisassembler(STI, Ctx) {}
- virtual ~AVRDisassembler() {}
+ virtual ~AVRDisassembler() = default;
DecodeStatus getInstruction(MCInst &Instr, uint64_t &Size,
ArrayRef<uint8_t> Bytes, uint64_t Address,
public:
AVRELFObjectWriter(uint8_t OSABI);
- virtual ~AVRELFObjectWriter() {}
+ virtual ~AVRELFObjectWriter() = default;
unsigned getRelocType(MCContext &Ctx, const MCValue &Target,
const MCFixup &Fixup, bool IsPCRel) const override;
private:
explicit AVRMCExpr(VariantKind Kind, const MCExpr *Expr, bool Negated)
: Kind(Kind), SubExpr(Expr), Negated(Negated) {}
- ~AVRMCExpr() {}
+ ~AVRMCExpr() = default;
};
} // end namespace llvm
struct RegisterSet : private BitVector {
RegisterSet() = default;
explicit RegisterSet(unsigned s, bool t = false) : BitVector(s, t) {}
- RegisterSet(const RegisterSet &RS) : BitVector(RS) {}
- RegisterSet &operator=(const RegisterSet &RS) {
- BitVector::operator=(RS);
- return *this;
- }
+ RegisterSet(const RegisterSet &RS) = default;
+ RegisterSet &operator=(const RegisterSet &RS) = default;
using BitVector::clear;
return TargetTransformInfo(HexagonTTIImpl(this, F));
}
-
-HexagonTargetMachine::~HexagonTargetMachine() {}
+HexagonTargetMachine::~HexagonTargetMachine() = default;
namespace {
/// Hexagon Code Generator Pass Configuration Options.
/// Hexagon Vector Loop Carried Reuse Pass
struct HexagonVectorLoopCarriedReusePass
: public PassInfoMixin<HexagonVectorLoopCarriedReusePass> {
- HexagonVectorLoopCarriedReusePass() {}
+ HexagonVectorLoopCarriedReusePass() = default;
/// Run pass over the Loop.
PreservedAnalyses run(Loop &L, LoopAnalysisManager &LAM,
public:
MSP430AsmBackend(const MCSubtargetInfo &STI, uint8_t OSABI)
: MCAsmBackend(support::little), OSABI(OSABI) {}
- ~MSP430AsmBackend() override {}
+ ~MSP430AsmBackend() override = default;
void applyFixup(const MCAssembler &Asm, const MCFixup &Fixup,
const MCValue &Target, MutableArrayRef<char> Data,
: MCELFObjectTargetWriter(false, OSABI, ELF::EM_MSP430,
/*HasRelocationAddend*/ true) {}
- ~MSP430ELFObjectWriter() override {}
+ ~MSP430ELFObjectWriter() override = default;
protected:
unsigned getRelocType(MCContext &Ctx, const MCValue &Target,
initAsmInfo();
}
-MSP430TargetMachine::~MSP430TargetMachine() {}
+MSP430TargetMachine::~MSP430TargetMachine() = default;
namespace {
/// MSP430 Code Generator Pass Configuration Options.
#define DEBUG_TYPE "mips16-registerinfo"
-Mips16RegisterInfo::Mips16RegisterInfo() {}
+Mips16RegisterInfo::Mips16RegisterInfo() = default;
bool Mips16RegisterInfo::requiresRegisterScavenging
(const MachineFunction &MF) const {
#define DEBUG_TYPE "mips-reg-info"
-MipsSERegisterInfo::MipsSERegisterInfo() {}
+MipsSERegisterInfo::MipsSERegisterInfo() = default;
bool MipsSERegisterInfo::
requiresRegisterScavenging(const MachineFunction &MF) const {
}
// Pin NVPTXTargetObjectFile's vtables to this file.
-NVPTXTargetObjectFile::~NVPTXTargetObjectFile() {}
+NVPTXTargetObjectFile::~NVPTXTargetObjectFile() = default;
MCSection *NVPTXTargetObjectFile::SelectSectionForGlobal(
const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
class NVPTXTargetObjectFile : public TargetLoweringObjectFile {
public:
- NVPTXTargetObjectFile() {}
+ NVPTXTargetObjectFile() = default;
~NVPTXTargetObjectFile() override;
STI.getTargetTriple(), STI.getFeatureBits(), Options.getABIName());
RISCVFeatures::validate(STI.getTargetTriple(), STI.getFeatureBits());
}
- ~RISCVAsmBackend() override {}
+ ~RISCVAsmBackend() override = default;
void setForceRelocs() { ForceRelocs = true; }
: MCELFObjectTargetWriter(Is64Bit, OSABI, ELF::EM_RISCV,
/*HasRelocationAddend*/ true) {}
-RISCVELFObjectWriter::~RISCVELFObjectWriter() {}
+RISCVELFObjectWriter::~RISCVELFObjectWriter() = default;
unsigned RISCVELFObjectWriter::getRelocType(MCContext &Ctx,
const MCValue &Target,
RISCVMCCodeEmitter(MCContext &ctx, MCInstrInfo const &MCII)
: Ctx(ctx), MCII(MCII) {}
- ~RISCVMCCodeEmitter() override {}
+ ~RISCVMCCodeEmitter() override = default;
void encodeInstruction(const MCInst &MI, raw_ostream &OS,
SmallVectorImpl<MCFixup> &Fixups,
// Keeps track of whether the block is already in the queue.
bool InQueue = false;
- BlockData() {}
+ BlockData() = default;
};
class RISCVInsertVSETVLI : public MachineFunctionPass {
public:
SparcDisassembler(const MCSubtargetInfo &STI, MCContext &Ctx)
: MCDisassembler(STI, Ctx) {}
- virtual ~SparcDisassembler() {}
+ virtual ~SparcDisassembler() = default;
DecodeStatus getInstruction(MCInst &Instr, uint64_t &Size,
ArrayRef<uint8_t> Bytes, uint64_t Address,
Is64Bit ? ELF::EM_SPARCV9 : ELF::EM_SPARC,
/*HasRelocationAddend*/ true) {}
- ~SparcELFObjectWriter() override {}
+ ~SparcELFObjectWriter() override = default;
protected:
unsigned getRelocType(MCContext &Ctx, const MCValue &Target,
initAsmInfo();
}
-SparcTargetMachine::~SparcTargetMachine() {}
+SparcTargetMachine::~SparcTargetMachine() = default;
const SparcSubtarget *
SparcTargetMachine::getSubtargetImpl(const Function &F) const {
class SparcELFTargetObjectFile : public TargetLoweringObjectFileELF {
public:
- SparcELFTargetObjectFile() {}
+ SparcELFTargetObjectFile() = default;
void Initialize(MCContext &Ctx, const TargetMachine &TM) override;
/// Destroys the object. Bogus destructor allowing derived classes
/// to override it.
- virtual ~SystemZCallingConventionRegisters(){};
+ virtual ~SystemZCallingConventionRegisters() = default;
};
/// XPLINK64 calling convention specific use registers
int getStackPointerBias() override final { return 2048; }
/// Destroys the object. Bogus destructor overriding base class destructor
- ~SystemZXPLINK64Registers(){};
+ ~SystemZXPLINK64Registers() = default;
+ ;
};
/// ELF calling convention specific use registers
int getStackPointerBias() override final { return 0; }
/// Destroys the object. Bogus destructor overriding base class destructor
- ~SystemZELFRegisters(){};
+ ~SystemZELFRegisters() = default;
};
struct SystemZRegisterInfo : public SystemZGenRegisterInfo {
#include "llvm/IR/Function.h"
using namespace llvm;
-TargetIntrinsicInfo::TargetIntrinsicInfo() {
-}
+TargetIntrinsicInfo::TargetIntrinsicInfo() = default;
-TargetIntrinsicInfo::~TargetIntrinsicInfo() {
-}
+TargetIntrinsicInfo::~TargetIntrinsicInfo() = default;
unsigned TargetIntrinsicInfo::getIntrinsicID(const Function *F) const {
const ValueName *ValName = F->getValueName();
public:
VEDisassembler(const MCSubtargetInfo &STI, MCContext &Ctx)
: MCDisassembler(STI, Ctx) {}
- virtual ~VEDisassembler() {}
+ virtual ~VEDisassembler() = default;
DecodeStatus getInstruction(MCInst &Instr, uint64_t &Size,
ArrayRef<uint8_t> Bytes, uint64_t Address,
: MCELFObjectTargetWriter(/* Is64Bit */ true, OSABI, ELF::EM_VE,
/* HasRelocationAddend */ true) {}
- ~VEELFObjectWriter() override {}
+ ~VEELFObjectWriter() override = default;
protected:
unsigned getRelocType(MCContext &Ctx, const MCValue &Target,
initAsmInfo();
}
-VETargetMachine::~VETargetMachine() {}
+VETargetMachine::~VETargetMachine() = default;
TargetTransformInfo VETargetMachine::getTargetTransformInfo(const Function &F) {
return TargetTransformInfo(VETTIImpl(this, F));
X86InstrPostProcess(const MCSubtargetInfo &STI, const MCInstrInfo &MCII)
: InstrPostProcess(STI, MCII) {}
- ~X86InstrPostProcess() {}
+ ~X86InstrPostProcess() = default;
void postProcessInstruction(std::unique_ptr<Instruction> &Inst,
const MCInst &MCI) override;
public:
InstrConverterBase(unsigned SrcOpcode) : SrcOpcode(SrcOpcode) {}
- virtual ~InstrConverterBase() {}
+ virtual ~InstrConverterBase() = default;
/// \returns true if \p MI is legal to convert.
virtual bool isLegal(const MachineInstr *MI,
return R;
}
- State() {}
+ State() = default;
State(const State &SIS) : AccessBins(SIS.AccessBins) {}
State(State &&SIS) : AccessBins(std::move(SIS.AccessBins)) {}
/// Abstract State interface
///{
- KernelInfoState() {}
+ KernelInfoState() = default;
KernelInfoState(bool BestState) {
if (!BestState)
indicatePessimisticFixpoint();
};
struct FunctionOutliningMultiRegionInfo {
- FunctionOutliningMultiRegionInfo() {}
+ FunctionOutliningMultiRegionInfo() = default;
// Container for outline regions
struct OutlineRegionInfo {
: InstCombiner(Worklist, Builder, MinimizeSize, AA, AC, TLI, TTI, DT, ORE,
BFI, PSI, DL, LI) {}
- virtual ~InstCombinerImpl() {}
+ virtual ~InstCombinerImpl() = default;
/// Run the combiner over the entire worklist until it is empty.
///
ArrayType *MapTy;
public:
- InstrOrderFile() {}
+ InstrOrderFile() = default;
void createOrderFileData(Module &M) {
LLVMContext &Ctx = M.getContext();
} // end anonymous namespace
-MemProfilerPass::MemProfilerPass() {}
+MemProfilerPass::MemProfilerPass() = default;
PreservedAnalyses MemProfilerPass::run(Function &F,
AnalysisManager<Function> &AM) {
return PreservedAnalyses::all();
}
-ModuleMemProfilerPass::ModuleMemProfilerPass() {}
+ModuleMemProfilerPass::ModuleMemProfilerPass() = default;
PreservedAnalyses ModuleMemProfilerPass::run(Module &M,
AnalysisManager<Module> &AM) {
SmallVector<ConstraintTy, 4> Constraints;
SmallVector<PreconditionTy, 4> Preconditions;
- ConstraintListTy() {}
+ ConstraintListTy() = default;
ConstraintListTy(ArrayRef<ConstraintTy> Constraints,
ArrayRef<PreconditionTy> Preconditions)
LoopICmp(ICmpInst::Predicate Pred, const SCEVAddRecExpr *IV,
const SCEV *Limit)
: Pred(Pred), IV(IV), Limit(Limit) {}
- LoopICmp() {}
+ LoopICmp() = default;
void dump() {
dbgs() << "LoopICmp Pred = " << Pred << ", IV = " << *IV
<< ", Limit = " << *Limit << "\n";
/// together with the corresponfiding merge 'type' and 'offset'.
class MergeGainTy {
public:
- explicit MergeGainTy() {}
+ explicit MergeGainTy() = default;
explicit MergeGainTy(double Score, size_t MergeOffset, MergeTypeTy MergeType)
: Score(Score), MergeOffset(MergeOffset), MergeType(MergeType) {}
LLVMContext &Ctx)
: Visitor(new SCCPInstVisitor(DL, std::move(GetTLI), Ctx)) {}
-SCCPSolver::~SCCPSolver() {}
+SCCPSolver::~SCCPSolver() = default;
void SCCPSolver::addAnalysis(Function &F, AnalysisResultsForFn A) {
return Visitor->addAnalysis(F, std::move(A));
}
public:
- VPBuilder() {}
+ VPBuilder() = default;
/// Clear the insertion point: created instructions will not be inserted into
/// a block.
WindowsManifestMerger::WindowsManifestMerger()
: Impl(std::make_unique<WindowsManifestMergerImpl>()) {}
-WindowsManifestMerger::~WindowsManifestMerger() {}
+WindowsManifestMerger::~WindowsManifestMerger() = default;
Error WindowsManifestMerger::merge(MemoryBufferRef Manifest) {
return Impl->merge(Manifest);
OS.write(FreeFormBytes);
}
-FDRTraceWriter::~FDRTraceWriter() {}
+FDRTraceWriter::~FDRTraceWriter() = default;
Error FDRTraceWriter::visit(BufferExtents &R) {
return writeMetadata<7u>(OS, R.size());
projects / platform / upstream / llvm.git / commitdiff