llvm-project/llvm/lib/CodeGen/MachinePostDominators.cpp
Andrew Rogers ad0fba211c
[llvm] annotate remaining CodeGen and CodeGenTypes library interfaces for DLL export (#145361)
## Purpose

This patch is one in a series of code-mods that annotate LLVM’s public
interface for export. This patch annotates the remaining LLVM CodeGen
and CodeGenTypes library interfaces that were missed in, or modified
since, previous patches. The annotations currently have no meaningful
impact on the LLVM build; however, they are a prerequisite to support an
LLVM Windows DLL (shared library) build.

## Background

This effort is tracked in #109483. Additional context is provided in
[this
discourse](https://discourse.llvm.org/t/psa-annotating-llvm-public-interface/85307),
and documentation for `LLVM_ABI` and related annotations is found in the
LLVM repo
[here](https://github.com/llvm/llvm-project/blob/main/llvm/docs/InterfaceExportAnnotations.rst).

## Overview

The bulk of these changes were generated automatically using the
[Interface Definition Scanner (IDS)](https://github.com/compnerd/ids)
tool, followed formatting with `git clang-format`.

The following manual adjustments were also applied after running IDS:
- Explicitly instantiate `CallLowering::setArgFlags` template method
instances in `CodeGen/GlobalISel/CallLowering.h` and annotate them with
`LLVM_ABI`. These methods are already explicitly instantiated in
`lib/CodeGen/GlobalISel/CallLowering.cpp` but were not `extern` declared
in the header.
- Annotate several explicit template instantiations with
`LLVM_EXPORT_TEMPLATE`.
- Include `llvm/CodeGen/Passes.h` from
`llvm/lib/CodeGen/GlobalMergeFunctions.cpp` to pick up the declaration
of `llvm::createGlobalMergeFuncPass` with the `LLVM_ABI` annotation
(instead of adding `LLVM_ABI` to the function definition in this file)

## Validation

Local builds and tests to validate cross-platform compatibility. This
included llvm, clang, and lldb on the following configurations:

- Windows with MSVC
- Windows with Clang
- Linux with GCC
- Linux with Clang
- Darwin with Clang
2025-06-25 13:00:59 -07:00

124 lines
4.3 KiB
C++

//===- MachinePostDominators.cpp -Machine Post Dominator Calculation ------===//
//
// 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 implements simple dominator construction algorithms for finding
// post dominators on machine functions.
//
//===----------------------------------------------------------------------===//
#include "llvm/CodeGen/MachinePostDominators.h"
#include "llvm/InitializePasses.h"
#include "llvm/Support/GenericDomTreeConstruction.h"
using namespace llvm;
namespace llvm {
template class LLVM_EXPORT_TEMPLATE
DominatorTreeBase<MachineBasicBlock, true>; // PostDomTreeBase
namespace DomTreeBuilder {
template LLVM_EXPORT_TEMPLATE void
Calculate<MBBPostDomTree>(MBBPostDomTree &DT);
template LLVM_EXPORT_TEMPLATE void
InsertEdge<MBBPostDomTree>(MBBPostDomTree &DT, MachineBasicBlock *From,
MachineBasicBlock *To);
template LLVM_EXPORT_TEMPLATE void
DeleteEdge<MBBPostDomTree>(MBBPostDomTree &DT, MachineBasicBlock *From,
MachineBasicBlock *To);
template LLVM_EXPORT_TEMPLATE void
ApplyUpdates<MBBPostDomTree>(MBBPostDomTree &DT, MBBPostDomTreeGraphDiff &,
MBBPostDomTreeGraphDiff *);
template LLVM_EXPORT_TEMPLATE bool
Verify<MBBPostDomTree>(const MBBPostDomTree &DT,
MBBPostDomTree::VerificationLevel VL);
} // namespace DomTreeBuilder
extern bool VerifyMachineDomInfo;
} // namespace llvm
AnalysisKey MachinePostDominatorTreeAnalysis::Key;
MachinePostDominatorTreeAnalysis::Result
MachinePostDominatorTreeAnalysis::run(MachineFunction &MF,
MachineFunctionAnalysisManager &) {
return MachinePostDominatorTree(MF);
}
PreservedAnalyses
MachinePostDominatorTreePrinterPass::run(MachineFunction &MF,
MachineFunctionAnalysisManager &MFAM) {
OS << "MachinePostDominatorTree for machine function: " << MF.getName()
<< '\n';
MFAM.getResult<MachinePostDominatorTreeAnalysis>(MF).print(OS);
return PreservedAnalyses::all();
}
char MachinePostDominatorTreeWrapperPass::ID = 0;
//declare initializeMachinePostDominatorTreePass
INITIALIZE_PASS(MachinePostDominatorTreeWrapperPass, "machinepostdomtree",
"MachinePostDominator Tree Construction", true, true)
MachinePostDominatorTreeWrapperPass::MachinePostDominatorTreeWrapperPass()
: MachineFunctionPass(ID), PDT() {
initializeMachinePostDominatorTreeWrapperPassPass(
*PassRegistry::getPassRegistry());
}
bool MachinePostDominatorTreeWrapperPass::runOnMachineFunction(
MachineFunction &F) {
PDT = MachinePostDominatorTree();
PDT->recalculate(F);
return false;
}
void MachinePostDominatorTreeWrapperPass::getAnalysisUsage(
AnalysisUsage &AU) const {
AU.setPreservesAll();
MachineFunctionPass::getAnalysisUsage(AU);
}
bool MachinePostDominatorTree::invalidate(
MachineFunction &, const PreservedAnalyses &PA,
MachineFunctionAnalysisManager::Invalidator &) {
// Check whether the analysis, all analyses on machine functions, or the
// machine function's CFG have been preserved.
auto PAC = PA.getChecker<MachinePostDominatorTreeAnalysis>();
return !PAC.preserved() &&
!PAC.preservedSet<AllAnalysesOn<MachineFunction>>() &&
!PAC.preservedSet<CFGAnalyses>();
}
MachineBasicBlock *MachinePostDominatorTree::findNearestCommonDominator(
ArrayRef<MachineBasicBlock *> Blocks) const {
assert(!Blocks.empty());
MachineBasicBlock *NCD = Blocks.front();
for (MachineBasicBlock *BB : Blocks.drop_front()) {
NCD = Base::findNearestCommonDominator(NCD, BB);
// Stop when the root is reached.
if (isVirtualRoot(getNode(NCD)))
return nullptr;
}
return NCD;
}
void MachinePostDominatorTreeWrapperPass::verifyAnalysis() const {
if (VerifyMachineDomInfo && PDT &&
!PDT->verify(MachinePostDominatorTree::VerificationLevel::Basic))
report_fatal_error("MachinePostDominatorTree verification failed!");
}
void MachinePostDominatorTreeWrapperPass::print(llvm::raw_ostream &OS,
const Module *M) const {
PDT->print(OS);
}