2d14ea68b8
The ExternalNameConversion pass can be surprisingly slow on big programs. On an example with a 50kloc Fortran file with about 10000 calls to external procedures, the pass alone took 25s on my machine. This patch reduces this to 0.16s. The root cause is that using `replaceAllSymbolUses` on each modified FuncOp is very expensive: it is walking all operations and attribute every time. An alternative would be to use mlir::SymbolUserMap to avoid walking the module again and again, but this is still much more expensive than what is needed because it is essentially caching all symbol uses of the module, and there is no need to such caching here. Instead: - Do a shallow walk of the module (only top level operation) to detect FuncOp/GlobalOp that needs to be updated. Update them and place the name remapping in a DenseMap. - If any remapping were done, do a single deep walk of the module operation, and update any SymbolRefAttr that matches a name that was remapped.
113 lines
4.3 KiB
C++
113 lines
4.3 KiB
C++
//===- ExternalNameConversion.cpp -- convert name with external convention ===//
|
|
//
|
|
// 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 "flang/Common/Fortran.h"
|
|
#include "flang/Optimizer/Dialect/FIRDialect.h"
|
|
#include "flang/Optimizer/Dialect/FIROps.h"
|
|
#include "flang/Optimizer/Dialect/FIROpsSupport.h"
|
|
#include "flang/Optimizer/Support/InternalNames.h"
|
|
#include "flang/Optimizer/Transforms/Passes.h"
|
|
#include "mlir/IR/Attributes.h"
|
|
#include "mlir/IR/SymbolTable.h"
|
|
#include "mlir/Pass/Pass.h"
|
|
|
|
namespace fir {
|
|
#define GEN_PASS_DEF_EXTERNALNAMECONVERSION
|
|
#include "flang/Optimizer/Transforms/Passes.h.inc"
|
|
} // namespace fir
|
|
|
|
using namespace mlir;
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Helper functions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// Mangle the name with gfortran convention.
|
|
std::string
|
|
mangleExternalName(const std::pair<fir::NameUniquer::NameKind,
|
|
fir::NameUniquer::DeconstructedName>
|
|
result,
|
|
bool appendUnderscore) {
|
|
if (result.first == fir::NameUniquer::NameKind::COMMON &&
|
|
result.second.name.empty())
|
|
return Fortran::common::blankCommonObjectName;
|
|
return Fortran::common::GetExternalAssemblyName(result.second.name,
|
|
appendUnderscore);
|
|
}
|
|
|
|
namespace {
|
|
|
|
class ExternalNameConversionPass
|
|
: public fir::impl::ExternalNameConversionBase<ExternalNameConversionPass> {
|
|
public:
|
|
ExternalNameConversionPass(bool appendUnderscoring)
|
|
: appendUnderscores(appendUnderscoring) {}
|
|
|
|
ExternalNameConversionPass() { usePassOpt = true; }
|
|
|
|
mlir::ModuleOp getModule() { return getOperation(); }
|
|
void runOnOperation() override;
|
|
|
|
private:
|
|
bool appendUnderscores;
|
|
bool usePassOpt = false;
|
|
};
|
|
} // namespace
|
|
|
|
void ExternalNameConversionPass::runOnOperation() {
|
|
auto op = getOperation();
|
|
auto *context = &getContext();
|
|
|
|
appendUnderscores = (usePassOpt) ? appendUnderscoreOpt : appendUnderscores;
|
|
llvm::DenseMap<mlir::StringAttr, mlir::FlatSymbolRefAttr> remappings;
|
|
// Update names of external Fortran functions and names of Common Block
|
|
// globals.
|
|
for (auto &funcOrGlobal : op->getRegion(0).front()) {
|
|
if (llvm::isa<mlir::func::FuncOp>(funcOrGlobal) ||
|
|
llvm::isa<fir::GlobalOp>(funcOrGlobal)) {
|
|
auto symName = funcOrGlobal.getAttrOfType<mlir::StringAttr>(
|
|
mlir::SymbolTable::getSymbolAttrName());
|
|
auto deconstructedName = fir::NameUniquer::deconstruct(symName);
|
|
if (fir::NameUniquer::isExternalFacingUniquedName(deconstructedName)) {
|
|
auto newName = mangleExternalName(deconstructedName, appendUnderscores);
|
|
auto newAttr = mlir::StringAttr::get(context, newName);
|
|
mlir::SymbolTable::setSymbolName(&funcOrGlobal, newAttr);
|
|
auto newSymRef = mlir::FlatSymbolRefAttr::get(newAttr);
|
|
remappings.try_emplace(symName, newSymRef);
|
|
if (llvm::isa<mlir::func::FuncOp>(funcOrGlobal))
|
|
funcOrGlobal.setAttr(fir::getInternalFuncNameAttrName(), symName);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (remappings.empty())
|
|
return;
|
|
|
|
// Update all uses of the functions and globals that have been renamed.
|
|
op.walk([&remappings](mlir::Operation *nestedOp) {
|
|
llvm::SmallVector<std::pair<mlir::StringAttr, mlir::SymbolRefAttr>> updates;
|
|
for (const mlir::NamedAttribute &attr : nestedOp->getAttrDictionary())
|
|
if (auto symRef = llvm::dyn_cast<mlir::SymbolRefAttr>(attr.getValue()))
|
|
if (auto remap = remappings.find(symRef.getRootReference());
|
|
remap != remappings.end())
|
|
updates.emplace_back(std::pair<mlir::StringAttr, mlir::SymbolRefAttr>{
|
|
attr.getName(), mlir::SymbolRefAttr(remap->second)});
|
|
for (auto update : updates)
|
|
nestedOp->setAttr(update.first, update.second);
|
|
});
|
|
}
|
|
|
|
std::unique_ptr<mlir::Pass> fir::createExternalNameConversionPass() {
|
|
return std::make_unique<ExternalNameConversionPass>();
|
|
}
|
|
|
|
std::unique_ptr<mlir::Pass>
|
|
fir::createExternalNameConversionPass(bool appendUnderscoring) {
|
|
return std::make_unique<ExternalNameConversionPass>(appendUnderscoring);
|
|
}
|