aboutsummaryrefslogtreecommitdiff
path: root/flang/lib
diff options
context:
space:
mode:
Diffstat (limited to 'flang/lib')
-rw-r--r--flang/lib/Frontend/CMakeLists.txt1
-rw-r--r--flang/lib/Frontend/CompilerInvocation.cpp547
-rw-r--r--flang/lib/FrontendTool/CMakeLists.txt1
-rw-r--r--flang/lib/FrontendTool/ExecuteCompilerInvocation.cpp6
-rw-r--r--flang/lib/Lower/Bridge.cpp3
-rw-r--r--flang/lib/Optimizer/Analysis/AliasAnalysis.cpp57
-rw-r--r--flang/lib/Optimizer/Builder/CUFCommon.cpp23
-rw-r--r--flang/lib/Optimizer/OpenMP/MapInfoFinalization.cpp32
-rw-r--r--flang/lib/Optimizer/Transforms/CUFComputeSharedMemoryOffsetsAndSize.cpp3
-rw-r--r--flang/lib/Optimizer/Transforms/CUFOpConversion.cpp28
-rw-r--r--flang/lib/Parser/Fortran-parsers.cpp4
-rw-r--r--flang/lib/Parser/unparse.cpp4
-rw-r--r--flang/lib/Semantics/check-omp-atomic.cpp8
-rw-r--r--flang/lib/Semantics/resolve-names.cpp1
14 files changed, 347 insertions, 371 deletions
diff --git a/flang/lib/Frontend/CMakeLists.txt b/flang/lib/Frontend/CMakeLists.txt
index 2b3bc0e..bb0b4a3 100644
--- a/flang/lib/Frontend/CMakeLists.txt
+++ b/flang/lib/Frontend/CMakeLists.txt
@@ -76,6 +76,7 @@ add_flang_library(flangFrontend
CLANG_LIBS
clangBasic
clangDriver
+ clangOptions
)
target_precompile_headers(flangFrontend PRIVATE
diff --git a/flang/lib/Frontend/CompilerInvocation.cpp b/flang/lib/Frontend/CompilerInvocation.cpp
index f05c4cf..a9bb78d 100644
--- a/flang/lib/Frontend/CompilerInvocation.cpp
+++ b/flang/lib/Frontend/CompilerInvocation.cpp
@@ -26,8 +26,8 @@
#include "clang/Basic/DiagnosticOptions.h"
#include "clang/Driver/CommonArgs.h"
#include "clang/Driver/Driver.h"
-#include "clang/Driver/OptionUtils.h"
-#include "clang/Driver/Options.h"
+#include "clang/Options/OptionUtils.h"
+#include "clang/Options/Options.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/StringSwitch.h"
@@ -82,11 +82,11 @@ static bool parseShowColorsArgs(const llvm::opt::ArgList &args,
for (auto *a : args) {
const llvm::opt::Option &opt = a->getOption();
- if (opt.matches(clang::driver::options::OPT_fcolor_diagnostics)) {
+ if (opt.matches(clang::options::OPT_fcolor_diagnostics)) {
showColors = Colors_On;
- } else if (opt.matches(clang::driver::options::OPT_fno_color_diagnostics)) {
+ } else if (opt.matches(clang::options::OPT_fno_color_diagnostics)) {
showColors = Colors_Off;
- } else if (opt.matches(clang::driver::options::OPT_fdiagnostics_color_EQ)) {
+ } else if (opt.matches(clang::options::OPT_fdiagnostics_color_EQ)) {
llvm::StringRef value(a->getValue());
if (value == "always")
showColors = Colors_On;
@@ -107,15 +107,13 @@ static unsigned getOptimizationLevel(llvm::opt::ArgList &args,
clang::DiagnosticsEngine &diags) {
unsigned defaultOpt = 0;
- if (llvm::opt::Arg *a =
- args.getLastArg(clang::driver::options::OPT_O_Group)) {
- if (a->getOption().matches(clang::driver::options::OPT_O0))
+ if (llvm::opt::Arg *a = args.getLastArg(clang::options::OPT_O_Group)) {
+ if (a->getOption().matches(clang::options::OPT_O0))
return 0;
- assert(a->getOption().matches(clang::driver::options::OPT_O));
+ assert(a->getOption().matches(clang::options::OPT_O));
- return getLastArgIntValue(args, clang::driver::options::OPT_O, defaultOpt,
- diags);
+ return getLastArgIntValue(args, clang::options::OPT_O, defaultOpt, diags);
}
return defaultOpt;
@@ -133,7 +131,7 @@ static bool parseDebugArgs(Fortran::frontend::CodeGenOptions &opts,
clang::DiagnosticsEngine &diags) {
using DebugInfoKind = llvm::codegenoptions::DebugInfoKind;
if (llvm::opt::Arg *arg =
- args.getLastArg(clang::driver::options::OPT_debug_info_kind_EQ)) {
+ args.getLastArg(clang::options::OPT_debug_info_kind_EQ)) {
std::optional<DebugInfoKind> val =
llvm::StringSwitch<std::optional<DebugInfoKind>>(arg->getValue())
.Case("line-tables-only", llvm::codegenoptions::DebugLineTablesOnly)
@@ -158,13 +156,13 @@ static bool parseDebugArgs(Fortran::frontend::CodeGenOptions &opts,
diags.Report(debugWarning) << arg->getValue();
}
opts.DwarfVersion =
- getLastArgIntValue(args, clang::driver::options::OPT_dwarf_version_EQ,
+ getLastArgIntValue(args, clang::options::OPT_dwarf_version_EQ,
/*Default=*/0, diags);
if (const llvm::opt::Arg *a =
- args.getLastArg(clang::driver::options::OPT_split_dwarf_file))
+ args.getLastArg(clang::options::OPT_split_dwarf_file))
opts.SplitDwarfFile = a->getValue();
if (const llvm::opt::Arg *a =
- args.getLastArg(clang::driver::options::OPT_split_dwarf_output))
+ args.getLastArg(clang::options::OPT_split_dwarf_output))
opts.SplitDwarfOutput = a->getValue();
}
return true;
@@ -174,7 +172,7 @@ static void parseDoConcurrentMapping(Fortran::frontend::CodeGenOptions &opts,
llvm::opt::ArgList &args,
clang::DiagnosticsEngine &diags) {
llvm::opt::Arg *arg =
- args.getLastArg(clang::driver::options::OPT_fdo_concurrent_to_openmp_EQ);
+ args.getLastArg(clang::options::OPT_fdo_concurrent_to_openmp_EQ);
if (!arg)
return;
@@ -199,7 +197,7 @@ static void parseDoConcurrentMapping(Fortran::frontend::CodeGenOptions &opts,
static bool parseVectorLibArg(Fortran::frontend::CodeGenOptions &opts,
llvm::opt::ArgList &args,
clang::DiagnosticsEngine &diags) {
- llvm::opt::Arg *arg = args.getLastArg(clang::driver::options::OPT_fveclib);
+ llvm::opt::Arg *arg = args.getLastArg(clang::options::OPT_fveclib);
if (!arg)
return true;
@@ -237,7 +235,7 @@ parseOptimizationRemark(clang::DiagnosticsEngine &diags,
CodeGenOptions::OptRemark result;
for (llvm::opt::Arg *a : args) {
- if (a->getOption().matches(clang::driver::options::OPT_R_Joined)) {
+ if (a->getOption().matches(clang::options::OPT_R_Joined)) {
llvm::StringRef value = a->getValue();
if (value == remarkOptName) {
@@ -274,39 +272,39 @@ static void parseCodeGenArgs(Fortran::frontend::CodeGenOptions &opts,
clang::DiagnosticsEngine &diags) {
opts.OptimizationLevel = getOptimizationLevel(args, diags);
- if (args.hasFlag(clang::driver::options::OPT_fdebug_pass_manager,
- clang::driver::options::OPT_fno_debug_pass_manager, false))
+ if (args.hasFlag(clang::options::OPT_fdebug_pass_manager,
+ clang::options::OPT_fno_debug_pass_manager, false))
opts.DebugPassManager = 1;
- if (args.hasFlag(clang::driver::options::OPT_fstack_arrays,
- clang::driver::options::OPT_fno_stack_arrays, false))
+ if (args.hasFlag(clang::options::OPT_fstack_arrays,
+ clang::options::OPT_fno_stack_arrays, false))
opts.StackArrays = 1;
- if (args.getLastArg(clang::driver::options::OPT_floop_interchange))
+ if (args.getLastArg(clang::options::OPT_floop_interchange))
opts.InterchangeLoops = 1;
- if (args.getLastArg(clang::driver::options::OPT_fexperimental_loop_fusion))
+ if (args.getLastArg(clang::options::OPT_fexperimental_loop_fusion))
opts.FuseLoops = 1;
- if (args.getLastArg(clang::driver::options::OPT_vectorize_loops))
+ if (args.getLastArg(clang::options::OPT_vectorize_loops))
opts.VectorizeLoop = 1;
- if (args.getLastArg(clang::driver::options::OPT_vectorize_slp))
+ if (args.getLastArg(clang::options::OPT_vectorize_slp))
opts.VectorizeSLP = 1;
- if (args.hasFlag(clang::driver::options::OPT_floop_versioning,
- clang::driver::options::OPT_fno_loop_versioning, false))
+ if (args.hasFlag(clang::options::OPT_floop_versioning,
+ clang::options::OPT_fno_loop_versioning, false))
opts.LoopVersioning = 1;
- opts.UnrollLoops = args.hasFlag(clang::driver::options::OPT_funroll_loops,
- clang::driver::options::OPT_fno_unroll_loops,
+ opts.UnrollLoops = args.hasFlag(clang::options::OPT_funroll_loops,
+ clang::options::OPT_fno_unroll_loops,
(opts.OptimizationLevel > 1));
opts.AliasAnalysis = opts.OptimizationLevel > 0;
// -mframe-pointer=none/non-leaf/reserved/all option.
if (const llvm::opt::Arg *a =
- args.getLastArg(clang::driver::options::OPT_mframe_pointer_EQ)) {
+ args.getLastArg(clang::options::OPT_mframe_pointer_EQ)) {
std::optional<llvm::FramePointerKind> val =
llvm::StringSwitch<std::optional<llvm::FramePointerKind>>(a->getValue())
.Case("none", llvm::FramePointerKind::None)
@@ -322,7 +320,7 @@ static void parseCodeGenArgs(Fortran::frontend::CodeGenOptions &opts,
opts.setFramePointer(val.value());
}
- for (auto *a : args.filtered(clang::driver::options::OPT_fpass_plugin_EQ))
+ for (auto *a : args.filtered(clang::options::OPT_fpass_plugin_EQ))
opts.LLVMPassPlugins.push_back(a->getValue());
opts.Reciprocals = clang::driver::tools::parseMRecipOption(diags, args);
@@ -331,15 +329,14 @@ static void parseCodeGenArgs(Fortran::frontend::CodeGenOptions &opts,
clang::driver::tools::parseMPreferVectorWidthOption(diags, args);
// -fembed-offload-object option
- for (auto *a :
- args.filtered(clang::driver::options::OPT_fembed_offload_object_EQ))
+ for (auto *a : args.filtered(clang::options::OPT_fembed_offload_object_EQ))
opts.OffloadObjects.push_back(a->getValue());
- if (args.hasArg(clang::driver::options::OPT_finstrument_functions))
+ if (args.hasArg(clang::options::OPT_finstrument_functions))
opts.InstrumentFunctions = 1;
- if (const llvm::opt::Arg *a = args.getLastArg(
- clang::driver::options::OPT_mcode_object_version_EQ)) {
+ if (const llvm::opt::Arg *a =
+ args.getLastArg(clang::options::OPT_mcode_object_version_EQ)) {
llvm::StringRef s = a->getValue();
if (s == "6")
opts.CodeObjectVersion = llvm::CodeObjectVersionKind::COV_6;
@@ -353,36 +350,36 @@ static void parseCodeGenArgs(Fortran::frontend::CodeGenOptions &opts,
// -f[no-]save-optimization-record[=<format>]
if (const llvm::opt::Arg *a =
- args.getLastArg(clang::driver::options::OPT_opt_record_file))
+ args.getLastArg(clang::options::OPT_opt_record_file))
opts.OptRecordFile = a->getValue();
// Optimization file format. Defaults to yaml
if (const llvm::opt::Arg *a =
- args.getLastArg(clang::driver::options::OPT_opt_record_format))
+ args.getLastArg(clang::options::OPT_opt_record_format))
opts.OptRecordFormat = a->getValue();
// Specifies, using a regex, which successful optimization passes(middle and
// backend), to include in the final optimization record file generated. If
// not provided -fsave-optimization-record will include all passes.
if (const llvm::opt::Arg *a =
- args.getLastArg(clang::driver::options::OPT_opt_record_passes))
+ args.getLastArg(clang::options::OPT_opt_record_passes))
opts.OptRecordPasses = a->getValue();
// Create OptRemark that allows printing of all successful optimization
// passes applied.
opts.OptimizationRemark =
- parseOptimizationRemark(diags, args, clang::driver::options::OPT_Rpass_EQ,
+ parseOptimizationRemark(diags, args, clang::options::OPT_Rpass_EQ,
/*remarkOptName=*/"pass");
// Create OptRemark that allows all missed optimization passes to be printed.
- opts.OptimizationRemarkMissed = parseOptimizationRemark(
- diags, args, clang::driver::options::OPT_Rpass_missed_EQ,
- /*remarkOptName=*/"pass-missed");
+ opts.OptimizationRemarkMissed =
+ parseOptimizationRemark(diags, args, clang::options::OPT_Rpass_missed_EQ,
+ /*remarkOptName=*/"pass-missed");
// Create OptRemark that allows all optimization decisions made by LLVM
// to be printed.
opts.OptimizationRemarkAnalysis = parseOptimizationRemark(
- diags, args, clang::driver::options::OPT_Rpass_analysis_EQ,
+ diags, args, clang::options::OPT_Rpass_analysis_EQ,
/*remarkOptName=*/"pass-analysis");
if (opts.getDebugInfo() == llvm::codegenoptions::NoDebugInfo) {
@@ -400,23 +397,22 @@ static void parseCodeGenArgs(Fortran::frontend::CodeGenOptions &opts,
opts.setDebugInfo(llvm::codegenoptions::LocTrackingOnly);
}
- if (auto *a = args.getLastArg(clang::driver::options::OPT_save_temps_EQ))
+ if (auto *a = args.getLastArg(clang::options::OPT_save_temps_EQ))
opts.SaveTempsDir = a->getValue();
// -record-command-line option.
if (const llvm::opt::Arg *a =
- args.getLastArg(clang::driver::options::OPT_record_command_line)) {
+ args.getLastArg(clang::options::OPT_record_command_line)) {
opts.RecordCommandLine = a->getValue();
}
// -mlink-builtin-bitcode
- for (auto *a :
- args.filtered(clang::driver::options::OPT_mlink_builtin_bitcode))
+ for (auto *a : args.filtered(clang::options::OPT_mlink_builtin_bitcode))
opts.BuiltinBCLibs.push_back(a->getValue());
// -mrelocation-model option.
if (const llvm::opt::Arg *a =
- args.getLastArg(clang::driver::options::OPT_mrelocation_model)) {
+ args.getLastArg(clang::options::OPT_mrelocation_model)) {
llvm::StringRef modelName = a->getValue();
auto relocModel =
llvm::StringSwitch<std::optional<llvm::Reloc::Model>>(modelName)
@@ -435,31 +431,30 @@ static void parseCodeGenArgs(Fortran::frontend::CodeGenOptions &opts,
}
// -pic-level and -pic-is-pie option.
- if (int picLevel = getLastArgIntValue(
- args, clang::driver::options::OPT_pic_level, 0, diags)) {
+ if (int picLevel =
+ getLastArgIntValue(args, clang::options::OPT_pic_level, 0, diags)) {
if (picLevel > 2)
diags.Report(clang::diag::err_drv_invalid_value)
- << args.getLastArg(clang::driver::options::OPT_pic_level)
- ->getAsString(args)
+ << args.getLastArg(clang::options::OPT_pic_level)->getAsString(args)
<< picLevel;
opts.PICLevel = picLevel;
- if (args.hasArg(clang::driver::options::OPT_pic_is_pie))
+ if (args.hasArg(clang::options::OPT_pic_is_pie))
opts.IsPIE = 1;
}
- if (args.hasArg(clang::driver::options::OPT_fprofile_generate)) {
+ if (args.hasArg(clang::options::OPT_fprofile_generate)) {
opts.setProfileInstr(llvm::driver::ProfileInstrKind::ProfileIRInstr);
}
- if (auto A = args.getLastArg(clang::driver::options::OPT_fprofile_use_EQ)) {
+ if (auto A = args.getLastArg(clang::options::OPT_fprofile_use_EQ)) {
opts.setProfileUse(llvm::driver::ProfileInstrKind::ProfileIRInstr);
opts.ProfileInstrumentUsePath = A->getValue();
}
// -mcmodel option.
if (const llvm::opt::Arg *a =
- args.getLastArg(clang::driver::options::OPT_mcmodel_EQ)) {
+ args.getLastArg(clang::options::OPT_mcmodel_EQ)) {
llvm::StringRef modelName = a->getValue();
std::optional<llvm::CodeModel::Model> codeModel = getCodeModel(modelName);
@@ -470,8 +465,8 @@ static void parseCodeGenArgs(Fortran::frontend::CodeGenOptions &opts,
<< a->getAsString(args) << modelName;
}
- if (const llvm::opt::Arg *arg = args.getLastArg(
- clang::driver::options::OPT_mlarge_data_threshold_EQ)) {
+ if (const llvm::opt::Arg *arg =
+ args.getLastArg(clang::options::OPT_mlarge_data_threshold_EQ)) {
uint64_t LDT;
if (llvm::StringRef(arg->getValue()).getAsInteger(/*Radix=*/10, LDT)) {
diags.Report(clang::diag::err_drv_invalid_value)
@@ -481,15 +476,15 @@ static void parseCodeGenArgs(Fortran::frontend::CodeGenOptions &opts,
}
// This option is compatible with -f[no-]underscoring in gfortran.
- if (args.hasFlag(clang::driver::options::OPT_fno_underscoring,
- clang::driver::options::OPT_funderscoring, false)) {
+ if (args.hasFlag(clang::options::OPT_fno_underscoring,
+ clang::options::OPT_funderscoring, false)) {
opts.Underscoring = 0;
}
parseDoConcurrentMapping(opts, args, diags);
if (const llvm::opt::Arg *arg =
- args.getLastArg(clang::driver::options::OPT_complex_range_EQ)) {
+ args.getLastArg(clang::options::OPT_complex_range_EQ)) {
llvm::StringRef argValue = llvm::StringRef(arg->getValue());
if (argValue == "full") {
opts.setComplexRange(CodeGenOptions::ComplexRangeKind::CX_Full);
@@ -510,46 +505,42 @@ static void parseCodeGenArgs(Fortran::frontend::CodeGenOptions &opts,
/// \param [in] opts The target options instance to update
/// \param [in] args The list of input arguments (from the compiler invocation)
static void parseTargetArgs(TargetOptions &opts, llvm::opt::ArgList &args) {
- if (const llvm::opt::Arg *a =
- args.getLastArg(clang::driver::options::OPT_triple))
+ if (const llvm::opt::Arg *a = args.getLastArg(clang::options::OPT_triple))
opts.triple = a->getValue();
- opts.atomicIgnoreDenormalMode = args.hasFlag(
- clang::driver::options::OPT_fatomic_ignore_denormal_mode,
- clang::driver::options::OPT_fno_atomic_ignore_denormal_mode, false);
- opts.atomicFineGrainedMemory = args.hasFlag(
- clang::driver::options::OPT_fatomic_fine_grained_memory,
- clang::driver::options::OPT_fno_atomic_fine_grained_memory, false);
+ opts.atomicIgnoreDenormalMode =
+ args.hasFlag(clang::options::OPT_fatomic_ignore_denormal_mode,
+ clang::options::OPT_fno_atomic_ignore_denormal_mode, false);
+ opts.atomicFineGrainedMemory =
+ args.hasFlag(clang::options::OPT_fatomic_fine_grained_memory,
+ clang::options::OPT_fno_atomic_fine_grained_memory, false);
opts.atomicRemoteMemory =
- args.hasFlag(clang::driver::options::OPT_fatomic_remote_memory,
- clang::driver::options::OPT_fno_atomic_remote_memory, false);
+ args.hasFlag(clang::options::OPT_fatomic_remote_memory,
+ clang::options::OPT_fno_atomic_remote_memory, false);
- if (const llvm::opt::Arg *a =
- args.getLastArg(clang::driver::options::OPT_target_cpu))
+ if (const llvm::opt::Arg *a = args.getLastArg(clang::options::OPT_target_cpu))
opts.cpu = a->getValue();
- if (const llvm::opt::Arg *a =
- args.getLastArg(clang::driver::options::OPT_tune_cpu))
+ if (const llvm::opt::Arg *a = args.getLastArg(clang::options::OPT_tune_cpu))
opts.cpuToTuneFor = a->getValue();
for (const llvm::opt::Arg *currentArg :
- args.filtered(clang::driver::options::OPT_target_feature))
+ args.filtered(clang::options::OPT_target_feature))
opts.featuresAsWritten.emplace_back(currentArg->getValue());
- if (args.hasArg(clang::driver::options::OPT_fdisable_real_10))
+ if (args.hasArg(clang::options::OPT_fdisable_real_10))
opts.disabledRealKinds.push_back(10);
- if (args.hasArg(clang::driver::options::OPT_fdisable_real_3))
+ if (args.hasArg(clang::options::OPT_fdisable_real_3))
opts.disabledRealKinds.push_back(3);
- if (args.hasArg(clang::driver::options::OPT_fdisable_integer_2))
+ if (args.hasArg(clang::options::OPT_fdisable_integer_2))
opts.disabledIntegerKinds.push_back(2);
- if (args.hasArg(clang::driver::options::OPT_fdisable_integer_16))
+ if (args.hasArg(clang::options::OPT_fdisable_integer_16))
opts.disabledIntegerKinds.push_back(16);
- if (const llvm::opt::Arg *a =
- args.getLastArg(clang::driver::options::OPT_mabi_EQ)) {
+ if (const llvm::opt::Arg *a = args.getLastArg(clang::options::OPT_mabi_EQ)) {
opts.abi = a->getValue();
llvm::StringRef V = a->getValue();
if (V == "vec-extabi") {
@@ -559,9 +550,8 @@ static void parseTargetArgs(TargetOptions &opts, llvm::opt::ArgList &args) {
}
}
- opts.asmVerbose =
- args.hasFlag(clang::driver::options::OPT_fverbose_asm,
- clang::driver::options::OPT_fno_verbose_asm, false);
+ opts.asmVerbose = args.hasFlag(clang::options::OPT_fverbose_asm,
+ clang::options::OPT_fno_verbose_asm, false);
}
// Tweak the frontend configuration based on the frontend action
static void setUpFrontendBasedOnAction(FrontendOptions &opts) {
@@ -594,11 +584,11 @@ static bool parseFrontendArgs(FrontendOptions &opts, llvm::opt::ArgList &args,
// Treat multiple action options as an invocation error. Note that `clang
// -cc1` does accept multiple action options, but will only consider the
// rightmost one.
- if (args.hasMultipleArgs(clang::driver::options::OPT_Action_Group)) {
+ if (args.hasMultipleArgs(clang::options::OPT_Action_Group)) {
llvm::SmallString<32> buf;
llvm::raw_svector_ostream os(buf);
for (const llvm::opt::Arg *arg :
- args.filtered(clang::driver::options::OPT_Action_Group)) {
+ args.filtered(clang::options::OPT_Action_Group)) {
if (buf.size())
os << ", ";
os << "'" << arg->getSpelling() << "'";
@@ -609,99 +599,99 @@ static bool parseFrontendArgs(FrontendOptions &opts, llvm::opt::ArgList &args,
// Identify the action (i.e. opts.ProgramAction)
if (const llvm::opt::Arg *a =
- args.getLastArg(clang::driver::options::OPT_Action_Group)) {
+ args.getLastArg(clang::options::OPT_Action_Group)) {
switch (a->getOption().getID()) {
default: {
llvm_unreachable("Invalid option in group!");
}
- case clang::driver::options::OPT_test_io:
+ case clang::options::OPT_test_io:
opts.programAction = InputOutputTest;
break;
- case clang::driver::options::OPT_E:
+ case clang::options::OPT_E:
opts.programAction = PrintPreprocessedInput;
break;
- case clang::driver::options::OPT_fsyntax_only:
+ case clang::options::OPT_fsyntax_only:
opts.programAction = ParseSyntaxOnly;
break;
- case clang::driver::options::OPT_emit_fir:
+ case clang::options::OPT_emit_fir:
opts.programAction = EmitFIR;
break;
- case clang::driver::options::OPT_emit_hlfir:
+ case clang::options::OPT_emit_hlfir:
opts.programAction = EmitHLFIR;
break;
- case clang::driver::options::OPT_emit_llvm:
+ case clang::options::OPT_emit_llvm:
opts.programAction = EmitLLVM;
break;
- case clang::driver::options::OPT_emit_llvm_bc:
+ case clang::options::OPT_emit_llvm_bc:
opts.programAction = EmitLLVMBitcode;
break;
- case clang::driver::options::OPT_emit_obj:
+ case clang::options::OPT_emit_obj:
opts.programAction = EmitObj;
break;
- case clang::driver::options::OPT_S:
+ case clang::options::OPT_S:
opts.programAction = EmitAssembly;
break;
- case clang::driver::options::OPT_fdebug_unparse:
+ case clang::options::OPT_fdebug_unparse:
opts.programAction = DebugUnparse;
break;
- case clang::driver::options::OPT_fdebug_unparse_no_sema:
+ case clang::options::OPT_fdebug_unparse_no_sema:
opts.programAction = DebugUnparseNoSema;
break;
- case clang::driver::options::OPT_fdebug_unparse_with_symbols:
+ case clang::options::OPT_fdebug_unparse_with_symbols:
opts.programAction = DebugUnparseWithSymbols;
break;
- case clang::driver::options::OPT_fdebug_unparse_with_modules:
+ case clang::options::OPT_fdebug_unparse_with_modules:
opts.programAction = DebugUnparseWithModules;
break;
- case clang::driver::options::OPT_fdebug_dump_symbols:
+ case clang::options::OPT_fdebug_dump_symbols:
opts.programAction = DebugDumpSymbols;
break;
- case clang::driver::options::OPT_fdebug_dump_parse_tree:
+ case clang::options::OPT_fdebug_dump_parse_tree:
opts.programAction = DebugDumpParseTree;
break;
- case clang::driver::options::OPT_fdebug_dump_pft:
+ case clang::options::OPT_fdebug_dump_pft:
opts.programAction = DebugDumpPFT;
break;
- case clang::driver::options::OPT_fdebug_dump_all:
+ case clang::options::OPT_fdebug_dump_all:
opts.programAction = DebugDumpAll;
break;
- case clang::driver::options::OPT_fdebug_dump_parse_tree_no_sema:
+ case clang::options::OPT_fdebug_dump_parse_tree_no_sema:
opts.programAction = DebugDumpParseTreeNoSema;
break;
- case clang::driver::options::OPT_fdebug_dump_provenance:
+ case clang::options::OPT_fdebug_dump_provenance:
opts.programAction = DebugDumpProvenance;
break;
- case clang::driver::options::OPT_fdebug_dump_parsing_log:
+ case clang::options::OPT_fdebug_dump_parsing_log:
opts.programAction = DebugDumpParsingLog;
break;
- case clang::driver::options::OPT_fdebug_measure_parse_tree:
+ case clang::options::OPT_fdebug_measure_parse_tree:
opts.programAction = DebugMeasureParseTree;
break;
- case clang::driver::options::OPT_fdebug_pre_fir_tree:
+ case clang::options::OPT_fdebug_pre_fir_tree:
opts.programAction = DebugPreFIRTree;
break;
- case clang::driver::options::OPT_fget_symbols_sources:
+ case clang::options::OPT_fget_symbols_sources:
opts.programAction = GetSymbolsSources;
break;
- case clang::driver::options::OPT_fget_definition:
+ case clang::options::OPT_fget_definition:
opts.programAction = GetDefinition;
break;
- case clang::driver::options::OPT_init_only:
+ case clang::options::OPT_init_only:
opts.programAction = InitOnly;
break;
// TODO:
- // case clang::driver::options::OPT_emit_llvm:
- // case clang::driver::options::OPT_emit_llvm_only:
- // case clang::driver::options::OPT_emit_codegen_only:
- // case clang::driver::options::OPT_emit_module:
+ // case clang::options::OPT_emit_llvm:
+ // case clang::options::OPT_emit_llvm_only:
+ // case clang::options::OPT_emit_codegen_only:
+ // case clang::options::OPT_emit_module:
// (...)
}
// Parse the values provided with `-fget-definition` (there should be 3
// integers)
if (llvm::opt::OptSpecifier(a->getOption().getID()) ==
- clang::driver::options::OPT_fget_definition) {
+ clang::options::OPT_fget_definition) {
unsigned optVals[3] = {0, 0, 0};
for (unsigned i = 0; i < 3; i++) {
@@ -721,27 +711,25 @@ static bool parseFrontendArgs(FrontendOptions &opts, llvm::opt::ArgList &args,
}
// Parsing -load <dsopath> option and storing shared object path
- if (llvm::opt::Arg *a = args.getLastArg(clang::driver::options::OPT_load)) {
+ if (llvm::opt::Arg *a = args.getLastArg(clang::options::OPT_load)) {
opts.plugins.push_back(a->getValue());
}
// Parsing -plugin <name> option and storing plugin name and setting action
- if (const llvm::opt::Arg *a =
- args.getLastArg(clang::driver::options::OPT_plugin)) {
+ if (const llvm::opt::Arg *a = args.getLastArg(clang::options::OPT_plugin)) {
opts.programAction = PluginAction;
opts.actionName = a->getValue();
}
- opts.outputFile = args.getLastArgValue(clang::driver::options::OPT_o);
- opts.showHelp = args.hasArg(clang::driver::options::OPT_help);
- opts.showVersion = args.hasArg(clang::driver::options::OPT_version);
+ opts.outputFile = args.getLastArgValue(clang::options::OPT_o);
+ opts.showHelp = args.hasArg(clang::options::OPT_help);
+ opts.showVersion = args.hasArg(clang::options::OPT_version);
opts.printSupportedCPUs =
- args.hasArg(clang::driver::options::OPT_print_supported_cpus);
+ args.hasArg(clang::options::OPT_print_supported_cpus);
// Get the input kind (from the value passed via `-x`)
InputKind dashX(Language::Unknown);
- if (const llvm::opt::Arg *a =
- args.getLastArg(clang::driver::options::OPT_x)) {
+ if (const llvm::opt::Arg *a = args.getLastArg(clang::options::OPT_x)) {
llvm::StringRef xValue = a->getValue();
// Principal languages.
dashX = llvm::StringSwitch<InputKind>(xValue)
@@ -768,7 +756,7 @@ static bool parseFrontendArgs(FrontendOptions &opts, llvm::opt::ArgList &args,
// Collect the input files and save them in our instance of FrontendOptions.
std::vector<std::string> inputs =
- args.getAllArgValues(clang::driver::options::OPT_INPUT);
+ args.getAllArgValues(clang::options::OPT_INPUT);
opts.inputs.clear();
if (inputs.empty())
// '-' is the default input if none is given.
@@ -788,18 +776,16 @@ static bool parseFrontendArgs(FrontendOptions &opts, llvm::opt::ArgList &args,
}
// Set fortranForm based on options -ffree-form and -ffixed-form.
- if (const auto *arg =
- args.getLastArg(clang::driver::options::OPT_ffixed_form,
- clang::driver::options::OPT_ffree_form)) {
- opts.fortranForm =
- arg->getOption().matches(clang::driver::options::OPT_ffixed_form)
- ? FortranForm::FixedForm
- : FortranForm::FreeForm;
+ if (const auto *arg = args.getLastArg(clang::options::OPT_ffixed_form,
+ clang::options::OPT_ffree_form)) {
+ opts.fortranForm = arg->getOption().matches(clang::options::OPT_ffixed_form)
+ ? FortranForm::FixedForm
+ : FortranForm::FreeForm;
}
// Set fixedFormColumns based on -ffixed-line-length=<value>
if (const auto *arg =
- args.getLastArg(clang::driver::options::OPT_ffixed_line_length_EQ)) {
+ args.getLastArg(clang::options::OPT_ffixed_line_length_EQ)) {
llvm::StringRef argValue = llvm::StringRef(arg->getValue());
std::int64_t columns = -1;
if (argValue == "none") {
@@ -821,8 +807,7 @@ static bool parseFrontendArgs(FrontendOptions &opts, llvm::opt::ArgList &args,
}
// Set conversion based on -fconvert=<value>
- if (const auto *arg =
- args.getLastArg(clang::driver::options::OPT_fconvert_EQ)) {
+ if (const auto *arg = args.getLastArg(clang::options::OPT_fconvert_EQ)) {
const char *argValue = arg->getValue();
if (auto convert = parseConvertArg(argValue))
opts.envDefaults.push_back({"FORT_CONVERT", *convert});
@@ -832,59 +817,55 @@ static bool parseFrontendArgs(FrontendOptions &opts, llvm::opt::ArgList &args,
}
// -f{no-}implicit-none
- opts.features.Enable(
- Fortran::common::LanguageFeature::ImplicitNoneTypeAlways,
- args.hasFlag(clang::driver::options::OPT_fimplicit_none,
- clang::driver::options::OPT_fno_implicit_none, false));
+ opts.features.Enable(Fortran::common::LanguageFeature::ImplicitNoneTypeAlways,
+ args.hasFlag(clang::options::OPT_fimplicit_none,
+ clang::options::OPT_fno_implicit_none,
+ false));
// -f{no-}implicit-none-ext
- opts.features.Enable(
- Fortran::common::LanguageFeature::ImplicitNoneExternal,
- args.hasFlag(clang::driver::options::OPT_fimplicit_none_ext,
- clang::driver::options::OPT_fno_implicit_none_ext, false));
+ opts.features.Enable(Fortran::common::LanguageFeature::ImplicitNoneExternal,
+ args.hasFlag(clang::options::OPT_fimplicit_none_ext,
+ clang::options::OPT_fno_implicit_none_ext,
+ false));
// -f{no-}backslash
opts.features.Enable(Fortran::common::LanguageFeature::BackslashEscapes,
- args.hasFlag(clang::driver::options::OPT_fbackslash,
- clang::driver::options::OPT_fno_backslash,
- false));
+ args.hasFlag(clang::options::OPT_fbackslash,
+ clang::options::OPT_fno_backslash, false));
// -f{no-}logical-abbreviations
opts.features.Enable(
Fortran::common::LanguageFeature::LogicalAbbreviations,
- args.hasFlag(clang::driver::options::OPT_flogical_abbreviations,
- clang::driver::options::OPT_fno_logical_abbreviations,
- false));
+ args.hasFlag(clang::options::OPT_flogical_abbreviations,
+ clang::options::OPT_fno_logical_abbreviations, false));
// -f{no-}unsigned
opts.features.Enable(Fortran::common::LanguageFeature::Unsigned,
- args.hasFlag(clang::driver::options::OPT_funsigned,
- clang::driver::options::OPT_fno_unsigned,
- false));
+ args.hasFlag(clang::options::OPT_funsigned,
+ clang::options::OPT_fno_unsigned, false));
// -f{no-}xor-operator
- opts.features.Enable(
- Fortran::common::LanguageFeature::XOROperator,
- args.hasFlag(clang::driver::options::OPT_fxor_operator,
- clang::driver::options::OPT_fno_xor_operator, false));
+ opts.features.Enable(Fortran::common::LanguageFeature::XOROperator,
+ args.hasFlag(clang::options::OPT_fxor_operator,
+ clang::options::OPT_fno_xor_operator,
+ false));
// -fno-automatic
- if (args.hasArg(clang::driver::options::OPT_fno_automatic)) {
+ if (args.hasArg(clang::options::OPT_fno_automatic)) {
opts.features.Enable(Fortran::common::LanguageFeature::DefaultSave);
}
// -f{no}-save-main-program
- opts.features.Enable(
- Fortran::common::LanguageFeature::SaveMainProgram,
- args.hasFlag(clang::driver::options::OPT_fsave_main_program,
- clang::driver::options::OPT_fno_save_main_program, false));
+ opts.features.Enable(Fortran::common::LanguageFeature::SaveMainProgram,
+ args.hasFlag(clang::options::OPT_fsave_main_program,
+ clang::options::OPT_fno_save_main_program,
+ false));
- if (args.hasArg(
- clang::driver::options::OPT_falternative_parameter_statement)) {
+ if (args.hasArg(clang::options::OPT_falternative_parameter_statement)) {
opts.features.Enable(Fortran::common::LanguageFeature::OldStyleParameter);
}
if (const llvm::opt::Arg *arg =
- args.getLastArg(clang::driver::options::OPT_finput_charset_EQ)) {
+ args.getLastArg(clang::options::OPT_finput_charset_EQ)) {
llvm::StringRef argValue = arg->getValue();
if (argValue == "utf-8") {
opts.encoding = Fortran::parser::Encoding::UTF_8;
@@ -929,9 +910,9 @@ static std::string getOpenMPHeadersDir(const char *argv) {
static void parsePreprocessorArgs(Fortran::frontend::PreprocessorOptions &opts,
llvm::opt::ArgList &args) {
// Add macros from the command line.
- for (const auto *currentArg : args.filtered(clang::driver::options::OPT_D,
- clang::driver::options::OPT_U)) {
- if (currentArg->getOption().matches(clang::driver::options::OPT_D)) {
+ for (const auto *currentArg :
+ args.filtered(clang::options::OPT_D, clang::options::OPT_U)) {
+ if (currentArg->getOption().matches(clang::options::OPT_D)) {
opts.addMacroDef(currentArg->getValue());
} else {
opts.addMacroUndef(currentArg->getValue());
@@ -939,34 +920,33 @@ static void parsePreprocessorArgs(Fortran::frontend::PreprocessorOptions &opts,
}
// Add the ordered list of -I's.
- for (const auto *currentArg : args.filtered(clang::driver::options::OPT_I))
+ for (const auto *currentArg : args.filtered(clang::options::OPT_I))
opts.searchDirectoriesFromDashI.emplace_back(currentArg->getValue());
// Prepend the ordered list of -intrinsic-modules-path
// to the default location to search.
for (const auto *currentArg :
- args.filtered(clang::driver::options::OPT_fintrinsic_modules_path))
+ args.filtered(clang::options::OPT_fintrinsic_modules_path))
opts.searchDirectoriesFromIntrModPath.emplace_back(currentArg->getValue());
// -cpp/-nocpp
- if (const auto *currentArg = args.getLastArg(
- clang::driver::options::OPT_cpp, clang::driver::options::OPT_nocpp))
- opts.macrosFlag =
- (currentArg->getOption().matches(clang::driver::options::OPT_cpp))
- ? PPMacrosFlag::Include
- : PPMacrosFlag::Exclude;
+ if (const auto *currentArg =
+ args.getLastArg(clang::options::OPT_cpp, clang::options::OPT_nocpp))
+ opts.macrosFlag = (currentArg->getOption().matches(clang::options::OPT_cpp))
+ ? PPMacrosFlag::Include
+ : PPMacrosFlag::Exclude;
// Enable -cpp based on -x unless explicitly disabled with -nocpp
if (opts.macrosFlag != PPMacrosFlag::Exclude)
- if (const auto *dashX = args.getLastArg(clang::driver::options::OPT_x))
+ if (const auto *dashX = args.getLastArg(clang::options::OPT_x))
opts.macrosFlag = llvm::StringSwitch<PPMacrosFlag>(dashX->getValue())
.Case("f95-cpp-input", PPMacrosFlag::Include)
.Default(opts.macrosFlag);
- opts.noReformat = args.hasArg(clang::driver::options::OPT_fno_reformat);
+ opts.noReformat = args.hasArg(clang::options::OPT_fno_reformat);
opts.preprocessIncludeLines =
- args.hasArg(clang::driver::options::OPT_fpreprocess_include_lines);
- opts.noLineDirectives = args.hasArg(clang::driver::options::OPT_P);
- opts.showMacros = args.hasArg(clang::driver::options::OPT_dM);
+ args.hasArg(clang::options::OPT_fpreprocess_include_lines);
+ opts.noLineDirectives = args.hasArg(clang::options::OPT_P);
+ opts.showMacros = args.hasArg(clang::options::OPT_dM);
}
/// Parses all semantic related arguments and populates the variables
@@ -977,7 +957,7 @@ static bool parseSemaArgs(CompilerInvocation &res, llvm::opt::ArgList &args,
// -J/module-dir option
std::vector<std::string> moduleDirList =
- args.getAllArgValues(clang::driver::options::OPT_module_dir);
+ args.getAllArgValues(clang::options::OPT_module_dir);
// User can only specify one -J/-module-dir directory, but may repeat
// -J/-module-dir as long as the directory is the same each time.
// https://gcc.gnu.org/onlinedocs/gfortran/Directory-Options.html
@@ -996,25 +976,25 @@ static bool parseSemaArgs(CompilerInvocation &res, llvm::opt::ArgList &args,
res.setModuleDir(moduleDirList[0]);
// -fdebug-module-writer option
- if (args.hasArg(clang::driver::options::OPT_fdebug_module_writer)) {
+ if (args.hasArg(clang::options::OPT_fdebug_module_writer)) {
res.setDebugModuleDir(true);
}
// -fhermetic-module-files option
- if (args.hasArg(clang::driver::options::OPT_fhermetic_module_files)) {
+ if (args.hasArg(clang::options::OPT_fhermetic_module_files)) {
res.setHermeticModuleFileOutput(true);
}
// -module-suffix
if (const auto *moduleSuffix =
- args.getLastArg(clang::driver::options::OPT_module_suffix)) {
+ args.getLastArg(clang::options::OPT_module_suffix)) {
res.setModuleFileSuffix(moduleSuffix->getValue());
}
// -f{no-}analyzed-objects-for-unparse
- res.setUseAnalyzedObjectsForUnparse(args.hasFlag(
- clang::driver::options::OPT_fanalyzed_objects_for_unparse,
- clang::driver::options::OPT_fno_analyzed_objects_for_unparse, true));
+ res.setUseAnalyzedObjectsForUnparse(
+ args.hasFlag(clang::options::OPT_fanalyzed_objects_for_unparse,
+ clang::options::OPT_fno_analyzed_objects_for_unparse, true));
return diags.getNumErrors() == numErrorsBefore;
}
@@ -1031,7 +1011,7 @@ static bool parseDiagArgs(CompilerInvocation &res, llvm::opt::ArgList &args,
// chosen to match clang's behavior.
// -pedantic
- if (args.hasArg(clang::driver::options::OPT_pedantic)) {
+ if (args.hasArg(clang::options::OPT_pedantic)) {
features.WarnOnAllNonstandard();
features.WarnOnAllUsage();
res.setEnableConformanceChecks();
@@ -1041,9 +1021,8 @@ static bool parseDiagArgs(CompilerInvocation &res, llvm::opt::ArgList &args,
// -Werror option
// TODO: Currently throws a Diagnostic for anything other than -W<error>,
// this has to change when other -W<opt>'s are supported.
- if (args.hasArg(clang::driver::options::OPT_W_Joined)) {
- const auto &wArgs =
- args.getAllArgValues(clang::driver::options::OPT_W_Joined);
+ if (args.hasArg(clang::options::OPT_W_Joined)) {
+ const auto &wArgs = args.getAllArgValues(clang::options::OPT_W_Joined);
for (const auto &wArg : wArgs) {
if (wArg == "error") {
res.setWarnAsErr(true);
@@ -1060,7 +1039,7 @@ static bool parseDiagArgs(CompilerInvocation &res, llvm::opt::ArgList &args,
}
// -w
- if (args.hasArg(clang::driver::options::OPT_w)) {
+ if (args.hasArg(clang::options::OPT_w)) {
features.DisableAllWarnings();
res.setDisableWarnings();
}
@@ -1080,7 +1059,7 @@ static bool parseDialectArgs(CompilerInvocation &res, llvm::opt::ArgList &args,
unsigned numErrorsBefore = diags.getNumErrors();
// -fd-lines-as-code
- if (args.hasArg(clang::driver::options::OPT_fd_lines_as_code)) {
+ if (args.hasArg(clang::options::OPT_fd_lines_as_code)) {
if (res.getFrontendOpts().fortranForm == FortranForm::FreeForm) {
const unsigned fdLinesAsWarning = diags.getCustomDiagID(
clang::DiagnosticsEngine::Warning,
@@ -1093,7 +1072,7 @@ static bool parseDialectArgs(CompilerInvocation &res, llvm::opt::ArgList &args,
}
// -fd-lines-as-comments
- if (args.hasArg(clang::driver::options::OPT_fd_lines_as_comments)) {
+ if (args.hasArg(clang::options::OPT_fd_lines_as_comments)) {
if (res.getFrontendOpts().fortranForm == FortranForm::FreeForm) {
const unsigned fdLinesAsWarning = diags.getCustomDiagID(
clang::DiagnosticsEngine::Warning,
@@ -1106,18 +1085,18 @@ static bool parseDialectArgs(CompilerInvocation &res, llvm::opt::ArgList &args,
}
// -fdefault* family
- if (args.hasArg(clang::driver::options::OPT_fdefault_real_8)) {
+ if (args.hasArg(clang::options::OPT_fdefault_real_8)) {
res.getDefaultKinds().set_defaultRealKind(8);
res.getDefaultKinds().set_doublePrecisionKind(16);
}
- if (args.hasArg(clang::driver::options::OPT_fdefault_integer_8)) {
+ if (args.hasArg(clang::options::OPT_fdefault_integer_8)) {
res.getDefaultKinds().set_defaultIntegerKind(8);
res.getDefaultKinds().set_subscriptIntegerKind(8);
res.getDefaultKinds().set_sizeIntegerKind(8);
res.getDefaultKinds().set_defaultLogicalKind(8);
}
- if (args.hasArg(clang::driver::options::OPT_fdefault_double_8)) {
- if (!args.hasArg(clang::driver::options::OPT_fdefault_real_8)) {
+ if (args.hasArg(clang::options::OPT_fdefault_double_8)) {
+ if (!args.hasArg(clang::options::OPT_fdefault_real_8)) {
// -fdefault-double-8 has to be used with -fdefault-real-8
// to be compatible with gfortran
const unsigned diagID = diags.getCustomDiagID(
@@ -1128,18 +1107,18 @@ static bool parseDialectArgs(CompilerInvocation &res, llvm::opt::ArgList &args,
// https://gcc.gnu.org/onlinedocs/gfortran/Fortran-Dialect-Options.html
res.getDefaultKinds().set_doublePrecisionKind(8);
}
- if (args.hasArg(clang::driver::options::OPT_flarge_sizes))
+ if (args.hasArg(clang::options::OPT_flarge_sizes))
res.getDefaultKinds().set_sizeIntegerKind(8);
// -x cuda
- auto language = args.getLastArgValue(clang::driver::options::OPT_x);
+ auto language = args.getLastArgValue(clang::options::OPT_x);
if (language == "cuda") {
res.getFrontendOpts().features.Enable(
Fortran::common::LanguageFeature::CUDA);
}
// -fopenacc
- if (args.hasArg(clang::driver::options::OPT_fopenacc)) {
+ if (args.hasArg(clang::options::OPT_fopenacc)) {
res.getFrontendOpts().features.Enable(
Fortran::common::LanguageFeature::OpenACC);
}
@@ -1147,8 +1126,8 @@ static bool parseDialectArgs(CompilerInvocation &res, llvm::opt::ArgList &args,
// -std=f2018
// TODO: Set proper options when more fortran standards
// are supported.
- if (args.hasArg(clang::driver::options::OPT_std_EQ)) {
- auto standard = args.getLastArgValue(clang::driver::options::OPT_std_EQ);
+ if (args.hasArg(clang::options::OPT_std_EQ)) {
+ auto standard = args.getLastArgValue(clang::options::OPT_std_EQ);
// We only allow f2018 as the given standard
if (standard == "f2018") {
res.setEnableConformanceChecks();
@@ -1161,7 +1140,7 @@ static bool parseDialectArgs(CompilerInvocation &res, llvm::opt::ArgList &args,
}
}
// -fcoarray
- if (args.hasArg(clang::driver::options::OPT_fcoarray)) {
+ if (args.hasArg(clang::options::OPT_fcoarray)) {
res.getFrontendOpts().features.Enable(
Fortran::common::LanguageFeature::Coarray);
const unsigned diagID =
@@ -1179,13 +1158,12 @@ static bool parseDialectArgs(CompilerInvocation &res, llvm::opt::ArgList &args,
/// generated.
static bool parseOpenMPArgs(CompilerInvocation &res, llvm::opt::ArgList &args,
clang::DiagnosticsEngine &diags) {
- llvm::opt::Arg *arg = args.getLastArg(clang::driver::options::OPT_fopenmp,
- clang::driver::options::OPT_fno_openmp);
- if (!arg ||
- arg->getOption().matches(clang::driver::options::OPT_fno_openmp)) {
- bool isSimdSpecified = args.hasFlag(
- clang::driver::options::OPT_fopenmp_simd,
- clang::driver::options::OPT_fno_openmp_simd, /*Default=*/false);
+ llvm::opt::Arg *arg = args.getLastArg(clang::options::OPT_fopenmp,
+ clang::options::OPT_fno_openmp);
+ if (!arg || arg->getOption().matches(clang::options::OPT_fno_openmp)) {
+ bool isSimdSpecified =
+ args.hasFlag(clang::options::OPT_fopenmp_simd,
+ clang::options::OPT_fno_openmp_simd, /*Default=*/false);
if (!isSimdSpecified)
return true;
res.getLangOpts().OpenMPSimd = 1;
@@ -1200,8 +1178,7 @@ static bool parseOpenMPArgs(CompilerInvocation &res, llvm::opt::ArgList &args,
res.getLangOpts().OpenMPVersion = newestFullySupported;
res.getFrontendOpts().features.Enable(
Fortran::common::LanguageFeature::OpenMP);
- if (auto *arg =
- args.getLastArg(clang::driver::options::OPT_fopenmp_version_EQ)) {
+ if (auto *arg = args.getLastArg(clang::options::OPT_fopenmp_version_EQ)) {
llvm::ArrayRef<unsigned> ompVersions = llvm::omp::getOpenMPVersions();
unsigned oldVersions[] = {11, 20, 25, 30};
unsigned version = 0;
@@ -1254,16 +1231,16 @@ static bool parseOpenMPArgs(CompilerInvocation &res, llvm::opt::ArgList &args,
}
}
- if (args.hasArg(clang::driver::options::OPT_fopenmp_force_usm)) {
+ if (args.hasArg(clang::options::OPT_fopenmp_force_usm)) {
res.getLangOpts().OpenMPForceUSM = 1;
}
- if (args.hasArg(clang::driver::options::OPT_fopenmp_is_target_device)) {
+ if (args.hasArg(clang::options::OPT_fopenmp_is_target_device)) {
res.getLangOpts().OpenMPIsTargetDevice = 1;
// Get OpenMP host file path if any and report if a non existent file is
// found
- if (auto *arg = args.getLastArg(
- clang::driver::options::OPT_fopenmp_host_ir_file_path)) {
+ if (auto *arg =
+ args.getLastArg(clang::options::OPT_fopenmp_host_ir_file_path)) {
res.getLangOpts().OMPHostIRFile = arg->getValue();
if (!llvm::sys::fs::exists(res.getLangOpts().OMPHostIRFile))
diags.Report(clang::diag::err_omp_host_ir_file_not_found)
@@ -1271,37 +1248,34 @@ static bool parseOpenMPArgs(CompilerInvocation &res, llvm::opt::ArgList &args,
}
if (args.hasFlag(
- clang::driver::options::OPT_fopenmp_assume_teams_oversubscription,
- clang::driver::options::
- OPT_fno_openmp_assume_teams_oversubscription,
+ clang::options::OPT_fopenmp_assume_teams_oversubscription,
+ clang::options::OPT_fno_openmp_assume_teams_oversubscription,
/*Default=*/false))
res.getLangOpts().OpenMPTeamSubscription = true;
- if (args.hasArg(clang::driver::options::OPT_fopenmp_assume_no_thread_state))
+ if (args.hasArg(clang::options::OPT_fopenmp_assume_no_thread_state))
res.getLangOpts().OpenMPNoThreadState = 1;
- if (args.hasArg(
- clang::driver::options::OPT_fopenmp_assume_no_nested_parallelism))
+ if (args.hasArg(clang::options::OPT_fopenmp_assume_no_nested_parallelism))
res.getLangOpts().OpenMPNoNestedParallelism = 1;
if (args.hasFlag(
- clang::driver::options::OPT_fopenmp_assume_threads_oversubscription,
- clang::driver::options::
- OPT_fno_openmp_assume_threads_oversubscription,
+ clang::options::OPT_fopenmp_assume_threads_oversubscription,
+ clang::options::OPT_fno_openmp_assume_threads_oversubscription,
/*Default=*/false))
res.getLangOpts().OpenMPThreadSubscription = true;
- if ((args.hasArg(clang::driver::options::OPT_fopenmp_target_debug) ||
- args.hasArg(clang::driver::options::OPT_fopenmp_target_debug_EQ))) {
- res.getLangOpts().OpenMPTargetDebug = getLastArgIntValue(
- args, clang::driver::options::OPT_fopenmp_target_debug_EQ,
- res.getLangOpts().OpenMPTargetDebug, diags);
+ if ((args.hasArg(clang::options::OPT_fopenmp_target_debug) ||
+ args.hasArg(clang::options::OPT_fopenmp_target_debug_EQ))) {
+ res.getLangOpts().OpenMPTargetDebug =
+ getLastArgIntValue(args, clang::options::OPT_fopenmp_target_debug_EQ,
+ res.getLangOpts().OpenMPTargetDebug, diags);
if (!res.getLangOpts().OpenMPTargetDebug &&
- args.hasArg(clang::driver::options::OPT_fopenmp_target_debug))
+ args.hasArg(clang::options::OPT_fopenmp_target_debug))
res.getLangOpts().OpenMPTargetDebug = 1;
}
- if (args.hasArg(clang::driver::options::OPT_no_offloadlib))
+ if (args.hasArg(clang::options::OPT_no_offloadlib))
res.getLangOpts().NoGPULib = 1;
}
if (llvm::Triple(res.getTargetOpts().triple).isGPU()) {
@@ -1317,8 +1291,7 @@ static bool parseOpenMPArgs(CompilerInvocation &res, llvm::opt::ArgList &args,
}
// Get the OpenMP target triples if any.
- if (auto *arg =
- args.getLastArg(clang::driver::options::OPT_offload_targets_EQ)) {
+ if (auto *arg = args.getLastArg(clang::options::OPT_offload_targets_EQ)) {
enum ArchPtrSize { Arch16Bit, Arch32Bit, Arch64Bit };
auto getArchPtrSize = [](const llvm::Triple &triple) {
if (triple.isArch16Bit())
@@ -1361,7 +1334,7 @@ static bool parseIntegerOverflowArgs(CompilerInvocation &invoc,
clang::DiagnosticsEngine &diags) {
Fortran::common::LangOptions &opts = invoc.getLangOpts();
- if (args.getLastArg(clang::driver::options::OPT_fwrapv))
+ if (args.getLastArg(clang::options::OPT_fwrapv))
opts.setSignedOverflowBehavior(Fortran::common::LangOptions::SOB_Defined);
return true;
@@ -1380,7 +1353,7 @@ static bool parseFloatingPointArgs(CompilerInvocation &invoc,
Fortran::common::LangOptions &opts = invoc.getLangOpts();
if (const llvm::opt::Arg *a =
- args.getLastArg(clang::driver::options::OPT_ffp_contract)) {
+ args.getLastArg(clang::options::OPT_ffp_contract)) {
const llvm::StringRef val = a->getValue();
enum Fortran::common::LangOptions::FPModeKind fpContractMode;
@@ -1397,31 +1370,31 @@ static bool parseFloatingPointArgs(CompilerInvocation &invoc,
opts.setFPContractMode(fpContractMode);
}
- if (args.getLastArg(clang::driver::options::OPT_menable_no_infs)) {
+ if (args.getLastArg(clang::options::OPT_menable_no_infs)) {
opts.NoHonorInfs = true;
}
- if (args.getLastArg(clang::driver::options::OPT_menable_no_nans)) {
+ if (args.getLastArg(clang::options::OPT_menable_no_nans)) {
opts.NoHonorNaNs = true;
}
- if (args.getLastArg(clang::driver::options::OPT_fapprox_func)) {
+ if (args.getLastArg(clang::options::OPT_fapprox_func)) {
opts.ApproxFunc = true;
}
- if (args.getLastArg(clang::driver::options::OPT_fno_signed_zeros)) {
+ if (args.getLastArg(clang::options::OPT_fno_signed_zeros)) {
opts.NoSignedZeros = true;
}
- if (args.getLastArg(clang::driver::options::OPT_mreassociate)) {
+ if (args.getLastArg(clang::options::OPT_mreassociate)) {
opts.AssociativeMath = true;
}
- if (args.getLastArg(clang::driver::options::OPT_freciprocal_math)) {
+ if (args.getLastArg(clang::options::OPT_freciprocal_math)) {
opts.ReciprocalMath = true;
}
- if (args.getLastArg(clang::driver::options::OPT_ffast_math)) {
+ if (args.getLastArg(clang::options::OPT_ffast_math)) {
opts.NoHonorInfs = true;
opts.NoHonorNaNs = true;
opts.AssociativeMath = true;
@@ -1431,7 +1404,7 @@ static bool parseFloatingPointArgs(CompilerInvocation &invoc,
opts.setFPContractMode(Fortran::common::LangOptions::FPM_Fast);
}
- if (args.hasArg(clang::driver::options::OPT_fno_fast_real_mod))
+ if (args.hasArg(clang::options::OPT_fno_fast_real_mod))
opts.NoFastRealMod = true;
return true;
@@ -1446,10 +1419,8 @@ static bool parseFloatingPointArgs(CompilerInvocation &invoc,
/// \param [out] diags DiagnosticsEngine to report erros with
static bool parseVScaleArgs(CompilerInvocation &invoc, llvm::opt::ArgList &args,
clang::DiagnosticsEngine &diags) {
- const auto *vscaleMin =
- args.getLastArg(clang::driver::options::OPT_mvscale_min_EQ);
- const auto *vscaleMax =
- args.getLastArg(clang::driver::options::OPT_mvscale_max_EQ);
+ const auto *vscaleMin = args.getLastArg(clang::options::OPT_mvscale_min_EQ);
+ const auto *vscaleMax = args.getLastArg(clang::options::OPT_mvscale_max_EQ);
if (!vscaleMin && !vscaleMax)
return true;
@@ -1497,8 +1468,7 @@ static bool parseLinkerOptionsArgs(CompilerInvocation &invoc,
// TODO: support --dependent-lib on other platforms when MLIR supports
// !llvm.dependent.lib
- if (args.hasArg(clang::driver::options::OPT_dependent_lib) &&
- !triple.isOSWindows()) {
+ if (args.hasArg(clang::options::OPT_dependent_lib) && !triple.isOSWindows()) {
const unsigned diagID =
diags.getCustomDiagID(clang::DiagnosticsEngine::Error,
"--dependent-lib is only supported on Windows");
@@ -1506,12 +1476,10 @@ static bool parseLinkerOptionsArgs(CompilerInvocation &invoc,
return false;
}
- opts.DependentLibs =
- args.getAllArgValues(clang::driver::options::OPT_dependent_lib);
+ opts.DependentLibs = args.getAllArgValues(clang::options::OPT_dependent_lib);
// -flto=full/thin option.
- if (const llvm::opt::Arg *a =
- args.getLastArg(clang::driver::options::OPT_flto_EQ)) {
+ if (const llvm::opt::Arg *a = args.getLastArg(clang::options::OPT_flto_EQ)) {
llvm::StringRef s = a->getValue();
assert((s == "full" || s == "thin") && "Unknown LTO mode.");
if (s == "full")
@@ -1522,10 +1490,10 @@ static bool parseLinkerOptionsArgs(CompilerInvocation &invoc,
// -ffat-lto-objects
if (const llvm::opt::Arg *arg =
- args.getLastArg(clang::driver::options::OPT_ffat_lto_objects,
- clang::driver::options::OPT_fno_fat_lto_objects)) {
+ args.getLastArg(clang::options::OPT_ffat_lto_objects,
+ clang::options::OPT_fno_fat_lto_objects)) {
opts.PrepareForFatLTO =
- arg->getOption().matches(clang::driver::options::OPT_ffat_lto_objects);
+ arg->getOption().matches(clang::options::OPT_ffat_lto_objects);
if (opts.PrepareForFatLTO) {
assert((opts.PrepareForFullLTO || opts.PrepareForThinLTO) &&
"Unknown LTO mode");
@@ -1566,8 +1534,8 @@ bool CompilerInvocation::createFromArgs(
llvm::Triple::normalize(llvm::sys::getDefaultTargetTriple());
// Parse the arguments
- const llvm::opt::OptTable &opts = clang::driver::getDriverOptTable();
- llvm::opt::Visibility visibilityMask(clang::driver::options::FC1Option);
+ const llvm::opt::OptTable &opts = clang::getDriverOptTable();
+ llvm::opt::Visibility visibilityMask(clang::options::FC1Option);
unsigned missingArgIndex, missingArgCount;
llvm::opt::InputArgList args = opts.ParseArgs(
commandLineArgs, missingArgIndex, missingArgCount, visibilityMask);
@@ -1580,7 +1548,7 @@ bool CompilerInvocation::createFromArgs(
}
// Issue errors on unknown arguments
- for (const auto *a : args.filtered(clang::driver::options::OPT_UNKNOWN)) {
+ for (const auto *a : args.filtered(clang::options::OPT_UNKNOWN)) {
auto argString = a->getAsString(args);
std::string nearest;
if (opts.findNearest(argString, nearest, visibilityMask) > 1)
@@ -1592,15 +1560,15 @@ bool CompilerInvocation::createFromArgs(
}
// -flang-experimental-hlfir
- if (args.hasArg(clang::driver::options::OPT_flang_experimental_hlfir) ||
- args.hasArg(clang::driver::options::OPT_emit_hlfir)) {
+ if (args.hasArg(clang::options::OPT_flang_experimental_hlfir) ||
+ args.hasArg(clang::options::OPT_emit_hlfir)) {
invoc.loweringOpts.setLowerToHighLevelFIR(true);
}
// -flang-deprecated-no-hlfir
- if (args.hasArg(clang::driver::options::OPT_flang_deprecated_no_hlfir) &&
- !args.hasArg(clang::driver::options::OPT_emit_hlfir)) {
- if (args.hasArg(clang::driver::options::OPT_flang_experimental_hlfir)) {
+ if (args.hasArg(clang::options::OPT_flang_deprecated_no_hlfir) &&
+ !args.hasArg(clang::options::OPT_emit_hlfir)) {
+ if (args.hasArg(clang::options::OPT_flang_experimental_hlfir)) {
const unsigned diagID = diags.getCustomDiagID(
clang::DiagnosticsEngine::Error,
"Options '-flang-experimental-hlfir' and "
@@ -1611,13 +1579,13 @@ bool CompilerInvocation::createFromArgs(
}
// -fno-ppc-native-vector-element-order
- if (args.hasArg(clang::driver::options::OPT_fno_ppc_native_vec_elem_order)) {
+ if (args.hasArg(clang::options::OPT_fno_ppc_native_vec_elem_order)) {
invoc.loweringOpts.setNoPPCNativeVecElemOrder(true);
}
// -f[no-]init-global-zero
- if (args.hasFlag(clang::driver::options::OPT_finit_global_zero,
- clang::driver::options::OPT_fno_init_global_zero,
+ if (args.hasFlag(clang::options::OPT_finit_global_zero,
+ clang::options::OPT_fno_init_global_zero,
/*default=*/true))
invoc.loweringOpts.setInitGlobalZero(true);
else
@@ -1626,8 +1594,8 @@ bool CompilerInvocation::createFromArgs(
// Preserve all the remark options requested, i.e. -Rpass, -Rpass-missed or
// -Rpass-analysis. This will be used later when processing and outputting the
// remarks generated by LLVM in ExecuteCompilerInvocation.cpp.
- for (auto *a : args.filtered(clang::driver::options::OPT_R_Group)) {
- if (a->getOption().matches(clang::driver::options::OPT_R_value_Group))
+ for (auto *a : args.filtered(clang::options::OPT_R_Group)) {
+ if (a->getOption().matches(clang::options::OPT_R_value_Group))
// This is -Rfoo=, where foo is the name of the diagnostic
// group. Add only the remark option name to the diagnostics. e.g. for
// -Rpass= we will add the string "pass".
@@ -1640,20 +1608,19 @@ bool CompilerInvocation::createFromArgs(
}
// -frealloc-lhs is the default.
- if (!args.hasFlag(clang::driver::options::OPT_frealloc_lhs,
- clang::driver::options::OPT_fno_realloc_lhs, true))
+ if (!args.hasFlag(clang::options::OPT_frealloc_lhs,
+ clang::options::OPT_fno_realloc_lhs, true))
invoc.loweringOpts.setReallocateLHS(false);
- invoc.loweringOpts.setRepackArrays(
- args.hasFlag(clang::driver::options::OPT_frepack_arrays,
- clang::driver::options::OPT_fno_repack_arrays,
- /*default=*/false));
+ invoc.loweringOpts.setRepackArrays(args.hasFlag(
+ clang::options::OPT_frepack_arrays, clang::options::OPT_fno_repack_arrays,
+ /*default=*/false));
invoc.loweringOpts.setStackRepackArrays(
- args.hasFlag(clang::driver::options::OPT_fstack_repack_arrays,
- clang::driver::options::OPT_fno_stack_repack_arrays,
+ args.hasFlag(clang::options::OPT_fstack_repack_arrays,
+ clang::options::OPT_fno_stack_repack_arrays,
/*default=*/false));
- if (auto *arg = args.getLastArg(
- clang::driver::options::OPT_frepack_arrays_contiguity_EQ))
+ if (auto *arg =
+ args.getLastArg(clang::options::OPT_frepack_arrays_contiguity_EQ))
invoc.loweringOpts.setRepackArraysWhole(arg->getValue() ==
llvm::StringRef{"whole"});
@@ -1673,10 +1640,8 @@ bool CompilerInvocation::createFromArgs(
// `mlirArgs`. Instead, you can use
// * `-mllvm <your-llvm-option>`, or
// * `-mmlir <your-mlir-option>`.
- invoc.frontendOpts.llvmArgs =
- args.getAllArgValues(clang::driver::options::OPT_mllvm);
- invoc.frontendOpts.mlirArgs =
- args.getAllArgValues(clang::driver::options::OPT_mmlir);
+ invoc.frontendOpts.llvmArgs = args.getAllArgValues(clang::options::OPT_mllvm);
+ invoc.frontendOpts.mlirArgs = args.getAllArgValues(clang::options::OPT_mmlir);
success &= parseLangOptionsArgs(invoc, args, diags);
@@ -1700,7 +1665,7 @@ bool CompilerInvocation::createFromArgs(
}
// Process the timing-related options.
- if (args.hasArg(clang::driver::options::OPT_ftime_report))
+ if (args.hasArg(clang::options::OPT_ftime_report))
invoc.enableTimers = true;
invoc.setArgv0(argv0);
diff --git a/flang/lib/FrontendTool/CMakeLists.txt b/flang/lib/FrontendTool/CMakeLists.txt
index faf56e9..b69436c 100644
--- a/flang/lib/FrontendTool/CMakeLists.txt
+++ b/flang/lib/FrontendTool/CMakeLists.txt
@@ -18,5 +18,6 @@ add_flang_library(flangFrontendTool
CLANG_LIBS
clangBasic
+ clangOptions
clangDriver
)
diff --git a/flang/lib/FrontendTool/ExecuteCompilerInvocation.cpp b/flang/lib/FrontendTool/ExecuteCompilerInvocation.cpp
index 09ac129..7586be5 100644
--- a/flang/lib/FrontendTool/ExecuteCompilerInvocation.cpp
+++ b/flang/lib/FrontendTool/ExecuteCompilerInvocation.cpp
@@ -23,7 +23,7 @@
#include "mlir/IR/MLIRContext.h"
#include "mlir/Pass/PassManager.h"
#include "clang/Basic/DiagnosticFrontend.h"
-#include "clang/Driver/Options.h"
+#include "clang/Options/Options.h"
#include "llvm/Option/OptTable.h"
#include "llvm/Option/Option.h"
#include "llvm/Support/BuryPointer.h"
@@ -153,10 +153,10 @@ updateDiagEngineForOptRemarks(clang::DiagnosticsEngine &diagsEng,
bool executeCompilerInvocation(CompilerInstance *flang) {
// Honor -help.
if (flang->getFrontendOpts().showHelp) {
- clang::driver::getDriverOptTable().printHelp(
+ clang::getDriverOptTable().printHelp(
llvm::outs(), "flang -fc1 [options] file...", "LLVM 'Flang' Compiler",
/*ShowHidden=*/false, /*ShowAllAliases=*/false,
- llvm::opt::Visibility(clang::driver::options::FC1Option));
+ llvm::opt::Visibility(clang::options::FC1Option));
return true;
}
diff --git a/flang/lib/Lower/Bridge.cpp b/flang/lib/Lower/Bridge.cpp
index 0f4b39a..5779bcd 100644
--- a/flang/lib/Lower/Bridge.cpp
+++ b/flang/lib/Lower/Bridge.cpp
@@ -3275,6 +3275,9 @@ private:
[&](const Fortran::parser::CompilerDirective::NoInline &) {
attachInliningDirectiveToStmt(dir, &eval);
},
+ [&](const Fortran::parser::CompilerDirective::Prefetch &prefetch) {
+ TODO(getCurrentLocation(), "!$dir prefetch");
+ },
[&](const auto &) {}},
dir.u);
}
diff --git a/flang/lib/Optimizer/Analysis/AliasAnalysis.cpp b/flang/lib/Optimizer/Analysis/AliasAnalysis.cpp
index 73ddd1f..ef98942 100644
--- a/flang/lib/Optimizer/Analysis/AliasAnalysis.cpp
+++ b/flang/lib/Optimizer/Analysis/AliasAnalysis.cpp
@@ -27,6 +27,26 @@ using namespace mlir;
#define DEBUG_TYPE "fir-alias-analysis"
+// Inspect for value-scoped Allocate effects and determine whether
+// 'candidate' is a new allocation. Returns SourceKind::Allocate if a
+// MemAlloc effect is attached
+static fir::AliasAnalysis::SourceKind
+classifyAllocateFromEffects(mlir::Operation *op, mlir::Value candidate) {
+ if (!op)
+ return fir::AliasAnalysis::SourceKind::Unknown;
+ auto interface = llvm::dyn_cast<mlir::MemoryEffectOpInterface>(op);
+ if (!interface)
+ return fir::AliasAnalysis::SourceKind::Unknown;
+ llvm::SmallVector<mlir::MemoryEffects::EffectInstance, 4> effects;
+ interface.getEffects(effects);
+ for (mlir::MemoryEffects::EffectInstance &e : effects) {
+ if (mlir::isa<mlir::MemoryEffects::Allocate>(e.getEffect()) &&
+ e.getValue() && e.getValue() == candidate)
+ return fir::AliasAnalysis::SourceKind::Allocate;
+ }
+ return fir::AliasAnalysis::SourceKind::Unknown;
+}
+
//===----------------------------------------------------------------------===//
// AliasAnalysis: alias
//===----------------------------------------------------------------------===//
@@ -535,6 +555,11 @@ AliasAnalysis::Source AliasAnalysis::getSource(mlir::Value v,
mlir::Operation *instantiationPoint{nullptr};
while (defOp && !breakFromLoop) {
ty = defOp->getResultTypes()[0];
+ // Value-scoped allocation detection via effects.
+ if (classifyAllocateFromEffects(defOp, v) == SourceKind::Allocate) {
+ type = SourceKind::Allocate;
+ break;
+ }
llvm::TypeSwitch<Operation *>(defOp)
.Case<hlfir::AsExprOp>([&](auto op) {
v = op.getVar();
@@ -554,11 +579,6 @@ AliasAnalysis::Source AliasAnalysis::getSource(mlir::Value v,
defOp = v.getDefiningOp();
}
})
- .Case<fir::AllocaOp, fir::AllocMemOp>([&](auto op) {
- // Unique memory allocation.
- type = SourceKind::Allocate;
- breakFromLoop = true;
- })
.Case<fir::ConvertOp>([&](auto op) {
// Skip ConvertOp's and track further through the operand.
v = op->getOperand(0);
@@ -628,16 +648,23 @@ AliasAnalysis::Source AliasAnalysis::getSource(mlir::Value v,
type = SourceKind::Global;
} else {
auto def = llvm::cast<mlir::Value>(boxSrc.origin.u);
- // TODO: Add support to fir.allocmem
- if (auto allocOp = def.template getDefiningOp<fir::AllocaOp>()) {
- v = def;
- defOp = v.getDefiningOp();
- type = SourceKind::Allocate;
- } else if (isDummyArgument(def)) {
- defOp = nullptr;
- v = def;
- } else {
- type = SourceKind::Indirect;
+ bool classified = false;
+ if (auto defDefOp = def.getDefiningOp()) {
+ if (classifyAllocateFromEffects(defDefOp, def) ==
+ SourceKind::Allocate) {
+ v = def;
+ defOp = defDefOp;
+ type = SourceKind::Allocate;
+ classified = true;
+ }
+ }
+ if (!classified) {
+ if (isDummyArgument(def)) {
+ defOp = nullptr;
+ v = def;
+ } else {
+ type = SourceKind::Indirect;
+ }
}
}
breakFromLoop = true;
diff --git a/flang/lib/Optimizer/Builder/CUFCommon.cpp b/flang/lib/Optimizer/Builder/CUFCommon.cpp
index cf7588f..461deb8 100644
--- a/flang/lib/Optimizer/Builder/CUFCommon.cpp
+++ b/flang/lib/Optimizer/Builder/CUFCommon.cpp
@@ -9,6 +9,7 @@
#include "flang/Optimizer/Builder/CUFCommon.h"
#include "flang/Optimizer/Builder/FIRBuilder.h"
#include "flang/Optimizer/Dialect/CUF/CUFOps.h"
+#include "flang/Optimizer/Dialect/Support/KindMapping.h"
#include "flang/Optimizer/HLFIR/HLFIROps.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/LLVMIR/NVVMDialect.h"
@@ -91,3 +92,25 @@ void cuf::genPointerSync(const mlir::Value box, fir::FirOpBuilder &builder) {
}
}
}
+
+int cuf::computeElementByteSize(mlir::Location loc, mlir::Type type,
+ fir::KindMapping &kindMap,
+ bool emitErrorOnFailure) {
+ auto eleTy = fir::unwrapSequenceType(type);
+ if (auto t{mlir::dyn_cast<mlir::IntegerType>(eleTy)})
+ return t.getWidth() / 8;
+ if (auto t{mlir::dyn_cast<mlir::FloatType>(eleTy)})
+ return t.getWidth() / 8;
+ if (auto t{mlir::dyn_cast<fir::LogicalType>(eleTy)})
+ return kindMap.getLogicalBitsize(t.getFKind()) / 8;
+ if (auto t{mlir::dyn_cast<mlir::ComplexType>(eleTy)}) {
+ int elemSize =
+ mlir::cast<mlir::FloatType>(t.getElementType()).getWidth() / 8;
+ return 2 * elemSize;
+ }
+ if (auto t{mlir::dyn_cast<fir::CharacterType>(eleTy)})
+ return kindMap.getCharacterBitsize(t.getFKind()) / 8;
+ if (emitErrorOnFailure)
+ mlir::emitError(loc, "unsupported type");
+ return 0;
+}
diff --git a/flang/lib/Optimizer/OpenMP/MapInfoFinalization.cpp b/flang/lib/Optimizer/OpenMP/MapInfoFinalization.cpp
index d60da89..8382a48 100644
--- a/flang/lib/Optimizer/OpenMP/MapInfoFinalization.cpp
+++ b/flang/lib/Optimizer/OpenMP/MapInfoFinalization.cpp
@@ -943,38 +943,6 @@ class MapInfoFinalizationPass
localBoxAllocas.clear();
deferrableDesc.clear();
- // First, walk `omp.map.info` ops to see if any of them have varPtrs
- // with an underlying type of fir.char<k, ?>, i.e a character
- // with dynamic length. If so, check if they need bounds added.
- func->walk([&](mlir::omp::MapInfoOp op) {
- if (!op.getBounds().empty())
- return;
-
- mlir::Value varPtr = op.getVarPtr();
- mlir::Type underlyingVarType = fir::unwrapRefType(varPtr.getType());
-
- if (!fir::characterWithDynamicLen(underlyingVarType))
- return;
-
- fir::factory::AddrAndBoundsInfo info =
- fir::factory::getDataOperandBaseAddr(
- builder, varPtr, /*isOptional=*/false, varPtr.getLoc());
-
- fir::ExtendedValue extendedValue =
- hlfir::translateToExtendedValue(varPtr.getLoc(), builder,
- hlfir::Entity{info.addr},
- /*continguousHint=*/true)
- .first;
- builder.setInsertionPoint(op);
- llvm::SmallVector<mlir::Value> boundsOps =
- fir::factory::genImplicitBoundsOps<mlir::omp::MapBoundsOp,
- mlir::omp::MapBoundsType>(
- builder, info, extendedValue,
- /*dataExvIsAssumedSize=*/false, varPtr.getLoc());
-
- op.getBoundsMutable().append(boundsOps);
- });
-
// Next, walk `omp.map.info` ops to see if any record members should be
// implicitly mapped.
func->walk([&](mlir::omp::MapInfoOp op) {
diff --git a/flang/lib/Optimizer/Transforms/CUFComputeSharedMemoryOffsetsAndSize.cpp b/flang/lib/Optimizer/Transforms/CUFComputeSharedMemoryOffsetsAndSize.cpp
index 09126e0..a644945 100644
--- a/flang/lib/Optimizer/Transforms/CUFComputeSharedMemoryOffsetsAndSize.cpp
+++ b/flang/lib/Optimizer/Transforms/CUFComputeSharedMemoryOffsetsAndSize.cpp
@@ -41,8 +41,7 @@ namespace {
static bool isAssumedSize(mlir::ValueRange shape) {
if (shape.size() != 1)
return false;
- std::optional<std::int64_t> val = fir::getIntIfConstant(shape[0]);
- if (val && *val == -1)
+ if (llvm::isa_and_nonnull<fir::AssumedSizeExtentOp>(shape[0].getDefiningOp()))
return true;
return false;
}
diff --git a/flang/lib/Optimizer/Transforms/CUFOpConversion.cpp b/flang/lib/Optimizer/Transforms/CUFOpConversion.cpp
index 8d00272..5b1b0a2 100644
--- a/flang/lib/Optimizer/Transforms/CUFOpConversion.cpp
+++ b/flang/lib/Optimizer/Transforms/CUFOpConversion.cpp
@@ -263,28 +263,6 @@ static bool inDeviceContext(mlir::Operation *op) {
return false;
}
-static int computeWidth(mlir::Location loc, mlir::Type type,
- fir::KindMapping &kindMap) {
- auto eleTy = fir::unwrapSequenceType(type);
- if (auto t{mlir::dyn_cast<mlir::IntegerType>(eleTy)})
- return t.getWidth() / 8;
- if (auto t{mlir::dyn_cast<mlir::FloatType>(eleTy)})
- return t.getWidth() / 8;
- if (eleTy.isInteger(1))
- return 1;
- if (auto t{mlir::dyn_cast<fir::LogicalType>(eleTy)})
- return kindMap.getLogicalBitsize(t.getFKind()) / 8;
- if (auto t{mlir::dyn_cast<mlir::ComplexType>(eleTy)}) {
- int elemSize =
- mlir::cast<mlir::FloatType>(t.getElementType()).getWidth() / 8;
- return 2 * elemSize;
- }
- if (auto t{mlir::dyn_cast_or_null<fir::CharacterType>(eleTy)})
- return kindMap.getCharacterBitsize(t.getFKind()) / 8;
- mlir::emitError(loc, "unsupported type");
- return 0;
-}
-
struct CUFAllocOpConversion : public mlir::OpRewritePattern<cuf::AllocOp> {
using OpRewritePattern::OpRewritePattern;
@@ -320,7 +298,7 @@ struct CUFAllocOpConversion : public mlir::OpRewritePattern<cuf::AllocOp> {
mlir::Value bytes;
fir::KindMapping kindMap{fir::getKindMapping(mod)};
if (fir::isa_trivial(op.getInType())) {
- int width = computeWidth(loc, op.getInType(), kindMap);
+ int width = cuf::computeElementByteSize(loc, op.getInType(), kindMap);
bytes =
builder.createIntegerConstant(loc, builder.getIndexType(), width);
} else if (auto seqTy = mlir::dyn_cast_or_null<fir::SequenceType>(
@@ -330,7 +308,7 @@ struct CUFAllocOpConversion : public mlir::OpRewritePattern<cuf::AllocOp> {
mlir::Type structTy = typeConverter->convertType(seqTy.getEleTy());
size = dl->getTypeSizeInBits(structTy) / 8;
} else {
- size = computeWidth(loc, seqTy.getEleTy(), kindMap);
+ size = cuf::computeElementByteSize(loc, seqTy.getEleTy(), kindMap);
}
mlir::Value width =
builder.createIntegerConstant(loc, builder.getIndexType(), size);
@@ -704,7 +682,7 @@ struct CUFDataTransferOpConversion
typeConverter->convertType(fir::unwrapSequenceType(dstTy));
width = dl->getTypeSizeInBits(structTy) / 8;
} else {
- width = computeWidth(loc, dstTy, kindMap);
+ width = cuf::computeElementByteSize(loc, dstTy, kindMap);
}
mlir::Value widthValue = mlir::arith::ConstantOp::create(
rewriter, loc, i64Ty, rewriter.getIntegerAttr(i64Ty, width));
diff --git a/flang/lib/Parser/Fortran-parsers.cpp b/flang/lib/Parser/Fortran-parsers.cpp
index ea6a1ea..cdc9b0a 100644
--- a/flang/lib/Parser/Fortran-parsers.cpp
+++ b/flang/lib/Parser/Fortran-parsers.cpp
@@ -1297,6 +1297,7 @@ TYPE_PARSER(construct<StatOrErrmsg>("STAT =" >> statVariable) ||
// !DIR$ LOOP COUNT (n1[, n2]...)
// !DIR$ name[=value] [, name[=value]]...
// !DIR$ UNROLL [n]
+// !DIR$ PREFETCH designator[, designator]...
// !DIR$ <anything else>
constexpr auto ignore_tkr{
"IGNORE_TKR" >> optionalList(construct<CompilerDirective::IgnoreTKR>(
@@ -1311,6 +1312,8 @@ constexpr auto vectorAlways{
"VECTOR ALWAYS" >> construct<CompilerDirective::VectorAlways>()};
constexpr auto unroll{
"UNROLL" >> construct<CompilerDirective::Unroll>(maybe(digitString64))};
+constexpr auto prefetch{"PREFETCH" >>
+ construct<CompilerDirective::Prefetch>(nonemptyList(indirect(designator)))};
constexpr auto unrollAndJam{"UNROLL_AND_JAM" >>
construct<CompilerDirective::UnrollAndJam>(maybe(digitString64))};
constexpr auto novector{"NOVECTOR" >> construct<CompilerDirective::NoVector>()};
@@ -1329,6 +1332,7 @@ TYPE_PARSER(beginDirective >> "DIR$ "_tok >>
construct<CompilerDirective>(vectorAlways) ||
construct<CompilerDirective>(unrollAndJam) ||
construct<CompilerDirective>(unroll) ||
+ construct<CompilerDirective>(prefetch) ||
construct<CompilerDirective>(novector) ||
construct<CompilerDirective>(nounrollAndJam) ||
construct<CompilerDirective>(nounroll) ||
diff --git a/flang/lib/Parser/unparse.cpp b/flang/lib/Parser/unparse.cpp
index 6bb14a43..dc0f083 100644
--- a/flang/lib/Parser/unparse.cpp
+++ b/flang/lib/Parser/unparse.cpp
@@ -1855,6 +1855,10 @@ public:
Word("!DIR$ UNROLL");
Walk(" ", unroll.v);
},
+ [&](const CompilerDirective::Prefetch &prefetch) {
+ Word("!DIR$ PREFETCH");
+ Walk(" ", prefetch.v);
+ },
[&](const CompilerDirective::UnrollAndJam &unrollAndJam) {
Word("!DIR$ UNROLL_AND_JAM");
Walk(" ", unrollAndJam.v);
diff --git a/flang/lib/Semantics/check-omp-atomic.cpp b/flang/lib/Semantics/check-omp-atomic.cpp
index 2707921..ec03e6f 100644
--- a/flang/lib/Semantics/check-omp-atomic.cpp
+++ b/flang/lib/Semantics/check-omp-atomic.cpp
@@ -590,9 +590,11 @@ void OmpStructureChecker::CheckAtomicVariable(
CheckAtomicType(syms.back(), source, atom.AsFortran(), checkTypeOnPointer);
- if (IsAllocatable(syms.back()) && !IsArrayElement(atom)) {
- context_.Say(source, "Atomic variable %s cannot be ALLOCATABLE"_err_en_US,
- atom.AsFortran());
+ if (!IsArrayElement(atom) && !ExtractComplexPart(atom)) {
+ if (IsAllocatable(syms.back())) {
+ context_.Say(source, "Atomic variable %s cannot be ALLOCATABLE"_err_en_US,
+ atom.AsFortran());
+ }
}
}
diff --git a/flang/lib/Semantics/resolve-names.cpp b/flang/lib/Semantics/resolve-names.cpp
index a2062ef..09ec951 100644
--- a/flang/lib/Semantics/resolve-names.cpp
+++ b/flang/lib/Semantics/resolve-names.cpp
@@ -10065,6 +10065,7 @@ void ResolveNamesVisitor::Post(const parser::CompilerDirective &x) {
std::holds_alternative<parser::CompilerDirective::NoUnrollAndJam>(x.u) ||
std::holds_alternative<parser::CompilerDirective::ForceInline>(x.u) ||
std::holds_alternative<parser::CompilerDirective::Inline>(x.u) ||
+ std::holds_alternative<parser::CompilerDirective::Prefetch>(x.u) ||
std::holds_alternative<parser::CompilerDirective::NoInline>(x.u)) {
return;
}
generated by cgit v1.1 at 2025-11-11 00:38:42 +0000