[flang-commits] [flang] [flang] Updating drivers to create data layout before semantics (PR #73301)
via flang-commits
flang-commits at lists.llvm.org
Fri Nov 24 01:24:29 PST 2023
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-flang-fir-hlfir
@llvm/pr-subscribers-flang-driver
Author: None (jeanPerier)
<details>
<summary>Changes</summary>
Preliminary patch to change lowering/code generation to use llvm::DataLayout information instead of generating "sizeof" GEP (see https://github.com/llvm/llvm-project/issues/71507).
Fortran Semantic analysis needs to know about the target type size and alignment to deal with common blocks, and intrinsics like C_SIZEOF/TRANSFER. This information should be obtained from the llvm::DataLayout so that it is consistent during the whole compilation flow.
This change is changing flang-new and bbc drivers to:
1. Create the llvm::TargetMachine so that the data layout of the target can be obtained before semantics.
2. Sharing bbc/flang-new set-up of the SemanticConstext.targetCharateristics from the llvm::TargetMachine. For now, the actual part that set-up the Fortran type size and alignment from the llvm::DataLayout is left TODO so that this change is mostly an NFC impacting the drivers.
3. Let the lowering bridge set-up the mlir::Module datalayout attributes since it is doing it for the target attribute, and that allows the llvm data layout information to be available during lowering.
For flang-new, the changes are code shuffling: the `llvm::TargetMachine` instance is moved to `CompilerInvocation` class so that it can be used to set-up the semantic contexts. `setMLIRDataLayout` is moved to `flang/Optimizer/Support/DataLayout.h` (it will need to be used from codegen pass for fir-opt target independent testing.)), and the code setting-up semantics targetCharacteristics is moved to `Tools/TargetSetup.h` so that it can be shared with bbc.
As a consequence, LLVM targets must be registered when running semantics, and it is not possible to run semantics for a target that is not registered with the -triple option (hence the power pc specific modules can only be built if the PowerPC target is available, @<!-- -->DanielCChen and @<!-- -->kkwli , I think I got it right, but you may want to double check the `tools/f18/CMakeLists.txt` change).
---
Patch is 47.80 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/73301.diff
21 Files Affected:
- (modified) flang/include/flang/Frontend/CompilerInvocation.h (+17)
- (modified) flang/include/flang/Frontend/FrontendActions.h (-4)
- (modified) flang/include/flang/Lower/Bridge.h (+10-3)
- (added) flang/include/flang/Optimizer/Support/DataLayout.h (+39)
- (added) flang/include/flang/Tools/TargetSetup.h (+63)
- (modified) flang/lib/Frontend/CompilerInstance.cpp (+2)
- (modified) flang/lib/Frontend/CompilerInvocation.cpp (+132-14)
- (modified) flang/lib/Frontend/FrontendActions.cpp (+21-159)
- (modified) flang/lib/Lower/Bridge.cpp (+5-1)
- (modified) flang/lib/Optimizer/Support/CMakeLists.txt (+2)
- (added) flang/lib/Optimizer/Support/DataLayout.cpp (+47)
- (added) flang/test/Fir/tco-default-datalayout.fir (+12)
- (added) flang/test/Fir/tco-explicit-datalayout.fir (+13)
- (added) flang/test/Lower/bbc-host-datalayout.f90 (+9)
- (added) flang/test/Lower/bbc-target-datalayout.f90 (+10)
- (modified) flang/test/Semantics/realkinds-aarch64-01.f90 (+1)
- (modified) flang/tools/bbc/CMakeLists.txt (+3)
- (modified) flang/tools/bbc/bbc.cpp (+31-15)
- (modified) flang/tools/f18/CMakeLists.txt (+8-3)
- (modified) flang/tools/tco/tco.cpp (+9-5)
- (modified) flang/unittests/Frontend/FrontendActionTest.cpp (+7-12)
``````````diff
diff --git a/flang/include/flang/Frontend/CompilerInvocation.h b/flang/include/flang/Frontend/CompilerInvocation.h
index 229aa75748f725d..acbf644af24cde4 100644
--- a/flang/include/flang/Frontend/CompilerInvocation.h
+++ b/flang/include/flang/Frontend/CompilerInvocation.h
@@ -24,6 +24,7 @@
#include "clang/Basic/Diagnostic.h"
#include "clang/Basic/DiagnosticOptions.h"
#include "llvm/Option/ArgList.h"
+#include "llvm/Target/TargetMachine.h"
#include <memory>
namespace Fortran::frontend {
@@ -113,6 +114,8 @@ class CompilerInvocation : public CompilerInvocationBase {
bool enableConformanceChecks = false;
bool enableUsageChecks = false;
+ std::unique_ptr<llvm::TargetMachine> targetMachine;
+
/// Used in e.g. unparsing to dump the analyzed rather than the original
/// parse-tree objects.
Fortran::parser::AnalyzedObjectsAsFortran asFortran{
@@ -206,6 +209,14 @@ class CompilerInvocation : public CompilerInvocationBase {
const Fortran::common::IntrinsicTypeDefaultKinds &getDefaultKinds() const {
return defaultKinds;
}
+ const llvm::TargetMachine &getTargetMachine() const {
+ assert(targetMachine && "target machine was not set");
+ return *targetMachine;
+ }
+ llvm::TargetMachine &getTargetMachine() {
+ assert(targetMachine && "target machine was not set");
+ return *targetMachine;
+ }
/// Create a compiler invocation from a list of input options.
/// \returns true on success.
@@ -260,6 +271,12 @@ class CompilerInvocation : public CompilerInvocationBase {
/// Set \p loweringOptions controlling lowering behavior based
/// on the \p optimizationLevel.
void setLoweringOptions();
+
+ /// Sets up LLVM's TargetMachine.
+ bool setUpTargetMachine(clang::DiagnosticsEngine &diags);
+
+ /// Produces the string which represents target feature
+ std::string getTargetFeatures(clang::DiagnosticsEngine &diags);
};
} // end namespace Fortran::frontend
diff --git a/flang/include/flang/Frontend/FrontendActions.h b/flang/include/flang/Frontend/FrontendActions.h
index 8272e0729ce3fc6..e2e859f3a81bd7a 100644
--- a/flang/include/flang/Frontend/FrontendActions.h
+++ b/flang/include/flang/Frontend/FrontendActions.h
@@ -21,7 +21,6 @@
#include "mlir/IR/BuiltinOps.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/IR/Module.h"
-#include "llvm/Target/TargetMachine.h"
#include <memory>
namespace Fortran::frontend {
@@ -204,8 +203,6 @@ class CodeGenAction : public FrontendAction {
void executeAction() override;
/// Runs prescan, parsing, sema and lowers to MLIR.
bool beginSourceFileAction() override;
- /// Sets up LLVM's TargetMachine.
- bool setUpTargetMachine();
/// Runs the optimization (aka middle-end) pipeline on the LLVM module
/// associated with this action.
void runOptimizationPipeline(llvm::raw_pwrite_stream &os);
@@ -234,7 +231,6 @@ class CodeGenAction : public FrontendAction {
BackendActionTy action;
- std::unique_ptr<llvm::TargetMachine> tm;
/// }
public:
~CodeGenAction() override;
diff --git a/flang/include/flang/Lower/Bridge.h b/flang/include/flang/Lower/Bridge.h
index d363068acfdbb9d..6c0d14d65edae1e 100644
--- a/flang/include/flang/Lower/Bridge.h
+++ b/flang/include/flang/Lower/Bridge.h
@@ -22,6 +22,10 @@
#include "flang/Optimizer/Dialect/Support/KindMapping.h"
#include "mlir/IR/BuiltinOps.h"
+namespace llvm {
+class DataLayout;
+} // namespace llvm
+
namespace Fortran {
namespace common {
class IntrinsicTypeDefaultKinds;
@@ -59,10 +63,12 @@ class LoweringBridge {
llvm::StringRef triple, fir::KindMapping &kindMap,
const Fortran::lower::LoweringOptions &loweringOptions,
const std::vector<Fortran::lower::EnvironmentDefault> &envDefaults,
- const Fortran::common::LanguageFeatureControl &languageFeatures) {
+ const Fortran::common::LanguageFeatureControl &languageFeatures,
+ const llvm::DataLayout *dataLayout = nullptr) {
return LoweringBridge(ctx, semanticsContext, defaultKinds, intrinsics,
targetCharacteristics, allCooked, triple, kindMap,
- loweringOptions, envDefaults, languageFeatures);
+ loweringOptions, envDefaults, languageFeatures,
+ dataLayout);
}
//===--------------------------------------------------------------------===//
@@ -140,7 +146,8 @@ class LoweringBridge {
fir::KindMapping &kindMap,
const Fortran::lower::LoweringOptions &loweringOptions,
const std::vector<Fortran::lower::EnvironmentDefault> &envDefaults,
- const Fortran::common::LanguageFeatureControl &languageFeatures);
+ const Fortran::common::LanguageFeatureControl &languageFeatures,
+ const llvm::DataLayout *dataLayout);
LoweringBridge() = delete;
LoweringBridge(const LoweringBridge &) = delete;
diff --git a/flang/include/flang/Optimizer/Support/DataLayout.h b/flang/include/flang/Optimizer/Support/DataLayout.h
new file mode 100644
index 000000000000000..fe683a72927df04
--- /dev/null
+++ b/flang/include/flang/Optimizer/Support/DataLayout.h
@@ -0,0 +1,39 @@
+//===-- Optimizer/Support/DataLayout.h --------------------------*- C++ -*-===//
+//
+// 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/
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef FORTRAN_OPTIMIZER_SUPPORT_DATALAYOUT_H
+#define FORTRAN_OPTIMIZER_SUPPORT_DATALAYOUT_H
+
+namespace mlir {
+class ModuleOp;
+}
+namespace llvm {
+class DataLayout;
+}
+
+namespace fir::support {
+/// Create an mlir::DataLayoutSpecInterface attribute from an llvm::DataLayout
+/// and set it on the provided mlir::ModuleOp.
+/// Also set the llvm.data_layout attribute with the string representation of
+/// the llvm::DataLayout on the module.
+/// These attributes are replaced if they were already set.
+void setMLIRDataLayout(mlir::ModuleOp mlirModule, const llvm::DataLayout &dl);
+
+/// Create an mlir::DataLayoutSpecInterface from the llvm>data_layout attribute
+/// if one is provided. If such attribute is not available, create a default
+/// target independent layout when allowDefaultLayout is true. Otherwise do
+/// nothing.
+void setMLIRDataLayoutFromAttributes(mlir::ModuleOp mlirModule,
+ bool allowDefaultLayout);
+} // namespace fir::support
+
+#endif // FORTRAN_OPTIMIZER_SUPPORT_DATALAYOUT_H
diff --git a/flang/include/flang/Tools/TargetSetup.h b/flang/include/flang/Tools/TargetSetup.h
new file mode 100644
index 000000000000000..0b09acefde98a3c
--- /dev/null
+++ b/flang/include/flang/Tools/TargetSetup.h
@@ -0,0 +1,63 @@
+//===-- Tools/TargetSetup.h ------------------------------------- *-C++-*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef FORTRAN_TOOLS_TARGET_SETUP_H
+#define FORTRAN_TOOLS_TARGET_SETUP_H
+
+#include "flang/Evaluate/target.h"
+#include "llvm/MC/TargetRegistry.h"
+#include "llvm/Target/TargetMachine.h"
+#include "llvm/TargetParser/Host.h"
+#include <memory>
+
+namespace Fortran::tools {
+
+[[maybe_unused]] inline static void setUpTargetCharacteristics(
+ Fortran::evaluate::TargetCharacteristics &targetCharacteristics,
+ const llvm::TargetMachine &targetMachine,
+ const std::string &compilerVersion, const std::string &compilerOptions) {
+
+ const llvm::Triple &targetTriple{targetMachine.getTargetTriple()};
+ // FIXME: Handle real(3) ?
+ if (targetTriple.getArch() != llvm::Triple::ArchType::x86_64)
+ targetCharacteristics.DisableType(
+ Fortran::common::TypeCategory::Real, /*kind=*/10);
+
+ targetCharacteristics.set_compilerOptionsString(compilerOptions)
+ .set_compilerVersionString(compilerVersion);
+
+ if (targetTriple.isPPC())
+ targetCharacteristics.set_isPPC(true);
+
+ // TODO: use target machine data layout to set-up the target characteristics
+ // type size and alignment info.
+}
+
+/// Create a target machine that is at least sufficient to get data-layout
+/// information required by flang semantics and lowering. Note that it may not
+/// contain all the CPU feature information to get optimized assembly generation
+/// from LLVM IR. Drivers that needs to generate assembly from LLVM IR should
+/// create a target machine according to their specific options.
+[[maybe_unused]] inline static std::unique_ptr<llvm::TargetMachine>
+createTargetMachine(llvm::StringRef targetTriple, std::string &error) {
+ std::string triple{targetTriple};
+ if (triple.empty())
+ triple = llvm::sys::getDefaultTargetTriple();
+
+ const llvm::Target *theTarget =
+ llvm::TargetRegistry::lookupTarget(triple, error);
+ if (!theTarget)
+ return nullptr;
+ return std::unique_ptr<llvm::TargetMachine>{
+ theTarget->createTargetMachine(triple, /*CPU=*/"",
+ /*Features=*/"", llvm::TargetOptions(),
+ /*Reloc::Model=*/std::nullopt)};
+}
+} // namespace Fortran::tools
+
+#endif // FORTRAN_TOOLS_TARGET_SETUP_H
diff --git a/flang/lib/Frontend/CompilerInstance.cpp b/flang/lib/Frontend/CompilerInstance.cpp
index 21ebf52f76410bd..1e3f5034a438a24 100644
--- a/flang/lib/Frontend/CompilerInstance.cpp
+++ b/flang/lib/Frontend/CompilerInstance.cpp
@@ -156,6 +156,8 @@ bool CompilerInstance::executeAction(FrontendAction &act) {
invoc.setFortranOpts();
// Set the encoding to read all input files in based on user input.
allSources->set_encoding(invoc.getFortranOpts().encoding);
+ if (!invoc.setUpTargetMachine(getDiagnostics()))
+ return false;
// Create the semantics context and set semantic options.
invoc.setSemanticsOpts(*this->allCookedSources);
// Set options controlling lowering to FIR.
diff --git a/flang/lib/Frontend/CompilerInvocation.cpp b/flang/lib/Frontend/CompilerInvocation.cpp
index cb4f2d6a6225205..fe53f0f2116ad66 100644
--- a/flang/lib/Frontend/CompilerInvocation.cpp
+++ b/flang/lib/Frontend/CompilerInvocation.cpp
@@ -18,6 +18,7 @@
#include "flang/Frontend/PreprocessorOptions.h"
#include "flang/Frontend/TargetOptions.h"
#include "flang/Semantics/semantics.h"
+#include "flang/Tools/TargetSetup.h"
#include "flang/Version.inc"
#include "clang/Basic/AllDiagnostics.h"
#include "clang/Basic/DiagnosticDriver.h"
@@ -25,9 +26,11 @@
#include "clang/Driver/DriverDiagnostic.h"
#include "clang/Driver/OptionUtils.h"
#include "clang/Driver/Options.h"
+#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/StringSwitch.h"
#include "llvm/Frontend/Debug/Options.h"
+#include "llvm/MC/TargetRegistry.h"
#include "llvm/Option/Arg.h"
#include "llvm/Option/ArgList.h"
#include "llvm/Option/OptTable.h"
@@ -37,6 +40,7 @@
#include "llvm/Support/Process.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/TargetParser/Host.h"
+#include "llvm/TargetParser/TargetParser.h"
#include "llvm/TargetParser/Triple.h"
#include <cstdlib>
#include <memory>
@@ -1347,20 +1351,10 @@ void CompilerInvocation::setSemanticsOpts(
.set_moduleFileSuffix(getModuleFileSuffix())
.set_underscoring(getCodeGenOpts().Underscoring);
- llvm::Triple targetTriple{llvm::Triple(this->targetOpts.triple)};
- // FIXME: Handle real(3) ?
- if (targetTriple.getArch() != llvm::Triple::ArchType::x86_64) {
- semanticsContext->targetCharacteristics().DisableType(
- Fortran::common::TypeCategory::Real, /*kind=*/10);
- }
-
- std::string version = Fortran::common::getFlangFullVersion();
- semanticsContext->targetCharacteristics()
- .set_compilerOptionsString(allCompilerInvocOpts)
- .set_compilerVersionString(version);
-
- if (targetTriple.isPPC())
- semanticsContext->targetCharacteristics().set_isPPC(true);
+ std::string compilerVersion = Fortran::common::getFlangFullVersion();
+ Fortran::tools::setUpTargetCharacteristics(
+ semanticsContext->targetCharacteristics(), getTargetMachine(),
+ compilerVersion, allCompilerInvocOpts);
}
/// Set \p loweringOptions controlling lowering behavior based
@@ -1387,3 +1381,127 @@ void CompilerInvocation::setLoweringOptions() {
.setAssociativeMath(langOptions.AssociativeMath)
.setReciprocalMath(langOptions.ReciprocalMath);
}
+
+// Get feature string which represents combined explicit target features
+// for AMD GPU and the target features specified by the user
+static std::string
+getExplicitAndImplicitAMDGPUTargetFeatures(clang::DiagnosticsEngine &diags,
+ const TargetOptions &targetOpts,
+ const llvm::Triple triple) {
+ llvm::StringRef cpu = targetOpts.cpu;
+ llvm::StringMap<bool> implicitFeaturesMap;
+ std::string errorMsg;
+ // Get the set of implicit target features
+ llvm::AMDGPU::fillAMDGPUFeatureMap(cpu, triple, implicitFeaturesMap);
+
+ // Add target features specified by the user
+ for (auto &userFeature : targetOpts.featuresAsWritten) {
+ std::string userKeyString = userFeature.substr(1);
+ implicitFeaturesMap[userKeyString] = (userFeature[0] == '+');
+ }
+
+ if (!llvm::AMDGPU::insertWaveSizeFeature(cpu, triple, implicitFeaturesMap,
+ errorMsg)) {
+ unsigned diagID = diags.getCustomDiagID(clang::DiagnosticsEngine::Error,
+ "Unsupported feature ID: %0");
+ diags.Report(diagID) << errorMsg.data();
+ return std::string();
+ }
+
+ llvm::SmallVector<std::string> featuresVec;
+ for (auto &implicitFeatureItem : implicitFeaturesMap) {
+ featuresVec.push_back((llvm::Twine(implicitFeatureItem.second ? "+" : "-") +
+ implicitFeatureItem.first().str())
+ .str());
+ }
+ llvm::sort(featuresVec);
+ return llvm::join(featuresVec, ",");
+}
+
+// Get feature string which represents combined explicit target features
+// for NVPTX and the target features specified by the user/
+// TODO: Have a more robust target conf like `clang/lib/Basic/Targets/NVPTX.cpp`
+static std::string
+getExplicitAndImplicitNVPTXTargetFeatures(clang::DiagnosticsEngine &diags,
+ const TargetOptions &targetOpts,
+ const llvm::Triple triple) {
+ llvm::StringRef cpu = targetOpts.cpu;
+ llvm::StringMap<bool> implicitFeaturesMap;
+ std::string errorMsg;
+ bool ptxVer = false;
+
+ // Add target features specified by the user
+ for (auto &userFeature : targetOpts.featuresAsWritten) {
+ llvm::StringRef userKeyString(llvm::StringRef(userFeature).drop_front(1));
+ implicitFeaturesMap[userKeyString.str()] = (userFeature[0] == '+');
+ // Check if the user provided a PTX version
+ if (userKeyString.startswith("ptx"))
+ ptxVer = true;
+ }
+
+ // Set the default PTX version to `ptx61` if none was provided.
+ // TODO: set the default PTX version based on the chip.
+ if (!ptxVer)
+ implicitFeaturesMap["ptx61"] = true;
+
+ // Set the compute capability.
+ implicitFeaturesMap[cpu.str()] = true;
+
+ llvm::SmallVector<std::string> featuresVec;
+ for (auto &implicitFeatureItem : implicitFeaturesMap) {
+ featuresVec.push_back((llvm::Twine(implicitFeatureItem.second ? "+" : "-") +
+ implicitFeatureItem.first().str())
+ .str());
+ }
+ llvm::sort(featuresVec);
+ return llvm::join(featuresVec, ",");
+}
+
+std::string
+CompilerInvocation::getTargetFeatures(clang::DiagnosticsEngine &diags) {
+ const TargetOptions &targetOpts = getTargetOpts();
+ const llvm::Triple triple(targetOpts.triple);
+
+ // Clang does not append all target features to the clang -cc1 invocation.
+ // Some target features are parsed implicitly by clang::TargetInfo child
+ // class. Clang::TargetInfo classes are the basic clang classes and
+ // they cannot be reused by Flang.
+ // That's why we need to extract implicit target features and add
+ // them to the target features specified by the user
+ if (triple.isAMDGPU()) {
+ return getExplicitAndImplicitAMDGPUTargetFeatures(diags, targetOpts,
+ triple);
+ } else if (triple.isNVPTX()) {
+ return getExplicitAndImplicitNVPTXTargetFeatures(diags, targetOpts, triple);
+ }
+ return llvm::join(targetOpts.featuresAsWritten.begin(),
+ targetOpts.featuresAsWritten.end(), ",");
+}
+
+bool CompilerInvocation::setUpTargetMachine(clang::DiagnosticsEngine &diags) {
+ const std::string &theTriple = getTargetOpts().triple;
+
+ // Create `Target`
+ std::string error;
+ const llvm::Target *theTarget =
+ llvm::TargetRegistry::lookupTarget(theTriple, error);
+ if (!theTarget) {
+ diags.Report(clang::diag::err_fe_unable_to_create_target) << error;
+ return false;
+ }
+
+ // Create `TargetMachine`
+ const auto &CGOpts = getCodeGenOpts();
+ std::optional<llvm::CodeGenOptLevel> OptLevelOrNone =
+ llvm::CodeGenOpt::getLevel(CGOpts.OptimizationLevel);
+ assert(OptLevelOrNone && "Invalid optimization level!");
+ llvm::CodeGenOptLevel OptLevel = *OptLevelOrNone;
+ std::string featuresStr = getTargetFeatures(diags);
+ targetMachine.reset(theTarget->createTargetMachine(
+ theTriple, /*CPU=*/targetOpts.cpu,
+ /*Features=*/featuresStr, llvm::TargetOptions(),
+ /*Reloc::Model=*/CGOpts.getRelocationModel(),
+ /*CodeModel::Model=*/std::nullopt, OptLevel));
+ assert(tm && "Failed to create TargetMachine");
+ return true;
+}
diff --git a/flang/lib/Frontend/FrontendActions.cpp b/flang/lib/Frontend/FrontendActions.cpp
index f573ac82c91cd8e..1cf064366f9c6e6 100644
--- a/flang/lib/Frontend/FrontendActions.cpp
+++ b/flang/lib/Frontend/FrontendActions.cpp
@@ -21,6 +21,7 @@
#include "flang/Lower/Support/Verifier.h"
#include "flang/Optimizer/Dialect/Support/FIRContext.h"
#include "flang/Optimizer/Dialect/Support/KindMapping.h"
+#include "flang/Optimizer/Support/DataLayout.h"
#include "flang/Optimizer/Support/InitFIR.h"
#include "flang/Optimizer/Support/Utils.h"
#include "flang/Optimizer/Transforms/Passes.h"
@@ -53,7 +54,6 @@
#include "llvm/IR/LegacyPassManager.h"
#include "llvm/IR/Verifier.h"
#include "llvm/IRReader/IRReader.h"
-#include "llvm/MC/TargetRegistry.h"
#include "llvm/Object/OffloadBinary.h"
#include "llvm/Passes/PassBuilder.h"
#include "llvm/Passes/PassPlugin.h"
@@ -65,7 +65,6 @@
#include "llvm/Support/SourceMgr.h"
#include "llvm/Support/ToolOutputFile.h"
#include "llvm/Target/TargetMachine.h"
-#include "llvm/TargetParser/TargetParser.h"
#include "llvm/Transforms/Utils/ModuleUtils.h"
#include <memory>
#include <system_error>
@@ -139,111 +138,6 @@ bool PrescanAndSemaDebugAction::beginSourceFileAction() {
(generateRtTypeTables() || true);
}
-// Get feature string which represents combined explicit target features
-// for AMD GPU and the target features specified by the user
-static std::string
-getExplicitAndImplicitAMDGPUTargetFeatures(CompilerInstance &ci,
- const TargetOptions &targetOpts,
- const llvm::Triple triple) {
- llvm::StringRef cpu = targetOpts.cpu;
- llvm::StringMap<bool> implicitFeaturesMap;
- std::string errorMsg;
- // Get the set of implicit target features
- llvm::AMDGPU::fillAMDGPUFeatureMap(cpu, triple, implicitFeaturesMap);
-
- // Add target features specified by the user
- for (auto &userFeature : targetOpts.featuresAsWritten) {
- std::string userKeyString = userFeature.substr(1);
- implicitFeaturesMap[userKeyString] = (userFeature[0] == '+');
- }
-
- if (!llvm::AMDGPU::insertWaveSizeFeature(cpu, triple, implicitFeaturesMap,
- errorMsg)) {
- unsigned diagID = ci.getDiagnostics().getCustomDiagID(
- clang::DiagnosticsEngine::Error, "Unsupported feature ID: %0");
- ci.getDiagnostics().Report(diagID) << errorMsg.data();
- return std::string();
- }
-
- llvm::SmallVect...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/73301
More information about the flang-commits
mailing list