shylie/llvm-project
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add basic -mtune support (#98517)

Browse Source 
Initial implementation for the -mtune flag in Flang.

This PR is a clean version of PR #96688, which is a re-land of PR #95043
This commit is contained in:
Alexis Perry-Holby 2024-07-16 09:48:24 -06:00 committed by GitHub
parent 266a784cce
commit f1d3fe7aae
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
26 changed files with 186 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
clang/include/clang/Driver/Options.td
View File

@ -5456,6 +5456,7 @@ def module_file_info : Flag<["-"], "module-file-info">, Flags<[]>,
HelpText<"Provide information about a particular module file">;
def mthumb : Flag<["-"], "mthumb">, Group<m_Group>;
def mtune_EQ : Joined<["-"], "mtune=">, Group<m_Group>,
Visibility<[ClangOption, FlangOption]>,
HelpText<"Only supported on AArch64, PowerPC, RISC-V, SPARC, SystemZ, and X86">;
def multi__module : Flag<["-"], "multi_module">;
def multiply__defined__unused : Separate<["-"], "multiply_defined_unused">;
@ -6783,9 +6784,6 @@ def emit_hlfir : Flag<["-"], "emit-hlfir">, Group<Action_Group>,
let Visibility = [CC1Option, CC1AsOption] in {
def tune_cpu : Separate<["-"], "tune-cpu">,
HelpText<"Tune for a specific cpu type">,
MarshallingInfoString<TargetOpts<"TuneCPU">>;
def target_abi : Separate<["-"], "target-abi">,
HelpText<"Target a particular ABI type">,
MarshallingInfoString<TargetOpts<"ABI">>;
@ -6812,6 +6810,9 @@ def darwin_target_variant_triple : Separate<["-"], "darwin-target-variant-triple
let Visibility = [CC1Option, CC1AsOption, FC1Option] in {
def tune_cpu : Separate<["-"], "tune-cpu">,
HelpText<"Tune for a specific cpu type">,
MarshallingInfoString<TargetOpts<"TuneCPU">>;
def target_cpu : Separate<["-"], "target-cpu">,
HelpText<"Target a specific cpu type">,
MarshallingInfoString<TargetOpts<"CPU">>;

8
clang/lib/Driver/ToolChains/Flang.cpp
View File

@ -15,6 +15,7 @@
#include "llvm/Frontend/Debug/Options.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/Path.h"
#include "llvm/TargetParser/Host.h"
#include "llvm/TargetParser/RISCVISAInfo.h"
#include "llvm/TargetParser/RISCVTargetParser.h"
@ -419,6 +420,13 @@ void Flang::addTargetOptions(const ArgList &Args,
}
// TODO: Add target specific flags, ABI, mtune option etc.
if (const Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) {
CmdArgs.push_back("-tune-cpu");
if (A->getValue() == StringRef{"native"})
CmdArgs.push_back(Args.MakeArgString(llvm::sys::getHostCPUName()));
else
CmdArgs.push_back(A->getValue());
}
}
void Flang::addOffloadOptions(Compilation &C, const InputInfoList &Inputs,

3
flang/include/flang/Frontend/TargetOptions.h
View File

@ -32,6 +32,9 @@ public:
/// If given, the name of the target CPU to generate code for.
std::string cpu;
/// If given, the name of the target CPU to tune code for.
std::string cpuToTuneFor;
/// The list of target specific features to enable or disable, as written on
/// the command line.
std::vector<std::string> featuresAsWritten;

6
flang/include/flang/Lower/Bridge.h
View File

@ -65,11 +65,11 @@ public:
const Fortran::lower::LoweringOptions &loweringOptions,
const std::vector<Fortran::lower::EnvironmentDefault> &envDefaults,
const Fortran::common::LanguageFeatureControl &languageFeatures,
const llvm::TargetMachine &targetMachine) {
const llvm::TargetMachine &targetMachine, llvm::StringRef tuneCPU) {
return LoweringBridge(ctx, semanticsContext, defaultKinds, intrinsics,
targetCharacteristics, allCooked, triple, kindMap,
loweringOptions, envDefaults, languageFeatures,
targetMachine);
targetMachine, tuneCPU);
}
//===--------------------------------------------------------------------===//
@ -148,7 +148,7 @@ private:
const Fortran::lower::LoweringOptions &loweringOptions,
const std::vector<Fortran::lower::EnvironmentDefault> &envDefaults,
const Fortran::common::LanguageFeatureControl &languageFeatures,
const llvm::TargetMachine &targetMachine);
const llvm::TargetMachine &targetMachine, const llvm::StringRef tuneCPU);
LoweringBridge() = delete;
LoweringBridge(const LoweringBridge &) = delete;

4
flang/include/flang/Optimizer/CodeGen/CGPasses.td
View File

@ -31,6 +31,8 @@ def FIRToLLVMLowering : Pass<"fir-to-llvm-ir", "mlir::ModuleOp"> {
"Override module's data layout.">,
Option<"forcedTargetCPU", "target-cpu", "std::string", /*default=*/"",
"Override module's target CPU.">,
Option<"forcedTuneCPU", "tune-cpu", "std::string", /*default=*/"",
"Override module's tune CPU.">,
Option<"forcedTargetFeatures", "target-features", "std::string",
/*default=*/"", "Override module's target features.">,
Option<"applyTBAA", "apply-tbaa", "bool", /*default=*/"false",
@ -68,6 +70,8 @@ def TargetRewritePass : Pass<"target-rewrite", "mlir::ModuleOp"> {
"Override module's target triple.">,
Option<"forcedTargetCPU", "target-cpu", "std::string", /*default=*/"",
"Override module's target CPU.">,
Option<"forcedTuneCPU", "tune-cpu", "std::string", /*default=*/"",
"Override module's tune CPU.">,
Option<"forcedTargetFeatures", "target-features", "std::string",
/*default=*/"", "Override module's target features.">,
Option<"noCharacterConversion", "no-character-conversion",

19
flang/include/flang/Optimizer/CodeGen/Target.h
View File

@ -76,6 +76,11 @@ public:
llvm::StringRef targetCPU, mlir::LLVM::TargetFeaturesAttr targetFeatures,
const mlir::DataLayout &dl);
static std::unique_ptr<CodeGenSpecifics>
get(mlir::MLIRContext *ctx, llvm::Triple &&trp, KindMapping &&kindMap,
llvm::StringRef targetCPU, mlir::LLVM::TargetFeaturesAttr targetFeatures,
const mlir::DataLayout &dl, llvm::StringRef tuneCPU);
static TypeAndAttr getTypeAndAttr(mlir::Type t) { return TypeAndAttr{t, {}}; }
CodeGenSpecifics(mlir::MLIRContext *ctx, llvm::Triple &&trp,
@ -83,7 +88,17 @@ public:
mlir::LLVM::TargetFeaturesAttr targetFeatures,
const mlir::DataLayout &dl)
: context{*ctx}, triple{std::move(trp)}, kindMap{std::move(kindMap)},
targetCPU{targetCPU}, targetFeatures{targetFeatures}, dataLayout{&dl} {}
targetCPU{targetCPU}, targetFeatures{targetFeatures}, dataLayout{&dl},
tuneCPU{""} {}
CodeGenSpecifics(mlir::MLIRContext *ctx, llvm::Triple &&trp,
KindMapping &&kindMap, llvm::StringRef targetCPU,
mlir::LLVM::TargetFeaturesAttr targetFeatures,
const mlir::DataLayout &dl, llvm::StringRef tuneCPU)
: context{*ctx}, triple{std::move(trp)}, kindMap{std::move(kindMap)},
targetCPU{targetCPU}, targetFeatures{targetFeatures}, dataLayout{&dl},
tuneCPU{tuneCPU} {}
CodeGenSpecifics() = delete;
virtual ~CodeGenSpecifics() {}
@ -165,6 +180,7 @@ public:
virtual unsigned char getCIntTypeWidth() const = 0;
llvm::StringRef getTargetCPU() const { return targetCPU; }
llvm::StringRef getTuneCPU() const { return tuneCPU; }
mlir::LLVM::TargetFeaturesAttr getTargetFeatures() const {
return targetFeatures;
@ -182,6 +198,7 @@ protected:
llvm::StringRef targetCPU;
mlir::LLVM::TargetFeaturesAttr targetFeatures;
const mlir::DataLayout *dataLayout = nullptr;
llvm::StringRef tuneCPU;
};
} // namespace fir

7
flang/include/flang/Optimizer/Dialect/Support/FIRContext.h
View File

@ -58,6 +58,13 @@ void setTargetCPU(mlir::ModuleOp mod, llvm::StringRef cpu);
/// Get the target CPU string from the Module or return a null reference.
llvm::StringRef getTargetCPU(mlir::ModuleOp mod);
/// Set the tune CPU for the module. `cpu` must not be deallocated while
/// module `mod` is still live.
void setTuneCPU(mlir::ModuleOp mod, llvm::StringRef cpu);
/// Get the tune CPU string from the Module or return a null reference.
llvm::StringRef getTuneCPU(mlir::ModuleOp mod);
/// Set the target features for the module.
void setTargetFeatures(mlir::ModuleOp mod, llvm::StringRef features);

5
flang/include/flang/Optimizer/Transforms/Passes.td
View File

@ -411,7 +411,10 @@ def FunctionAttr : Pass<"function-attr", "mlir::func::FuncOp"> {
Option<"unsafeFPMath", "unsafe-fp-math",
"bool", /*default=*/"false",
"Set the unsafe-fp-math attribute on functions in the module.">,
];
Option<"tuneCPU", "tune-cpu",
"llvm::StringRef", /*default=*/"llvm::StringRef{}",
"Set the tune-cpu attribute on functions in the module.">,
];
}
def AssumedRankOpConversion : Pass<"fir-assumed-rank-op", "mlir::ModuleOp"> {

4
flang/lib/Frontend/CompilerInvocation.cpp
View File

@ -431,6 +431,10 @@ static void parseTargetArgs(TargetOptions &opts, llvm::opt::ArgList &args) {
args.getLastArg(clang::driver::options::OPT_target_cpu))
opts.cpu = a->getValue();
if (const llvm::opt::Arg *a =
args.getLastArg(clang::driver::options::OPT_tune_cpu))
opts.cpuToTuneFor = a->getValue();
for (const llvm::opt::Arg *currentArg :
args.filtered(clang::driver::options::OPT_target_feature))
opts.featuresAsWritten.emplace_back(currentArg->getValue());

3
flang/lib/Frontend/FrontendActions.cpp
View File

@ -297,7 +297,8 @@ bool CodeGenAction::beginSourceFileAction() {
ci.getParsing().allCooked(), ci.getInvocation().getTargetOpts().triple,
kindMap, ci.getInvocation().getLoweringOpts(),
ci.getInvocation().getFrontendOpts().envDefaults,
ci.getInvocation().getFrontendOpts().features, targetMachine);
ci.getInvocation().getFrontendOpts().features, targetMachine,
ci.getInvocation().getTargetOpts().cpuToTuneFor);
// Fetch module from lb, so we can set
mlirModule = std::make_unique<mlir::ModuleOp>(lb.getModule());

3
flang/lib/Lower/Bridge.cpp
View File

@ -6025,7 +6025,7 @@ Fortran::lower::LoweringBridge::LoweringBridge(
const Fortran::lower::LoweringOptions &loweringOptions,
const std::vector<Fortran::lower::EnvironmentDefault> &envDefaults,
const Fortran::common::LanguageFeatureControl &languageFeatures,
const llvm::TargetMachine &targetMachine)
const llvm::TargetMachine &targetMachine, const llvm::StringRef tuneCPU)
: semanticsContext{semanticsContext}, defaultKinds{defaultKinds},
intrinsics{intrinsics}, targetCharacteristics{targetCharacteristics},
cooked{&cooked}, context{context}, kindMap{kindMap},
@ -6082,6 +6082,7 @@ Fortran::lower::LoweringBridge::LoweringBridge(
fir::setTargetTriple(*module.get(), triple);
fir::setKindMapping(*module.get(), kindMap);
fir::setTargetCPU(*module.get(), targetMachine.getTargetCPU());
fir::setTuneCPU(*module.get(), tuneCPU);
fir::setTargetFeatures(*module.get(), targetMachine.getTargetFeatureString());
fir::support::setMLIRDataLayout(*module.get(),
targetMachine.createDataLayout());

3
flang/lib/Optimizer/CodeGen/CodeGen.cpp
View File

@ -3595,6 +3595,9 @@ public:
if (!forcedTargetCPU.empty())
fir::setTargetCPU(mod, forcedTargetCPU);
if (!forcedTuneCPU.empty())
fir::setTuneCPU(mod, forcedTuneCPU);
if (!forcedTargetFeatures.empty())
fir::setTargetFeatures(mod, forcedTargetFeatures);

11
flang/lib/Optimizer/CodeGen/Target.cpp
View File

@ -1113,3 +1113,14 @@ fir::CodeGenSpecifics::get(mlir::MLIRContext *ctx, llvm::Triple &&trp,
}
TODO(mlir::UnknownLoc::get(ctx), "target not implemented");
}
std::unique_ptr<fir::CodeGenSpecifics> fir::CodeGenSpecifics::get(
mlir::MLIRContext *ctx, llvm::Triple &&trp, KindMapping &&kindMap,
llvm::StringRef targetCPU, mlir::LLVM::TargetFeaturesAttr targetFeatures,
const mlir::DataLayout &dl, llvm::StringRef tuneCPU) {
std::unique_ptr<fir::CodeGenSpecifics> CGS = fir::CodeGenSpecifics::get(
ctx, std::move(trp), std::move(kindMap), targetCPU, targetFeatures, dl);
CGS->tuneCPU = tuneCPU;
return CGS;
}

12
flang/lib/Optimizer/CodeGen/TargetRewrite.cpp
View File

@ -89,6 +89,9 @@ public:
if (!forcedTargetCPU.empty())
fir::setTargetCPU(mod, forcedTargetCPU);
if (!forcedTuneCPU.empty())
fir::setTuneCPU(mod, forcedTuneCPU);
if (!forcedTargetFeatures.empty())
fir::setTargetFeatures(mod, forcedTargetFeatures);
@ -106,7 +109,8 @@ public:
auto specifics = fir::CodeGenSpecifics::get(
mod.getContext(), fir::getTargetTriple(mod), fir::getKindMapping(mod),
fir::getTargetCPU(mod), fir::getTargetFeatures(mod), *dl);
fir::getTargetCPU(mod), fir::getTargetFeatures(mod), *dl,
fir::getTuneCPU(mod));
setMembers(specifics.get(), &rewriter, &*dl);
@ -672,12 +676,18 @@ public:
auto targetCPU = specifics->getTargetCPU();
mlir::StringAttr targetCPUAttr =
targetCPU.empty() ? nullptr : mlir::StringAttr::get(ctx, targetCPU);
auto tuneCPU = specifics->getTuneCPU();
mlir::StringAttr tuneCPUAttr =
tuneCPU.empty() ? nullptr : mlir::StringAttr::get(ctx, tuneCPU);
auto targetFeaturesAttr = specifics->getTargetFeatures();
for (auto fn : mod.getOps<mlir::func::FuncOp>()) {
if (targetCPUAttr)
fn->setAttr("target_cpu", targetCPUAttr);
if (tuneCPUAttr)
fn->setAttr("tune_cpu", tuneCPUAttr);
if (targetFeaturesAttr)
fn->setAttr("target_features", targetFeaturesAttr);

3
flang/lib/Optimizer/CodeGen/TypeConverter.cpp
View File

@ -35,7 +35,8 @@ LLVMTypeConverter::LLVMTypeConverter(mlir::ModuleOp module, bool applyTBAA,
kindMapping(getKindMapping(module)),
specifics(CodeGenSpecifics::get(
module.getContext(), getTargetTriple(module), getKindMapping(module),
getTargetCPU(module), getTargetFeatures(module), dl)),
getTargetCPU(module), getTargetFeatures(module), dl,
getTuneCPU(module))),
tbaaBuilder(std::make_unique<TBAABuilder>(module->getContext(), applyTBAA,
forceUnifiedTBAATree)),
dataLayout{&dl} {

18
flang/lib/Optimizer/Dialect/Support/FIRContext.cpp
View File

@ -77,6 +77,24 @@ llvm::StringRef fir::getTargetCPU(mlir::ModuleOp mod) {
return {};
}
static constexpr const char *tuneCpuName = "fir.tune_cpu";
void fir::setTuneCPU(mlir::ModuleOp mod, llvm::StringRef cpu) {
if (cpu.empty())
return;
auto *ctx = mod.getContext();
mod->setAttr(tuneCpuName, mlir::StringAttr::get(ctx, cpu));
}
llvm::StringRef fir::getTuneCPU(mlir::ModuleOp mod) {
if (auto attr = mod->getAttrOfType<mlir::StringAttr>(tuneCpuName))
return attr.getValue();
return {};
}
static constexpr const char *targetFeaturesName = "fir.target_features";
void fir::setTargetFeatures(mlir::ModuleOp mod, llvm::StringRef features) {

25
flang/test/Driver/tune-cpu-fir.f90 Normal file
View File

@ -0,0 +1,25 @@
! RUN: %if aarch64-registered-target %{ %flang_fc1 -emit-fir -triple aarch64-unknown-linux-gnu -target-cpu aarch64 %s -o - | FileCheck %s --check-prefixes=ALL,ARMCPU %}
! RUN: %if aarch64-registered-target %{ %flang_fc1 -emit-fir -triple aarch64-unknown-linux-gnu -tune-cpu neoverse-n1 %s -o - | FileCheck %s --check-prefixes=ALL,ARMTUNE %}
! RUN: %if aarch64-registered-target %{ %flang_fc1 -emit-fir -triple aarch64-unknown-linux-gnu -target-cpu aarch64 -tune-cpu neoverse-n1 %s -o - | FileCheck %s --check-prefixes=ALL,ARMBOTH %}
! RUN: %if x86-registered-target %{ %flang_fc1 -emit-fir -triple x86_64-unknown-linux-gnu -target-cpu x86-64 %s -o - | FileCheck %s --check-prefixes=ALL,X86CPU %}
! RUN: %if x86-registered-target %{ %flang_fc1 -emit-fir -triple x86_64-unknown-linux-gnu -tune-cpu pentium4 %s -o - | FileCheck %s --check-prefixes=ALL,X86TUNE %}
! RUN: %if x86-registered-target %{ %flang_fc1 -emit-fir -triple x86_64-unknown-linux-gnu -target-cpu x86-64 -tune-cpu pentium4 %s -o - | FileCheck %s --check-prefixes=ALL,X86BOTH %}
! ALL: module attributes {
! ARMCPU-SAME: fir.target_cpu = "aarch64"
! ARMCPU-NOT: fir.tune_cpu = "neoverse-n1"
! ARMTUNE-SAME: fir.tune_cpu = "neoverse-n1"
! ARMBOTH-SAME: fir.target_cpu = "aarch64"
! ARMBOTH-SAME: fir.tune_cpu = "neoverse-n1"
! X86CPU-SAME: fir.target_cpu = "x86-64"
! X86CPU-NOT: fir.tune_cpu = "pentium4"
! X86TUNE-SAME: fir.tune_cpu = "pentium4"
! X86BOTH-SAME: fir.target_cpu = "x86-64"
! X86BOTH-SAME: fir.tune_cpu = "pentium4"

8
flang/test/Lower/tune-cpu-llvm.f90 Normal file
View File

@ -0,0 +1,8 @@
! RUN: %if x86-registered-target %{ %flang -mtune=pentium4 -S -emit-llvm %s -o - | FileCheck %s --check-prefixes=ALL,CHECK-X86 %}
! RUN: %if aarch64-registered-target %{ %flang -mtune=neoverse-n1 -S -emit-llvm %s -o - | FileCheck %s --check-prefixes=ALL,CHECK-ARM %}
!ALL: attributes #{{[0-9]+}} = {
!CHECK-X86-SAME: "tune-cpu"="pentium4"
!CHECK-ARM-SAME: "tune-cpu"="neoverse-n1"
subroutine a
end subroutine a

3
flang/tools/bbc/bbc.cpp
View File

@ -367,11 +367,12 @@ static llvm::LogicalResult convertFortranSourceToMLIR(
loweringOptions.setLowerToHighLevelFIR(useHLFIR || emitHLFIR);
loweringOptions.setNSWOnLoopVarInc(setNSW);
std::vector<Fortran::lower::EnvironmentDefault> envDefaults = {};
constexpr const char *tuneCPU = "";
auto burnside = Fortran::lower::LoweringBridge::create(
ctx, semanticsContext, defKinds, semanticsContext.intrinsics(),
semanticsContext.targetCharacteristics(), parsing.allCooked(),
targetTriple, kindMap, loweringOptions, envDefaults,
semanticsContext.languageFeatures(), targetMachine);
semanticsContext.languageFeatures(), targetMachine, tuneCPU);
mlir::ModuleOp mlirModule = burnside.getModule();
if (enableOpenMP) {
if (enableOpenMPGPU && !enableOpenMPDevice) {

4
flang/tools/tco/tco.cpp
View File

@ -58,6 +58,9 @@ static cl::opt<std::string> targetTriple("target",
static cl::opt<std::string>
targetCPU("target-cpu", cl::desc("specify a target CPU"), cl::init(""));
static cl::opt<std::string> tuneCPU("tune-cpu", cl::desc("specify a tune CPU"),
cl::init(""));
static cl::opt<std::string>
targetFeatures("target-features", cl::desc("specify the target features"),
cl::init(""));
@ -113,6 +116,7 @@ compileFIR(const mlir::PassPipelineCLParser &passPipeline) {
fir::setTargetTriple(*owningRef, targetTriple);
fir::setKindMapping(*owningRef, kindMap);
fir::setTargetCPU(*owningRef, targetCPU);
fir::setTuneCPU(*owningRef, tuneCPU);
fir::setTargetFeatures(*owningRef, targetFeatures);
// tco is a testing tool, so it will happily use the target independent
// data layout if none is on the module.

3
flang/unittests/Optimizer/FIRContextTest.cpp
View File

@ -34,6 +34,7 @@ public:
"i10:80,l3:24,a1:8,r54:Double,r62:X86_FP80,r11:PPC_FP128";
std::string target = "powerpc64le-unknown-linux-gnu";
std::string targetCPU = "gfx90a";
std::string tuneCPU = "generic";
std::string targetFeatures = "+gfx9-insts,+wavefrontsize64";
mlir::ModuleOp mod;
};
@ -42,6 +43,7 @@ TEST_F(StringAttributesTests, moduleStringAttrTest) {
setTargetTriple(mod, target);
setKindMapping(mod, *kindMap);
setTargetCPU(mod, targetCPU);
setTuneCPU(mod, tuneCPU);
setTargetFeatures(mod, targetFeatures);
auto triple = getTargetTriple(mod);
@ -61,6 +63,7 @@ TEST_F(StringAttributesTests, moduleStringAttrTest) {
EXPECT_TRUE(mapStr.find("r62:X86_FP80") != std::string::npos);
EXPECT_EQ(getTargetCPU(mod), targetCPU);
EXPECT_EQ(getTuneCPU(mod), tuneCPU);
auto features = getTargetFeatures(mod);
auto featuresList = features.getFeatures();

1
mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td
View File

@ -1449,6 +1449,7 @@ def LLVM_LLVMFuncOp : LLVM_Op<"func", [
OptionalAttr<LLVM_VScaleRangeAttr>:$vscale_range,
OptionalAttr<FramePointerKindAttr>:$frame_pointer,
OptionalAttr<StrAttr>:$target_cpu,
OptionalAttr<StrAttr>:$tune_cpu,
OptionalAttr<LLVM_TargetFeaturesAttr>:$target_features,
OptionalAttr<BoolAttr>:$unsafe_fp_math,
OptionalAttr<BoolAttr>:$no_infs_fp_math,

5
mlir/lib/Target/LLVMIR/ModuleImport.cpp
View File

@ -1688,6 +1688,7 @@ static constexpr std::array kExplicitAttributes{
StringLiteral("noinline"),
StringLiteral("optnone"),
StringLiteral("target-features"),
StringLiteral("tune-cpu"),
StringLiteral("unsafe-fp-math"),
StringLiteral("vscale_range"),
};
@ -1804,6 +1805,10 @@ void ModuleImport::processFunctionAttributes(llvm::Function *func,
attr.isStringAttribute())
funcOp.setTargetCpuAttr(StringAttr::get(context, attr.getValueAsString()));
if (llvm::Attribute attr = func->getFnAttribute("tune-cpu");
attr.isStringAttribute())
funcOp.setTuneCpuAttr(StringAttr::get(context, attr.getValueAsString()));
if (llvm::Attribute attr = func->getFnAttribute("target-features");
attr.isStringAttribute())
funcOp.setTargetFeaturesAttr(

3
mlir/lib/Target/LLVMIR/ModuleTranslation.cpp
View File

@ -1331,6 +1331,9 @@ LogicalResult ModuleTranslation::convertOneFunction(LLVMFuncOp func) {
if (auto targetCpu = func.getTargetCpu())
llvmFunc->addFnAttr("target-cpu", *targetCpu);
if (auto tuneCpu = func.getTuneCpu())
llvmFunc->addFnAttr("tune-cpu", *tuneCpu);
if (auto targetFeatures = func.getTargetFeatures())
llvmFunc->addFnAttr("target-features", targetFeatures->getFeaturesString());

16
mlir/test/Target/LLVMIR/Import/tune-cpu.ll Normal file
View File

@ -0,0 +1,16 @@
; RUN: mlir-translate -import-llvm -split-input-file %s | FileCheck %s
; CHECK-LABEL: llvm.func @tune_cpu_x86()
; CHECK-SAME: tune_cpu = "pentium4"
define void @tune_cpu_x86() #0 {
ret void
}
; CHECK-LABEL: llvm.func @tune_cpu_arm()
; CHECK-SAME: tune_cpu = "neoverse-n1"
define void @tune_cpu_arm() #1 {
ret void
}
attributes #0 = { "tune-cpu"="pentium4" }
attributes #1 = { "tune-cpu"="neoverse-n1" }

14
mlir/test/Target/LLVMIR/tune-cpu.mlir Normal file
View File

@ -0,0 +1,14 @@
// RUN: mlir-translate -mlir-to-llvmir %s | FileCheck %s
// CHECK: define void @tune_cpu_x86() #[[ATTRSX86:.*]] {
// CHECK: define void @tune_cpu_arm() #[[ATTRSARM:.*]] {
// CHECK: attributes #[[ATTRSX86]] = { "tune-cpu"="pentium4" }
// CHECK: attributes #[[ATTRSARM]] = { "tune-cpu"="neoverse-n1" }
llvm.func @tune_cpu_x86() attributes {tune_cpu = "pentium4"} {
llvm.return
}
llvm.func @tune_cpu_arm() attributes {tune_cpu = "neoverse-n1"} {
llvm.return
}