837bff11cb
This patch forwards the target CPU and features information from the Flang frontend to MLIR func.func operation attributes, which are later used to populate the target_cpu and target_features llvm.func attributes. This is achieved in two stages: 1. Introduce the `fir.target_cpu` and `fir.target_features` module attributes with information from the target machine immediately after the initial creation of the MLIR module in the lowering bridge. 2. Update the target rewrite flang pass to get this information from the module and pass it along to all func.func MLIR operations, respectively as attributes named `target_cpu` and `target_features`. These attributes will be automatically picked up during Func to LLVM dialect lowering and used to initialize the corresponding llvm.func named attributes. The target rewrite and FIR to LLVM lowering passes are updated with the ability to override these module attributes, and the `CodeGenSpecifics` optimizer class is augmented to make this information available to target-specific MLIR transformations. This completes a full flow by which target CPU and features make it all the way from compiler options to LLVM IR function attributes.
109 lines
3.7 KiB
C++
109 lines
3.7 KiB
C++
//===-- FIRContext.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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "flang/Optimizer/Dialect/Support/FIRContext.h"
|
|
#include "flang/Optimizer/Dialect/Support/KindMapping.h"
|
|
#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
|
|
#include "mlir/IR/BuiltinAttributes.h"
|
|
#include "mlir/IR/BuiltinOps.h"
|
|
#include "llvm/TargetParser/Host.h"
|
|
|
|
void fir::setTargetTriple(mlir::ModuleOp mod, llvm::StringRef triple) {
|
|
auto target = fir::determineTargetTriple(triple);
|
|
mod->setAttr(mlir::LLVM::LLVMDialect::getTargetTripleAttrName(),
|
|
mlir::StringAttr::get(mod.getContext(), target));
|
|
}
|
|
|
|
llvm::Triple fir::getTargetTriple(mlir::ModuleOp mod) {
|
|
if (auto target = mod->getAttrOfType<mlir::StringAttr>(
|
|
mlir::LLVM::LLVMDialect::getTargetTripleAttrName()))
|
|
return llvm::Triple(target.getValue());
|
|
return llvm::Triple(llvm::sys::getDefaultTargetTriple());
|
|
}
|
|
|
|
static constexpr const char *kindMapName = "fir.kindmap";
|
|
static constexpr const char *defKindName = "fir.defaultkind";
|
|
|
|
void fir::setKindMapping(mlir::ModuleOp mod, fir::KindMapping &kindMap) {
|
|
auto *ctx = mod.getContext();
|
|
mod->setAttr(kindMapName, mlir::StringAttr::get(ctx, kindMap.mapToString()));
|
|
auto defs = kindMap.defaultsToString();
|
|
mod->setAttr(defKindName, mlir::StringAttr::get(ctx, defs));
|
|
}
|
|
|
|
fir::KindMapping fir::getKindMapping(mlir::ModuleOp mod) {
|
|
auto *ctx = mod.getContext();
|
|
if (auto defs = mod->getAttrOfType<mlir::StringAttr>(defKindName)) {
|
|
auto defVals = fir::KindMapping::toDefaultKinds(defs.getValue());
|
|
if (auto maps = mod->getAttrOfType<mlir::StringAttr>(kindMapName))
|
|
return fir::KindMapping(ctx, maps.getValue(), defVals);
|
|
return fir::KindMapping(ctx, defVals);
|
|
}
|
|
return fir::KindMapping(ctx);
|
|
}
|
|
|
|
fir::KindMapping fir::getKindMapping(mlir::Operation *op) {
|
|
auto moduleOp = mlir::dyn_cast<mlir::ModuleOp>(op);
|
|
if (moduleOp)
|
|
return getKindMapping(moduleOp);
|
|
|
|
moduleOp = op->getParentOfType<mlir::ModuleOp>();
|
|
return getKindMapping(moduleOp);
|
|
}
|
|
|
|
static constexpr const char *targetCpuName = "fir.target_cpu";
|
|
|
|
void fir::setTargetCPU(mlir::ModuleOp mod, llvm::StringRef cpu) {
|
|
if (cpu.empty())
|
|
return;
|
|
|
|
auto *ctx = mod.getContext();
|
|
mod->setAttr(targetCpuName, mlir::StringAttr::get(ctx, cpu));
|
|
}
|
|
|
|
llvm::StringRef fir::getTargetCPU(mlir::ModuleOp mod) {
|
|
if (auto attr = mod->getAttrOfType<mlir::StringAttr>(targetCpuName))
|
|
return attr.getValue();
|
|
|
|
return {};
|
|
}
|
|
|
|
static constexpr const char *targetFeaturesName = "fir.target_features";
|
|
|
|
void fir::setTargetFeatures(mlir::ModuleOp mod, llvm::StringRef features) {
|
|
if (features.empty())
|
|
return;
|
|
|
|
auto *ctx = mod.getContext();
|
|
mod->setAttr(targetFeaturesName,
|
|
mlir::LLVM::TargetFeaturesAttr::get(ctx, features));
|
|
}
|
|
|
|
mlir::LLVM::TargetFeaturesAttr fir::getTargetFeatures(mlir::ModuleOp mod) {
|
|
if (auto attr = mod->getAttrOfType<mlir::LLVM::TargetFeaturesAttr>(
|
|
targetFeaturesName))
|
|
return attr;
|
|
|
|
return {};
|
|
}
|
|
|
|
std::string fir::determineTargetTriple(llvm::StringRef triple) {
|
|
// Treat "" or "default" as stand-ins for the default machine.
|
|
if (triple.empty() || triple == "default")
|
|
return llvm::sys::getDefaultTargetTriple();
|
|
// Treat "native" as stand-in for the host machine.
|
|
if (triple == "native")
|
|
return llvm::sys::getProcessTriple();
|
|
// TODO: normalize the triple?
|
|
return triple.str();
|
|
}
|