From fb3f4e449c7986efafad3dc04c9597214c6bb70c Mon Sep 17 00:00:00 2001 From: Eric Schweitz Date: Wed, 21 Aug 2019 13:26:26 -0700 Subject: [PATCH 01/60] Port Classic Flang to LLVM 15 This commit cherry-picks 427c0e83a9f271c3b3f0028201a0c310c7143464 from the release_14x branch, which is a combination of the following legacy patches: Commit 82b38d24a518: [ClassicFlang] Port release_90 changes from flang-compiler/llvm Cherry-picked commit 2085211cfcca70411dc63f0d08763facc8a02090 by Eric Schweitz, resolved merge conflicts, fixed build failures (e.g. adapted CGDebugInfo.cpp to the new API), and fixed the DIGlobalVariable unit tests, which have been broken since commit edfad65eebdf045b050f37380b6b61d673513982. Commit 885dd87e5fdc: [DebugInfo] Removal of DIFortranArrayType and DIFortranSubrange These extensions are no more required after merge of below PR. Commit 5c9b2e0867d5: Modification to incorporate comments from @bryanpkc. Commit 822de2c2a9cc: [AsmPrinter] Fix redundant names and types A bug was introduced in 82b38d24a51871a210a184dd558e9b955a421e8e while cherry-picking a DIGlobalVariable-related patch. Commit 45a70a89626a: Port driver changes from release/11x Cherry-picked c51f89679135f84675f492d560ec5535c2000cfe by Varun Jayathirtha from release_90, and resolved merge conflicts. To avoid conflicts with the new Flang, lib/Driver/ToolChains/Flang.{cpp,h} have been renamed to ClassicFlang.{cpp,h}, and the ENABLE_CLASSIC_FLANG macro is introduced to select which incarnation of Flang to build. The macro is set by running CMake with -DLLVM_ENABLE_CLASSIC_FLANG. After merge with LLVM 11: Move flang options to the end of the definitions list. Commit a9a803645a7d: Port Classic Flang to LLVM 13 File changes to TargetLibraryInfo and DebugLocEntry to adapt to the code from release/13.x and make it work. Comment out the changes due a segmentation fault, code need to be reviewed properly once all commits are in Commit fe989b724392: Fix -fveclib=PGMATH The use of #ifdef in include/clang/Driver/Options.td was incorrect and unsupported. As a result -fveclib=PGMATH was silently ignored, and in LLVM 12, it causes the invocation to fail. This patch unguards the option so that it is parsed correctly, but lets the FLANG_LLVM_EXTENSIONS macro continue to toggle the feature. Commit 7c224ae4708d: Fix use of classic Flang as preprocessor Commit 8403c8335f9a: Merge FLANG_LLVM_EXTENSIONS macro into ENABLE_CLASSIC_FLANG Commit 486741e2e30f: Fix test failures when in classic Flang mode Add a new lit feature tag "classic_flang" to select which tests can or cannot be run when the driver is built for classic Flang. Handle LLVM_ENABLE_CLASSIC_FLANG in llvm/cmake/modules/HandleLLVMOptions.cmake instead of clang/CMakeLists.txt so that macro works in both clang and llvm. Commit a10f592d3b02: Port Classic Flang to LLVM 13 LLVM port from release_12x to release_13x, changes done in order to make project able to be build. Commit d3853218de1a (partial): Change to Options.td in order to add the correct invocation for ffixed_line_length_VALUE. This commit also includes the following legacy patch: Commit 5da2c11605e0: Add DebugInfo tests Commit c379c8d515c0: [ClassicFlang][Driver] Correct the LLVM version passed by the Driver Commit 33013f4b1c38: [ClassicFlang][Driver] Fix warnings * -Wsuggest-override for ClassicFlangMacroBuilder::defineMacro Signed-off-by: Itay Bookstein --- clang/CMakeLists.txt | 5 + .../clang/Basic/DiagnosticDriverKinds.td | 6 + clang/include/clang/Basic/MacroBuilder.h | 5 +- clang/include/clang/Basic/Sanitizers.def | 3 + clang/include/clang/Driver/Action.h | 11 + clang/include/clang/Driver/Options.td | 181 +++ clang/include/clang/Driver/Phases.h | 1 + clang/include/clang/Driver/ToolChain.h | 15 + clang/include/clang/Driver/Types.def | 7 + clang/include/clang/Driver/Types.h | 8 + clang/include/clang/Frontend/Utils.h | 32 + clang/lib/CodeGen/CGDebugInfo.cpp | 10 +- clang/lib/Driver/Action.cpp | 7 + clang/lib/Driver/CMakeLists.txt | 5 + clang/lib/Driver/Driver.cpp | 41 + clang/lib/Driver/OffloadBundler.cpp | 4 + clang/lib/Driver/Phases.cpp | 1 + clang/lib/Driver/ToolChain.cpp | 59 +- clang/lib/Driver/ToolChains/Clang.cpp | 60 + clang/lib/Driver/ToolChains/ClassicFlang.cpp | 1068 +++++++++++++++++ clang/lib/Driver/ToolChains/ClassicFlang.h | 49 + clang/lib/Driver/ToolChains/CommonArgs.cpp | 35 + clang/lib/Driver/ToolChains/CommonArgs.h | 2 + clang/lib/Driver/ToolChains/Cuda.cpp | 33 + clang/lib/Driver/ToolChains/Cuda.h | 6 + clang/lib/Driver/ToolChains/Gnu.cpp | 10 + clang/lib/Driver/ToolChains/Linux.cpp | 188 +++ clang/lib/Driver/ToolChains/Linux.h | 3 + clang/lib/Driver/Types.cpp | 49 + clang/lib/Frontend/InitPreprocessor.cpp | 20 - clang/test/Driver/autocomplete.c | 2 +- clang/test/Driver/flang/classic_flang.f95 | 28 + clang/test/Driver/flang/flang.f90 | 2 + clang/test/Driver/flang/flang_ucase.F90 | 2 + .../Driver/flang/multiple-inputs-mixed.f90 | 2 + clang/test/Driver/flang/multiple-inputs.f90 | 2 + clang/test/Driver/fortran.f95 | 2 + clang/test/Driver/gfortran.f90 | 1 + clang/test/lit.cfg.py | 3 + clang/test/lit.site.cfg.py.in | 1 + clang/tools/driver/CMakeLists.txt | 2 +- clang/tools/driver/cc1as_main.cpp | 2 +- llvm/cmake/modules/HandleLLVMOptions.cmake | 8 + llvm/include/llvm-c/DebugInfo.h | 5 +- .../include/llvm/Analysis/TargetLibraryInfo.h | 3 + .../llvm/Frontend/Driver/CodeGenOptions.h | 3 + llvm/include/llvm/IR/DIBuilder.h | 28 +- llvm/include/llvm/IR/DebugInfoMetadata.h | 32 +- llvm/lib/Analysis/TargetLibraryInfo.cpp | 455 +++++++ llvm/lib/AsmParser/LLParser.cpp | 22 +- llvm/lib/Bitcode/Reader/MetadataLoader.cpp | 42 +- llvm/lib/Bitcode/Writer/BitcodeWriter.cpp | 3 +- llvm/lib/CodeGen/AsmPrinter/DebugLocEntry.h | 89 ++ .../lib/CodeGen/AsmPrinter/DebugLocStream.cpp | 5 + llvm/lib/CodeGen/AsmPrinter/DebugLocStream.h | 6 + .../CodeGen/AsmPrinter/DwarfCompileUnit.cpp | 3 + .../lib/CodeGen/AsmPrinter/DwarfCompileUnit.h | 8 + llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp | 76 ++ llvm/lib/CodeGen/AsmPrinter/DwarfDebug.h | 12 + llvm/lib/Frontend/Driver/CodeGenOptions.cpp | 6 + llvm/lib/IR/AsmWriter.cpp | 1 + llvm/lib/IR/DIBuilder.cpp | 12 +- llvm/lib/IR/DebugInfo.cpp | 10 +- llvm/lib/IR/DebugInfoMetadata.cpp | 12 +- llvm/lib/IR/LLVMContextImpl.h | 11 +- .../Instrumentation/InstrProfiling.cpp | 4 +- .../Transforms/Vectorize/LoopVectorize.cpp | 6 +- .../invalid-diglobalvariable-empty-name.ll | 1 + .../Generic/fortran-subprogram-at.ll | 24 + .../DebugInfo/Generic/more-subprogram-attr.ll | 38 + llvm/test/DebugInfo/X86/DICommonBlock.ll | 36 + llvm/test/lit.cfg.py | 3 + llvm/test/lit.site.cfg.py.in | 1 + llvm/tools/llvm-c-test/debuginfo.c | 4 +- llvm/unittests/IR/MetadataTest.cpp | 47 +- 75 files changed, 2882 insertions(+), 107 deletions(-) create mode 100644 clang/lib/Driver/ToolChains/ClassicFlang.cpp create mode 100644 clang/lib/Driver/ToolChains/ClassicFlang.h mode change 100644 => 100755 clang/lib/Driver/Types.cpp create mode 100644 clang/test/Driver/flang/classic_flang.f95 create mode 100644 llvm/test/DebugInfo/Generic/fortran-subprogram-at.ll create mode 100644 llvm/test/DebugInfo/Generic/more-subprogram-attr.ll create mode 100644 llvm/test/DebugInfo/X86/DICommonBlock.ll diff --git a/clang/CMakeLists.txt b/clang/CMakeLists.txt index 24e656eced6d..3f02ebae02c2 100644 --- a/clang/CMakeLists.txt +++ b/clang/CMakeLists.txt @@ -413,6 +413,11 @@ if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY) endif() endif() +option(LLVM_ENABLE_CLASSIC_FLANG "Build support for classic Flang instead of the new built-in Flang" OFF) +if(LLVM_ENABLE_CLASSIC_FLANG) + add_definitions( -DENABLE_CLASSIC_FLANG ) +endif() + option(CLANG_BUILD_TOOLS "Build the Clang tools. If OFF, just generate build targets." ON) diff --git a/clang/include/clang/Basic/DiagnosticDriverKinds.td b/clang/include/clang/Basic/DiagnosticDriverKinds.td index 288786b8ce93..d1103729cbca 100644 --- a/clang/include/clang/Basic/DiagnosticDriverKinds.td +++ b/clang/include/clang/Basic/DiagnosticDriverKinds.td @@ -156,6 +156,10 @@ def err_drv_invalid_linker_name : Error< "invalid linker name in argument '%0'">; def err_drv_invalid_rtlib_name : Error< "invalid runtime library name in argument '%0'">; +def err_drv_invalid_allocatable_mode : Error< + "invalid semantic mode for assignments to allocatables in argument '%0'">; +def err_drv_unsupported_fixed_line_length : Error< + "unsupported fixed-format line length in argument '%0'">; def err_drv_unsupported_rtlib_for_platform : Error< "unsupported runtime library '%0' for platform '%1'">; def err_drv_invalid_unwindlib_name : Error< @@ -384,6 +388,8 @@ def err_drv_small_columns : Error< def warn_drv_fraw_string_literals_in_cxx11 : Warning< "ignoring '-f%select{no-|}0raw-string-literals', which is only valid for C and C++ standards before C++11">, InGroup; +def err_drv_clang_unsupported_minfo_arg : Error< + "'%0' option does not support '%1' value">; def err_drv_invalid_malign_branch_EQ : Error< "invalid argument '%0' to -malign-branch=; each element must be one of: %1">; diff --git a/clang/include/clang/Basic/MacroBuilder.h b/clang/include/clang/Basic/MacroBuilder.h index d83f27c236e3..a84c16d0eaac 100644 --- a/clang/include/clang/Basic/MacroBuilder.h +++ b/clang/include/clang/Basic/MacroBuilder.h @@ -24,12 +24,13 @@ class MacroBuilder { raw_ostream &Out; public: MacroBuilder(raw_ostream &Output) : Out(Output) {} + virtual ~MacroBuilder() {} /// Append a \#define line for macro of the form "\#define Name Value\n". /// If DeprecationMsg is provided, also append a pragma to deprecate the /// defined macro. - void defineMacro(const Twine &Name, const Twine &Value = "1", - Twine DeprecationMsg = "") { + virtual void defineMacro(const Twine &Name, const Twine &Value = "1", + Twine DeprecationMsg = "") { Out << "#define " << Name << ' ' << Value << '\n'; if (!DeprecationMsg.isTriviallyEmpty()) Out << "#pragma clang deprecated(" << Name << ", \"" << DeprecationMsg diff --git a/clang/include/clang/Basic/Sanitizers.def b/clang/include/clang/Basic/Sanitizers.def index f234488eaa80..68b00d948eb1 100644 --- a/clang/include/clang/Basic/Sanitizers.def +++ b/clang/include/clang/Basic/Sanitizers.def @@ -196,6 +196,9 @@ SANITIZER_GROUP("bounds", Bounds, ArrayBounds | LocalBounds) // Scudo hardened allocator SANITIZER("scudo", Scudo) +// Fortran contiguous pointer checks +SANITIZER("discontiguous", Discontiguous) + // Magic group, containing all sanitizers. For example, "-fno-sanitize=all" // can be used to disable all the sanitizers. SANITIZER_GROUP("all", All, ~SanitizerMask()) diff --git a/clang/include/clang/Driver/Action.h b/clang/include/clang/Driver/Action.h index feeabae89d6b..6c9481f7cf59 100644 --- a/clang/include/clang/Driver/Action.h +++ b/clang/include/clang/Driver/Action.h @@ -62,6 +62,7 @@ class Action { AnalyzeJobClass, MigrateJobClass, CompileJobClass, + FortranFrontendJobClass, BackendJobClass, AssembleJobClass, LinkJobClass, @@ -471,6 +472,16 @@ class MigrateJobAction : public JobAction { } }; +class FortranFrontendJobAction : public JobAction { + void anchor() override; +public: + FortranFrontendJobAction(Action *Input, types::ID OutputType); + + static bool classof(const Action *A) { + return A->getKind() == FortranFrontendJobClass; + } +}; + class CompileJobAction : public JobAction { void anchor() override; diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td index 02e5c4cbb4bf..ced2ba129339 100644 --- a/clang/include/clang/Driver/Options.td +++ b/clang/include/clang/Driver/Options.td @@ -3459,10 +3459,17 @@ def fveclib : Joined<["-"], "fveclib=">, Group, HelpTextForVariants<[ClangOption, CC1Option], "Use the given vector functions library. " "Note: -fveclib={ArmPL,SLEEF} implies -fno-math-errno">, +#ifdef ENABLE_CLASSIC_FLANG + Values<"Accelerate,libmvec,MASSV,PGMATH,SVML,SLEEF,Darwin_libsystem_m,ArmPL,AMDLIBM,none">, + NormalizedValuesScope<"llvm::driver::VectorLibrary">, + NormalizedValues<["Accelerate", "LIBMVEC", "MASSV", "PGMATH", "SVML", "SLEEF", + "Darwin_libsystem_m", "ArmPL", "AMDLIBM", "NoLibrary"]>, +#else Values<"Accelerate,libmvec,MASSV,SVML,SLEEF,Darwin_libsystem_m,ArmPL,AMDLIBM,none">, NormalizedValuesScope<"llvm::driver::VectorLibrary">, NormalizedValues<["Accelerate", "LIBMVEC", "MASSV", "SVML", "SLEEF", "Darwin_libsystem_m", "ArmPL", "AMDLIBM", "NoLibrary"]>, +#endif MarshallingInfoEnum, "NoLibrary">; def fno_lax_vector_conversions : Flag<["-"], "fno-lax-vector-conversions">, Group, Alias, AliasArgs<["none"]>; @@ -6937,6 +6944,20 @@ def module_dir : JoinedOrSeparate<["-"], "module-dir">, MetaVarName<"">, It is also added to the list of directories to be searched by an USE statement. The default is the current directory.}]>; +#ifdef ENABLE_CLASSIC_FLANG +// Define a group for Fortran source format options. +def fortran_format_Group : OptionGroup<"Fortran format Group">, Group; +def ffixed_form : Flag<["-"], "ffixed-form">, Group, + HelpText<"Process source files in fixed form">; +def fno_fixed_form : Flag<["-"], "fno-fixed-form">, Group, + HelpText<"Disable fixed-form format for Fortran">; +def ffree_form : Flag<["-"], "ffree-form">, Group, + HelpText<"Process source files in free form">; +def fno_free_form : Flag<["-"], "fno-free-form">, Group, + HelpText<"Disable free-form format for Fortran">; +def ffixed_line_length_VALUE : Joined<["-"], "ffixed-line-length-">, Group, + HelpText<"Set line length in fixed-form format Fortran, current supporting only 72 and 132 characters">; +#else def ffixed_form : Flag<["-"], "ffixed-form">, Group, HelpText<"Process source files in fixed form">; def ffree_form : Flag<["-"], "ffree-form">, Group, @@ -6946,14 +6967,21 @@ def ffixed_line_length_EQ : Joined<["-"], "ffixed-line-length=">, Group DocBrief<[{Set column after which characters are ignored in typical fixed-form lines in the source file}]>; def ffixed_line_length_VALUE : Joined<["-"], "ffixed-line-length-">, Group, Alias; +#endif def fconvert_EQ : Joined<["-"], "fconvert=">, Group, HelpText<"Set endian conversion of data for unformatted files">; def fdefault_double_8 : Flag<["-"],"fdefault-double-8">, Group, HelpText<"Set the default double precision kind to an 8 byte wide type">; +#ifdef ENABLE_CLASSIC_FLANG +def fno_default_integer_8 : Flag<["-"], "fno-default-integer-8">, Group; +#endif def fdefault_integer_8 : Flag<["-"],"fdefault-integer-8">, Group, HelpText<"Set the default integer and logical kind to an 8 byte wide type">; def fdefault_real_8 : Flag<["-"],"fdefault-real-8">, Group, HelpText<"Set the default real kind to an 8 byte wide type">; +#ifdef ENABLE_CLASSIC_FLANG +def fno_default_real_8 : Flag<["-"], "fno-default-real-8">, Group; +#endif def fdisable_real_3 : Flag<["-"],"fdisable-real-3">, Group, HelpText<"Disable real(KIND=3) from TargetCharacteristics">, Flags<[HelpHidden]>; def fdisable_real_10 : Flag<["-"],"fdisable-real-10">, Group, @@ -6972,6 +7000,13 @@ def fintrinsic_modules_path : Separate<["-"], "fintrinsic-modules-path">, Group DocBrief<[{This option specifies the location of pre-compiled intrinsic modules, if they are not in the default location expected by the compiler.}]>; +#ifdef ENABLE_CLASSIC_FLANG +def fbackslash : Flag<["-"], "fbackslash">, Group, + HelpText<"Specify that backslash in string introduces an escape character">, + DocBrief<[{Change the interpretation of backslashes in string literals from +a single backslash character to "C-style" escape characters.}]>; +def fno_backslash : Flag<["-"], "fno-backslash">, Group; +#else defm backslash : OptInFC1FFlag<"backslash", "Specify that backslash in string introduces an escape character">; defm xor_operator : OptInFC1FFlag<"xor-operator", "Enable .XOR. as a synonym of .NEQV.">; defm logical_abbreviations : OptInFC1FFlag<"logical-abbreviations", "Enable logical abbreviations">; @@ -6984,6 +7019,7 @@ defm unsigned : OptInFC1FFlag<"unsigned", "Enables UNSIGNED type">; def fno_automatic : Flag<["-"], "fno-automatic">, Group, HelpText<"Implies the SAVE attribute for non-automatic local objects in subprograms unless RECURSIVE">; +#endif defm save_main_program : BoolOptionWithoutMarshalling<"f", "save-main-program", PosFlag, Group; } // let Visibility = [FC1Option, FlangOption] +#ifdef ENABLE_CLASSIC_FLANG +def J : JoinedOrSeparate<["-"], "J">, + Flags<[RenderJoined]>, + Group; +#else def J : JoinedOrSeparate<["-"], "J">, Flags<[RenderJoined]>, Visibility<[FlangOption, FC1Option]>, Group, Alias; +#endif //===----------------------------------------------------------------------===// // FC1 Options @@ -9136,3 +9178,142 @@ def wasm_opt : Flag<["--"], "wasm-opt">, Group, HelpText<"Enable the wasm-opt optimizer (default)">, MarshallingInfoNegativeFlag>; + +#ifdef ENABLE_CLASSIC_FLANG +// gfortran options that we recognize in the driver and pass along when +// invoking GCC to compile Fortran code. +def flang_rt_Group : OptionGroup<"Flang runtime library Group">; +def pgi_fortran_Group : OptionGroup<"PGI Fortran compatibility Group">, + Flags<[HelpHidden]>; + +// Classic Flang-specific options +multiclass BooleanKFlag { + def _on : Flag<["-"], "K"#name>; + def _off : Flag<["-"], "Kno"#name>; +} + +multiclass BooleanMFlag { + def _on : Flag<["-"], "M"#name>; + def _off : Flag<["-"], "Mno"#name>; +} + +def Mfixed : Flag<["-"], "Mfixed">, Group, + HelpText<"Force fixed-form format Fortran">, + Flags<[HelpHidden]>; +def Mfree_on: Flag<["-"], "Mfree">, Group, + HelpText<"Enable free-form format for Fortran">, + Flags<[HelpHidden]>; +def Mfree_off: Flag<["-"], "Mnofree">, Group, + HelpText<"Disable free-form format for Fortran">, + Flags<[HelpHidden]>; +def Mfreeform_on: Flag<["-"], "Mfreeform">, Group, + HelpText<"Enable free-form format for Fortran">, + Flags<[HelpHidden]>; +def Mfreeform_off: Flag<["-"], "Mnofreeform">, Group, + HelpText<"Disable free-form format for Fortran">, + Flags<[HelpHidden]>; + +def Minfo_EQ : CommaJoined<["-"], "Minfo=">, + HelpText<"Diagnostic information about successful optimizations">, + Values<"all,vect,inline">; +def Minfoall : Flag<["-"], "Minfo">, + HelpText<"Diagnostic information about all successful optimizations">; +def Mneginfo_EQ : CommaJoined<["-"], "Mneginfo=">, + HelpText<"Diagnostic information about missed optimizations">, + Values<"all,vect,inline">; +def Mneginfoall : Flag<["-"], "Mneginfo">, + HelpText<"Diagnostic information about all missed optimizations">; + +def Mipa: Joined<["-"], "Mipa">, Group; +def Mstackarrays: Joined<["-"], "Mstack_arrays">, Group; +def pc: JoinedOrSeparate<["-"], "pc">, Group; +def Mfprelaxed: Joined<["-"], "Mfprelaxed">, Group; +def Mnofprelaxed: Joined<["-"], "Mnofprelaxed">, Group; +defm Mstride0: BooleanMFlag<"stride0">, Group; +defm Mrecursive: BooleanMFlag<"recursive">, Group; +defm Mreentrant: BooleanMFlag<"reentrant">, Group; +defm Mbounds: BooleanMFlag<"bounds">, Group; +def Mdaz_on: Flag<["-"], "Mdaz">, Group, + HelpText<"Treat denormalized numbers as zero">; +def Mdaz_off: Flag<["-"], "Mnodaz">, Group, + HelpText<"Disable treating denormalized numbers as zero">; +def Kieee_on : Flag<["-"], "Kieee">, Group, + HelpText<"Enable IEEE division">; +def Kieee_off : Flag<["-"], "Knoieee">, Group, + HelpText<"Disable IEEE division">; +def Mextend : Flag<["-"], "Mextend">, Group, + HelpText<"Allow lines up to 132 characters in Fortran sources">; +def Mpreprocess : Flag<["-"], "Mpreprocess">, Group, + HelpText<"Preprocess Fortran files">; +def Mstandard: Flag<["-"], "Mstandard">, Group, + HelpText<"Check Fortran standard conformance">; +def Mchkptr: Flag<["-"], "Mchkptr">, Group; +def Mwritable_constants: Flag<["-"], "Mwritable-constants">, Group, + HelpText<"Store constants in the writable data segment">; +defm Minline: BooleanMFlag<"inline">, Group; +def fma: Flag<["-"], "fma">, Group, + HelpText<"Enable generation of FMA instructions">; +def nofma: Flag<["-"], "nofma">, Group, + HelpText<"Disable generation of FMA instructions">; +defm Mfma: BooleanMFlag<"fma">, Group, + HelpText<"Enable generation of FMA instructions">; +def mp: Flag<["-"], "mp">, Group, + HelpText<"Enable OpenMP">; +def nomp: Flag<["-"], "nomp">, Group, + HelpText<"Do not link with OpenMP library libomp">; +def Mflushz_on: Flag<["-"], "Mflushz">, Group, + HelpText<"Set SSE to flush-to-zero mode">; +def Mflushz_off: Flag<["-"], "Mnoflushz">, Group, + HelpText<"Disabling setting SSE to flush-to-zero mode">; +def Msave_on: Flag<["-"], "Msave">, Group, + HelpText<"Assume all Fortran variables have SAVE attribute">; +def Msave_off: Flag<["-"], "Mnosave">, Group, + HelpText<"Assume no Fortran variables have SAVE attribute">; +def Mcache_align_on: Flag<["-"], "Mcache_align">, Group, + HelpText<"Align large objects on cache-line boundaries">; +def Mcache_align_off: Flag<["-"], "Mnocache_align">, Group, + HelpText<"Disable aligning large objects on cache-line boundaries">; +def ModuleDir : Separate<["-"], "module">, Group, + HelpText<"Fortran module path">; +def Minform_EQ : Joined<["-"], "Minform=">, + HelpText<"Set error level of messages to display">; +def Mallocatable_EQ : Joined<["-"], "Mallocatable=">, + HelpText<"Select semantics for assignments to allocatables (F03 or F95)">; +def Mbyteswapio: Flag<["-"], "Mbyteswapio">, Group, + HelpText<"Swap byte-order for unformatted input/output">; +def byteswapio: Flag<["-"], "byteswapio">, Group, + HelpText<"Swap byte-order for unformatted input/output">; +def Mbackslash: Flag<["-"], "Mbackslash">, Group, + HelpText<"Treat backslash like any other character in character strings">; +def Mnobackslash: Flag<["-"], "Mnobackslash">, Group, + HelpText<"Treat backslash as C-style escape character">; +def staticFlangLibs: Flag<["-"], "static-flang-libs">, Group, + HelpText<"Link using static Flang libraries">; +def noFlangLibs: Flag<["-"], "no-flang-libs">, Group, + HelpText<"Do not link against Flang libraries">; +def r8: Flag<["-"], "r8">, Group, + HelpText<"Treat REAL as REAL*8">; +def i8: Flag<["-"], "i8">, Group, + HelpText<"Treat INTEGER and LOGICAL as INTEGER*8 and LOGICAL*8">; +def Mnomain: Flag<["-"], "Mnomain">, Group, + HelpText<"Don't link in Fortran main">; +def frelaxed_math : Flag<["-"], "frelaxed-math">, Group, + HelpText<"Use relaxed Math intrinsic functions">; +def Memit_dwarf_common_blocks_name: Flag<["-"], "Memit-dwarf-common-blocks-name">, + Group, HelpText<"Emit COMMON blocks name in DWARF">; +def Munixlogical: Flag<["-"], "Munixlogical">, Group, + HelpText<"Use unixlogical for all loigical operations">; + +// Flang internal debug options +def Mx_EQ : Joined<["-"], "Mx,">, Group; +def My_EQ : Joined<["-"], "My,">, Group; +def Hx_EQ : Joined<["-"], "Hx,">, Group; +def Hy_EQ : Joined<["-"], "Hy,">, Group; +def Wm_EQ : Joined<["-"], "Wm,">, Group; + +def Mq_EQ : Joined<["-"], "Mq,">, Group; +def Hq_EQ : Joined<["-"], "Hq,">, Group; +def Mqq_EQ : Joined<["-"], "Mqq,">, Group; +def Hqq_EQ : Joined<["-"], "Hqq,">, Group; +def Wh_EQ : Joined<["-"], "Wh,">, Group; +#endif diff --git a/clang/include/clang/Driver/Phases.h b/clang/include/clang/Driver/Phases.h index 9003c5857351..f8cac9548d02 100644 --- a/clang/include/clang/Driver/Phases.h +++ b/clang/include/clang/Driver/Phases.h @@ -17,6 +17,7 @@ namespace phases { enum ID { Preprocess, Precompile, + FortranFrontend, Compile, Backend, Assemble, diff --git a/clang/include/clang/Driver/ToolChain.h b/clang/include/clang/Driver/ToolChain.h index 7d1d8feebf35..6f3481f328d9 100644 --- a/clang/include/clang/Driver/ToolChain.h +++ b/clang/include/clang/Driver/ToolChain.h @@ -159,6 +159,7 @@ class ToolChain { mutable std::unique_ptr Clang; mutable std::unique_ptr Flang; + mutable std::unique_ptr FortranFrontend; mutable std::unique_ptr Assemble; mutable std::unique_ptr Link; mutable std::unique_ptr StaticLibTool; @@ -169,6 +170,7 @@ class ToolChain { Tool *getClang() const; Tool *getFlang() const; + Tool *getFortranFrontend() const; Tool *getAssemble() const; Tool *getLink() const; Tool *getStaticLibTool() const; @@ -673,6 +675,14 @@ class ToolChain { AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const; + /// \brief Add the flang arguments for system include paths. + /// + /// This routine is responsible for adding the -stdinc argument to + /// include headers and module files from standard system header directories. + virtual void + AddFlangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, + llvm::opt::ArgStringList &Flang1Args) const { } + /// Add options that need to be passed to cc1 for this target. virtual void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, @@ -790,6 +800,11 @@ class ToolChain { virtual void AddHIPRuntimeLibArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const {} + /// AddFortranStdlibLibArgs - Add the system specific linker arguments to use + /// for the given Fortran runtime library type. + virtual void AddFortranStdlibLibArgs(const llvm::opt::ArgList &Args, + llvm::opt::ArgStringList &CmdArgs) const; + /// Return sanitizers which are available in this toolchain. virtual SanitizerMask getSupportedSanitizers() const; diff --git a/clang/include/clang/Driver/Types.def b/clang/include/clang/Driver/Types.def index 214c5e7a789f..d2b763a8fd5b 100644 --- a/clang/include/clang/Driver/Types.def +++ b/clang/include/clang/Driver/Types.def @@ -88,8 +88,15 @@ TYPE("assembler-with-cpp", Asm, PP_Asm, "S", phases // modules when Flang needs to emit pre-processed files. Therefore, the // `PP_TYPE` is set to `PP_Fortran` so that the driver is fine with // "pre-processing a pre-processed file". +#ifdef ENABLE_CLASSIC_FLANG +TYPE("f77", PP_F_FixedForm, INVALID, "f", phases::FortranFrontend, phases::Backend, phases::Assemble, phases::Link) +TYPE("f77-cpp-input", F_FixedForm, PP_F_FixedForm, "F", phases::FortranFrontend, phases::Backend, phases::Assemble, phases::Link) +TYPE("f95", PP_F_FreeForm, INVALID, "f95", phases::FortranFrontend, phases::Backend, phases::Assemble, phases::Link) +TYPE("f95-cpp-input", F_FreeForm, PP_F_FreeForm, "F95", phases::FortranFrontend, phases::Backend, phases::Assemble, phases::Link) +#else TYPE("f95", PP_Fortran, PP_Fortran, "i", phases::Preprocess, phases::Compile, phases::Backend, phases::Assemble, phases::Link) TYPE("f95-cpp-input", Fortran, PP_Fortran, nullptr, phases::Preprocess, phases::Compile, phases::Backend, phases::Assemble, phases::Link) +#endif TYPE("java", Java, INVALID, nullptr, phases::Compile, phases::Backend, phases::Assemble, phases::Link) // LLVM IR/LTO types. We define separate types for IR and LTO because LTO diff --git a/clang/include/clang/Driver/Types.h b/clang/include/clang/Driver/Types.h index 121b58a6b477..cab331a74b36 100644 --- a/clang/include/clang/Driver/Types.h +++ b/clang/include/clang/Driver/Types.h @@ -95,6 +95,14 @@ namespace types { /// isOpenCL - Is this an "OpenCL" input. bool isOpenCL(ID Id); +#ifdef ENABLE_CLASSIC_FLANG + /// isFreeFormFortran -- is it a free form layout Fortran input + bool isFreeFormFortran(ID Id); + + /// isFixedFormFortran -- is it a fixed form layout Fortran input + bool isFixedFormFortran(ID Id); +#endif + /// isHLSL - Is this an HLSL input. bool isHLSL(ID Id); diff --git a/clang/include/clang/Frontend/Utils.h b/clang/include/clang/Frontend/Utils.h index 604e42067a3f..9f74cc0501e6 100644 --- a/clang/include/clang/Frontend/Utils.h +++ b/clang/include/clang/Frontend/Utils.h @@ -15,8 +15,10 @@ #include "clang/Basic/Diagnostic.h" #include "clang/Basic/LLVM.h" +#include "clang/Basic/TargetInfo.h" #include "clang/Driver/OptionUtils.h" #include "clang/Frontend/DependencyOutputOptions.h" +#include "llvm/ADT/APInt.h" #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/IntrusiveRefCntPtr.h" #include "llvm/ADT/StringMap.h" @@ -31,6 +33,12 @@ #include #include +namespace llvm { + +class StringRef; + +} // namespace llvm + namespace clang { class ASTReader; @@ -39,6 +47,7 @@ class CompilerInvocation; class DiagnosticsEngine; class ExternalSemaSource; class FrontendOptions; +class MacroBuilder; class PCHContainerReader; class Preprocessor; class PreprocessorOptions; @@ -56,6 +65,29 @@ void InitializePreprocessor(Preprocessor &PP, const PreprocessorOptions &PPOpts, void DoPrintPreprocessedInput(Preprocessor &PP, raw_ostream *OS, const PreprocessorOutputOptions &Opts); +/// DefineTypeSize - Emit a macro to the predefines buffer that declares a macro +/// named MacroName with the max value for a type with width 'TypeWidth' a +/// signedness of 'isSigned' and with a value suffix of 'ValSuffix' (e.g. LL). +template +static void DefineTypeSize(const Twine &MacroName, unsigned TypeWidth, + StringRef ValSuffix, bool isSigned, + T &Builder) { + static_assert(std::is_base_of::value, "Illegal T value"); + llvm::APInt MaxVal = isSigned ? llvm::APInt::getSignedMaxValue(TypeWidth) + : llvm::APInt::getMaxValue(TypeWidth); + Builder.defineMacro(MacroName, toString(MaxVal, 10, isSigned) + ValSuffix); +} + +/// DefineTypeSize - An overloaded helper that uses TargetInfo to determine +/// the width, suffix, and signedness of the given type +template +static void DefineTypeSize(const Twine &MacroName, TargetInfo::IntType Ty, + const TargetInfo &TI, T &Builder) { + static_assert(std::is_base_of::value, "Illegal T value"); + DefineTypeSize(MacroName, TI.getTypeWidth(Ty), TI.getTypeConstantSuffix(Ty), + TI.isTypeSigned(Ty), Builder); +} + /// An interface for collecting the dependencies of a compilation. Users should /// use \c attachToPreprocessor and \c attachToASTReader to get all of the /// dependencies. diff --git a/clang/lib/CodeGen/CGDebugInfo.cpp b/clang/lib/CodeGen/CGDebugInfo.cpp index d28ef60f84e9..c99a20d619e0 100644 --- a/clang/lib/CodeGen/CGDebugInfo.cpp +++ b/clang/lib/CodeGen/CGDebugInfo.cpp @@ -4202,7 +4202,8 @@ CGDebugInfo::getGlobalVariableForwardDeclaration(const VarDecl *VD) { auto Align = getDeclAlignIfRequired(VD, CGM.getContext()); auto *GV = DBuilder.createTempGlobalVariableFwdDecl( DContext, Name, LinkageName, Unit, Line, getOrCreateType(T, Unit), - !VD->isExternallyVisible(), nullptr, TemplateParameters, Align); + !VD->isExternallyVisible(), nullptr, TemplateParameters, + llvm::DINode::FlagZero, Align); FwdDeclReplaceMap.emplace_back( std::piecewise_construct, std::make_tuple(cast(VD->getCanonicalDecl())), @@ -5723,7 +5724,7 @@ void CGDebugInfo::EmitGlobalVariable(llvm::GlobalVariable *Var, Var->hasLocalLinkage(), true, Expr.empty() ? nullptr : DBuilder.createExpression(Expr), getOrCreateStaticDataMemberDeclarationOrNull(D), TemplateParameters, - Align, Annotations); + llvm::DINode::FlagZero, Align, Annotations); Var->addDebugInfo(GVE); } DeclCache[D->getCanonicalDecl()].reset(GVE); @@ -5802,7 +5803,7 @@ void CGDebugInfo::EmitGlobalVariable(const ValueDecl *VD, const APValue &Init) { GV.reset(DBuilder.createGlobalVariableExpression( DContext, Name, StringRef(), Unit, getLineNumber(VD->getLocation()), Ty, true, true, InitExpr, getOrCreateStaticDataMemberDeclarationOrNull(VarD), - TemplateParameters, Align)); + TemplateParameters, llvm::DINode::FlagZero, Align)); } void CGDebugInfo::EmitExternalVariable(llvm::GlobalVariable *Var, @@ -5820,7 +5821,8 @@ void CGDebugInfo::EmitExternalVariable(llvm::GlobalVariable *Var, llvm::DIGlobalVariableExpression *GVE = DBuilder.createGlobalVariableExpression( DContext, Name, StringRef(), Unit, getLineNumber(D->getLocation()), - Ty, false, false, nullptr, nullptr, nullptr, Align); + Ty, false, false, nullptr, nullptr, nullptr, llvm::DINode::FlagZero, + Align); Var->addDebugInfo(GVE); } diff --git a/clang/lib/Driver/Action.cpp b/clang/lib/Driver/Action.cpp index 23dbcebc9a1c..d16aec2d0f85 100644 --- a/clang/lib/Driver/Action.cpp +++ b/clang/lib/Driver/Action.cpp @@ -29,6 +29,7 @@ const char *Action::getClassName(ActionClass AC) { return "api-extractor"; case AnalyzeJobClass: return "analyzer"; case MigrateJobClass: return "migrator"; + case FortranFrontendJobClass: return "fortran-frontend"; case CompileJobClass: return "compiler"; case BackendJobClass: return "backend"; case AssembleJobClass: return "assembler"; @@ -378,6 +379,12 @@ void MigrateJobAction::anchor() {} MigrateJobAction::MigrateJobAction(Action *Input, types::ID OutputType) : JobAction(MigrateJobClass, Input, OutputType) {} +void FortranFrontendJobAction::anchor() {} + +FortranFrontendJobAction::FortranFrontendJobAction(Action *Input, + types::ID OutputType) + : JobAction(FortranFrontendJobClass, Input, OutputType) {} + void CompileJobAction::anchor() {} CompileJobAction::CompileJobAction(Action *Input, types::ID OutputType) diff --git a/clang/lib/Driver/CMakeLists.txt b/clang/lib/Driver/CMakeLists.txt index 5bdb6614389c..fbbee65b8d62 100644 --- a/clang/lib/Driver/CMakeLists.txt +++ b/clang/lib/Driver/CMakeLists.txt @@ -14,6 +14,10 @@ if(WIN32) set(system_libs version) endif() +if(LLVM_ENABLE_CLASSIC_FLANG) + set(CLASSIC_FLANG_FILES ToolChains/ClassicFlang.cpp) +endif() + add_clang_library(clangDriver Action.cpp Compilation.cpp @@ -90,6 +94,7 @@ add_clang_library(clangDriver ToolChains/ZOS.cpp Types.cpp XRayArgs.cpp + ${CLASSIC_FLANG_FILES} DEPENDS ClangDriverOptions diff --git a/clang/lib/Driver/Driver.cpp b/clang/lib/Driver/Driver.cpp index 87855fdb7997..7f3939691219 100644 --- a/clang/lib/Driver/Driver.cpp +++ b/clang/lib/Driver/Driver.cpp @@ -396,11 +396,30 @@ phases::ID Driver::getFinalPhase(const DerivedArgList &DAL, // -{E,EP,P,M,MM} only run the preprocessor. if (CCCIsCPP() || (PhaseArg = DAL.getLastArg(options::OPT_E)) || +#ifdef ENABLE_CLASSIC_FLANG + (PhaseArg = DAL.getLastArg(options::OPT_fsyntax_only)) || +#endif (PhaseArg = DAL.getLastArg(options::OPT__SLASH_EP)) || (PhaseArg = DAL.getLastArg(options::OPT_M, options::OPT_MM)) || (PhaseArg = DAL.getLastArg(options::OPT__SLASH_P)) || CCGenDiagnostics) { +#ifdef ENABLE_CLASSIC_FLANG + // -fsyntax-only or -E stops Fortran compilation after FortranFrontend + if (IsFlangMode() && (DAL.getLastArg(options::OPT_E) || + DAL.getLastArg(options::OPT_fsyntax_only))) { + FinalPhase = phases::FortranFrontend; + + // if not Fortran, fsyntax_only implies 'Compile' is the FinalPhase + } else if (DAL.getLastArg(options::OPT_fsyntax_only)) { + FinalPhase = phases::Compile; + + // everything else has 'Preprocess' as its FinalPhase + } else { + FinalPhase = phases::Preprocess; + } +#else FinalPhase = phases::Preprocess; +#endif // --precompile only runs up to precompilation. // Options that cause the output of C++20 compiled module interfaces or @@ -410,9 +429,15 @@ phases::ID Driver::getFinalPhase(const DerivedArgList &DAL, (PhaseArg = DAL.getLastArg(options::OPT_fmodule_header, options::OPT_fmodule_header_EQ))) { FinalPhase = phases::Precompile; + +#ifdef ENABLE_CLASSIC_FLANG + // -{analyze,emit-ast} only run up to the compiler. + } else if ((PhaseArg = DAL.getLastArg(options::OPT_print_supported_cpus)) || +#else // -{fsyntax-only,-analyze,emit-ast} only run up to the compiler. } else if ((PhaseArg = DAL.getLastArg(options::OPT_fsyntax_only)) || (PhaseArg = DAL.getLastArg(options::OPT_print_supported_cpus)) || +#endif (PhaseArg = DAL.getLastArg(options::OPT_print_enabled_extensions)) || (PhaseArg = DAL.getLastArg(options::OPT_module_file_info)) || (PhaseArg = DAL.getLastArg(options::OPT_verify_pch)) || @@ -2934,7 +2959,11 @@ void Driver::BuildInputs(const ToolChain &TC, DerivedArgList &Args, // stdin must be handled specially. if (memcmp(Value, "-", 2) == 0) { if (IsFlangMode()) { +#ifdef ENABLE_CLASSIC_FLANG + Ty = types::TY_C; +#else Ty = types::TY_Fortran; +#endif } else if (IsDXCMode()) { Ty = types::TY_HLSL; } else { @@ -4259,6 +4288,11 @@ void Driver::handleArguments(Compilation &C, DerivedArgList &Args, if (InputArg->isClaimed()) continue; + // Fortran input is preprocessed using the frontend. + if (InitialPhase == phases::FortranFrontend && + FinalPhase == phases::Preprocess) + continue; + // Claim here to avoid the more general unused warning. InputArg->claim(); @@ -5068,6 +5102,13 @@ Action *Driver::ConstructPhaseAction( return C.MakeAction(Input, OutputTy); } + case phases::FortranFrontend: { + if (Args.hasArg(options::OPT_fsyntax_only)) + return C.MakeAction(Input, + types::TY_Nothing); + return C.MakeAction(Input, + types::TY_LLVM_IR); + } case phases::Compile: { if (Args.hasArg(options::OPT_fsyntax_only)) return C.MakeAction(Input, types::TY_Nothing); diff --git a/clang/lib/Driver/OffloadBundler.cpp b/clang/lib/Driver/OffloadBundler.cpp index 12d763e5c65b..4dbd02ef1825 100644 --- a/clang/lib/Driver/OffloadBundler.cpp +++ b/clang/lib/Driver/OffloadBundler.cpp @@ -918,6 +918,10 @@ CreateFileHandler(MemoryBuffer &FirstInput, return std::make_unique(/*Comment=*/"#"); if (FilesType == "ll") return std::make_unique(/*Comment=*/";"); +#ifdef ENABLE_CLASSIC_FLANG + if (FilesType == "f95") + return std::make_unique(/*Comment=*/"!"); +#endif if (FilesType == "bc") return std::make_unique(BundlerConfig); if (FilesType == "s") diff --git a/clang/lib/Driver/Phases.cpp b/clang/lib/Driver/Phases.cpp index 01598c59bd9e..f0216c5ab7c2 100644 --- a/clang/lib/Driver/Phases.cpp +++ b/clang/lib/Driver/Phases.cpp @@ -16,6 +16,7 @@ const char *phases::getPhaseName(ID Id) { switch (Id) { case Preprocess: return "preprocessor"; case Precompile: return "precompiler"; + case FortranFrontend: return "fortran-frontend"; case Compile: return "compiler"; case Backend: return "backend"; case Assemble: return "assembler"; diff --git a/clang/lib/Driver/ToolChain.cpp b/clang/lib/Driver/ToolChain.cpp index acf9d264d631..f617b2aa5e88 100644 --- a/clang/lib/Driver/ToolChain.cpp +++ b/clang/lib/Driver/ToolChain.cpp @@ -11,6 +11,9 @@ #include "ToolChains/Arch/ARM.h" #include "ToolChains/Arch/RISCV.h" #include "ToolChains/Clang.h" +#ifdef ENABLE_CLASSIC_FLANG +#include "ToolChains/ClassicFlang.h" +#endif #include "ToolChains/CommonArgs.h" #include "ToolChains/Flang.h" #include "ToolChains/InterfaceStubs.h" @@ -576,6 +579,16 @@ Tool *ToolChain::getAssemble() const { return Assemble.get(); } +Tool *ToolChain::getFortranFrontend() const { +#ifdef ENABLE_CLASSIC_FLANG + if (!FortranFrontend) + FortranFrontend.reset(new tools::ClassicFlang(*this)); + return FortranFrontend.get(); +#else + llvm_unreachable("Fortran is not supported by this toolchain"); +#endif +} + Tool *ToolChain::getClangAs() const { if (!Assemble) Assemble.reset(new tools::ClangAs(*this)); @@ -659,6 +672,9 @@ Tool *ToolChain::getTool(Action::ActionClass AC) const { return getOffloadPackager(); case Action::LinkerWrapperJobClass: return getLinkerWrapper(); + + case Action::FortranFrontendJobClass: + return getFortranFrontend(); } llvm_unreachable("Invalid tool kind."); @@ -1047,13 +1063,13 @@ std::string ToolChain::GetStaticLibToolPath() const { types::ID ToolChain::LookupTypeForExtension(StringRef Ext) const { types::ID id = types::lookupTypeForExtension(Ext); - +#ifndef ENABLE_CLASSIC_FLANG // Flang always runs the preprocessor and has no notion of "preprocessed // fortran". Here, TY_PP_Fortran is coerced to TY_Fortran to avoid treating // them differently. if (D.IsFlangMode() && id == types::TY_PP_Fortran) id = types::TY_Fortran; - +#endif return id; } @@ -1413,6 +1429,45 @@ void ToolChain::AddCCKextLibArgs(const ArgList &Args, CmdArgs.push_back("-lcc_kext"); } +void ToolChain::AddFortranStdlibLibArgs(const ArgList &Args, + ArgStringList &CmdArgs) const { + bool staticFlangLibs = false; + bool useOpenMP = false; + + if (Args.hasArg(options::OPT_staticFlangLibs)) { + for (auto *A: Args.filtered(options::OPT_staticFlangLibs)) { + A->claim(); + staticFlangLibs = true; + } + } + + Arg *A = Args.getLastArg(options::OPT_mp, options::OPT_nomp, + options::OPT_fopenmp, options::OPT_fno_openmp); + if (A && + (A->getOption().matches(options::OPT_mp) || + A->getOption().matches(options::OPT_fopenmp))) { + useOpenMP = true; + } + + if (staticFlangLibs) + CmdArgs.push_back("-Bstatic"); + CmdArgs.push_back("-lflang"); + CmdArgs.push_back("-lflangrti"); + CmdArgs.push_back("-lpgmath"); + if (useOpenMP) + CmdArgs.push_back("-lomp"); + else + CmdArgs.push_back("-lompstub"); + if (staticFlangLibs) + CmdArgs.push_back("-Bdynamic"); + + CmdArgs.push_back("-lm"); + CmdArgs.push_back("-lrt"); + + // Allways link Fortran executables with Pthreads + CmdArgs.push_back("-lpthread"); +} + bool ToolChain::isFastMathRuntimeAvailable(const ArgList &Args, std::string &Path) const { // Don't implicitly link in mode-changing libraries in a shared library, since diff --git a/clang/lib/Driver/ToolChains/Clang.cpp b/clang/lib/Driver/ToolChains/Clang.cpp index 57b7d2bd4698..99d5a1a3edf8 100644 --- a/clang/lib/Driver/ToolChains/Clang.cpp +++ b/clang/lib/Driver/ToolChains/Clang.cpp @@ -5869,6 +5869,66 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, } A->render(Args, CmdArgs); } +#ifdef ENABLE_CLASSIC_FLANG + // Use PGMATH for Classic Flang by default. + else { + CmdArgs.push_back("-fveclib=PGMATH"); + } + + std::string PassRemarkVal(""), PassRemarkOpt(""); + if (Args.getLastArg(options::OPT_Minfoall)) { + PassRemarkVal = ".*"; + Args.ClaimAllArgs(options::OPT_Minfoall); + } else if (Arg *A = Args.getLastArg(options::OPT_Minfo_EQ)) { + for (StringRef val : A->getValues()) { + if (val == "all") { + PassRemarkVal = ".*"; + break; + } else if (val == "inline" || val == "vect") { + PassRemarkVal += PassRemarkVal.empty() ? "" : "|"; + PassRemarkVal += val; + } else { + D.Diag(diag::err_drv_clang_unsupported_minfo_arg) + << A->getOption().getName() + << val.str(); + break; + } + } + } + PassRemarkOpt = "-pass-remarks=" + PassRemarkVal; + CmdArgs.push_back("-mllvm"); + CmdArgs.push_back(Args.MakeArgString(PassRemarkOpt)); + Args.ClaimAllArgs(options::OPT_Minfo_EQ); + PassRemarkVal.clear(); + PassRemarkOpt.clear(); + + if (Args.getLastArg(options::OPT_Mneginfoall)) { + PassRemarkVal = ".*"; + Args.ClaimAllArgs(options::OPT_Mneginfoall); + } else if (Arg *A = Args.getLastArg(options::OPT_Mneginfo_EQ)) { + for (StringRef val : A->getValues()) { + if (val == "all") { + PassRemarkVal = ".*"; + break; + } else if (val == "inline" || val == "vect") { + PassRemarkVal += PassRemarkVal.empty() ? "" : "|"; + PassRemarkVal += val; + } else { + D.Diag(diag::err_drv_clang_unsupported_minfo_arg) + << A->getOption().getName() + << val.str(); + break; + } + } + } + PassRemarkOpt = "-pass-remarks-missed=" + PassRemarkVal; + CmdArgs.push_back("-mllvm"); + CmdArgs.push_back(Args.MakeArgString(PassRemarkOpt)); + PassRemarkOpt = "-pass-remarks-analysis=" + PassRemarkVal; + CmdArgs.push_back("-mllvm"); + CmdArgs.push_back(Args.MakeArgString(PassRemarkOpt)); + Args.ClaimAllArgs(options::OPT_Mneginfo_EQ); +#endif if (Args.hasFlag(options::OPT_fmerge_all_constants, options::OPT_fno_merge_all_constants, false)) diff --git a/clang/lib/Driver/ToolChains/ClassicFlang.cpp b/clang/lib/Driver/ToolChains/ClassicFlang.cpp new file mode 100644 index 000000000000..bf234f1b93c4 --- /dev/null +++ b/clang/lib/Driver/ToolChains/ClassicFlang.cpp @@ -0,0 +1,1068 @@ +//===-- ClassicFlang.cpp - Flang+LLVM ToolChain Implementations -*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "ClassicFlang.h" +#include "CommonArgs.h" +#include "clang/Driver/InputInfo.h" +#include "clang/Basic/CharInfo.h" +#include "clang/Basic/LangOptions.h" +#include "clang/Basic/MacroBuilder.h" +#include "clang/Basic/ObjCRuntime.h" +#include "clang/Basic/TargetInfo.h" +#include "clang/Basic/TargetOptions.h" +#include "clang/Basic/Version.h" +#include "clang/Config/config.h" +#include "clang/Driver/DriverDiagnostic.h" +#include "clang/Driver/Options.h" +#include "clang/Driver/SanitizerArgs.h" +#include "clang/Driver/XRayArgs.h" +#include "clang/Frontend/CompilerInstance.h" +#include "clang/Frontend/Utils.h" +#include "llvm/ADT/StringExtras.h" +#include "llvm/Option/ArgList.h" +#include "llvm/Support/CodeGen.h" +#include "llvm/Support/Compression.h" +#include "llvm/Support/FileSystem.h" +#include "llvm/Support/Path.h" +#include "llvm/Support/Process.h" +#include "llvm/Support/TargetParser.h" +#include "llvm/Support/YAMLParser.h" + +#ifdef LLVM_ON_UNIX +#include // For getuid(). +#endif + +using namespace clang::driver; +using namespace clang::driver::tools; +using namespace clang; +using namespace llvm::opt; + +class ClassicFlangMacroBuilder : public MacroBuilder { + ArgStringList &CmdArgs; + const ArgList &DriverArgs; + public: + ClassicFlangMacroBuilder(ArgStringList &UpperCmdArgs, const ArgList &DriverArgs, llvm::raw_string_ostream &Output) + : MacroBuilder(Output), CmdArgs(UpperCmdArgs), DriverArgs(DriverArgs) { + } + virtual void defineMacro(const Twine &Name, const Twine &Value = "1", + Twine DeprecationMsg = "") override { + CmdArgs.push_back("-def"); + CmdArgs.push_back(DriverArgs.MakeArgString(Name + Twine('=') + Value)); + } +}; + +void ClassicFlang::ConstructJob(Compilation &C, const JobAction &JA, + const InputInfo &Output, const InputInfoList &Inputs, + const ArgList &Args, const char *LinkingOutput) const { + ArgStringList CommonCmdArgs; + ArgStringList UpperCmdArgs; + ArgStringList LowerCmdArgs; + SmallString<256> Stem; + std::string OutFile; + bool NeedIEEE = false; + bool NeedFastMath = false; + bool NeedRelaxedMath = false; + + // Check number of inputs for sanity. We need at least one input. + assert(Inputs.size() >= 1 && "Must have at least one input."); + + /***** Process file arguments to both parts *****/ + const InputInfo &Input = Inputs[0]; + types::ID InputType = Input.getType(); + // Check file type sanity + assert(types::isAcceptedByFlang(InputType) && "Can only accept Fortran"); + + if (Args.hasArg(options::OPT_fsyntax_only)) { + // For -fsyntax-only produce temp files only + Stem = C.getDriver().GetTemporaryPath("", ""); + } else { + OutFile = Output.getFilename(); + Stem = llvm::sys::path::filename(OutFile); + llvm::sys::path::replace_extension(Stem, ""); + } + + // Add input file name to the compilation line + UpperCmdArgs.push_back(Input.getBaseInput()); + + // Add temporary output for ILM + const char * ILMFile = Args.MakeArgString(Stem + ".ilm"); + LowerCmdArgs.push_back(ILMFile); + C.addTempFile(ILMFile); + + // Generate -cmdline + std::string CmdLine("'+flang"); + // ignore the first argument which reads "--driver-mode=fortran" + for (unsigned i = 1; i < Args.getNumInputArgStrings(); ++i) { + CmdLine.append(" "); + CmdLine.append(Args.getArgString(i)); + } + CmdLine.append("'"); + + CommonCmdArgs.push_back("-cmdline"); + CommonCmdArgs.push_back(Args.MakeArgString(CmdLine)); + + /***** Process common args *****/ + + // Add "inform level" flag + if (Args.hasArg(options::OPT_Minform_EQ)) { + // Parse arguments to set its value + for (Arg *A : Args.filtered(options::OPT_Minform_EQ)) { + A->claim(); + CommonCmdArgs.push_back("-inform"); + CommonCmdArgs.push_back(A->getValue(0)); + } + } else { + // Default value + CommonCmdArgs.push_back("-inform"); + CommonCmdArgs.push_back("warn"); + } + + for (auto Arg : Args.filtered(options::OPT_Msave_on)) { + Arg->claim(); + CommonCmdArgs.push_back("-save"); + } + + for (auto Arg : Args.filtered(options::OPT_Msave_off)) { + Arg->claim(); + CommonCmdArgs.push_back("-nosave"); + } + + // Treat denormalized numbers as zero: On + for (auto Arg : Args.filtered(options::OPT_Mdaz_on)) { + Arg->claim(); + CommonCmdArgs.push_back("-x"); + CommonCmdArgs.push_back("129"); + CommonCmdArgs.push_back("4"); + CommonCmdArgs.push_back("-y"); + CommonCmdArgs.push_back("129"); + CommonCmdArgs.push_back("0x400"); + } + + // Treat denormalized numbers as zero: Off + for (auto Arg : Args.filtered(options::OPT_Mdaz_off)) { + Arg->claim(); + CommonCmdArgs.push_back("-y"); + CommonCmdArgs.push_back("129"); + CommonCmdArgs.push_back("4"); + CommonCmdArgs.push_back("-x"); + CommonCmdArgs.push_back("129"); + CommonCmdArgs.push_back("0x400"); + } + + // Store constants in writable data segment + for (auto Arg : Args.filtered(options::OPT_Mwritable_constants)) { + Arg->claim(); + LowerCmdArgs.push_back("-x"); + LowerCmdArgs.push_back("183"); + LowerCmdArgs.push_back("0x20000000"); + } + + // Bounds checking: On + for (auto Arg : Args.filtered(options::OPT_Mbounds_on)) { + Arg->claim(); + CommonCmdArgs.push_back("-x"); + CommonCmdArgs.push_back("70"); + CommonCmdArgs.push_back("2"); + } + + // Bounds checking: Off + for (auto Arg : Args.filtered(options::OPT_Mbounds_off)) { + Arg->claim(); + CommonCmdArgs.push_back("-y"); + CommonCmdArgs.push_back("70"); + CommonCmdArgs.push_back("2"); + } + + // Generate code allowing recursive subprograms + for (auto Arg : Args.filtered(options::OPT_Mrecursive_on)) { + Arg->claim(); + CommonCmdArgs.push_back("-recursive"); + } + + // Disable recursive subprograms + for (auto Arg : Args.filtered(options::OPT_Mrecursive_off)) { + Arg->claim(); + CommonCmdArgs.push_back("-norecursive"); + } + + // Enable generating reentrant code (disable optimizations that inhibit it) + for (auto Arg : Args.filtered(options::OPT_Mreentrant_on)) { + Arg->claim(); + CommonCmdArgs.push_back("-reentrant"); + } + + // Allow optimizations inhibiting reentrancy + for (auto Arg : Args.filtered(options::OPT_Mreentrant_off)) { + Arg->claim(); + CommonCmdArgs.push_back("-noreentrant"); + } + + // Swap byte order for unformatted IO + for (auto Arg : Args.filtered(options::OPT_Mbyteswapio, options::OPT_byteswapio)) { + Arg->claim(); + CommonCmdArgs.push_back("-x"); + CommonCmdArgs.push_back("125"); + CommonCmdArgs.push_back("2"); + } + + // Contiguous pointer checks + if (Arg *A = Args.getLastArg(options::OPT_fsanitize_EQ)) { + for (StringRef val : A->getValues()) { + if (val == "discontiguous" || val == "undefined") { + // -x 54 0x40 -x 54 0x80 -x 54 0x200 + UpperCmdArgs.push_back("-x"); + UpperCmdArgs.push_back("54"); + UpperCmdArgs.push_back("0x2c0"); + + // -fsanitze=discontiguous has no meaning in LLVM, only flang driver needs to + // recognize it. However -fsanitize=undefined needs to be passed on for further + // processing by the non-flang part of the driver. + if (val == "discontiguous") + A->claim(); + break; + } + } + } + + // Treat backslashes as regular characters + for (auto Arg : Args.filtered(options::OPT_fno_backslash, options::OPT_Mbackslash)) { + Arg->claim(); + CommonCmdArgs.push_back("-x"); + CommonCmdArgs.push_back("124"); + CommonCmdArgs.push_back("0x40"); + } + + // Treat backslashes as C-style escape characters + for (auto Arg : Args.filtered(options::OPT_fbackslash, options::OPT_Mnobackslash)) { + Arg->claim(); + CommonCmdArgs.push_back("-y"); + CommonCmdArgs.push_back("124"); + CommonCmdArgs.push_back("0x40"); + } + + // handle OpemMP options + if (auto *A = Args.getLastArg(options::OPT_mp, options::OPT_nomp, + options::OPT_fopenmp, options::OPT_fno_openmp)) { + for (auto Arg : Args.filtered(options::OPT_mp, options::OPT_nomp)) { + Arg->claim(); + } + for (auto Arg : Args.filtered(options::OPT_fopenmp, + options::OPT_fno_openmp)) { + Arg->claim(); + } + + if (A->getOption().matches(options::OPT_mp) || + A->getOption().matches(options::OPT_fopenmp)) { + + CommonCmdArgs.push_back("-mp"); + + // Allocate threadprivate data local to the thread + CommonCmdArgs.push_back("-x"); + CommonCmdArgs.push_back("69"); + CommonCmdArgs.push_back("0x200"); + + // Use the 'fair' schedule as the default static schedule + // for parallel do loops + CommonCmdArgs.push_back("-x"); + CommonCmdArgs.push_back("69"); + CommonCmdArgs.push_back("0x400"); + + // Disable use of native atomic instructions + // for OpenMP atomics pending either a named + // option or a libatomic bundled with flang. + UpperCmdArgs.push_back("-x"); + UpperCmdArgs.push_back("69"); + UpperCmdArgs.push_back("0x1000"); + } + } + + // Align large objects on cache lines + for (auto Arg : Args.filtered(options::OPT_Mcache_align_on)) { + Arg->claim(); + CommonCmdArgs.push_back("-x"); + CommonCmdArgs.push_back("119"); + CommonCmdArgs.push_back("0x10000000"); + LowerCmdArgs.push_back("-x"); + LowerCmdArgs.push_back("129"); + LowerCmdArgs.push_back("0x40000000"); + } + + // Disable special alignment of large objects + for (auto Arg : Args.filtered(options::OPT_Mcache_align_off)) { + Arg->claim(); + CommonCmdArgs.push_back("-y"); + CommonCmdArgs.push_back("119"); + CommonCmdArgs.push_back("0x10000000"); + LowerCmdArgs.push_back("-y"); + LowerCmdArgs.push_back("129"); + LowerCmdArgs.push_back("0x40000000"); + } + + // -Mstack_arrays + for (auto Arg : Args.filtered(options::OPT_Mstackarrays)) { + Arg->claim(); + CommonCmdArgs.push_back("-x"); + CommonCmdArgs.push_back("54"); + CommonCmdArgs.push_back("8"); + } + + // -Memit-dwarf-common-blocks-name, only add xbit to flang2. + for (auto Arg : Args.filtered(options::OPT_Memit_dwarf_common_blocks_name)) { + Arg->claim(); + LowerCmdArgs.push_back("-x"); + LowerCmdArgs.push_back("183"); + LowerCmdArgs.push_back("0x40000000"); + } + + // -Munixlogical, only add xbit to flang2. + for (auto Arg : Args.filtered(options::OPT_Munixlogical)) { + Arg->claim(); + LowerCmdArgs.push_back("-x"); + LowerCmdArgs.push_back("125"); + LowerCmdArgs.push_back("0x8"); + } + + // -g should produce DWARFv2 + for (auto Arg : Args.filtered(options::OPT_g_Flag)) { + Arg->claim(); + CommonCmdArgs.push_back("-x"); + CommonCmdArgs.push_back("120"); + CommonCmdArgs.push_back("0x200"); + } + + // -gdwarf-2 + for (auto Arg : Args.filtered(options::OPT_gdwarf_2)) { + Arg->claim(); + CommonCmdArgs.push_back("-x"); + CommonCmdArgs.push_back("120"); + CommonCmdArgs.push_back("0x200"); + } + + // -gdwarf-3 + for (auto Arg : Args.filtered(options::OPT_gdwarf_3)) { + Arg->claim(); + CommonCmdArgs.push_back("-x"); + CommonCmdArgs.push_back("120"); + CommonCmdArgs.push_back("0x4000"); + } + + // -Mipa has no effect + if (Arg *A = Args.getLastArg(options::OPT_Mipa)) { + getToolChain().getDriver().Diag(diag::warn_drv_clang_unsupported) + << A->getAsString(Args); + } + + // -Minline has no effect + if (Arg *A = Args.getLastArg(options::OPT_Minline_on)) { + getToolChain().getDriver().Diag(diag::warn_drv_clang_unsupported) + << A->getAsString(Args); + } + + // Handle -fdefault-real-8 (and its alias, -r8) and -fno-default-real-8 + if (Arg *A = Args.getLastArg(options::OPT_r8, + options::OPT_fdefault_real_8, + options::OPT_default_real_8_fno)) { + const char * fl; + // For -f version add -x flag, for -fno add -y + if (A->getOption().matches(options::OPT_default_real_8_fno)) { + fl = "-y"; + } else { + fl = "-x"; + } + + for (Arg *A : Args.filtered(options::OPT_r8, + options::OPT_fdefault_real_8, + options::OPT_default_real_8_fno)) { + A->claim(); + } + + UpperCmdArgs.push_back(fl); + UpperCmdArgs.push_back("124"); + UpperCmdArgs.push_back("0x8"); + UpperCmdArgs.push_back(fl); + UpperCmdArgs.push_back("124"); + UpperCmdArgs.push_back("0x80000"); + } + + // Process and claim -i8/-fdefault-integer-8/-fno-default-integer-8 argument + if (Arg *A = Args.getLastArg(options::OPT_i8, + options::OPT_fdefault_integer_8, + options::OPT_default_integer_8_fno)) { + const char * fl; + + if (A->getOption().matches(options::OPT_default_integer_8_fno)) { + fl = "-y"; + } else { + fl = "-x"; + } + + for (Arg *A : Args.filtered(options::OPT_i8, + options::OPT_fdefault_integer_8, + options::OPT_default_integer_8_fno)) { + A->claim(); + } + + UpperCmdArgs.push_back(fl); + UpperCmdArgs.push_back("124"); + UpperCmdArgs.push_back("0x10"); + } + + // Pass an arbitrary flag for first part of Fortran frontend + for (Arg *A : Args.filtered(options::OPT_Wh_EQ)) { + A->claim(); + StringRef Value = A->getValue(); + SmallVector PassArgs; + Value.split(PassArgs, StringRef(",")); + for (StringRef PassArg : PassArgs) { + UpperCmdArgs.push_back(Args.MakeArgString(PassArg)); + } + } + + // Flush to zero mode + // Disabled by default, but can be enabled by a switch + if (Args.hasArg(options::OPT_Mflushz_on)) { + // For -Mflushz set -x 129 2 for second part of Fortran frontend + for (Arg *A: Args.filtered(options::OPT_Mflushz_on)) { + A->claim(); + LowerCmdArgs.push_back("-x"); + LowerCmdArgs.push_back("129"); + LowerCmdArgs.push_back("2"); + } + } else { + LowerCmdArgs.push_back("-y"); + LowerCmdArgs.push_back("129"); + LowerCmdArgs.push_back("2"); + for (Arg *A: Args.filtered(options::OPT_Mflushz_off)) { + A->claim(); + } + } + + // Enable FMA + for (Arg *A: Args.filtered(options::OPT_Mfma_on, options::OPT_fma)) { + A->claim(); + LowerCmdArgs.push_back("-x"); + LowerCmdArgs.push_back("172"); + LowerCmdArgs.push_back("0x40000000"); + LowerCmdArgs.push_back("-x"); + LowerCmdArgs.push_back("179"); + LowerCmdArgs.push_back("1"); + } + + // Disable FMA + for (Arg *A: Args.filtered(options::OPT_Mfma_off, options::OPT_nofma)) { + A->claim(); + LowerCmdArgs.push_back("-x"); + LowerCmdArgs.push_back("171"); + LowerCmdArgs.push_back("0x40000000"); + LowerCmdArgs.push_back("-x"); + LowerCmdArgs.push_back("178"); + LowerCmdArgs.push_back("1"); + } + + // For -fPIC set -x 62 8 for second part of Fortran frontend + for (Arg *A: Args.filtered(options::OPT_fPIC)) { + A->claim(); + LowerCmdArgs.push_back("-x"); + LowerCmdArgs.push_back("62"); + LowerCmdArgs.push_back("8"); + } + + StringRef OptOStr("0"); + if (Arg *A = Args.getLastArg(options::OPT_O_Group)) { + if (A->getOption().matches(options::OPT_O4)) { + OptOStr = "4"; // FIXME what should this be? + } else if (A->getOption().matches(options::OPT_Ofast)) { + OptOStr = "2"; // FIXME what should this be? + } else if (A->getOption().matches(options::OPT_O0)) { + // intentionally do nothing + } else { + assert(A->getOption().matches(options::OPT_O) && "Must have a -O flag"); + StringRef S(A->getValue()); + if ((S == "s") || (S == "z")) { + // -Os = size; -Oz = more size + OptOStr = "2"; // FIXME -Os|-Oz => -opt ? + } else if ((S == "1") || (S == "2") || (S == "3")) { + OptOStr = S; + } else { + OptOStr = "4"; + } + } + } + unsigned OptLevel = std::stoi(OptOStr.str()); + + if (Args.hasArg(options::OPT_g_Group)) { + // pass -g to lower and upper + CommonCmdArgs.push_back("-debug"); + } + + /* Pick the last among conflicting flags, if a positive and negative flag + exists for ex. "-ffast-math -fno-fast-math" they get nullified. Also any + previously overwritten flag remains that way. + For ex. "-Kieee -ffast-math -fno-fast-math". -Kieee gets overwritten by + -ffast-math which then gets negated by -fno-fast-math, finally behaving as + if none of those flags were passed. + */ + for(Arg *A: Args.filtered(options::OPT_ffast_math, options::OPT_fno_fast_math, + options::OPT_Ofast, options::OPT_Kieee_off, + options::OPT_Kieee_on, options::OPT_frelaxed_math)) { + if (A->getOption().matches(options::OPT_ffast_math) || + A->getOption().matches(options::OPT_Ofast)) { + NeedIEEE = NeedRelaxedMath = false; + NeedFastMath = true; + } else if (A->getOption().matches(options::OPT_Kieee_on)) { + NeedFastMath = NeedRelaxedMath = false; + NeedIEEE = true; + } else if (A->getOption().matches(options::OPT_frelaxed_math)) { + NeedFastMath = NeedIEEE = false; + NeedRelaxedMath = true; + } else if (A->getOption().matches(options::OPT_fno_fast_math)) { + NeedFastMath = false; + } else if (A->getOption().matches(options::OPT_Kieee_off)) { + NeedIEEE = false; + } + A->claim(); + } + + if (NeedFastMath) { + // Lower: -x 216 1 + LowerCmdArgs.push_back("-x"); + LowerCmdArgs.push_back("216"); + LowerCmdArgs.push_back("1"); + // Lower: -ieee 0 + CommonCmdArgs.push_back("-ieee"); + CommonCmdArgs.push_back("0"); + } else if (NeedIEEE) { + // Common: -y 129 2 + CommonCmdArgs.push_back("-y"); + CommonCmdArgs.push_back("129"); + CommonCmdArgs.push_back("2"); + // Lower: -x 6 0x100 + LowerCmdArgs.push_back("-x"); + LowerCmdArgs.push_back("6"); + LowerCmdArgs.push_back("0x100"); + // Lower: -x 42 0x400000 + LowerCmdArgs.push_back("-x"); + LowerCmdArgs.push_back("42"); + LowerCmdArgs.push_back("0x400000"); + // Lower: -y 129 4 + LowerCmdArgs.push_back("-y"); + LowerCmdArgs.push_back("129"); + LowerCmdArgs.push_back("4"); + // Lower: -x 129 0x400 + LowerCmdArgs.push_back("-x"); + LowerCmdArgs.push_back("129"); + LowerCmdArgs.push_back("0x400"); + // Lower: -y 216 1 (OPT_fno_fast_math) + LowerCmdArgs.push_back("-y"); + LowerCmdArgs.push_back("216"); + LowerCmdArgs.push_back("1"); + // Lower: -ieee 1 + CommonCmdArgs.push_back("-ieee"); + CommonCmdArgs.push_back("1"); + } else if (NeedRelaxedMath) { + // Lower: -x 15 0x400 + LowerCmdArgs.push_back("-x"); + LowerCmdArgs.push_back("15"); + LowerCmdArgs.push_back("0x400"); + // Lower: -y 216 1 (OPT_fno_fast_math) + LowerCmdArgs.push_back("-y"); + LowerCmdArgs.push_back("216"); + LowerCmdArgs.push_back("1"); + // Lower: -ieee 0 + CommonCmdArgs.push_back("-ieee"); + CommonCmdArgs.push_back("0"); + } else { + // Lower: -ieee 0 + CommonCmdArgs.push_back("-ieee"); + CommonCmdArgs.push_back("0"); + } + + /***** Upper part of the Fortran frontend *****/ + + // TODO do we need to invoke this under GDB sometimes? + const char *UpperExec = Args.MakeArgString(getToolChain().GetProgramPath("flang1")); + + UpperCmdArgs.push_back("-opt"); UpperCmdArgs.push_back(Args.MakeArgString(OptOStr)); + UpperCmdArgs.push_back("-terse"); UpperCmdArgs.push_back("1"); + UpperCmdArgs.push_back("-inform"); UpperCmdArgs.push_back("warn"); + UpperCmdArgs.push_back("-nohpf"); + UpperCmdArgs.push_back("-nostatic"); + UpperCmdArgs.append(CommonCmdArgs.begin(), CommonCmdArgs.end()); // Append common arguments + UpperCmdArgs.push_back("-x"); UpperCmdArgs.push_back("19"); UpperCmdArgs.push_back("0x400000"); + UpperCmdArgs.push_back("-quad"); + UpperCmdArgs.push_back("-x"); UpperCmdArgs.push_back("68"); UpperCmdArgs.push_back("0x1"); + UpperCmdArgs.push_back("-x"); UpperCmdArgs.push_back("59"); UpperCmdArgs.push_back("4"); + UpperCmdArgs.push_back("-x"); UpperCmdArgs.push_back("15"); UpperCmdArgs.push_back("2"); + UpperCmdArgs.push_back("-x"); UpperCmdArgs.push_back("49"); UpperCmdArgs.push_back("0x400004"); + UpperCmdArgs.push_back("-x"); UpperCmdArgs.push_back("51"); UpperCmdArgs.push_back("0x20"); + UpperCmdArgs.push_back("-x"); UpperCmdArgs.push_back("57"); UpperCmdArgs.push_back("0x4c"); + UpperCmdArgs.push_back("-x"); UpperCmdArgs.push_back("58"); UpperCmdArgs.push_back("0x10000"); + UpperCmdArgs.push_back("-x"); UpperCmdArgs.push_back("124"); UpperCmdArgs.push_back("0x1000"); + UpperCmdArgs.push_back("-tp"); UpperCmdArgs.push_back("px"); + UpperCmdArgs.push_back("-x"); UpperCmdArgs.push_back("57"); UpperCmdArgs.push_back("0xfb0000"); + UpperCmdArgs.push_back("-x"); UpperCmdArgs.push_back("58"); UpperCmdArgs.push_back("0x78031040"); + UpperCmdArgs.push_back("-x"); UpperCmdArgs.push_back("47"); UpperCmdArgs.push_back("0x08"); + UpperCmdArgs.push_back("-x"); UpperCmdArgs.push_back("48"); UpperCmdArgs.push_back("4608"); + UpperCmdArgs.push_back("-x"); UpperCmdArgs.push_back("49"); UpperCmdArgs.push_back("0x100"); + if (OptLevel >= 2) { + UpperCmdArgs.push_back("-x"); + UpperCmdArgs.push_back("70"); + UpperCmdArgs.push_back("0x6c00"); + UpperCmdArgs.push_back("-x"); + UpperCmdArgs.push_back("119"); + UpperCmdArgs.push_back("0x10000000"); + UpperCmdArgs.push_back("-x"); + UpperCmdArgs.push_back("129"); + UpperCmdArgs.push_back("2"); + UpperCmdArgs.push_back("-x"); + UpperCmdArgs.push_back("47"); + UpperCmdArgs.push_back("0x400000"); + UpperCmdArgs.push_back("-x"); + UpperCmdArgs.push_back("52"); + UpperCmdArgs.push_back("2"); + } + + // Add system include arguments. + getToolChain().AddFlangSystemIncludeArgs(Args, UpperCmdArgs); + + // Use clang's predefined macros + DiagnosticsEngine DE(new DiagnosticIDs(), new DiagnosticOptions, new IgnoringDiagConsumer()); + std::shared_ptr TO = std::make_shared(); + TO->Triple = getToolChain().getEffectiveTriple().getTriple(); + std::shared_ptr TI(clang::TargetInfo::CreateTargetInfo(DE, TO)); + std::string PredefineBuffer; + llvm::raw_string_ostream Predefines(PredefineBuffer); + ClassicFlangMacroBuilder Builder(UpperCmdArgs, Args, Predefines); + + LangOptions LO; + VersionTuple VT = getToolChain().computeMSVCVersion(&getToolChain().getDriver(), Args); + if (!VT.empty()) { + // Set the MSCompatibility version. Subminor version has 5 decimal digits. + // Minor and major versions have 2 decimal digits each. + LO.MSCompatibilityVersion = VT.getMajor() * 10000000 + + VT.getMinor().value_or(0) * 100000 + + VT.getSubminor().value_or(0); + } + + // Define Target specific macros like __linux__ + TI->getTargetDefines(LO, Builder); + + Builder.defineMacro("__SIZE_TYPE__", + TargetInfo::getTypeName(TI->getSizeType())); + Builder.defineMacro( + "__PTRDIFF_TYPE__", + TargetInfo::getTypeName(TI->getPtrDiffType(LangAS::Default))); + + if (TI->getPointerWidth(LangAS::Default) == 64 && TI->getLongWidth() == 64 + && TI->getIntWidth() == 32) { + Builder.defineMacro("_LP64"); + Builder.defineMacro("__LP64__"); + } + + if (TI->getPointerWidth(LangAS::Default) == 32 && TI->getLongWidth() == 32 + && TI->getIntWidth() == 32) { + Builder.defineMacro("_ILP32"); + Builder.defineMacro("__ILP32__"); + } + + DefineTypeSize("__LONG_MAX__", TargetInfo::SignedLong, *TI, Builder); + + // Add additional predefined macros + switch (getToolChain().getEffectiveTriple().getArch()) { + case llvm::Triple::aarch64: + UpperCmdArgs.push_back("-def"); UpperCmdArgs.push_back("__ARM_ARCH__=8"); + break; + case llvm::Triple::x86_64: + UpperCmdArgs.push_back("-def"); UpperCmdArgs.push_back("__amd_64__amd64__"); + UpperCmdArgs.push_back("-def"); UpperCmdArgs.push_back("__k8"); + UpperCmdArgs.push_back("-def"); UpperCmdArgs.push_back("__k8__"); + break; + default: /* generic 64-bit */ + ; + } + UpperCmdArgs.push_back("-def"); UpperCmdArgs.push_back("__THROW="); + UpperCmdArgs.push_back("-def"); UpperCmdArgs.push_back("__extension__="); + UpperCmdArgs.push_back("-def"); UpperCmdArgs.push_back("__PGLLVM__"); + + // Enable preprocessor + if (Args.hasArg(options::OPT_Mpreprocess) || + Args.hasArg(options::OPT_cpp) || + Args.hasArg(options::OPT_E) || + types::getPreprocessedType(InputType) != types::TY_INVALID) { + UpperCmdArgs.push_back("-preprocess"); + for (auto Arg : Args.filtered(options::OPT_Mpreprocess, options::OPT_cpp, options::OPT_E)) { + Arg->claim(); + } + + // When -E option is provided, run only the fortran preprocessor. + // Only in -E mode, consume -P if it exists + if (Args.hasArg(options::OPT_E)) { + UpperCmdArgs.push_back("-es"); + // Line marker mode is disabled + if (Args.hasArg(options::OPT_P)) { + Args.ClaimAllArgs(options::OPT_P); + } else { + // -pp enables line marker mode in fortran preprocessor + UpperCmdArgs.push_back("-pp"); + } + } + } + + // Enable standards checking + if (Args.hasArg(options::OPT_Mstandard)) { + UpperCmdArgs.push_back("-standard"); + for (auto Arg : Args.filtered(options::OPT_Mstandard)) { + Arg->claim(); + } + } + + // Free or fixed form file + if (Args.hasArg(options::OPT_fortran_format_Group)) { + // Override file name suffix, scan arguments for that + for (Arg *A : Args.filtered(options::OPT_fortran_format_Group)) { + A->claim(); + switch (A->getOption().getID()) { + default: + llvm_unreachable("missed a case"); + case options::OPT_ffixed_form: + case options::OPT_free_form_off: + case options::OPT_Mfixed: + case options::OPT_Mfree_off: + case options::OPT_Mfreeform_off: + UpperCmdArgs.push_back("-nofreeform"); + break; + case options::OPT_ffree_form: + case options::OPT_fixed_form_off: + case options::OPT_Mfree_on: + case options::OPT_Mfreeform_on: + UpperCmdArgs.push_back("-freeform"); + break; + } + } + } else { + // Deduce format from file name suffix + if (types::isFreeFormFortran(InputType)) { + UpperCmdArgs.push_back("-freeform"); + } else { + UpperCmdArgs.push_back("-nofreeform"); + } + } + + // Extend lines to 132 characters + for (auto Arg : Args.filtered(options::OPT_Mextend)) { + Arg->claim(); + UpperCmdArgs.push_back("-extend"); + } + + for (auto Arg : Args.filtered(options::OPT_ffixed_line_length_VALUE)) { + StringRef Value = Arg->getValue(); + if (Value == "72") { + Arg->claim(); + } else if (Value == "132") { + Arg->claim(); + UpperCmdArgs.push_back("-extend"); + } else { + getToolChain().getDriver().Diag(diag::err_drv_unsupported_fixed_line_length) + << Arg->getAsString(Args); + } + } + + // Add user-defined include directories + for (auto Arg : Args.filtered(options::OPT_I)) { + Arg->claim(); + UpperCmdArgs.push_back("-idir"); + UpperCmdArgs.push_back(Arg->getValue(0)); + } + + // Add user-defined module directories + for (auto Arg : Args.filtered(options::OPT_ModuleDir, options::OPT_J)) { + Arg->claim(); + UpperCmdArgs.push_back("-moddir"); + UpperCmdArgs.push_back(Arg->getValue(0)); + } + + // "Define" preprocessor flags + for (auto Arg : Args.filtered(options::OPT_D)) { + Arg->claim(); + UpperCmdArgs.push_back("-def"); + UpperCmdArgs.push_back(Arg->getValue(0)); + } + + // "Define" preprocessor flags + for (auto Arg : Args.filtered(options::OPT_U)) { + Arg->claim(); + UpperCmdArgs.push_back("-undef"); + UpperCmdArgs.push_back(Arg->getValue(0)); + } + + UpperCmdArgs.push_back("-vect"); UpperCmdArgs.push_back("48"); + + // Semantics for assignments to allocatables + if (Arg *A = Args.getLastArg(options::OPT_Mallocatable_EQ)) { + // Argument is passed explicitly + StringRef Value = A->getValue(); + if (Value == "03") { // Enable Fortran 2003 semantics + UpperCmdArgs.push_back("-x"); // Set XBIT + } else if (Value == "95") { // Enable Fortran 2003 semantics + UpperCmdArgs.push_back("-y"); // Unset XBIT + } else { + getToolChain().getDriver().Diag(diag::err_drv_invalid_allocatable_mode) + << A->getAsString(Args); + } + } else { // No argument passed + UpperCmdArgs.push_back("-x"); // Default is 03 + } + UpperCmdArgs.push_back("54"); UpperCmdArgs.push_back("1"); // XBIT value + + UpperCmdArgs.push_back("-x"); UpperCmdArgs.push_back("70"); UpperCmdArgs.push_back("0x40000000"); + UpperCmdArgs.push_back("-y"); UpperCmdArgs.push_back("163"); UpperCmdArgs.push_back("0xc0000000"); + UpperCmdArgs.push_back("-x"); UpperCmdArgs.push_back("189"); UpperCmdArgs.push_back("0x10"); + + // Enable NULL pointer checking + if (Args.hasArg(options::OPT_Mchkptr)) { + UpperCmdArgs.push_back("-x"); + UpperCmdArgs.push_back("70"); + UpperCmdArgs.push_back("4"); + for (auto Arg : Args.filtered(options::OPT_Mchkptr)) { + Arg->claim(); + } + } + + // Set a -x flag for first part of Fortran frontend + for (Arg *A : Args.filtered(options::OPT_Hx_EQ)) { + A->claim(); + StringRef Value = A->getValue(); + auto XFlag = Value.split(","); + UpperCmdArgs.push_back("-x"); + UpperCmdArgs.push_back(Args.MakeArgString(XFlag.first)); + UpperCmdArgs.push_back(Args.MakeArgString(XFlag.second)); + } + + // Set a -y flag for first part of Fortran frontend + for (Arg *A : Args.filtered(options::OPT_Hy_EQ)) { + A->claim(); + StringRef Value = A->getValue(); + auto XFlag = Value.split(","); + UpperCmdArgs.push_back("-y"); + UpperCmdArgs.push_back(Args.MakeArgString(XFlag.first)); + UpperCmdArgs.push_back(Args.MakeArgString(XFlag.second)); + } + + // Set a -q (debug) flag for first part of Fortran frontend + for (Arg *A : Args.filtered(options::OPT_Hq_EQ)) { + A->claim(); + StringRef Value = A->getValue(); + auto XFlag = Value.split(","); + UpperCmdArgs.push_back("-q"); + UpperCmdArgs.push_back(Args.MakeArgString(XFlag.first)); + UpperCmdArgs.push_back(Args.MakeArgString(XFlag.second)); + } + + // Set a -qq (debug) flag for first part of Fortran frontend + for (Arg *A : Args.filtered(options::OPT_Hqq_EQ)) { + A->claim(); + StringRef Value = A->getValue(); + auto XFlag = Value.split(","); + UpperCmdArgs.push_back("-qq"); + UpperCmdArgs.push_back(Args.MakeArgString(XFlag.first)); + UpperCmdArgs.push_back(Args.MakeArgString(XFlag.second)); + } + + const char * STBFile = Args.MakeArgString(Stem + ".stb"); + C.addTempFile(STBFile); + UpperCmdArgs.push_back("-stbfile"); + UpperCmdArgs.push_back(STBFile); + + const char * ModuleExportFile = Args.MakeArgString(Stem + ".cmod"); + C.addTempFile(ModuleExportFile); + UpperCmdArgs.push_back("-modexport"); + UpperCmdArgs.push_back(ModuleExportFile); + + const char * ModuleIndexFile = Args.MakeArgString(Stem + ".cmdx"); + C.addTempFile(ModuleIndexFile); + UpperCmdArgs.push_back("-modindex"); + UpperCmdArgs.push_back(ModuleIndexFile); + + UpperCmdArgs.push_back("-output"); + UpperCmdArgs.push_back(ILMFile); + + SmallString<256> Path; + if(Args.getAllArgValues(options::OPT_fopenmp_targets_EQ).size() > 0) { + SmallString<128> TargetInfo; + Path = llvm::sys::path::parent_path(Output.getFilename()); + Arg* Tgts = Args.getLastArg(options::OPT_fopenmp_targets_EQ); + assert(Tgts && Tgts->getNumValues() && + "OpenMP offloading has to have targets specified."); + for (unsigned i = 0; i < Tgts->getNumValues(); ++i) { + if (i) + TargetInfo += ','; + llvm::Triple T(Tgts->getValue(i)); + TargetInfo += T.getTriple(); + } + UpperCmdArgs.push_back("-fopenmp-targets"); + UpperCmdArgs.push_back(Args.MakeArgString(TargetInfo.str())); + } + + C.addCommand(std::make_unique(JA, *this, ResponseFileSupport::AtFileUTF8(), UpperExec, UpperCmdArgs, Inputs)); + + // For -fsyntax-only or -E that is it + if (Args.hasArg(options::OPT_fsyntax_only) || + Args.hasArg(options::OPT_E)) return; + + /***** Lower part of Fortran frontend *****/ + + const char *LowerExec = Args.MakeArgString(getToolChain().GetProgramPath("flang2")); + + // TODO FLANG arg handling + LowerCmdArgs.push_back("-fn"); LowerCmdArgs.push_back(Input.getBaseInput()); + LowerCmdArgs.push_back("-opt"); LowerCmdArgs.push_back(Args.MakeArgString(OptOStr)); + LowerCmdArgs.push_back("-terse"); LowerCmdArgs.push_back("1"); + LowerCmdArgs.push_back("-inform"); LowerCmdArgs.push_back("warn"); + LowerCmdArgs.append(CommonCmdArgs.begin(), CommonCmdArgs.end()); // Append common arguments + LowerCmdArgs.push_back("-x"); LowerCmdArgs.push_back("68"); LowerCmdArgs.push_back("0x1"); + LowerCmdArgs.push_back("-x"); LowerCmdArgs.push_back("51"); LowerCmdArgs.push_back("0x20"); + LowerCmdArgs.push_back("-x"); LowerCmdArgs.push_back("119"); LowerCmdArgs.push_back("0xa10000"); + LowerCmdArgs.push_back("-x"); LowerCmdArgs.push_back("122"); LowerCmdArgs.push_back("0x40"); + LowerCmdArgs.push_back("-x"); LowerCmdArgs.push_back("123"); LowerCmdArgs.push_back("0x1000"); + LowerCmdArgs.push_back("-x"); LowerCmdArgs.push_back("127"); LowerCmdArgs.push_back("4"); + LowerCmdArgs.push_back("-x"); LowerCmdArgs.push_back("127"); LowerCmdArgs.push_back("17"); + LowerCmdArgs.push_back("-x"); LowerCmdArgs.push_back("19"); LowerCmdArgs.push_back("0x400000"); + LowerCmdArgs.push_back("-x"); LowerCmdArgs.push_back("28"); LowerCmdArgs.push_back("0x40000"); + LowerCmdArgs.push_back("-x"); LowerCmdArgs.push_back("120"); LowerCmdArgs.push_back("0x10000000"); + LowerCmdArgs.push_back("-x"); LowerCmdArgs.push_back("70"); LowerCmdArgs.push_back("0x8000"); + LowerCmdArgs.push_back("-x"); LowerCmdArgs.push_back("122"); LowerCmdArgs.push_back("1"); + LowerCmdArgs.push_back("-x"); LowerCmdArgs.push_back("125"); LowerCmdArgs.push_back("0x20000"); + LowerCmdArgs.push_back("-x"); LowerCmdArgs.push_back("164"); LowerCmdArgs.push_back("0x800000"); + LowerCmdArgs.push_back("-quad"); + LowerCmdArgs.push_back("-x"); LowerCmdArgs.push_back("59"); LowerCmdArgs.push_back("4"); + LowerCmdArgs.push_back("-tp"); LowerCmdArgs.push_back("px"); + LowerCmdArgs.push_back("-x"); LowerCmdArgs.push_back("120"); LowerCmdArgs.push_back("0x1000"); // debug lite + LowerCmdArgs.push_back("-x"); LowerCmdArgs.push_back("124"); LowerCmdArgs.push_back("0x1400"); + LowerCmdArgs.push_back("-y"); LowerCmdArgs.push_back("15"); LowerCmdArgs.push_back("2"); + LowerCmdArgs.push_back("-x"); LowerCmdArgs.push_back("57"); LowerCmdArgs.push_back("0x3b0000"); + LowerCmdArgs.push_back("-x"); LowerCmdArgs.push_back("58"); LowerCmdArgs.push_back("0x48000000"); + LowerCmdArgs.push_back("-x"); LowerCmdArgs.push_back("49"); LowerCmdArgs.push_back("0x100"); + LowerCmdArgs.push_back("-astype"); LowerCmdArgs.push_back("0"); + LowerCmdArgs.push_back("-x"); LowerCmdArgs.push_back("183"); LowerCmdArgs.push_back("4"); + LowerCmdArgs.push_back("-x"); LowerCmdArgs.push_back("121"); LowerCmdArgs.push_back("0x800"); + LowerCmdArgs.push_back("-x"); LowerCmdArgs.push_back("54"); LowerCmdArgs.push_back("0x10"); + LowerCmdArgs.push_back("-x"); LowerCmdArgs.push_back("70"); LowerCmdArgs.push_back("0x40000000"); + LowerCmdArgs.push_back("-x"); LowerCmdArgs.push_back("249"); LowerCmdArgs.push_back("150"); // LLVM version + LowerCmdArgs.push_back("-x"); LowerCmdArgs.push_back("124"); LowerCmdArgs.push_back("1"); + LowerCmdArgs.push_back("-y"); LowerCmdArgs.push_back("163"); LowerCmdArgs.push_back("0xc0000000"); + LowerCmdArgs.push_back("-x"); LowerCmdArgs.push_back("189"); LowerCmdArgs.push_back("0x10"); + LowerCmdArgs.push_back("-y"); LowerCmdArgs.push_back("189"); LowerCmdArgs.push_back("0x4000000"); + + // Remove "noinline" attriblute + LowerCmdArgs.push_back("-x"); LowerCmdArgs.push_back("183"); LowerCmdArgs.push_back("0x10"); + + // Set a -x flag for second part of Fortran frontend + for (Arg *A : Args.filtered(options::OPT_Mx_EQ)) { + A->claim(); + StringRef Value = A->getValue(); + auto XFlag = Value.split(","); + LowerCmdArgs.push_back("-x"); + LowerCmdArgs.push_back(Args.MakeArgString(XFlag.first)); + LowerCmdArgs.push_back(Args.MakeArgString(XFlag.second)); + } + + // Set a -y flag for second part of Fortran frontend + for (Arg *A : Args.filtered(options::OPT_My_EQ)) { + A->claim(); + StringRef Value = A->getValue(); + auto XFlag = Value.split(","); + LowerCmdArgs.push_back("-y"); + LowerCmdArgs.push_back(Args.MakeArgString(XFlag.first)); + LowerCmdArgs.push_back(Args.MakeArgString(XFlag.second)); + } + + // Set a -q (debug) flag for second part of Fortran frontend + for (Arg *A : Args.filtered(options::OPT_Mq_EQ)) { + A->claim(); + StringRef Value = A->getValue(); + auto XFlag = Value.split(","); + LowerCmdArgs.push_back("-q"); + LowerCmdArgs.push_back(Args.MakeArgString(XFlag.first)); + LowerCmdArgs.push_back(Args.MakeArgString(XFlag.second)); + } + + // Set a -qq (debug) flag for second part of Fortran frontend + for (Arg *A : Args.filtered(options::OPT_Mqq_EQ)) { + A->claim(); + StringRef Value = A->getValue(); + auto XFlag = Value.split(","); + LowerCmdArgs.push_back("-qq"); + LowerCmdArgs.push_back(Args.MakeArgString(XFlag.first)); + LowerCmdArgs.push_back(Args.MakeArgString(XFlag.second)); + } + + // Pass an arbitrary flag for second part of Fortran frontend + for (Arg *A : Args.filtered(options::OPT_Wm_EQ)) { + A->claim(); + StringRef Value = A->getValue(); + SmallVector PassArgs; + Value.split(PassArgs, StringRef(",")); + for (StringRef PassArg : PassArgs) { + LowerCmdArgs.push_back(Args.MakeArgString(PassArg)); + } + } + + LowerCmdArgs.push_back("-stbfile"); + LowerCmdArgs.push_back(STBFile); + + Path = llvm::sys::path::parent_path(Output.getFilename()); + bool IsOpenMPDevice = JA.isDeviceOffloading(Action::OFK_OpenMP); + + /* OpenMP GPU Offload */ + if(Args.getAllArgValues(options::OPT_fopenmp_targets_EQ).size() > 0) { + SmallString<128> TargetInfo;//("-fopenmp-targets "); + SmallString<256> TargetInfoAsm;//("-fopenmp-targets-asm "); + + Arg* Tgts = Args.getLastArg(options::OPT_fopenmp_targets_EQ); + assert(Tgts && Tgts->getNumValues() && + "OpenMP offloading has to have targets specified."); + for (unsigned i = 0; i < Tgts->getNumValues(); ++i) { + if (i) + TargetInfo += ','; + // We need to get the string from the triple because it may be not exactly + // the same as the one we get directly from the arguments. + llvm::Triple T(Tgts->getValue(i)); + TargetInfo += T.getTriple(); + // We also need to give a output file + TargetInfoAsm += Path; + TargetInfoAsm += "/"; + TargetInfoAsm += Stem; + TargetInfoAsm += "-"; + TargetInfoAsm += T.getTriple(); + TargetInfoAsm += ".ll"; + } + // The driver is aware that flang2 can generate multiple files at the same time. + // We mimic it here by exchanging the output files. + // The driver always uses the output file of -asm. + LowerCmdArgs.push_back("-fopenmp-targets"); + LowerCmdArgs.push_back(Args.MakeArgString(TargetInfo.str())); + if(IsOpenMPDevice) { + LowerCmdArgs.push_back("-fopenmp-targets-asm"); + LowerCmdArgs.push_back(Args.MakeArgString(OutFile)); + LowerCmdArgs.push_back("-asm"); + LowerCmdArgs.push_back(Args.MakeArgString(TargetInfoAsm.str())); + } else { + LowerCmdArgs.push_back("-fopenmp-targets-asm"); + LowerCmdArgs.push_back(Args.MakeArgString(TargetInfoAsm.str())); + LowerCmdArgs.push_back("-asm"); + LowerCmdArgs.push_back(Args.MakeArgString(OutFile)); + } + } else { + LowerCmdArgs.push_back("-asm"); + LowerCmdArgs.push_back(Args.MakeArgString(OutFile)); + } + + C.addCommand(std::make_unique(JA, *this, ResponseFileSupport::AtFileUTF8(), LowerExec, LowerCmdArgs, Inputs)); +} + diff --git a/clang/lib/Driver/ToolChains/ClassicFlang.h b/clang/lib/Driver/ToolChains/ClassicFlang.h new file mode 100644 index 000000000000..23ea1fe6b95d --- /dev/null +++ b/clang/lib/Driver/ToolChains/ClassicFlang.h @@ -0,0 +1,49 @@ +//===--- ClassicFlang.h - Flang ToolChain Implementations -------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_ClassicFlang_H +#define LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_ClassicFlang_H + +#include "MSVC.h" +#include "clang/Basic/DebugInfoOptions.h" +#include "clang/Driver/Driver.h" +#include "clang/Driver/Tool.h" +#include "clang/Driver/Types.h" +#include "llvm/ADT/Triple.h" +#include "llvm/Option/Option.h" +#include "llvm/Support/raw_ostream.h" + +namespace clang { +namespace driver { + +namespace tools { + +/// \brief Flang Fortran frontend +class LLVM_LIBRARY_VISIBILITY ClassicFlang : public Tool { +public: + ClassicFlang(const ToolChain &TC) + : Tool("flang:frontend", + "Fortran frontend to LLVM", TC) {} + + bool hasGoodDiagnostics() const override { return true; } + bool hasIntegratedAssembler() const override { return false; } + bool hasIntegratedCPP() const override { return false; } + + void ConstructJob(Compilation &C, const JobAction &JA, + const InputInfo &Output, const InputInfoList &Inputs, + const llvm::opt::ArgList &TCArgs, + const char *LinkingOutput) const override; +}; + +} // end namespace tools + +} // end namespace driver +} // end namespace clang + +#endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_ClassicFlang_H diff --git a/clang/lib/Driver/ToolChains/CommonArgs.cpp b/clang/lib/Driver/ToolChains/CommonArgs.cpp index ae635fb6a180..f3be7bcf08ed 100644 --- a/clang/lib/Driver/ToolChains/CommonArgs.cpp +++ b/clang/lib/Driver/ToolChains/CommonArgs.cpp @@ -342,6 +342,23 @@ static bool shouldIgnoreUnsupportedTargetFeature(const Arg &TargetFeatureArg, return TargetFeatureArg.getOption().matches(options::OPT_mno_cumode); } +/// \brief Determine if Fortran "main" object is needed +static bool needFortranMain(const Driver &D, const ArgList &Args) { + return (needFortranLibs(D, Args) + && (!Args.hasArg(options::OPT_Mnomain) || + !Args.hasArg(options::OPT_no_fortran_main))); +} + +/// \brief Determine if Fortran link libraies are needed +bool tools::needFortranLibs(const Driver &D, const ArgList &Args) { + if (D.IsFlangMode() && !Args.hasArg(options::OPT_nostdlib) && + !Args.hasArg(options::OPT_noFlangLibs)) { + return true; + } + + return false; +} + void tools::addPathIfExists(const Driver &D, const Twine &Path, ToolChain::path_list &Paths) { if (D.getVFS().exists(Path)) @@ -450,6 +467,7 @@ void tools::AddLinkerInputs(const ToolChain &TC, const InputInfoList &Inputs, const ArgList &Args, ArgStringList &CmdArgs, const JobAction &JA) { const Driver &D = TC.getDriver(); + bool SeenFirstLinkerInput = false; // Add extra linker input arguments which are not treated as inputs // (constructed via -Xarch_). @@ -483,6 +501,14 @@ void tools::AddLinkerInputs(const ToolChain &TC, const InputInfoList &Inputs, if (II.isNothing()) continue; + // Add Fortan "main" before the first linker input + if (!SeenFirstLinkerInput) { + if (needFortranMain(D, Args)) { + CmdArgs.push_back("-lflangmain"); + } + SeenFirstLinkerInput = true; + } + // Otherwise, this is a linker input argument. const Arg &A = II.getInputArg(); @@ -527,6 +553,15 @@ void tools::AddLinkerInputs(const ToolChain &TC, const InputInfoList &Inputs, addArchSpecificRPath(TC, Args, CmdArgs); } } + + if (!SeenFirstLinkerInput && needFortranMain(D, Args)) { + CmdArgs.push_back("-lflangmain"); + } + + // Claim "no Fortran main" arguments + for (auto Arg : Args.filtered(options::OPT_no_fortran_main, options::OPT_Mnomain)) { + Arg->claim(); + } } void tools::addLinkerCompressDebugSectionsOption( diff --git a/clang/lib/Driver/ToolChains/CommonArgs.h b/clang/lib/Driver/ToolChains/CommonArgs.h index b6ddd99b8727..27dd91c75670 100644 --- a/clang/lib/Driver/ToolChains/CommonArgs.h +++ b/clang/lib/Driver/ToolChains/CommonArgs.h @@ -24,6 +24,8 @@ namespace clang { namespace driver { namespace tools { +bool needFortranLibs(const Driver &D, const llvm::opt::ArgList &Args); + void addPathIfExists(const Driver &D, const Twine &Path, ToolChain::path_list &Paths); diff --git a/clang/lib/Driver/ToolChains/Cuda.cpp b/clang/lib/Driver/ToolChains/Cuda.cpp index 0922a97ed7c1..d2ce20583a14 100644 --- a/clang/lib/Driver/ToolChains/Cuda.cpp +++ b/clang/lib/Driver/ToolChains/Cuda.cpp @@ -1074,3 +1074,36 @@ VersionTuple CudaToolChain::computeMSVCVersion(const Driver *D, const ArgList &Args) const { return HostTC.computeMSVCVersion(D, Args); } + +static void AddFlangSysIncludeArg(const ArgList &DriverArgs, + ArgStringList &Flang1Args, + ToolChain::path_list IncludePathList) { + std::string ArgValue; // Path argument value + + // Make up argument value consisting of paths separated by colons + bool first = true; + for (auto P : IncludePathList) { + if (first) { + first = false; + } else { + ArgValue += ":"; + } + ArgValue += P; + } + + // Add the argument + Flang1Args.push_back("-stdinc"); + Flang1Args.push_back(DriverArgs.MakeArgString(ArgValue)); +} + +void CudaToolChain::AddFlangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, + llvm::opt::ArgStringList &Flang1Args) const { + path_list IncludePathList; + const Driver &D = getDriver(); + if (DriverArgs.hasArg(options::OPT_nostdinc)) + return; + SmallString<128> P(D.Dir); + llvm::sys::path::append(P, "../include"); + IncludePathList.push_back(P.c_str()); + AddFlangSysIncludeArg(DriverArgs, Flang1Args, IncludePathList); +} diff --git a/clang/lib/Driver/ToolChains/Cuda.h b/clang/lib/Driver/ToolChains/Cuda.h index 7a6a6fb20901..828538653310 100644 --- a/clang/lib/Driver/ToolChains/Cuda.h +++ b/clang/lib/Driver/ToolChains/Cuda.h @@ -231,6 +231,12 @@ class LLVM_LIBRARY_VISIBILITY CudaToolChain : public NVPTXToolChain { const ToolChain &HostTC; +#ifdef ENABLE_CLASSIC_FLANG + void + AddFlangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, + llvm::opt::ArgStringList &Flang1Args) const override; +#endif + protected: Tool *buildAssembler() const override; // ptxas Tool *buildLinker() const override; // fatbinary (ok, not really a linker) diff --git a/clang/lib/Driver/ToolChains/Gnu.cpp b/clang/lib/Driver/ToolChains/Gnu.cpp index f56eeda3cb5f..47391c2175c0 100644 --- a/clang/lib/Driver/ToolChains/Gnu.cpp +++ b/clang/lib/Driver/ToolChains/Gnu.cpp @@ -548,6 +548,16 @@ void tools::gnutools::Linker::ConstructJob(Compilation &C, const JobAction &JA, // The profile runtime also needs access to system libraries. getToolChain().addProfileRTLibs(Args, CmdArgs); + // Add Fortran runtime libraries + if (needFortranLibs(D, Args)) { + ToolChain.AddFortranStdlibLibArgs(Args, CmdArgs); + } else { + // Claim "no Flang libraries" arguments if any + for (auto Arg : Args.filtered(options::OPT_noFlangLibs)) { + Arg->claim(); + } + } + if (D.CCCIsCXX() && !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs, options::OPT_r)) { diff --git a/clang/lib/Driver/ToolChains/Linux.cpp b/clang/lib/Driver/ToolChains/Linux.cpp index 0767fe6c5879..9d0a38acec83 100644 --- a/clang/lib/Driver/ToolChains/Linux.cpp +++ b/clang/lib/Driver/ToolChains/Linux.cpp @@ -632,6 +632,194 @@ std::string Linux::getDynamicLinker(const ArgList &Args) const { return "/" + LibDir + "/" + Loader; } +/// Convert path list to Fortran frontend argument +static void AddFlangSysIncludeArg(const ArgList &DriverArgs, + ArgStringList &Flang1Args, + ToolChain::path_list IncludePathList) { + std::string ArgValue; // Path argument value + + // Make up argument value consisting of paths separated by colons + bool first = true; + for (auto P : IncludePathList) { + if (first) { + first = false; + } else { + ArgValue += ":"; + } + ArgValue += P; + } + + // Add the argument + Flang1Args.push_back("-stdinc"); + Flang1Args.push_back(DriverArgs.MakeArgString(ArgValue)); +} + +void Linux::AddFlangSystemIncludeArgs(const ArgList &DriverArgs, + ArgStringList &Flang1Args) const { + path_list IncludePathList; + const Driver &D = getDriver(); + std::string SysRoot = computeSysRoot(); + + if (DriverArgs.hasArg(options::OPT_nostdinc)) + return; + + { + SmallString<128> P(D.Dir); + llvm::sys::path::append(P, "../include"); + IncludePathList.push_back(P.c_str()); + } + + if (!DriverArgs.hasArg(options::OPT_nostdlibinc)) + IncludePathList.push_back(SysRoot + "/usr/local/include"); + + if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) { + SmallString<128> P(D.ResourceDir); + llvm::sys::path::append(P, "include"); + IncludePathList.push_back(P.c_str()); + } + + if (DriverArgs.hasArg(options::OPT_nostdlibinc)) { + AddFlangSysIncludeArg(DriverArgs, Flang1Args, IncludePathList); + return; + } + + // Check for configure-time C include directories. + StringRef CIncludeDirs(C_INCLUDE_DIRS); + if (CIncludeDirs != "") { + SmallVector dirs; + CIncludeDirs.split(dirs, ":"); + for (StringRef dir : dirs) { + StringRef Prefix = + llvm::sys::path::is_absolute(dir) ? StringRef(SysRoot) : ""; + IncludePathList.push_back(Prefix.str() + dir.str()); + } + AddFlangSysIncludeArg(DriverArgs, Flang1Args, IncludePathList); + return; + } + + // Lacking those, try to detect the correct set of system includes for the + // target triple. + + // Add include directories specific to the selected multilib set and multilib. + if (GCCInstallation.isValid()) { + const auto &Callback = Multilibs.includeDirsCallback(); + if (Callback) { + for (const auto &Path : Callback(GCCInstallation.getMultilib())) + addExternCSystemIncludeIfExists( + DriverArgs, Flang1Args, GCCInstallation.getInstallPath() + Path); + } + } + + // Implement generic Debian multiarch support. + const StringRef X86_64MultiarchIncludeDirs[] = { + "/usr/include/x86_64-linux-gnu", + + // FIXME: These are older forms of multiarch. It's not clear that they're + // in use in any released version of Debian, so we should consider + // removing them. + "/usr/include/i686-linux-gnu/64", "/usr/include/i486-linux-gnu/64"}; + const StringRef X86MultiarchIncludeDirs[] = { + "/usr/include/i386-linux-gnu", + + // FIXME: These are older forms of multiarch. It's not clear that they're + // in use in any released version of Debian, so we should consider + // removing them. + "/usr/include/x86_64-linux-gnu/32", "/usr/include/i686-linux-gnu", + "/usr/include/i486-linux-gnu"}; + const StringRef AArch64MultiarchIncludeDirs[] = { + "/usr/include/aarch64-linux-gnu"}; + const StringRef ARMMultiarchIncludeDirs[] = { + "/usr/include/arm-linux-gnueabi"}; + const StringRef ARMHFMultiarchIncludeDirs[] = { + "/usr/include/arm-linux-gnueabihf"}; + const StringRef MIPSMultiarchIncludeDirs[] = {"/usr/include/mips-linux-gnu"}; + const StringRef MIPSELMultiarchIncludeDirs[] = { + "/usr/include/mipsel-linux-gnu"}; + const StringRef MIPS64MultiarchIncludeDirs[] = { + "/usr/include/mips64-linux-gnu", "/usr/include/mips64-linux-gnuabi64"}; + const StringRef MIPS64ELMultiarchIncludeDirs[] = { + "/usr/include/mips64el-linux-gnu", + "/usr/include/mips64el-linux-gnuabi64"}; + const StringRef PPCMultiarchIncludeDirs[] = { + "/usr/include/powerpc-linux-gnu"}; + const StringRef PPC64MultiarchIncludeDirs[] = { + "/usr/include/powerpc64-linux-gnu"}; + const StringRef PPC64LEMultiarchIncludeDirs[] = { + "/usr/include/powerpc64le-linux-gnu"}; + const StringRef SparcMultiarchIncludeDirs[] = { + "/usr/include/sparc-linux-gnu"}; + const StringRef Sparc64MultiarchIncludeDirs[] = { + "/usr/include/sparc64-linux-gnu"}; + ArrayRef MultiarchIncludeDirs; + switch (getTriple().getArch()) { + case llvm::Triple::x86_64: + MultiarchIncludeDirs = X86_64MultiarchIncludeDirs; + break; + case llvm::Triple::x86: + MultiarchIncludeDirs = X86MultiarchIncludeDirs; + break; + case llvm::Triple::aarch64: + case llvm::Triple::aarch64_be: + MultiarchIncludeDirs = AArch64MultiarchIncludeDirs; + break; + case llvm::Triple::arm: + if (getTriple().getEnvironment() == llvm::Triple::GNUEABIHF) + MultiarchIncludeDirs = ARMHFMultiarchIncludeDirs; + else + MultiarchIncludeDirs = ARMMultiarchIncludeDirs; + break; + case llvm::Triple::mips: + MultiarchIncludeDirs = MIPSMultiarchIncludeDirs; + break; + case llvm::Triple::mipsel: + MultiarchIncludeDirs = MIPSELMultiarchIncludeDirs; + break; + case llvm::Triple::mips64: + MultiarchIncludeDirs = MIPS64MultiarchIncludeDirs; + break; + case llvm::Triple::mips64el: + MultiarchIncludeDirs = MIPS64ELMultiarchIncludeDirs; + break; + case llvm::Triple::ppc: + MultiarchIncludeDirs = PPCMultiarchIncludeDirs; + break; + case llvm::Triple::ppc64: + MultiarchIncludeDirs = PPC64MultiarchIncludeDirs; + break; + case llvm::Triple::ppc64le: + MultiarchIncludeDirs = PPC64LEMultiarchIncludeDirs; + break; + case llvm::Triple::sparc: + MultiarchIncludeDirs = SparcMultiarchIncludeDirs; + break; + case llvm::Triple::sparcv9: + MultiarchIncludeDirs = Sparc64MultiarchIncludeDirs; + break; + default: + break; + } + for (StringRef Dir : MultiarchIncludeDirs) { + if (llvm::sys::fs::exists(SysRoot + Dir)) { + IncludePathList.push_back(SysRoot + Dir.str()); + break; + } + } + + if (getTriple().getOS() == llvm::Triple::RTEMS) { + AddFlangSysIncludeArg(DriverArgs, Flang1Args, IncludePathList); + return; + } + + // Add an include of '/include' directly. This isn't provided by default by + // system GCCs, but is often used with cross-compiling GCCs, and harmless to + // add even when Clang is acting as-if it were a system compiler. + IncludePathList.push_back(SysRoot + "/include"); + + IncludePathList.push_back(SysRoot + "/usr/include"); + + AddFlangSysIncludeArg(DriverArgs, Flang1Args, IncludePathList); +} + void Linux::AddClangSystemIncludeArgs(const ArgList &DriverArgs, ArgStringList &CC1Args) const { const Driver &D = getDriver(); diff --git a/clang/lib/Driver/ToolChains/Linux.h b/clang/lib/Driver/ToolChains/Linux.h index 2eb2d05786fe..a40eedad1c61 100644 --- a/clang/lib/Driver/ToolChains/Linux.h +++ b/clang/lib/Driver/ToolChains/Linux.h @@ -28,6 +28,9 @@ class LLVM_LIBRARY_VISIBILITY Linux : public Generic_ELF { StringRef SysRoot) const override; void + AddFlangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, + llvm::opt::ArgStringList &Flang1Args) const override; + void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override; void addLibStdCxxIncludePaths( diff --git a/clang/lib/Driver/Types.cpp b/clang/lib/Driver/Types.cpp old mode 100644 new mode 100755 index eaca74a7b552..4de13b7fb52b --- a/clang/lib/Driver/Types.cpp +++ b/clang/lib/Driver/Types.cpp @@ -52,9 +52,11 @@ const char *types::getTypeName(ID Id) { types::ID types::getPreprocessedType(ID Id) { ID PPT = getInfo(Id).PreprocessedType; +#ifndef ENABLE_CLASSIC_FLANG assert((getInfo(Id).Phases.contains(phases::Preprocess) != (PPT == TY_INVALID)) && "Unexpected Preprocess Type."); +#endif return PPT; } @@ -131,6 +133,10 @@ bool types::isAcceptedByClang(ID Id) { case TY_Asm: case TY_C: case TY_PP_C: case TY_CL: case TY_PP_CL: case TY_CLCXX: case TY_PP_CLCXX: +#ifdef ENABLE_CLASSIC_FLANG + case TY_F_FreeForm: case TY_PP_F_FreeForm: + case TY_F_FixedForm: case TY_PP_F_FixedForm: +#endif case TY_CUDA: case TY_PP_CUDA: case TY_CUDA_DEVICE: case TY_HIP: @@ -161,8 +167,15 @@ bool types::isAcceptedByFlang(ID Id) { default: return false; +#ifdef ENABLE_CLASSIC_FLANG + case TY_F_FreeForm: + case TY_PP_F_FreeForm: + case TY_F_FixedForm: + case TY_PP_F_FixedForm: +#else case TY_Fortran: case TY_PP_Fortran: +#endif return true; case TY_LLVM_IR: case TY_LLVM_BC: @@ -290,6 +303,22 @@ bool types::isHIP(ID Id) { } } +#ifdef ENABLE_CLASSIC_FLANG +bool types::isFreeFormFortran(ID Id) { + if (!isAcceptedByFlang(Id)) + return false; + + return (Id == TY_F_FreeForm || Id == TY_PP_F_FreeForm); +} + +bool types::isFixedFormFortran(ID Id) { + if (!isAcceptedByFlang(Id)) + return false; + + return (Id == TY_F_FixedForm || Id == TY_PP_F_FixedForm); +} +#endif + bool types::isHLSL(ID Id) { return Id == TY_HLSL; } bool types::isSrcFile(ID Id) { @@ -300,8 +329,13 @@ types::ID types::lookupTypeForExtension(llvm::StringRef Ext) { return llvm::StringSwitch(Ext) .Case("c", TY_C) .Case("C", TY_CXX) +#ifdef ENABLE_CLASSIC_FLANG + .Case("F", TY_F_FixedForm) + .Case("f", TY_PP_F_FixedForm) +#else .Case("F", TY_Fortran) .Case("f", TY_PP_Fortran) +#endif .Case("h", TY_CHeader) .Case("H", TY_CXXHeader) .Case("i", TY_PP_C) @@ -336,6 +370,20 @@ types::ID types::lookupTypeForExtension(llvm::StringRef Ext) { .Case("cui", TY_PP_CUDA) .Case("cxx", TY_CXX) .Case("CXX", TY_CXX) +#ifdef ENABLE_CLASSIC_FLANG + .Case("for", TY_PP_F_FixedForm) + .Case("FOR", TY_PP_F_FixedForm) + .Case("fpp", TY_F_FixedForm) + .Case("FPP", TY_F_FixedForm) + .Case("f90", TY_PP_F_FreeForm) + .Case("f95", TY_PP_F_FreeForm) + .Case("f03", TY_PP_F_FreeForm) + .Case("f08", TY_PP_F_FreeForm) + .Case("F90", TY_F_FreeForm) + .Case("F95", TY_F_FreeForm) + .Case("F03", TY_F_FreeForm) + .Case("F08", TY_F_FreeForm) +#else .Case("F03", TY_Fortran) .Case("f03", TY_PP_Fortran) .Case("F08", TY_Fortran) @@ -348,6 +396,7 @@ types::ID types::lookupTypeForExtension(llvm::StringRef Ext) { .Case("FOR", TY_PP_Fortran) .Case("fpp", TY_Fortran) .Case("FPP", TY_Fortran) +#endif .Case("gch", TY_PCH) .Case("hip", TY_HIP) .Case("hipi", TY_PP_HIP) diff --git a/clang/lib/Frontend/InitPreprocessor.cpp b/clang/lib/Frontend/InitPreprocessor.cpp index 17f624e96453..c747c844f9c0 100644 --- a/clang/lib/Frontend/InitPreprocessor.cpp +++ b/clang/lib/Frontend/InitPreprocessor.cpp @@ -166,26 +166,6 @@ static void DefineFloatMacros(MacroBuilder &Builder, StringRef Prefix, Builder.defineMacro(DefPrefix + "MIN__", Twine(Min)+Ext); } - -/// DefineTypeSize - Emit a macro to the predefines buffer that declares a macro -/// named MacroName with the max value for a type with width 'TypeWidth' a -/// signedness of 'isSigned' and with a value suffix of 'ValSuffix' (e.g. LL). -static void DefineTypeSize(const Twine &MacroName, unsigned TypeWidth, - StringRef ValSuffix, bool isSigned, - MacroBuilder &Builder) { - llvm::APInt MaxVal = isSigned ? llvm::APInt::getSignedMaxValue(TypeWidth) - : llvm::APInt::getMaxValue(TypeWidth); - Builder.defineMacro(MacroName, toString(MaxVal, 10, isSigned) + ValSuffix); -} - -/// DefineTypeSize - An overloaded helper that uses TargetInfo to determine -/// the width, suffix, and signedness of the given type -static void DefineTypeSize(const Twine &MacroName, TargetInfo::IntType Ty, - const TargetInfo &TI, MacroBuilder &Builder) { - DefineTypeSize(MacroName, TI.getTypeWidth(Ty), TI.getTypeConstantSuffix(Ty), - TI.isTypeSigned(Ty), Builder); -} - static void DefineFmt(const LangOptions &LangOpts, const Twine &Prefix, TargetInfo::IntType Ty, const TargetInfo &TI, MacroBuilder &Builder) { diff --git a/clang/test/Driver/autocomplete.c b/clang/test/Driver/autocomplete.c index 8cc604dbff87..e279718b0a49 100644 --- a/clang/test/Driver/autocomplete.c +++ b/clang/test/Driver/autocomplete.c @@ -86,7 +86,7 @@ // FVECLIBALL-NEXT: libmvec // FVECLIBALL-NEXT: MASSV // FVECLIBALL-NEXT: none -// FVECLIBALL-NEXT: SLEEF +// FVECLIBALL: SLEEF // FVECLIBALL-NEXT: SVML // RUN: %clang --autocomplete=-fshow-overloads= | FileCheck %s -check-prefix=FSOVERALL // FSOVERALL: all diff --git a/clang/test/Driver/flang/classic_flang.f95 b/clang/test/Driver/flang/classic_flang.f95 new file mode 100644 index 000000000000..5d3098786905 --- /dev/null +++ b/clang/test/Driver/flang/classic_flang.f95 @@ -0,0 +1,28 @@ +! Check that the driver can invoke flang1 and flang2 to compile Fortran with +! --driver-mode=flang (default when the file extension is .f95). + +! REQUIRES: classic_flang + +! RUN: %clang -target x86_64-unknown-linux-gnu -integrated-as -c %s -### 2>&1 \ +! RUN: | FileCheck --check-prefix=CHECK-OBJECT %s +! CHECK-OBJECT: flang1 +! CHECK-OBJECT: flang2 +! CHECK-OBJECT-SAME: "-asm" [[LLFILE:.*.ll]] +! CHECK-OBJECT-NOT: cc1as +! CHECK-OBJECT: clang +! CHECK-OBJECT-SAME: -cc1 +! CHECK-OBJECT-SAME: "-o" "classic_flang.o" +! CHECK-OBJECT-SAME: "-x" "ir" +! CHECK-OBJECT-SAME: [[LLFILE]] + +! RUN: %clang -target x86_64-unknown-linux-gnu -integrated-as -S %s -### 2>&1 \ +! RUN: | FileCheck --check-prefix=CHECK-ASM %s +! CHECK-ASM: flang1 +! CHECK-ASM: flang2 +! CHECK-ASM-SAME: "-asm" [[LLFILE:.*.ll]] +! CHECK-ASM-NOT: cc1as +! CHECK-ASM: clang +! CHECK-ASM-SAME: -cc1 +! CHECK-ASM-SAME: "-o" "classic_flang.s" +! CHECK-ASM-SAME: "-x" "ir" +! CHECK-ASM-SAME: [[LLFILE]] diff --git a/clang/test/Driver/flang/flang.f90 b/clang/test/Driver/flang/flang.f90 index b52977ee66d7..20e43d050475 100644 --- a/clang/test/Driver/flang/flang.f90 +++ b/clang/test/Driver/flang/flang.f90 @@ -1,5 +1,7 @@ ! Check that flang -fc1 is invoked when in --driver-mode=flang. +! UNSUPPORTED: classic_flang + ! This is a copy of flang_ucase.F90 because the driver has logic in it which ! differentiates between F90 and f90 files. Flang will not treat these files ! differently. diff --git a/clang/test/Driver/flang/flang_ucase.F90 b/clang/test/Driver/flang/flang_ucase.F90 index 88aedc39fb94..e3352018a678 100644 --- a/clang/test/Driver/flang/flang_ucase.F90 +++ b/clang/test/Driver/flang/flang_ucase.F90 @@ -1,5 +1,7 @@ ! Check that flang -fc1 is invoked when in --driver-mode=flang. +! UNSUPPORTED: classic_flang + ! This is a copy of flang.f90 because the driver has logic in it which ! differentiates between F90 and f90 files. Flang will not treat these files ! differently. diff --git a/clang/test/Driver/flang/multiple-inputs-mixed.f90 b/clang/test/Driver/flang/multiple-inputs-mixed.f90 index 98d8cab00bdf..50e92aa96c85 100644 --- a/clang/test/Driver/flang/multiple-inputs-mixed.f90 +++ b/clang/test/Driver/flang/multiple-inputs-mixed.f90 @@ -1,5 +1,7 @@ ! Check that flang can handle mixed C and fortran inputs. +! UNSUPPORTED: classic_flang + ! RUN: %clang --driver-mode=flang -### -fsyntax-only %S/Inputs/one.f90 %S/Inputs/other.c 2>&1 | FileCheck --check-prefixes=CHECK-SYNTAX-ONLY %s ! CHECK-SYNTAX-ONLY-LABEL: "{{[^"]*}}flang{{[^"/]*}}" "-fc1" ! CHECK-SYNTAX-ONLY: "{{[^"]*}}/Inputs/one.f90" diff --git a/clang/test/Driver/flang/multiple-inputs.f90 b/clang/test/Driver/flang/multiple-inputs.f90 index 3c0f22e5d3e5..f88c8f37f0a4 100644 --- a/clang/test/Driver/flang/multiple-inputs.f90 +++ b/clang/test/Driver/flang/multiple-inputs.f90 @@ -1,5 +1,7 @@ ! Check that flang driver can handle multiple inputs at once. +! UNSUPPORTED: classic_flang + ! RUN: %clang --driver-mode=flang -### -fsyntax-only %S/Inputs/one.f90 %S/Inputs/two.f90 2>&1 | FileCheck --check-prefixes=CHECK-SYNTAX-ONLY %s ! CHECK-SYNTAX-ONLY-LABEL: "{{[^"]*}}flang{{[^"/]*}}" "-fc1" ! CHECK-SYNTAX-ONLY: "{{[^"]*}}/Inputs/one.f90" diff --git a/clang/test/Driver/fortran.f95 b/clang/test/Driver/fortran.f95 index 275b1886b2fd..260616d10f15 100644 --- a/clang/test/Driver/fortran.f95 +++ b/clang/test/Driver/fortran.f95 @@ -1,6 +1,8 @@ ! Check that the clang driver can invoke gcc to compile Fortran when in ! --driver-mode=clang. This is legacy behaviour - see also --driver-mode=flang. +! UNSUPPORTED: classic_flang + ! RUN: %clang --target=x86_64-unknown-linux-gnu -integrated-as -c %s -### 2>&1 \ ! RUN: | FileCheck --check-prefix=CHECK-OBJECT %s ! CHECK-OBJECT: gcc diff --git a/clang/test/Driver/gfortran.f90 b/clang/test/Driver/gfortran.f90 index c985428650ec..1276703b1f6e 100644 --- a/clang/test/Driver/gfortran.f90 +++ b/clang/test/Driver/gfortran.f90 @@ -1,4 +1,5 @@ ! XFAIL: * +! UNSUPPORTED: classic_flang ! Test that Clang can forward all of the flags which are documented as ! being supported by gfortran to GCC when falling back to GCC for ! a fortran input file. diff --git a/clang/test/lit.cfg.py b/clang/test/lit.cfg.py index e4b39c4f7159..24355e3787d5 100644 --- a/clang/test/lit.cfg.py +++ b/clang/test/lit.cfg.py @@ -367,3 +367,6 @@ def calculate_arch_features(arch_string): # possibly be present in system and user configuration files, so disable # default configs for the test runs. config.environment["CLANG_NO_DEFAULT_CONFIG"] = "1" + +if config.use_classic_flang: + config.available_features.add("classic_flang") diff --git a/clang/test/lit.site.cfg.py.in b/clang/test/lit.site.cfg.py.in index 1cbd876ac5bb..7250f2df3a61 100644 --- a/clang/test/lit.site.cfg.py.in +++ b/clang/test/lit.site.cfg.py.in @@ -44,6 +44,7 @@ config.standalone_build = @CLANG_BUILT_STANDALONE@ config.ppc_linux_default_ieeelongdouble = @PPC_LINUX_DEFAULT_IEEELONGDOUBLE@ config.have_llvm_driver = @LLVM_TOOL_LLVM_DRIVER_BUILD@ config.substitutions.append(("%llvm-version-major", "@LLVM_VERSION_MAJOR@")) +config.use_classic_flang = @LLVM_ENABLE_CLASSIC_FLANG@ import lit.llvm lit.llvm.initialize(lit_config, config) diff --git a/clang/tools/driver/CMakeLists.txt b/clang/tools/driver/CMakeLists.txt index ad336fcc45b6..2b3d719ba435 100644 --- a/clang/tools/driver/CMakeLists.txt +++ b/clang/tools/driver/CMakeLists.txt @@ -77,7 +77,7 @@ endif() add_dependencies(clang clang-resource-headers) if(NOT CLANG_LINKS_TO_CREATE) - set(CLANG_LINKS_TO_CREATE clang++ clang-cl clang-cpp) + set(CLANG_LINKS_TO_CREATE clang++ clang-cl clang-cpp flang) endif() if (CLANG_ENABLE_HLSL) diff --git a/clang/tools/driver/cc1as_main.cpp b/clang/tools/driver/cc1as_main.cpp index 7fe97cc6e6ac..865af5070494 100644 --- a/clang/tools/driver/cc1as_main.cpp +++ b/clang/tools/driver/cc1as_main.cpp @@ -679,7 +679,7 @@ int cc1as_main(ArrayRef Argv, const char *Argv0, void *MainAddr) { llvm::outs(), "clang -cc1as [options] file...", "Clang Integrated Assembler", /*ShowHidden=*/false, /*ShowAllAliases=*/false, - llvm::opt::Visibility(driver::options::CC1AsOption)); + llvm::opt::Visibility(clang::driver::options::CC1AsOption)); return 0; } diff --git a/llvm/cmake/modules/HandleLLVMOptions.cmake b/llvm/cmake/modules/HandleLLVMOptions.cmake index 5db06ccdadbe..8b30e7ce6032 100644 --- a/llvm/cmake/modules/HandleLLVMOptions.cmake +++ b/llvm/cmake/modules/HandleLLVMOptions.cmake @@ -144,6 +144,14 @@ if( LLVM_ENABLE_ASSERTIONS ) endif() endif() +option(LLVM_ENABLE_CLASSIC_FLANG "Build support for classic Flang instead of the new built-in Flang" OFF) +if(LLVM_ENABLE_CLASSIC_FLANG) + set(LLVM_ENABLE_CLASSIC_FLANG 1) + add_definitions( -DENABLE_CLASSIC_FLANG ) +else() + set(LLVM_ENABLE_CLASSIC_FLANG 0) +endif() + # If we are targeting a GPU architecture in a runtimes build we want to ignore # all the standard flag handling. if(LLVM_RUNTIMES_GPU_BUILD) diff --git a/llvm/include/llvm-c/DebugInfo.h b/llvm/include/llvm-c/DebugInfo.h index ac7ee5a7cc9a..486895474ec8 100644 --- a/llvm/include/llvm-c/DebugInfo.h +++ b/llvm/include/llvm-c/DebugInfo.h @@ -1165,7 +1165,8 @@ LLVMMetadataRef LLVMDIBuilderCreateGlobalVariableExpression( LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name, size_t NameLen, const char *Linkage, size_t LinkLen, LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty, LLVMBool LocalToUnit, - LLVMMetadataRef Expr, LLVMMetadataRef Decl, uint32_t AlignInBits); + LLVMMetadataRef Expr, LLVMMetadataRef Decl, LLVMDIFlags Flags, + uint32_t AlignInBits); /** @@ -1263,7 +1264,7 @@ LLVMMetadataRef LLVMDIBuilderCreateTempGlobalVariableFwdDecl( LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name, size_t NameLen, const char *Linkage, size_t LnkLen, LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty, LLVMBool LocalToUnit, - LLVMMetadataRef Decl, uint32_t AlignInBits); + LLVMMetadataRef Decl, LLVMDIFlags Flags, uint32_t AlignInBits); /** * Only use in "new debug format" (LLVMIsNewDbgInfoFormat() is true). diff --git a/llvm/include/llvm/Analysis/TargetLibraryInfo.h b/llvm/include/llvm/Analysis/TargetLibraryInfo.h index f51d2bb9d50a..ba813c02f41a 100644 --- a/llvm/include/llvm/Analysis/TargetLibraryInfo.h +++ b/llvm/include/llvm/Analysis/TargetLibraryInfo.h @@ -126,6 +126,9 @@ class TargetLibraryInfoImpl { DarwinLibSystemM, // Use Darwin's libsystem_m. LIBMVEC_X86, // GLIBC Vector Math library. MASSV, // IBM MASS vector library. +#ifdef ENABLE_CLASSIC_FLANG + PGMATH, // PGI math library. +#endif SVML, // Intel short vector math library. SLEEFGNUABI, // SLEEF - SIMD Library for Evaluating Elementary Functions. ArmPL, // Arm Performance Libraries. diff --git a/llvm/include/llvm/Frontend/Driver/CodeGenOptions.h b/llvm/include/llvm/Frontend/Driver/CodeGenOptions.h index 0180670c4c69..3aaf04b656dc 100644 --- a/llvm/include/llvm/Frontend/Driver/CodeGenOptions.h +++ b/llvm/include/llvm/Frontend/Driver/CodeGenOptions.h @@ -26,6 +26,9 @@ enum class VectorLibrary { Accelerate, // Use the Accelerate framework. LIBMVEC, // GLIBC vector math library. MASSV, // IBM MASS vector library. +#ifdef ENABLE_CLASSIC_FLANG + PGMATH, // PGI math library. +#endif SVML, // Intel short vector math library. SLEEF, // SLEEF SIMD Library for Evaluating Elementary Functions. Darwin_libsystem_m, // Use Darwin's libsystem_m vector functions. diff --git a/llvm/include/llvm/IR/DIBuilder.h b/llvm/include/llvm/IR/DIBuilder.h index f777206d0d73..ff2a8b9fcc58 100644 --- a/llvm/include/llvm/IR/DIBuilder.h +++ b/llvm/include/llvm/IR/DIBuilder.h @@ -711,15 +711,22 @@ namespace llvm { DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *File, unsigned LineNo, DIType *Ty, bool IsLocalToUnit, bool isDefined = true, DIExpression *Expr = nullptr, MDNode *Decl = nullptr, - MDTuple *TemplateParams = nullptr, uint32_t AlignInBits = 0, - DINodeArray Annotations = nullptr); + MDTuple *TemplateParams = nullptr, +#ifdef ENABLE_CLASSIC_FLANG + DINode::DIFlags Flags = DINode::FlagZero, +#endif + uint32_t AlignInBits = 0, DINodeArray Annotations = nullptr); /// Identical to createGlobalVariable /// except that the resulting DbgNode is temporary and meant to be RAUWed. DIGlobalVariable *createTempGlobalVariableFwdDecl( DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *File, - unsigned LineNo, DIType *Ty, bool IsLocalToUnit, MDNode *Decl = nullptr, - MDTuple *TemplateParams = nullptr, uint32_t AlignInBits = 0); + unsigned LineNo, DIType *Ty, bool isLocalToUnit, MDNode *Decl = nullptr, + MDTuple *TemplateParams = nullptr, +#ifdef ENABLE_CLASSIC_FLANG + DINode::DIFlags Flags = DINode::FlagZero, +#endif + uint32_t AlignInBits = 0); /// Create a new descriptor for an auto variable. This is a local variable /// that is not a subprogram parameter. @@ -850,6 +857,19 @@ namespace llvm { StringRef Name, DIFile *File, unsigned LineNo); +#ifdef ENABLE_CLASSIC_FLANG + /// Create common block entry for a Fortran common block + /// \param Scope Scope of this common block + /// \param Name The name of this common block + /// \param File The file this common block is defined + /// \param LineNo Line number + /// \param VarList List of variables that a located in common block + /// \param AlignInBits Common block alignment + DICommonBlock *createCommonBlock(DIScope *Scope, DIGlobalVariable *decl, + StringRef Name, DIFile *File, + unsigned LineNo, uint32_t AlignInBits = 0); + +#endif /// This creates new descriptor for a namespace with the specified /// parent scope. /// \param Scope Namespace scope diff --git a/llvm/include/llvm/IR/DebugInfoMetadata.h b/llvm/include/llvm/IR/DebugInfoMetadata.h index 5ea8c0d7b448..9f46126ec0d1 100644 --- a/llvm/include/llvm/IR/DebugInfoMetadata.h +++ b/llvm/include/llvm/IR/DebugInfoMetadata.h @@ -3318,12 +3318,14 @@ class DIGlobalVariable : public DIVariable { bool IsLocalToUnit; bool IsDefinition; + DIFlags Flags; DIGlobalVariable(LLVMContext &C, StorageType Storage, unsigned Line, - bool IsLocalToUnit, bool IsDefinition, uint32_t AlignInBits, - ArrayRef Ops) + bool IsLocalToUnit, bool IsDefinition, DIFlags Flags, + uint32_t AlignInBits, ArrayRef Ops) : DIVariable(C, DIGlobalVariableKind, Storage, Line, Ops, AlignInBits), - IsLocalToUnit(IsLocalToUnit), IsDefinition(IsDefinition) {} + IsLocalToUnit(IsLocalToUnit), IsDefinition(IsDefinition), + Flags(Flags) {} ~DIGlobalVariable() = default; static DIGlobalVariable * @@ -3331,12 +3333,12 @@ class DIGlobalVariable : public DIVariable { StringRef LinkageName, DIFile *File, unsigned Line, DIType *Type, bool IsLocalToUnit, bool IsDefinition, DIDerivedType *StaticDataMemberDeclaration, MDTuple *TemplateParams, - uint32_t AlignInBits, DINodeArray Annotations, StorageType Storage, - bool ShouldCreate = true) { + DIFlags Flags, uint32_t AlignInBits, DINodeArray Annotations, + StorageType Storage, bool ShouldCreate = true) { return getImpl(Context, Scope, getCanonicalMDString(Context, Name), getCanonicalMDString(Context, LinkageName), File, Line, Type, IsLocalToUnit, IsDefinition, StaticDataMemberDeclaration, - cast_or_null(TemplateParams), AlignInBits, + cast_or_null(TemplateParams), Flags, AlignInBits, Annotations.get(), Storage, ShouldCreate); } static DIGlobalVariable * @@ -3344,14 +3346,14 @@ class DIGlobalVariable : public DIVariable { MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type, bool IsLocalToUnit, bool IsDefinition, Metadata *StaticDataMemberDeclaration, Metadata *TemplateParams, - uint32_t AlignInBits, Metadata *Annotations, StorageType Storage, - bool ShouldCreate = true); + DIFlags Flags, uint32_t AlignInBits, Metadata *Annotations, + StorageType Storage, bool ShouldCreate = true); TempDIGlobalVariable cloneImpl() const { return getTemporary(getContext(), getScope(), getName(), getLinkageName(), getFile(), getLine(), getType(), isLocalToUnit(), isDefinition(), getStaticDataMemberDeclaration(), - getTemplateParams(), getAlignInBits(), + getTemplateParams(), getFlags(), getAlignInBits(), getAnnotations()); } @@ -3361,22 +3363,26 @@ class DIGlobalVariable : public DIVariable { (DIScope * Scope, StringRef Name, StringRef LinkageName, DIFile *File, unsigned Line, DIType *Type, bool IsLocalToUnit, bool IsDefinition, DIDerivedType *StaticDataMemberDeclaration, MDTuple *TemplateParams, - uint32_t AlignInBits, DINodeArray Annotations), + DIFlags Flags, uint32_t AlignInBits, DINodeArray Annotations), (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition, - StaticDataMemberDeclaration, TemplateParams, AlignInBits, Annotations)) + StaticDataMemberDeclaration, TemplateParams, Flags, AlignInBits, + Annotations)) DEFINE_MDNODE_GET( DIGlobalVariable, (Metadata * Scope, MDString *Name, MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type, bool IsLocalToUnit, bool IsDefinition, Metadata *StaticDataMemberDeclaration, Metadata *TemplateParams, - uint32_t AlignInBits, Metadata *Annotations), + DIFlags Flags, uint32_t AlignInBits, Metadata *Annotations), (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition, - StaticDataMemberDeclaration, TemplateParams, AlignInBits, Annotations)) + StaticDataMemberDeclaration, TemplateParams, Flags, AlignInBits, + Annotations)) TempDIGlobalVariable clone() const { return cloneImpl(); } bool isLocalToUnit() const { return IsLocalToUnit; } bool isDefinition() const { return IsDefinition; } + DIFlags getFlags() const { return Flags; } + bool isArtificial() const { return getFlags() & FlagArtificial; } StringRef getDisplayName() const { return getStringOperand(4); } StringRef getLinkageName() const { return getStringOperand(5); } DIDerivedType *getStaticDataMemberDeclaration() const { diff --git a/llvm/lib/Analysis/TargetLibraryInfo.cpp b/llvm/lib/Analysis/TargetLibraryInfo.cpp index 8557901192e4..214f5d53550f 100644 --- a/llvm/lib/Analysis/TargetLibraryInfo.cpp +++ b/llvm/lib/Analysis/TargetLibraryInfo.cpp @@ -33,6 +33,10 @@ static cl::opt ClVectorLibrary( "GLIBC Vector Math library"), clEnumValN(TargetLibraryInfoImpl::MASSV, "MASSV", "IBM MASS vector library"), +#ifdef ENABLE_CLASSIC_FLANG + clEnumValN(TargetLibraryInfoImpl::PGMATH, "PGMATH", + "PGI math library"), +#endif clEnumValN(TargetLibraryInfoImpl::SVML, "SVML", "Intel SVML library"), clEnumValN(TargetLibraryInfoImpl::SLEEFGNUABI, "sleefgnuabi", @@ -1403,6 +1407,457 @@ void TargetLibraryInfoImpl::addVectorizableFunctionsFromVecLib( addVectorizableFunctions(VecFuncs_AMDLIBM); break; } +#ifdef ENABLE_CLASSIC_FLANG + // NOTE: All routines listed here are not available on all the architectures. + // Based on the size of vector registers available and the size of data, the + // vector width should be chosen correctly. + case PGMATH: { + const VecDesc VecFuncs[] = { + {"__fd_sin_1", "__fd_sin_2", FIXED(2)}, + {"__fd_sin_1", "__fd_sin_4", FIXED(4)}, + {"__fd_sin_1", "__fd_sin_8", FIXED(8)}, + + {"__fs_sin_1", "__fs_sin_4", FIXED(4)}, + {"__fs_sin_1", "__fs_sin_8", FIXED(8)}, + {"__fs_sin_1", "__fs_sin_16", FIXED(16)}, + + {"__pd_sin_1", "__pd_sin_2", FIXED(2)}, + {"__pd_sin_1", "__pd_sin_4", FIXED(4)}, + {"__pd_sin_1", "__pd_sin_8", FIXED(8)}, + + {"__ps_sin_1", "__ps_sin_4", FIXED(4)}, + {"__ps_sin_1", "__ps_sin_8", FIXED(8)}, + {"__ps_sin_1", "__ps_sin_16", FIXED(16)}, + + {"__rd_sin_1", "__rd_sin_2", FIXED(2)}, + {"__rd_sin_1", "__rd_sin_4", FIXED(4)}, + {"__rd_sin_1", "__rd_sin_8", FIXED(8)}, + + {"__rs_sin_1", "__rs_sin_4", FIXED(4)}, + {"__rs_sin_1", "__rs_sin_8", FIXED(8)}, + {"__rs_sin_1", "__rs_sin_16", FIXED(16)}, + + {"__fd_cos_1", "__fd_cos_2", FIXED(2)}, + {"__fd_cos_1", "__fd_cos_4", FIXED(4)}, + {"__fd_cos_1", "__fd_cos_8", FIXED(8)}, + + {"__fs_cos_1", "__fs_cos_4", FIXED(4)}, + {"__fs_cos_1", "__fs_cos_8", FIXED(8)}, + {"__fs_cos_1", "__fs_cos_16", FIXED(16)}, + + {"__pd_cos_1", "__pd_cos_2", FIXED(2)}, + {"__pd_cos_1", "__pd_cos_4", FIXED(4)}, + {"__pd_cos_1", "__pd_cos_8", FIXED(8)}, + + {"__ps_cos_1", "__ps_cos_4", FIXED(4)}, + {"__ps_cos_1", "__ps_cos_8", FIXED(8)}, + {"__ps_cos_1", "__ps_cos_16", FIXED(16)}, + + {"__rd_cos_1", "__rd_cos_2", FIXED(2)}, + {"__rd_cos_1", "__rd_cos_4", FIXED(4)}, + {"__rd_cos_1", "__rd_cos_8", FIXED(8)}, + + {"__rs_cos_1", "__rs_cos_4", FIXED(4)}, + {"__rs_cos_1", "__rs_cos_8", FIXED(8)}, + {"__rs_cos_1", "__rs_cos_16", FIXED(16)}, + + {"__fd_sincos_1", "__fd_sincos_2", FIXED(2)}, + {"__fd_sincos_1", "__fd_sincos_4", FIXED(4)}, + {"__fd_sincos_1", "__fd_sincos_8", FIXED(8)}, + + {"__fs_sincos_1", "__fs_sincos_4", FIXED(4)}, + {"__fs_sincos_1", "__fs_sincos_8", FIXED(8)}, + {"__fs_sincos_1", "__fs_sincos_16", FIXED(16)}, + + {"__pd_sincos_1", "__pd_sincos_2", FIXED(2)}, + {"__pd_sincos_1", "__pd_sincos_4", FIXED(4)}, + {"__pd_sincos_1", "__pd_sincos_8", FIXED(8)}, + + {"__ps_sincos_1", "__ps_sincos_4", FIXED(4)}, + {"__ps_sincos_1", "__ps_sincos_8", FIXED(8)}, + {"__ps_sincos_1", "__ps_sincos_16", FIXED(16)}, + + {"__rd_sincos_1", "__rd_sincos_2", FIXED(2)}, + {"__rd_sincos_1", "__rd_sincos_4", FIXED(4)}, + {"__rd_sincos_1", "__rd_sincos_8", FIXED(8)}, + + {"__rs_sincos_1", "__rs_sincos_4", FIXED(4)}, + {"__rs_sincos_1", "__rs_sincos_8", FIXED(8)}, + {"__rs_sincos_1", "__rs_sincos_16", FIXED(16)}, + + {"__fd_tan_1", "__fd_tan_2", FIXED(2)}, + {"__fd_tan_1", "__fd_tan_4", FIXED(4)}, + {"__fd_tan_1", "__fd_tan_8", FIXED(8)}, + + {"__fs_tan_1", "__fs_tan_4", FIXED(4)}, + {"__fs_tan_1", "__fs_tan_8", FIXED(8)}, + {"__fs_tan_1", "__fs_tan_16", FIXED(16)}, + + {"__pd_tan_1", "__pd_tan_2", FIXED(2)}, + {"__pd_tan_1", "__pd_tan_4", FIXED(4)}, + {"__pd_tan_1", "__pd_tan_8", FIXED(8)}, + + {"__ps_tan_1", "__ps_tan_4", FIXED(4)}, + {"__ps_tan_1", "__ps_tan_8", FIXED(8)}, + {"__ps_tan_1", "__ps_tan_16", FIXED(16)}, + + {"__rd_tan_1", "__rd_tan_2", FIXED(2)}, + {"__rd_tan_1", "__rd_tan_4", FIXED(4)}, + {"__rd_tan_1", "__rd_tan_8", FIXED(8)}, + + {"__rs_tan_1", "__rs_tan_4", FIXED(4)}, + {"__rs_tan_1", "__rs_tan_8", FIXED(8)}, + {"__rs_tan_1", "__rs_tan_16", FIXED(16)}, + + {"__fd_sinh_1", "__fd_sinh_2", FIXED(2)}, + {"__fd_sinh_1", "__fd_sinh_4", FIXED(4)}, + {"__fd_sinh_1", "__fd_sinh_8", FIXED(8)}, + + {"__fs_sinh_1", "__fs_sinh_4", FIXED(4)}, + {"__fs_sinh_1", "__fs_sinh_8", FIXED(8)}, + {"__fs_sinh_1", "__fs_sinh_16", FIXED(16)}, + + {"__pd_sinh_1", "__pd_sinh_2", FIXED(2)}, + {"__pd_sinh_1", "__pd_sinh_4", FIXED(4)}, + {"__pd_sinh_1", "__pd_sinh_8", FIXED(8)}, + + {"__ps_sinh_1", "__ps_sinh_4", FIXED(4)}, + {"__ps_sinh_1", "__ps_sinh_8", FIXED(8)}, + {"__ps_sinh_1", "__ps_sinh_16", FIXED(16)}, + + {"__rd_sinh_1", "__rd_sinh_2", FIXED(2)}, + {"__rd_sinh_1", "__rd_sinh_4", FIXED(4)}, + {"__rd_sinh_1", "__rd_sinh_8", FIXED(8)}, + + {"__rs_sinh_1", "__rs_sinh_4", FIXED(4)}, + {"__rs_sinh_1", "__rs_sinh_8", FIXED(8)}, + {"__rs_sinh_1", "__rs_sinh_16", FIXED(16)}, + + {"__fd_cosh_1", "__fd_cosh_2", FIXED(2)}, + {"__fd_cosh_1", "__fd_cosh_4", FIXED(4)}, + {"__fd_cosh_1", "__fd_cosh_8", FIXED(8)}, + + {"__fs_cosh_1", "__fs_cosh_4", FIXED(4)}, + {"__fs_cosh_1", "__fs_cosh_8", FIXED(8)}, + {"__fs_cosh_1", "__fs_cosh_16", FIXED(16)}, + + {"__pd_cosh_1", "__pd_cosh_2", FIXED(2)}, + {"__pd_cosh_1", "__pd_cosh_4", FIXED(4)}, + {"__pd_cosh_1", "__pd_cosh_8", FIXED(8)}, + + {"__ps_cosh_1", "__ps_cosh_4", FIXED(4)}, + {"__ps_cosh_1", "__ps_cosh_8", FIXED(8)}, + {"__ps_cosh_1", "__ps_cosh_16", FIXED(16)}, + + {"__rd_cosh_1", "__rd_cosh_2", FIXED(2)}, + {"__rd_cosh_1", "__rd_cosh_4", FIXED(4)}, + {"__rd_cosh_1", "__rd_cosh_8", FIXED(8)}, + + {"__rs_cosh_1", "__rs_cosh_4", FIXED(4)}, + {"__rs_cosh_1", "__rs_cosh_8", FIXED(8)}, + {"__rs_cosh_1", "__rs_cosh_16", FIXED(16)}, + + {"__fd_tanh_1", "__fd_tanh_2", FIXED(2)}, + {"__fd_tanh_1", "__fd_tanh_4", FIXED(4)}, + {"__fd_tanh_1", "__fd_tanh_8", FIXED(8)}, + + {"__fs_tanh_1", "__fs_tanh_4", FIXED(4)}, + {"__fs_tanh_1", "__fs_tanh_8", FIXED(8)}, + {"__fs_tanh_1", "__fs_tanh_16", FIXED(16)}, + + {"__pd_tanh_1", "__pd_tanh_2", FIXED(2)}, + {"__pd_tanh_1", "__pd_tanh_4", FIXED(4)}, + {"__pd_tanh_1", "__pd_tanh_8", FIXED(8)}, + + {"__ps_tanh_1", "__ps_tanh_4", FIXED(4)}, + {"__ps_tanh_1", "__ps_tanh_8", FIXED(8)}, + {"__ps_tanh_1", "__ps_tanh_16", FIXED(16)}, + + {"__rd_tanh_1", "__rd_tanh_2", FIXED(2)}, + {"__rd_tanh_1", "__rd_tanh_4", FIXED(4)}, + {"__rd_tanh_1", "__rd_tanh_8", FIXED(8)}, + + {"__rs_tanh_1", "__rs_tanh_4", FIXED(4)}, + {"__rs_tanh_1", "__rs_tanh_8", FIXED(8)}, + {"__rs_tanh_1", "__rs_tanh_16", FIXED(16)}, + + {"__fd_asin_1", "__fd_asin_2", FIXED(2)}, + {"__fd_asin_1", "__fd_asin_4", FIXED(4)}, + {"__fd_asin_1", "__fd_asin_8", FIXED(8)}, + + {"__fs_asin_1", "__fs_asin_4", FIXED(4)}, + {"__fs_asin_1", "__fs_asin_8", FIXED(8)}, + {"__fs_asin_1", "__fs_asin_16", FIXED(16)}, + + {"__pd_asin_1", "__pd_asin_2", FIXED(2)}, + {"__pd_asin_1", "__pd_asin_4", FIXED(4)}, + {"__pd_asin_1", "__pd_asin_8", FIXED(8)}, + + {"__ps_asin_1", "__ps_asin_4", FIXED(4)}, + {"__ps_asin_1", "__ps_asin_8", FIXED(8)}, + {"__ps_asin_1", "__ps_asin_16", FIXED(16)}, + + {"__rd_asin_1", "__rd_asin_2", FIXED(2)}, + {"__rd_asin_1", "__rd_asin_4", FIXED(4)}, + {"__rd_asin_1", "__rd_asin_8", FIXED(8)}, + + {"__rs_asin_1", "__rs_asin_4", FIXED(4)}, + {"__rs_asin_1", "__rs_asin_8", FIXED(8)}, + {"__rs_asin_1", "__rs_asin_16", FIXED(16)}, + + {"__fd_acos_1", "__fd_acos_2", FIXED(2)}, + {"__fd_acos_1", "__fd_acos_4", FIXED(4)}, + {"__fd_acos_1", "__fd_acos_8", FIXED(8)}, + + {"__fs_acos_1", "__fs_acos_4", FIXED(4)}, + {"__fs_acos_1", "__fs_acos_8", FIXED(8)}, + {"__fs_acos_1", "__fs_acos_16", FIXED(16)}, + + {"__pd_acos_1", "__pd_acos_2", FIXED(2)}, + {"__pd_acos_1", "__pd_acos_4", FIXED(4)}, + {"__pd_acos_1", "__pd_acos_8", FIXED(8)}, + + {"__ps_acos_1", "__ps_acos_4", FIXED(4)}, + {"__ps_acos_1", "__ps_acos_8", FIXED(8)}, + {"__ps_acos_1", "__ps_acos_16", FIXED(16)}, + + {"__rd_acos_1", "__rd_acos_2", FIXED(2)}, + {"__rd_acos_1", "__rd_acos_4", FIXED(4)}, + {"__rd_acos_1", "__rd_acos_8", FIXED(8)}, + + {"__rs_acos_1", "__rs_acos_4", FIXED(4)}, + {"__rs_acos_1", "__rs_acos_8", FIXED(8)}, + {"__rs_acos_1", "__rs_acos_16", FIXED(16)}, + + {"__fd_atan_1", "__fd_atan_2", FIXED(2)}, + {"__fd_atan_1", "__fd_atan_4", FIXED(4)}, + {"__fd_atan_1", "__fd_atan_8", FIXED(8)}, + + {"__fs_atan_1", "__fs_atan_4", FIXED(4)}, + {"__fs_atan_1", "__fs_atan_8", FIXED(8)}, + {"__fs_atan_1", "__fs_atan_16", FIXED(16)}, + + {"__pd_atan_1", "__pd_atan_2", FIXED(2)}, + {"__pd_atan_1", "__pd_atan_4", FIXED(4)}, + {"__pd_atan_1", "__pd_atan_8", FIXED(8)}, + + {"__ps_atan_1", "__ps_atan_4", FIXED(4)}, + {"__ps_atan_1", "__ps_atan_8", FIXED(8)}, + {"__ps_atan_1", "__ps_atan_16", FIXED(16)}, + + {"__rd_atan_1", "__rd_atan_2", FIXED(2)}, + {"__rd_atan_1", "__rd_atan_4", FIXED(4)}, + {"__rd_atan_1", "__rd_atan_8", FIXED(8)}, + + {"__rs_atan_1", "__rs_atan_4", FIXED(4)}, + {"__rs_atan_1", "__rs_atan_8", FIXED(8)}, + {"__rs_atan_1", "__rs_atan_16", FIXED(16)}, + + {"__fd_atan2_1", "__fd_atan2_2", FIXED(2)}, + {"__fd_atan2_1", "__fd_atan2_4", FIXED(4)}, + {"__fd_atan2_1", "__fd_atan2_8", FIXED(8)}, + + {"__fs_atan2_1", "__fs_atan2_4", FIXED(4)}, + {"__fs_atan2_1", "__fs_atan2_8", FIXED(8)}, + {"__fs_atan2_1", "__fs_atan2_16", FIXED(16)}, + + {"__pd_atan2_1", "__pd_atan2_2", FIXED(2)}, + {"__pd_atan2_1", "__pd_atan2_4", FIXED(4)}, + {"__pd_atan2_1", "__pd_atan2_8", FIXED(8)}, + + {"__ps_atan2_1", "__ps_atan2_4", FIXED(4)}, + {"__ps_atan2_1", "__ps_atan2_8", FIXED(8)}, + {"__ps_atan2_1", "__ps_atan2_16", FIXED(16)}, + + {"__rd_atan2_1", "__rd_atan2_2", FIXED(2)}, + {"__rd_atan2_1", "__rd_atan2_4", FIXED(4)}, + {"__rd_atan2_1", "__rd_atan2_8", FIXED(8)}, + + {"__rs_atan2_1", "__rs_atan2_4", FIXED(4)}, + {"__rs_atan2_1", "__rs_atan2_8", FIXED(8)}, + {"__rs_atan2_1", "__rs_atan2_16", FIXED(16)}, + + {"__fd_pow_1", "__fd_pow_2", FIXED(2)}, + {"__fd_pow_1", "__fd_pow_4", FIXED(4)}, + {"__fd_pow_1", "__fd_pow_8", FIXED(8)}, + + {"__fs_pow_1", "__fs_pow_4", FIXED(4)}, + {"__fs_pow_1", "__fs_pow_8", FIXED(8)}, + {"__fs_pow_1", "__fs_pow_16", FIXED(16)}, + + {"__pd_pow_1", "__pd_pow_2", FIXED(2)}, + {"__pd_pow_1", "__pd_pow_4", FIXED(4)}, + {"__pd_pow_1", "__pd_pow_8", FIXED(8)}, + + {"__ps_pow_1", "__ps_pow_4", FIXED(4)}, + {"__ps_pow_1", "__ps_pow_8", FIXED(8)}, + {"__ps_pow_1", "__ps_pow_16", FIXED(16)}, + + {"__rd_pow_1", "__rd_pow_2", FIXED(2)}, + {"__rd_pow_1", "__rd_pow_4", FIXED(4)}, + {"__rd_pow_1", "__rd_pow_8", FIXED(8)}, + + {"__rs_pow_1", "__rs_pow_4", FIXED(4)}, + {"__rs_pow_1", "__rs_pow_8", FIXED(8)}, + {"__rs_pow_1", "__rs_pow_16", FIXED(16)}, + + {"__fs_powi_1", "__fs_powi_4", FIXED(4)}, + {"__fs_powi_1", "__fs_powi_8", FIXED(8)}, + {"__fs_powi_1", "__fs_powi_16", FIXED(16)}, + + {"__ps_powi_1", "__ps_powi_4", FIXED(4)}, + {"__ps_powi_1", "__ps_powi_8", FIXED(8)}, + {"__ps_powi_1", "__ps_powi_16", FIXED(16)}, + + {"__rs_powi_1", "__rs_powi_4", FIXED(4)}, + {"__rs_powi_1", "__rs_powi_8", FIXED(8)}, + {"__rs_powi_1", "__rs_powi_16", FIXED(16)}, + + {"__fd_powi1_1", "__fd_powi1_2", FIXED(2)}, + {"__fd_powi1_1", "__fd_powi1_4", FIXED(4)}, + {"__fd_powi1_1", "__fd_powi1_8", FIXED(8)}, + + {"__fs_powi1_1", "__fs_powi1_4", FIXED(4)}, + {"__fs_powi1_1", "__fs_powi1_8", FIXED(8)}, + {"__fs_powi1_1", "__fs_powi1_16", FIXED(16)}, + + {"__pd_powi1_1", "__pd_powi1_2", FIXED(2)}, + {"__pd_powi1_1", "__pd_powi1_4", FIXED(4)}, + {"__pd_powi1_1", "__pd_powi1_8", FIXED(8)}, + + {"__ps_powi1_1", "__ps_powi1_4", FIXED(4)}, + {"__ps_powi1_1", "__ps_powi1_8", FIXED(8)}, + {"__ps_powi1_1", "__ps_powi1_16", FIXED(16)}, + + {"__rd_powi1_1", "__rd_powi1_2", FIXED(2)}, + {"__rd_powi1_1", "__rd_powi1_4", FIXED(4)}, + {"__rd_powi1_1", "__rd_powi1_8", FIXED(8)}, + + {"__rs_powi1_1", "__rs_powi1_4", FIXED(4)}, + {"__rs_powi1_1", "__rs_powi1_8", FIXED(8)}, + {"__rs_powi1_1", "__rs_powi1_16", FIXED(16)}, + + {"__fd_powk_1", "__fd_powk_2", FIXED(2)}, + {"__fd_powk_1", "__fd_powk_4", FIXED(4)}, + {"__fd_powk_1", "__fd_powk_8", FIXED(8)}, + + {"__fs_powk_1", "__fs_powk_4", FIXED(4)}, + {"__fs_powk_1", "__fs_powk_8", FIXED(8)}, + {"__fs_powk_1", "__fs_powk_16", FIXED(16)}, + + {"__pd_powk_1", "__pd_powk_2", FIXED(2)}, + {"__pd_powk_1", "__pd_powk_4", FIXED(4)}, + {"__pd_powk_1", "__pd_powk_8", FIXED(8)}, + + {"__ps_powk_1", "__ps_powk_4", FIXED(4)}, + {"__ps_powk_1", "__ps_powk_8", FIXED(8)}, + {"__ps_powk_1", "__ps_powk_16", FIXED(16)}, + + {"__rd_powk_1", "__rd_powk_2", FIXED(2)}, + {"__rd_powk_1", "__rd_powk_4", FIXED(4)}, + {"__rd_powk_1", "__rd_powk_8", FIXED(8)}, + + {"__rs_powk_1", "__rs_powk_4", FIXED(4)}, + {"__rs_powk_1", "__rs_powk_8", FIXED(8)}, + {"__rs_powk_1", "__rs_powk_16", FIXED(16)}, + + {"__fd_powk1_1", "__fd_powk1_2", FIXED(2)}, + {"__fd_powk1_1", "__fd_powk1_4", FIXED(4)}, + {"__fd_powk1_1", "__fd_powk1_8", FIXED(8)}, + + {"__fs_powk1_1", "__fs_powk1_4", FIXED(4)}, + {"__fs_powk1_1", "__fs_powk1_8", FIXED(8)}, + {"__fs_powk1_1", "__fs_powk1_16", FIXED(16)}, + + {"__pd_powk1_1", "__pd_powk1_2", FIXED(2)}, + {"__pd_powk1_1", "__pd_powk1_4", FIXED(4)}, + {"__pd_powk1_1", "__pd_powk1_8", FIXED(8)}, + + {"__ps_powk1_1", "__ps_powk1_4", FIXED(4)}, + {"__ps_powk1_1", "__ps_powk1_8", FIXED(8)}, + {"__ps_powk1_1", "__ps_powk1_16", FIXED(16)}, + + {"__rd_powk1_1", "__rd_powk1_2", FIXED(2)}, + {"__rd_powk1_1", "__rd_powk1_4", FIXED(4)}, + {"__rd_powk1_1", "__rd_powk1_8", FIXED(8)}, + + {"__rs_powk1_1", "__rs_powk1_4", FIXED(4)}, + {"__rs_powk1_1", "__rs_powk1_8", FIXED(8)}, + {"__rs_powk1_1", "__rs_powk1_16", FIXED(16)}, + + {"__fd_log10_1", "__fd_log10_2", FIXED(2)}, + {"__fd_log10_1", "__fd_log10_4", FIXED(4)}, + {"__fd_log10_1", "__fd_log10_8", FIXED(8)}, + + {"__fs_log10_1", "__fs_log10_4", FIXED(4)}, + {"__fs_log10_1", "__fs_log10_8", FIXED(8)}, + {"__fs_log10_1", "__fs_log10_16", FIXED(16)}, + + {"__pd_log10_1", "__pd_log10_2", FIXED(2)}, + {"__pd_log10_1", "__pd_log10_4", FIXED(4)}, + {"__pd_log10_1", "__pd_log10_8", FIXED(8)}, + + {"__ps_log10_1", "__ps_log10_4", FIXED(4)}, + {"__ps_log10_1", "__ps_log10_8", FIXED(8)}, + {"__ps_log10_1", "__ps_log10_16", FIXED(16)}, + + {"__rd_log10_1", "__rd_log10_2", FIXED(2)}, + {"__rd_log10_1", "__rd_log10_4", FIXED(4)}, + {"__rd_log10_1", "__rd_log10_8", FIXED(8)}, + + {"__rs_log10_1", "__rs_log10_4", FIXED(4)}, + {"__rs_log10_1", "__rs_log10_8", FIXED(8)}, + {"__rs_log10_1", "__rs_log10_16", FIXED(16)}, + + {"__fd_log_1", "__fd_log_2", FIXED(2)}, + {"__fd_log_1", "__fd_log_4", FIXED(4)}, + {"__fd_log_1", "__fd_log_8", FIXED(8)}, + + {"__fs_log_1", "__fs_log_4", FIXED(4)}, + {"__fs_log_1", "__fs_log_8", FIXED(8)}, + {"__fs_log_1", "__fs_log_16", FIXED(16)}, + + {"__pd_log_1", "__pd_log_2", FIXED(2)}, + {"__pd_log_1", "__pd_log_4", FIXED(4)}, + {"__pd_log_1", "__pd_log_8", FIXED(8)}, + + {"__ps_log_1", "__ps_log_4", FIXED(4)}, + {"__ps_log_1", "__ps_log_8", FIXED(8)}, + {"__ps_log_1", "__ps_log_16", FIXED(16)}, + + {"__rd_log_1", "__rd_log_2", FIXED(2)}, + {"__rd_log_1", "__rd_log_4", FIXED(4)}, + {"__rd_log_1", "__rd_log_8", FIXED(8)}, + + {"__rs_log_1", "__rs_log_4", FIXED(4)}, + {"__rs_log_1", "__rs_log_8", FIXED(8)}, + {"__rs_log_1", "__rs_log_16", FIXED(16)}, + + {"__fs_exp_1", "__fs_exp_4", FIXED(4)}, + {"__fs_exp_1", "__fs_exp_8", FIXED(8)}, + {"__fs_exp_1", "__fs_exp_16", FIXED(16)}, + + {"__pd_exp_1", "__pd_exp_2", FIXED(2)}, + {"__pd_exp_1", "__pd_exp_4", FIXED(4)}, + {"__pd_exp_1", "__pd_exp_8", FIXED(8)}, + + {"__ps_exp_1", "__ps_exp_4", FIXED(4)}, + {"__ps_exp_1", "__ps_exp_8", FIXED(8)}, + {"__ps_exp_1", "__ps_exp_16", FIXED(16)}, + + {"__rd_exp_1", "__rd_exp_2", FIXED(2)}, + {"__rd_exp_1", "__rd_exp_4", FIXED(4)}, + {"__rd_exp_1", "__rd_exp_8", FIXED(8)}, + + {"__rs_exp_1", "__rs_exp_4", FIXED(4)}, + {"__rs_exp_1", "__rs_exp_8", FIXED(8)}, + {"__rs_exp_1", "__rs_exp_16", FIXED(16)} + }; + addVectorizableFunctions(VecFuncs); + break; + } +#endif + case NoLibrary: break; } diff --git a/llvm/lib/AsmParser/LLParser.cpp b/llvm/lib/AsmParser/LLParser.cpp index fa0079bac435..cb9853f3ff53 100644 --- a/llvm/lib/AsmParser/LLParser.cpp +++ b/llvm/lib/AsmParser/LLParser.cpp @@ -5844,6 +5844,22 @@ bool LLParser::parseDITemplateValueParameter(MDNode *&Result, bool IsDistinct) { /// isDefinition: true, templateParams: !3, /// declaration: !4, align: 8) bool LLParser::parseDIGlobalVariable(MDNode *&Result, bool IsDistinct) { +#ifdef ENABLE_CLASSIC_FLANG +#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \ + OPTIONAL(name, MDStringField, (/* AllowEmpty */ true)); \ + OPTIONAL(scope, MDField, ); \ + OPTIONAL(linkageName, MDStringField, ); \ + OPTIONAL(file, MDField, ); \ + OPTIONAL(line, LineField, ); \ + OPTIONAL(type, MDField, ); \ + OPTIONAL(isLocal, MDBoolField, ); \ + OPTIONAL(isDefinition, MDBoolField, (true)); \ + OPTIONAL(templateParams, MDField, ); \ + OPTIONAL(declaration, MDField, ); \ + OPTIONAL(flags, DIFlagField, ); \ + OPTIONAL(align, MDUnsignedField, (0, UINT32_MAX)); \ + OPTIONAL(annotations, MDField, ); +#else #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \ OPTIONAL(name, MDStringField, (/* AllowEmpty */ false)); \ OPTIONAL(scope, MDField, ); \ @@ -5855,8 +5871,10 @@ bool LLParser::parseDIGlobalVariable(MDNode *&Result, bool IsDistinct) { OPTIONAL(isDefinition, MDBoolField, (true)); \ OPTIONAL(templateParams, MDField, ); \ OPTIONAL(declaration, MDField, ); \ + OPTIONAL(flags, DIFlagField, ); \ OPTIONAL(align, MDUnsignedField, (0, UINT32_MAX)); \ OPTIONAL(annotations, MDField, ); +#endif PARSE_MD_FIELDS(); #undef VISIT_MD_FIELDS @@ -5864,8 +5882,8 @@ bool LLParser::parseDIGlobalVariable(MDNode *&Result, bool IsDistinct) { GET_OR_DISTINCT(DIGlobalVariable, (Context, scope.Val, name.Val, linkageName.Val, file.Val, line.Val, type.Val, isLocal.Val, isDefinition.Val, - declaration.Val, templateParams.Val, align.Val, - annotations.Val)); + declaration.Val, templateParams.Val, flags.Val, + align.Val, annotations.Val)); return false; } diff --git a/llvm/lib/Bitcode/Reader/MetadataLoader.cpp b/llvm/lib/Bitcode/Reader/MetadataLoader.cpp index 1caa8480efc5..09536cfdaaae 100644 --- a/llvm/lib/Bitcode/Reader/MetadataLoader.cpp +++ b/llvm/lib/Bitcode/Reader/MetadataLoader.cpp @@ -2025,25 +2025,43 @@ Error MetadataLoader::MetadataLoaderImpl::parseOneMetadata( break; } case bitc::METADATA_GLOBAL_VAR: { - if (Record.size() < 11 || Record.size() > 13) + if (Record.size() < 11 || Record.size() > 14) return error("Invalid record"); IsDistinct = Record[0] & 1; unsigned Version = Record[0] >> 1; - if (Version == 2) { + if (Version == 3) { + // Add support for DIFlags + Metadata *Annotations = nullptr; + if (Record.size() > 13) + Annotations = getMDOrNull(Record[13]); + + MetadataList.assignValue( + GET_OR_DISTINCT( + DIGlobalVariable, + (Context, getMDOrNull(Record[1]), getMDString(Record[2]), + getMDString(Record[3]), getMDOrNull(Record[4]), Record[5], + getDITypeRefOrNull(Record[6]), Record[7], Record[8], + getMDOrNull(Record[9]), getMDOrNull(Record[10]), + static_cast(Record[11]), Record[12], + Annotations)), + NextMetadataNo); + + NextMetadataNo++; + } else if (Version == 2) { Metadata *Annotations = nullptr; if (Record.size() > 12) Annotations = getMDOrNull(Record[12]); MetadataList.assignValue( - GET_OR_DISTINCT(DIGlobalVariable, - (Context, getMDOrNull(Record[1]), - getMDString(Record[2]), getMDString(Record[3]), - getMDOrNull(Record[4]), Record[5], - getDITypeRefOrNull(Record[6]), Record[7], Record[8], - getMDOrNull(Record[9]), getMDOrNull(Record[10]), - Record[11], Annotations)), + GET_OR_DISTINCT( + DIGlobalVariable, + (Context, getMDOrNull(Record[1]), getMDString(Record[2]), + getMDString(Record[3]), getMDOrNull(Record[4]), Record[5], + getDITypeRefOrNull(Record[6]), Record[7], Record[8], + getMDOrNull(Record[9]), getMDOrNull(Record[10]), + DINode::FlagZero, Record[11], Annotations)), NextMetadataNo); NextMetadataNo++; @@ -2056,7 +2074,8 @@ Error MetadataLoader::MetadataLoaderImpl::parseOneMetadata( (Context, getMDOrNull(Record[1]), getMDString(Record[2]), getMDString(Record[3]), getMDOrNull(Record[4]), Record[5], getDITypeRefOrNull(Record[6]), Record[7], Record[8], - getMDOrNull(Record[10]), nullptr, Record[11], nullptr)), + getMDOrNull(Record[10]), nullptr, DINode::FlagZero, Record[11], + nullptr)), NextMetadataNo); NextMetadataNo++; @@ -2089,7 +2108,8 @@ Error MetadataLoader::MetadataLoaderImpl::parseOneMetadata( (Context, getMDOrNull(Record[1]), getMDString(Record[2]), getMDString(Record[3]), getMDOrNull(Record[4]), Record[5], getDITypeRefOrNull(Record[6]), Record[7], Record[8], - getMDOrNull(Record[10]), nullptr, AlignInBits, nullptr)); + getMDOrNull(Record[10]), nullptr, DINode::FlagZero, AlignInBits, + nullptr)); DIGlobalVariableExpression *DGVE = nullptr; if (Attach || Expr) diff --git a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp index 31c96400dd0f..04dd2320e639 100644 --- a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp +++ b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp @@ -2198,7 +2198,7 @@ void ModuleBitcodeWriter::writeDITemplateValueParameter( void ModuleBitcodeWriter::writeDIGlobalVariable( const DIGlobalVariable *N, SmallVectorImpl &Record, unsigned Abbrev) { - const uint64_t Version = 2 << 1; + const uint64_t Version = 3 << 1; Record.push_back((uint64_t)N->isDistinct() | Version); Record.push_back(VE.getMetadataOrNullID(N->getScope())); Record.push_back(VE.getMetadataOrNullID(N->getRawName())); @@ -2210,6 +2210,7 @@ void ModuleBitcodeWriter::writeDIGlobalVariable( Record.push_back(N->isDefinition()); Record.push_back(VE.getMetadataOrNullID(N->getStaticDataMemberDeclaration())); Record.push_back(VE.getMetadataOrNullID(N->getTemplateParams())); + Record.push_back(N->getFlags()); Record.push_back(N->getAlignInBits()); Record.push_back(VE.getMetadataOrNullID(N->getAnnotations().get())); diff --git a/llvm/lib/CodeGen/AsmPrinter/DebugLocEntry.h b/llvm/lib/CodeGen/AsmPrinter/DebugLocEntry.h index 5358f7b54f41..8adecd02cb72 100644 --- a/llvm/lib/CodeGen/AsmPrinter/DebugLocEntry.h +++ b/llvm/lib/CodeGen/AsmPrinter/DebugLocEntry.h @@ -115,6 +115,29 @@ class DbgValueLoc { SmallVector ValueLocEntries; bool IsVariadic; + /// Type of entry that this represents. + enum EntryType { + E_Location, + E_Integer, + E_ConstantFP, + E_ConstantInt, + E_TargetIndexLocation + }; + enum EntryType EntryKind; + + /// Either a constant, + union { + int64_t Int; + const ConstantFP *CFP; + const ConstantInt *CIP; + } Constant; + + union { + /// Or a location in the machine frame. + MachineLocation Loc; + /// Or a location from target specific location. + TargetIndexLocation TIL; + }; public: DbgValueLoc(const DIExpression *Expr, ArrayRef Locs) @@ -137,6 +160,37 @@ class DbgValueLoc { assert(((Expr && Expr->isValid()) || !Loc.isLocation()) && "DBG_VALUE with a machine location must have a valid expression."); } + DbgValueLoc(const DIExpression *Expr, int64_t i) + : Expression(Expr), EntryKind(E_Integer) { + Constant.Int = i; + } + DbgValueLoc(const DIExpression *Expr, const ConstantFP *CFP) + : Expression(Expr), EntryKind(E_ConstantFP) { + Constant.CFP = CFP; + } + DbgValueLoc(const DIExpression *Expr, const ConstantInt *CIP) + : Expression(Expr), EntryKind(E_ConstantInt) { + Constant.CIP = CIP; + } + DbgValueLoc(const DIExpression *Expr, MachineLocation Loc) + : Expression(Expr), EntryKind(E_Location), Loc(Loc) { + assert(cast(Expr)->isValid()); + } + DbgValueLoc(const DIExpression *Expr, TargetIndexLocation Loc) + : Expression(Expr), EntryKind(E_TargetIndexLocation), TIL(Loc) {} + + bool isLocation() const { return EntryKind == E_Location; } + bool isTargetIndexLocation() const { + return EntryKind == E_TargetIndexLocation; + } + bool isInt() const { return EntryKind == E_Integer; } + bool isConstantFP() const { return EntryKind == E_ConstantFP; } + bool isConstantInt() const { return EntryKind == E_ConstantInt; } + int64_t getInt() const { return Constant.Int; } + const ConstantFP *getConstantFP() const { return Constant.CFP; } + const ConstantInt *getConstantInt() const { return Constant.CIP; } + MachineLocation getLoc() const { return Loc; } + TargetIndexLocation getTargetIndexLocation() const { return TIL; } bool isFragment() const { return getExpression()->isFragment(); } bool isEntryVal() const { return getExpression()->isEntryValue(); } @@ -172,6 +226,15 @@ class DbgValueLoc { LLVM_DUMP_METHOD void dump() const { for (const DbgValueLocEntry &DV : ValueLocEntries) DV.dump(); +// if (isLocation()) { +// llvm::dbgs() << "Loc = { reg=" << Loc.getReg() << " "; +// if (Loc.isIndirect()) +// llvm::dbgs() << "+0"; +// llvm::dbgs() << "} "; +// } else if (isConstantInt()) +// Constant.CIP->dump(); +// else if (isConstantFP()) +// Constant.CFP->dump(); if (Expression) Expression->dump(); } @@ -248,6 +311,9 @@ class DebugLocEntry { DebugLocStream::ListBuilder &List, const DIBasicType *BT, DwarfCompileUnit &TheCU); + +// void finalize(const AsmPrinter &AP, DebugLocStream::ListBuilder &List, +// const DIStringType *ST, DwarfCompileUnit &TheCU); }; /// Compare two DbgValueLocEntries for equality. @@ -276,6 +342,29 @@ inline bool operator==(const DbgValueLoc &A, const DbgValueLoc &B) { A.Expression == B.Expression && A.IsVariadic == B.IsVariadic; } +//inline bool operator==(const DbgValueLoc &A, +// const DbgValueLoc &B) { +// if (A.EntryKind != B.EntryKind) +// return false; +// +// if (A.Expression != B.Expression) +// return false; +// +// switch (A.EntryKind) { +// case DbgValueLoc::E_Location: +// return A.Loc == B.Loc; +// case DbgValueLoc::E_TargetIndexLocation: +// return A.TIL == B.TIL; +// case DbgValueLoc::E_Integer: +// return A.Constant.Int == B.Constant.Int; +// case DbgValueLoc::E_ConstantFP: +// return A.Constant.CFP == B.Constant.CFP; +// case DbgValueLoc::E_ConstantInt: +// return A.Constant.CIP == B.Constant.CIP; +// } +// llvm_unreachable("unhandled EntryKind"); +//} + /// Compare two fragments based on their offset. inline bool operator<(const DbgValueLoc &A, const DbgValueLoc &B) { diff --git a/llvm/lib/CodeGen/AsmPrinter/DebugLocStream.cpp b/llvm/lib/CodeGen/AsmPrinter/DebugLocStream.cpp index 700e24a08b5d..8213fb9de54e 100644 --- a/llvm/lib/CodeGen/AsmPrinter/DebugLocStream.cpp +++ b/llvm/lib/CodeGen/AsmPrinter/DebugLocStream.cpp @@ -38,6 +38,11 @@ void DebugLocStream::finalizeEntry() { } DebugLocStream::ListBuilder::~ListBuilder() { +#ifdef ENABLE_CLASSIC_FLANG + if (Finalized) + return; + Finalized = true; +#endif if (!Locs.finalizeList(Asm)) return; V.emplace(ListIndex, TagOffset); diff --git a/llvm/lib/CodeGen/AsmPrinter/DebugLocStream.h b/llvm/lib/CodeGen/AsmPrinter/DebugLocStream.h index 6f553dc85c64..25f4f571b899 100644 --- a/llvm/lib/CodeGen/AsmPrinter/DebugLocStream.h +++ b/llvm/lib/CodeGen/AsmPrinter/DebugLocStream.h @@ -156,12 +156,18 @@ class DebugLocStream::ListBuilder { AsmPrinter &Asm; DbgVariable &V; size_t ListIndex; +#ifdef ENABLE_CLASSIC_FLANG + bool Finalized; +#endif std::optional TagOffset; public: ListBuilder(DebugLocStream &Locs, DwarfCompileUnit &CU, AsmPrinter &Asm, DbgVariable &V) : Locs(Locs), Asm(Asm), V(V), ListIndex(Locs.startList(&CU)), +#ifdef ENABLE_CLASSIC_FLANG + Finalized(false), +#endif TagOffset(std::nullopt) {} void setTagOffset(uint8_t TO) { diff --git a/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp b/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp index 2f96366b78e9..1a95ef450d6e 100644 --- a/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp +++ b/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp @@ -205,6 +205,9 @@ DIE *DwarfCompileUnit::getOrCreateGlobalVariableDIE( else addGlobalName(GV->getName(), *VariableDIE, DeclContext); + if (GV->isArtificial()) + addFlag(*VariableDIE, dwarf::DW_AT_artificial); + addAnnotation(*VariableDIE, GV->getAnnotations()); if (uint32_t AlignInBytes = GV->getAlignInBytes()) diff --git a/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h b/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h index 104039db03c7..86040db75c97 100644 --- a/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h +++ b/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h @@ -178,6 +178,14 @@ class DwarfCompileUnit final : public DwarfUnit { std::vector ExprRefedBaseTypes; +private: + DenseMap> *globalVarMap; +public: + void setGlobalVarMap( + DenseMap> *p = nullptr) { + globalVarMap = p; + } + /// Get or create global variable DIE. DIE * getOrCreateGlobalVariableDIE(const DIGlobalVariable *GV, diff --git a/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp b/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp index 60d911d0383e..cb8ac307c181 100644 --- a/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp +++ b/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp @@ -1209,11 +1209,17 @@ void DwarfDebug::beginModule(Module *M) { } DenseSet Processed; +#if 0 + CU.setGlobalVarMap(&GVMap); +#endif for (auto *GVE : CUNode->getGlobalVariables()) { DIGlobalVariable *GV = GVE->getVariable(); if (Processed.insert(GV).second) CU.getOrCreateGlobalVariableDIE(GV, sortGlobalExprs(GVMap[GV])); } +#if 0 + CU.setGlobalVarMap(); +#endif for (auto *Ty : CUNode->getEnumTypes()) CU.getOrCreateTypeDIE(cast(Ty)); @@ -1873,10 +1879,28 @@ DbgEntity *DwarfDebug::createConcreteEntity(DwarfCompileUnit &TheCU, return ConcreteEntities.back().get(); } +#if 0 +void DwarfDebug::populateDependentTypeMap() { + for (const auto &I : DbgValues) { + InlinedEntity IV = I.first; + if (I.second.empty()) + continue; + if (const DIVariable *DIV = dyn_cast(IV.first)) { + if (const DIStringType *ST = dyn_cast( + static_cast(DIV->getType()))) + if (const DIVariable *LV = ST->getStringLength()) + VariableInDependentType[LV] = ST; + } + } +} +#endif + // Find variables for each lexical scope. void DwarfDebug::collectEntityInfo(DwarfCompileUnit &TheCU, const DISubprogram *SP, DenseSet &Processed) { +// clearDependentTracking(); +// populateDependentTypeMap(); // Grab the variable info that was squirreled away in the MMI side-table. collectVariableInfoFromMFTable(TheCU, Processed); @@ -1895,6 +1919,11 @@ void DwarfDebug::collectEntityInfo(DwarfCompileUnit &TheCU, LexicalScope *Scope = nullptr; const DILocalVariable *LocalVar = cast(IV.first); +#if 0 + const DILocalVariable *LocalVar = dyn_cast(IV.first); + if (!LocalVar) + continue; +#endif if (const DILocation *IA = IV.second) Scope = LScopes.findInlinedScope(LocalVar->getScope(), IA); else @@ -1949,6 +1978,24 @@ void DwarfDebug::collectEntityInfo(DwarfCompileUnit &TheCU, // Finalize the entry by lowering it into a DWARF bytestream. for (auto &Entry : Entries) Entry.finalize(*Asm, List, BT, TheCU); +#if 0 + List.finalize(); + + if (VariableInDependentType.count(LocalVar)) { + const DIType *DT = VariableInDependentType[LocalVar]; + if (const DIStringType *ST = dyn_cast(DT)) { + unsigned Offset; + DbgVariable TVar = {LocalVar, IV.second}; + DebugLocStream::ListBuilder LB(DebugLocs, TheCU, *Asm, TVar, *MInsn); + for (auto &Entry : Entries) + Entry.finalize(*Asm, LB, ST, TheCU); + LB.finalize(); + Offset = TVar.getDebugLocListIndex(); + if (Offset != ~0u) + addStringTypeLoc(ST, Offset); + } + } +#endif } // For each InlinedEntity collected from DBG_LABEL instructions, convert to @@ -3018,6 +3065,35 @@ void DebugLocEntry::finalize(const AsmPrinter &AP, List.setTagOffset(*DwarfExpr.TagOffset); } +#if 0 +inline static DbgValueLoc mkDbgValueLoc(const DIExpression *expr, + DbgValueLoc &value) { + if (value.isInt()) + return DbgValueLoc(expr, value.getInt()); + if (value.isLocation()) + return DbgValueLoc(expr, value.getLoc()); + if (value.isConstantInt()) + return DbgValueLoc(expr, value.getConstantInt()); + assert(value.isConstantFP()); + return DbgValueLoc(expr, value.getConstantFP()); +} + +void DebugLocEntry::finalize(const AsmPrinter &AP, + DebugLocStream::ListBuilder &List, + const DIStringType *ST, + DwarfCompileUnit &TheCU) { + DebugLocStream::EntryBuilder Entry(List, Begin, End); + BufferByteStreamer Streamer = Entry.getStreamer(); + DebugLocDwarfExpression DwarfExpr(AP.getDwarfVersion(), Streamer, TheCU); + DbgValueLoc &Value = Values[0]; + assert(!Value.isFragment()); + assert(Values.size() == 1 && "only fragments may have >1 value"); + Value = mkDbgValueLoc(ST->getStringLengthExp(), Value); + DwarfDebug::emitDebugLocValue(AP, nullptr, Value, DwarfExpr); + DwarfExpr.finalize(); +} +#endif + void DwarfDebug::emitDebugLocEntryLocation(const DebugLocStream::Entry &Entry, const DwarfCompileUnit *CU) { // Emit the size. diff --git a/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.h b/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.h index 9662c617d730..27b2519d879d 100644 --- a/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.h +++ b/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.h @@ -339,6 +339,8 @@ struct SymbolCU { DwarfCompileUnit *CU; }; +class DummyDwarfExpression; + /// The kind of accelerator tables we should emit. enum class AccelTableKind { Default, ///< Platform default. @@ -507,6 +509,8 @@ class DwarfDebug : public DebugHandlerBase { /// Map for tracking Fortran deferred CHARACTER lengths. DenseMap StringTypeLocMap; + DenseMap VariableInDependentType; + AddressPool AddrPool; /// Accelerator tables. @@ -701,6 +705,14 @@ class DwarfDebug : public DebugHandlerBase { void findForceIsStmtInstrs(const MachineFunction *MF); +#if 0 + /// Populate dependent type variable map + void populateDependentTypeMap(); +#endif + + /// Clear dependent type tracking map + void clearDependentTracking() { VariableInDependentType.clear(); } + protected: /// Gather pre-function debug information. void beginFunctionImpl(const MachineFunction *MF) override; diff --git a/llvm/lib/Frontend/Driver/CodeGenOptions.cpp b/llvm/lib/Frontend/Driver/CodeGenOptions.cpp index 2d74a91f62dc..b42803db4011 100644 --- a/llvm/lib/Frontend/Driver/CodeGenOptions.cpp +++ b/llvm/lib/Frontend/Driver/CodeGenOptions.cpp @@ -30,6 +30,12 @@ TargetLibraryInfoImpl *createTLII(llvm::Triple &TargetTriple, TLII->addVectorizableFunctionsFromVecLib(TargetLibraryInfoImpl::MASSV, TargetTriple); break; +#ifdef ENABLE_CLASSIC_FLANG + case VectorLibrary::PGMATH: + TLII->addVectorizableFunctionsFromVecLib(TargetLibraryInfoImpl::PGMATH, + TargetTriple); + break; +#endif case VectorLibrary::SVML: TLII->addVectorizableFunctionsFromVecLib(TargetLibraryInfoImpl::SVML, TargetTriple); diff --git a/llvm/lib/IR/AsmWriter.cpp b/llvm/lib/IR/AsmWriter.cpp index a37a8901489c..faed3a26008d 100644 --- a/llvm/lib/IR/AsmWriter.cpp +++ b/llvm/lib/IR/AsmWriter.cpp @@ -2464,6 +2464,7 @@ static void writeDIGlobalVariable(raw_ostream &Out, const DIGlobalVariable *N, Printer.printBool("isDefinition", N->isDefinition()); Printer.printMetadata("declaration", N->getRawStaticDataMemberDeclaration()); Printer.printMetadata("templateParams", N->getRawTemplateParams()); + Printer.printDIFlags("flags", N->getFlags()); Printer.printInt("align", N->getAlignInBits()); Printer.printMetadata("annotations", N->getRawAnnotations()); Out << ")"; diff --git a/llvm/lib/IR/DIBuilder.cpp b/llvm/lib/IR/DIBuilder.cpp index 752a43213b71..9e1f6630cb37 100644 --- a/llvm/lib/IR/DIBuilder.cpp +++ b/llvm/lib/IR/DIBuilder.cpp @@ -761,14 +761,14 @@ DIGlobalVariableExpression *DIBuilder::createGlobalVariableExpression( DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *F, unsigned LineNumber, DIType *Ty, bool IsLocalToUnit, bool isDefined, DIExpression *Expr, MDNode *Decl, MDTuple *TemplateParams, - uint32_t AlignInBits, DINodeArray Annotations) { + DINode::DIFlags Flags, uint32_t AlignInBits, DINodeArray Annotations) { checkGlobalVariableScope(Context); auto *GV = DIGlobalVariable::getDistinct( VMContext, cast_or_null(Context), Name, LinkageName, F, LineNumber, Ty, IsLocalToUnit, isDefined, - cast_or_null(Decl), TemplateParams, AlignInBits, - Annotations); + cast_or_null(Decl), TemplateParams, Flags, + AlignInBits, Annotations); if (!Expr) Expr = createExpression(); auto *N = DIGlobalVariableExpression::get(VMContext, GV, Expr); @@ -779,14 +779,14 @@ DIGlobalVariableExpression *DIBuilder::createGlobalVariableExpression( DIGlobalVariable *DIBuilder::createTempGlobalVariableFwdDecl( DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *F, unsigned LineNumber, DIType *Ty, bool IsLocalToUnit, MDNode *Decl, - MDTuple *TemplateParams, uint32_t AlignInBits) { + MDTuple *TemplateParams, DINode::DIFlags Flags, uint32_t AlignInBits) { checkGlobalVariableScope(Context); return DIGlobalVariable::getTemporary( VMContext, cast_or_null(Context), Name, LinkageName, F, LineNumber, Ty, IsLocalToUnit, false, - cast_or_null(Decl), TemplateParams, AlignInBits, - nullptr) + cast_or_null(Decl), TemplateParams, Flags, + AlignInBits, nullptr) .release(); } diff --git a/llvm/lib/IR/DebugInfo.cpp b/llvm/lib/IR/DebugInfo.cpp index 8c973eb8cf30..c368ca7e8592 100644 --- a/llvm/lib/IR/DebugInfo.cpp +++ b/llvm/lib/IR/DebugInfo.cpp @@ -1623,12 +1623,13 @@ LLVMMetadataRef LLVMDIBuilderCreateGlobalVariableExpression( LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name, size_t NameLen, const char *Linkage, size_t LinkLen, LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty, LLVMBool LocalToUnit, - LLVMMetadataRef Expr, LLVMMetadataRef Decl, uint32_t AlignInBits) { + LLVMMetadataRef Expr, LLVMMetadataRef Decl, LLVMDIFlags Flags, + uint32_t AlignInBits) { return wrap(unwrap(Builder)->createGlobalVariableExpression( unwrapDI(Scope), {Name, NameLen}, {Linkage, LinkLen}, unwrapDI(File), LineNo, unwrapDI(Ty), LocalToUnit, true, unwrap(Expr), unwrapDI(Decl), - nullptr, AlignInBits)); + nullptr, map_from_llvmDIFlags(Flags), AlignInBits)); } LLVMMetadataRef LLVMDIGlobalVariableExpressionGetVariable(LLVMMetadataRef GVE) { @@ -1673,11 +1674,12 @@ LLVMMetadataRef LLVMDIBuilderCreateTempGlobalVariableFwdDecl( LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name, size_t NameLen, const char *Linkage, size_t LnkLen, LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty, LLVMBool LocalToUnit, - LLVMMetadataRef Decl, uint32_t AlignInBits) { + LLVMMetadataRef Decl, LLVMDIFlags Flags, uint32_t AlignInBits) { return wrap(unwrap(Builder)->createTempGlobalVariableFwdDecl( unwrapDI(Scope), {Name, NameLen}, {Linkage, LnkLen}, unwrapDI(File), LineNo, unwrapDI(Ty), LocalToUnit, - unwrapDI(Decl), nullptr, AlignInBits)); + unwrapDI(Decl), nullptr, map_from_llvmDIFlags(Flags), + AlignInBits)); } LLVMDbgRecordRef LLVMDIBuilderInsertDeclareRecordBefore( diff --git a/llvm/lib/IR/DebugInfoMetadata.cpp b/llvm/lib/IR/DebugInfoMetadata.cpp index 915cdd301f2c..51fb01fa4fc3 100644 --- a/llvm/lib/IR/DebugInfoMetadata.cpp +++ b/llvm/lib/IR/DebugInfoMetadata.cpp @@ -1283,15 +1283,16 @@ DIGlobalVariable::getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name, MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type, bool IsLocalToUnit, bool IsDefinition, Metadata *StaticDataMemberDeclaration, - Metadata *TemplateParams, uint32_t AlignInBits, - Metadata *Annotations, StorageType Storage, - bool ShouldCreate) { + Metadata *TemplateParams, DIFlags Flags, + uint32_t AlignInBits, Metadata *Annotations, + StorageType Storage, bool ShouldCreate) { assert(isCanonical(Name) && "Expected canonical MDString"); assert(isCanonical(LinkageName) && "Expected canonical MDString"); DEFINE_GETIMPL_LOOKUP( DIGlobalVariable, (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition, - StaticDataMemberDeclaration, TemplateParams, AlignInBits, Annotations)); + StaticDataMemberDeclaration, TemplateParams, Flags, AlignInBits, + Annotations)); Metadata *Ops[] = {Scope, Name, File, @@ -1302,7 +1303,8 @@ DIGlobalVariable::getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name, TemplateParams, Annotations}; DEFINE_GETIMPL_STORE(DIGlobalVariable, - (Line, IsLocalToUnit, IsDefinition, AlignInBits), Ops); + (Line, IsLocalToUnit, IsDefinition, Flags, AlignInBits), + Ops); } DILocalVariable * diff --git a/llvm/lib/IR/LLVMContextImpl.h b/llvm/lib/IR/LLVMContextImpl.h index 69d90c58964f..90af19ba2ae9 100644 --- a/llvm/lib/IR/LLVMContextImpl.h +++ b/llvm/lib/IR/LLVMContextImpl.h @@ -1082,6 +1082,7 @@ template <> struct MDNodeKeyImpl { bool IsDefinition; Metadata *StaticDataMemberDeclaration; Metadata *TemplateParams; + unsigned Flags; uint32_t AlignInBits; Metadata *Annotations; @@ -1089,20 +1090,21 @@ template <> struct MDNodeKeyImpl { Metadata *File, unsigned Line, Metadata *Type, bool IsLocalToUnit, bool IsDefinition, Metadata *StaticDataMemberDeclaration, Metadata *TemplateParams, + unsigned Flags, uint32_t AlignInBits, Metadata *Annotations) : Scope(Scope), Name(Name), LinkageName(LinkageName), File(File), Line(Line), Type(Type), IsLocalToUnit(IsLocalToUnit), IsDefinition(IsDefinition), StaticDataMemberDeclaration(StaticDataMemberDeclaration), - TemplateParams(TemplateParams), AlignInBits(AlignInBits), - Annotations(Annotations) {} + TemplateParams(TemplateParams), Flags(Flags), + AlignInBits(AlignInBits), Annotations(Annotations) {} MDNodeKeyImpl(const DIGlobalVariable *N) : Scope(N->getRawScope()), Name(N->getRawName()), LinkageName(N->getRawLinkageName()), File(N->getRawFile()), Line(N->getLine()), Type(N->getRawType()), IsLocalToUnit(N->isLocalToUnit()), IsDefinition(N->isDefinition()), StaticDataMemberDeclaration(N->getRawStaticDataMemberDeclaration()), - TemplateParams(N->getRawTemplateParams()), + TemplateParams(N->getRawTemplateParams()), Flags(N->getFlags()), AlignInBits(N->getAlignInBits()), Annotations(N->getRawAnnotations()) {} bool isKeyOf(const DIGlobalVariable *RHS) const { @@ -1114,6 +1116,7 @@ template <> struct MDNodeKeyImpl { StaticDataMemberDeclaration == RHS->getRawStaticDataMemberDeclaration() && TemplateParams == RHS->getRawTemplateParams() && + Flags == RHS->getFlags() && AlignInBits == RHS->getAlignInBits() && Annotations == RHS->getRawAnnotations(); } @@ -1128,7 +1131,7 @@ template <> struct MDNodeKeyImpl { // TODO: make hashing work fine with such situations return hash_combine(Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition, /* AlignInBits, */ - StaticDataMemberDeclaration, Annotations); + StaticDataMemberDeclaration, Flags, Annotations); } }; diff --git a/llvm/lib/Transforms/Instrumentation/InstrProfiling.cpp b/llvm/lib/Transforms/Instrumentation/InstrProfiling.cpp index 54b328b79a64..da490fdb359a 100644 --- a/llvm/lib/Transforms/Instrumentation/InstrProfiling.cpp +++ b/llvm/lib/Transforms/Instrumentation/InstrProfiling.cpp @@ -1718,8 +1718,8 @@ InstrLowerer::getOrCreateRegionCounters(InstrProfCntrInstBase *Inc) { SP, CounterPtr->getName(), /*LinkageName=*/StringRef(), SP->getFile(), /*LineNo=*/0, DB.createUnspecifiedType("Profile Data Type"), CounterPtr->hasLocalLinkage(), /*IsDefined=*/true, /*Expr=*/nullptr, - /*Decl=*/nullptr, /*TemplateParams=*/nullptr, /*AlignInBits=*/0, - Annotations); + /*Decl=*/nullptr, /*TemplateParams=*/nullptr, + /*Flags=*/DINode::FlagZero, /*AlignInBits=*/0, Annotations); CounterPtr->addDebugInfo(DICounter); DB.finalize(); } diff --git a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp index 7cd395255163..9b8f31941552 100644 --- a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp +++ b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp @@ -4816,8 +4816,10 @@ void LoopVectorizationCostModel::collectElementTypesForWidening() { if (ValuesToIgnore.count(&I)) continue; - // Only examine Loads, Stores and PHINodes. - if (!isa(I) && !isa(I) && !isa(I)) + // Examine Loads, Stores, PHINodes + // Also examine instructions which convert to a float/double + if (!isa(I) && !isa(I) && !isa(I) && + !isa(I) && !isa(I) && !isa(I)) continue; // Examine PHI nodes that are reduction variables. Update the type to diff --git a/llvm/test/Assembler/invalid-diglobalvariable-empty-name.ll b/llvm/test/Assembler/invalid-diglobalvariable-empty-name.ll index a4e69f3c8b75..d3c476a03198 100644 --- a/llvm/test/Assembler/invalid-diglobalvariable-empty-name.ll +++ b/llvm/test/Assembler/invalid-diglobalvariable-empty-name.ll @@ -1,4 +1,5 @@ ; RUN: not llvm-as < %s -disable-output 2>&1 | FileCheck %s +; UNSUPPORTED: classic_flang ; CHECK: :[[@LINE+1]]:30: error: 'name' cannot be empty !0 = !DIGlobalVariable(name: "") diff --git a/llvm/test/DebugInfo/Generic/fortran-subprogram-at.ll b/llvm/test/DebugInfo/Generic/fortran-subprogram-at.ll new file mode 100644 index 000000000000..988c388fe218 --- /dev/null +++ b/llvm/test/DebugInfo/Generic/fortran-subprogram-at.ll @@ -0,0 +1,24 @@ +; Test for DIFlagPure, DIFlagElement and DIFlagRecursive. These three +; DIFlags are used to attach DW_AT_pure, DW_AT_element, and DW_AT_recursive +; attributes to DW_TAG_subprogram DIEs. + +; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis | FileCheck %s +; CHECK: !DISubprogram({{.*}}, spFlags: DISPFlagDefinition | DISPFlagPure | DISPFlagElemental | DISPFlagRecursive, + +!llvm.module.flags = !{!0, !1} +!llvm.dbg.cu = !{!2} + +define void @subprgm() !dbg !6 { +L: + ret void +} + +!0 = !{i32 2, !"Dwarf Version", i32 2} +!1 = !{i32 1, !"Debug Info Version", i32 3} +!2 = distinct !DICompileUnit(language: DW_LANG_Fortran90, file: !3, producer: "Flang", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, retainedTypes: !4, globals: !4, imports: !4) +!3 = !DIFile(filename: "fortran-subprogram-at.f", directory: "/") +!4 = !{} +!5 = !DIBasicType(name: "real", size: 32, align: 32, encoding: DW_ATE_float) +!6 = distinct !DISubprogram(name: "subprgm", scope: !2, file: !3, line: 256, type: !7, scopeLine: 256, spFlags: DISPFlagDefinition | DISPFlagPure | DISPFlagElemental | DISPFlagRecursive, unit: !2) +!7 = !DISubroutineType(types: !8) +!8 = !{null, !5} diff --git a/llvm/test/DebugInfo/Generic/more-subprogram-attr.ll b/llvm/test/DebugInfo/Generic/more-subprogram-attr.ll new file mode 100644 index 000000000000..0533cf6b2367 --- /dev/null +++ b/llvm/test/DebugInfo/Generic/more-subprogram-attr.ll @@ -0,0 +1,38 @@ +; REQUIRES: object-emission + +; RUN: %llc_dwarf -O0 -filetype=obj < %s > %t +; RUN: llvm-dwarfdump -v -debug-info %t | FileCheck %s + +; Make sure we're emitting DW_AT_{pure,elemental,recursive}. +; CHECK: DW_TAG_subprogram +; CHECK-NOT: {{DW_TAG|NULL}} +; CHECK: DW_AT_name {{.*}} "main" +; CHECK-NOT: {{DW_TAG|NULL}} +; CHECK: DW_AT_pure [DW_FORM_flag_present] (true) +; CHECK: DW_AT_elemental [DW_FORM_flag_present] (true) +; CHECK: DW_AT_recursive [DW_FORM_flag_present] (true) + +define dso_local i32 @main() !dbg !7 { +entry: + %retval = alloca i32, align 4 + store i32 0, i32* %retval, align 4 + ret i32 0, !dbg !12 +} + +!llvm.dbg.cu = !{!0} +!llvm.module.flags = !{!3, !4, !5} +!llvm.ident = !{!6} + +!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, nameTableKind: None) +!1 = !DIFile(filename: "x.c", directory: "/tmp") +!2 = !{} +!3 = !{i32 2, !"Dwarf Version", i32 4} +!4 = !{i32 2, !"Debug Info Version", i32 3} +!5 = !{i32 1, !"wchar_size", i32 4} +!6 = !{!"clang"} +!7 = distinct !DISubprogram(name: "main", scope: !8, file: !8, line: 1, type: !9, scopeLine: 2, spFlags: DISPFlagDefinition | DISPFlagPure | DISPFlagElemental | DISPFlagRecursive, unit: !0, retainedNodes: !2) +!8 = !DIFile(filename: "x.c", directory: "/tmp") +!9 = !DISubroutineType(types: !10) +!10 = !{!11} +!11 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed) +!12 = !DILocation(line: 3, column: 3, scope: !7) diff --git a/llvm/test/DebugInfo/X86/DICommonBlock.ll b/llvm/test/DebugInfo/X86/DICommonBlock.ll new file mode 100644 index 000000000000..6cfb7a90640d --- /dev/null +++ b/llvm/test/DebugInfo/X86/DICommonBlock.ll @@ -0,0 +1,36 @@ +; ModuleID = 'none.f90' +; RUN: llc %s -o %t -filetype=obj +; RUN: llvm-dwarfdump -debug-info %t | FileCheck %s +; CHECK: DW_TAG_common_block + +target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" +target triple = "x86_64-apple-macosx" + +@common_a = common global [32 x i8] zeroinitializer, align 8, !dbg !13 + +define i32 @subr() !dbg !9 { + %1 = getelementptr inbounds [32 x i8], [32 x i8]* @common_a, i64 0, i32 8 + %2 = bitcast i8* %1 to i32* + %3 = load i32, i32* %2 + ret i32 %3 +} + +!llvm.dbg.cu = !{!0} +!llvm.module.flags = !{!6, !7} +!llvm.ident = !{!8} + +!0 = distinct !DICompileUnit(language: DW_LANG_Fortran90, file: !1, producer: "PGI Fortran", isOptimized: false, runtimeVersion: 2, emissionKind: FullDebug, retainedTypes: !14, globals: !2) +!1 = !DIFile(filename: "none.f90", directory: "/not/here/") +!2 = !{!13} +!3 = !{} +!4 = !DIGlobalVariable(name: "common /a/", scope: !5, file: !1, line: 4, isLocal: false, isDefinition: true, type: !12) +!5 = !DICommonBlock(scope: !9, declaration: !4, name: "a", file: !1, line: 4) +!6 = !{i32 2, !"Dwarf Version", i32 4} +!7 = !{i32 2, !"Debug Info Version", i32 3} +!8 = !{!"PGI Fortran"} +!9 = distinct !DISubprogram(name: "subrtn", scope: !0, file: !1, line: 1, type: !10, isLocal: false, isDefinition: true, unit: !0) +!10 = !DISubroutineType(types: !11) +!11 = !{!12, !12} +!12 = !DIBasicType(name: "int", size: 32) +!13 = !DIGlobalVariableExpression(var: !4, expr: !DIExpression()) +!14 = !{!12, !10} diff --git a/llvm/test/lit.cfg.py b/llvm/test/lit.cfg.py index aad7a088551b..5dee62323980 100644 --- a/llvm/test/lit.cfg.py +++ b/llvm/test/lit.cfg.py @@ -684,3 +684,6 @@ def host_unwind_supports_jit(): if config.has_logf128: config.available_features.add("has_logf128") + +if config.use_classic_flang: + config.available_features.add("classic_flang") diff --git a/llvm/test/lit.site.cfg.py.in b/llvm/test/lit.site.cfg.py.in index 0d02920323d2..470e5fe579e7 100644 --- a/llvm/test/lit.site.cfg.py.in +++ b/llvm/test/lit.site.cfg.py.in @@ -65,6 +65,7 @@ config.spirv_tools_tests = @LLVM_INCLUDE_SPIRV_TOOLS_TESTS@ config.have_vc_rev = @LLVM_APPEND_VC_REV@ config.force_vc_rev = "@LLVM_FORCE_VC_REVISION@" config.has_logf128 = @LLVM_HAS_LOGF128@ +config.use_classic_flang = @LLVM_ENABLE_CLASSIC_FLANG@ import lit.llvm lit.llvm.initialize(lit_config, config) diff --git a/llvm/tools/llvm-c-test/debuginfo.c b/llvm/tools/llvm-c-test/debuginfo.c index baf4ddfcc9a3..6a14362fbba1 100644 --- a/llvm/tools/llvm-c-test/debuginfo.c +++ b/llvm/tools/llvm-c-test/debuginfo.c @@ -70,7 +70,7 @@ int llvm_test_dibuilder(void) { LLVMDIBuilderCreateConstantValueExpression(DIB, 0); LLVMDIBuilderCreateGlobalVariableExpression( DIB, Module, "globalClass", 11, "", 0, File, 1, ClassTy, true, - GlobalClassValueExpr, NULL, 0); + GlobalClassValueExpr, NULL, LLVMDIFlagZero, 0); LLVMMetadataRef Int64Ty = LLVMDIBuilderCreateBasicType(DIB, "Int64", 5, 64, 0, LLVMDIFlagZero); @@ -81,7 +81,7 @@ int llvm_test_dibuilder(void) { LLVMDIBuilderCreateConstantValueExpression(DIB, 0); LLVMDIBuilderCreateGlobalVariableExpression( DIB, Module, "global", 6, "", 0, File, 1, Int64TypeDef, true, - GlobalVarValueExpr, NULL, 0); + GlobalVarValueExpr, NULL, LLVMDIFlagZero, 0); LLVMMetadataRef NameSpace = LLVMDIBuilderCreateNameSpace(DIB, Module, "NameSpace", 9, false); diff --git a/llvm/unittests/IR/MetadataTest.cpp b/llvm/unittests/IR/MetadataTest.cpp index 628221339c89..020e66dc535a 100644 --- a/llvm/unittests/IR/MetadataTest.cpp +++ b/llvm/unittests/IR/MetadataTest.cpp @@ -2932,12 +2932,13 @@ TEST_F(DIGlobalVariableTest, get) { DIDerivedType *StaticDataMemberDeclaration = cast(getDerivedType()); + DINode::DIFlags Flags = static_cast(7); uint32_t AlignInBits = 8; auto *N = DIGlobalVariable::get( Context, Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit, - IsDefinition, StaticDataMemberDeclaration, templateParams, AlignInBits, - nullptr); + IsDefinition, StaticDataMemberDeclaration, templateParams, Flags, + AlignInBits, nullptr); EXPECT_EQ(dwarf::DW_TAG_variable, N->getTag()); EXPECT_EQ(Scope, N->getScope()); @@ -2950,57 +2951,66 @@ TEST_F(DIGlobalVariableTest, get) { EXPECT_EQ(IsDefinition, N->isDefinition()); EXPECT_EQ(StaticDataMemberDeclaration, N->getStaticDataMemberDeclaration()); EXPECT_EQ(templateParams, N->getTemplateParams()); + EXPECT_EQ(Flags, N->getFlags()); EXPECT_EQ(AlignInBits, N->getAlignInBits()); EXPECT_EQ(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition, StaticDataMemberDeclaration, - templateParams, AlignInBits, nullptr)); + templateParams, Flags, AlignInBits, + nullptr)); EXPECT_NE(N, DIGlobalVariable::get( Context, getSubprogram(), Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition, - StaticDataMemberDeclaration, templateParams, AlignInBits, - nullptr)); + StaticDataMemberDeclaration, templateParams, Flags, + AlignInBits, nullptr)); EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, "other", LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition, StaticDataMemberDeclaration, - templateParams, AlignInBits, nullptr)); + templateParams, Flags, AlignInBits, + nullptr)); EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, "other", File, Line, Type, IsLocalToUnit, IsDefinition, StaticDataMemberDeclaration, - templateParams, AlignInBits, nullptr)); + templateParams, Flags, AlignInBits, nullptr)); EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, getFile(), Line, Type, IsLocalToUnit, IsDefinition, StaticDataMemberDeclaration, - templateParams, AlignInBits, nullptr)); + templateParams, Flags, AlignInBits, nullptr)); EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, File, Line + 1, Type, IsLocalToUnit, IsDefinition, StaticDataMemberDeclaration, - templateParams, AlignInBits, nullptr)); + templateParams, Flags, AlignInBits, nullptr)); EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, File, Line, getDerivedType(), IsLocalToUnit, IsDefinition, StaticDataMemberDeclaration, - templateParams, AlignInBits, nullptr)); + templateParams, Flags, AlignInBits, nullptr)); EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, File, Line, Type, !IsLocalToUnit, IsDefinition, StaticDataMemberDeclaration, - templateParams, AlignInBits, nullptr)); + templateParams, Flags, AlignInBits, nullptr)); EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit, !IsDefinition, StaticDataMemberDeclaration, - templateParams, AlignInBits, nullptr)); + templateParams, Flags, AlignInBits, nullptr)); EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition, cast(getDerivedType()), - templateParams, AlignInBits, nullptr)); + templateParams, Flags, AlignInBits, nullptr)); EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition, StaticDataMemberDeclaration, nullptr, + Flags, AlignInBits, nullptr)); + EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, File, + Line, Type, IsLocalToUnit, IsDefinition, + StaticDataMemberDeclaration, + templateParams, + static_cast(Flags + 1), AlignInBits, nullptr)); EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition, StaticDataMemberDeclaration, - templateParams, (AlignInBits << 1), + templateParams, Flags, (AlignInBits << 1), nullptr)); TempDIGlobalVariable Temp = N->clone(); @@ -3023,16 +3033,17 @@ TEST_F(DIGlobalVariableExpressionTest, get) { auto *Expr2 = DIExpression::get(Context, {1, 2, 3}); DIDerivedType *StaticDataMemberDeclaration = cast(getDerivedType()); + DINode::DIFlags Flags = static_cast(7); uint32_t AlignInBits = 8; auto *Var = DIGlobalVariable::get( Context, Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit, - IsDefinition, StaticDataMemberDeclaration, templateParams, AlignInBits, - nullptr); + IsDefinition, StaticDataMemberDeclaration, templateParams, Flags, + AlignInBits, nullptr); auto *Var2 = DIGlobalVariable::get( Context, Scope, "other", LinkageName, File, Line, Type, IsLocalToUnit, - IsDefinition, StaticDataMemberDeclaration, templateParams, AlignInBits, - nullptr); + IsDefinition, StaticDataMemberDeclaration, templateParams, Flags, + AlignInBits, nullptr); auto *N = DIGlobalVariableExpression::get(Context, Var, Expr); EXPECT_EQ(Var, N->getVariable()); From c742b6fca4e18e50b0f3100050a417b91302895a Mon Sep 17 00:00:00 2001 From: Bryan Chan Date: Sun, 1 May 2022 21:43:45 -0400 Subject: [PATCH 02/60] [ClassicFlang][Driver] Coexist with LLVM Flang Make TableGen respect the ENABLE_CLASSIC_FLANG macro and better separate the driver options that are mutually exclusive. When the macro is defined, do not build LLVM Flang at all. --- clang/include/clang/Driver/CMakeLists.txt | 6 +++++- clang/include/clang/Driver/Options.td | 8 ++++---- clang/include/clang/Driver/ToolChain.h | 4 ++++ clang/lib/Driver/CMakeLists.txt | 7 ++++--- clang/lib/Driver/ToolChain.cpp | 6 ++++++ clang/lib/Driver/ToolChains/ClassicFlang.cpp | 16 ++++++++-------- clang/lib/Driver/ToolChains/CommonArgs.cpp | 10 ++++++++-- clang/lib/Driver/ToolChains/CommonArgs.h | 2 ++ clang/lib/Driver/ToolChains/Cuda.cpp | 2 ++ clang/lib/Driver/ToolChains/Cuda.h | 11 +++++------ clang/lib/Driver/ToolChains/Gnu.cpp | 2 ++ clang/lib/Driver/ToolChains/Linux.cpp | 2 ++ clang/lib/Driver/ToolChains/Linux.h | 2 ++ 13 files changed, 54 insertions(+), 24 deletions(-) diff --git a/clang/include/clang/Driver/CMakeLists.txt b/clang/include/clang/Driver/CMakeLists.txt index a9d988047920..8543ae37ca4c 100644 --- a/clang/include/clang/Driver/CMakeLists.txt +++ b/clang/include/clang/Driver/CMakeLists.txt @@ -1,3 +1,7 @@ set(LLVM_TARGET_DEFINITIONS Options.td) -tablegen(LLVM Options.inc -gen-opt-parser-defs) +if(LLVM_ENABLE_CLASSIC_FLANG) + tablegen(LLVM Options.inc -DENABLE_CLASSIC_FLANG -gen-opt-parser-defs) +else() + tablegen(LLVM Options.inc -gen-opt-parser-defs) +endif() add_public_tablegen_target(ClangDriverOptions) diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td index ced2ba129339..dfe37883a7a1 100644 --- a/clang/include/clang/Driver/Options.td +++ b/clang/include/clang/Driver/Options.td @@ -6972,11 +6972,11 @@ def fconvert_EQ : Joined<["-"], "fconvert=">, Group, HelpText<"Set endian conversion of data for unformatted files">; def fdefault_double_8 : Flag<["-"],"fdefault-double-8">, Group, HelpText<"Set the default double precision kind to an 8 byte wide type">; +def fdefault_integer_8 : Flag<["-"],"fdefault-integer-8">, Group, + HelpText<"Set the default integer and logical kind to an 8 byte wide type">; #ifdef ENABLE_CLASSIC_FLANG def fno_default_integer_8 : Flag<["-"], "fno-default-integer-8">, Group; #endif -def fdefault_integer_8 : Flag<["-"],"fdefault-integer-8">, Group, - HelpText<"Set the default integer and logical kind to an 8 byte wide type">; def fdefault_real_8 : Flag<["-"],"fdefault-real-8">, Group, HelpText<"Set the default real kind to an 8 byte wide type">; #ifdef ENABLE_CLASSIC_FLANG @@ -9180,8 +9180,8 @@ def wasm_opt : Flag<["--"], "wasm-opt">, MarshallingInfoNegativeFlag>; #ifdef ENABLE_CLASSIC_FLANG -// gfortran options that we recognize in the driver and pass along when -// invoking GCC to compile Fortran code. +// Classic Flang options that we recognize in the driver and pass along when +// invoking flang1/flang2 to compile Fortran code. def flang_rt_Group : OptionGroup<"Flang runtime library Group">; def pgi_fortran_Group : OptionGroup<"PGI Fortran compatibility Group">, Flags<[HelpHidden]>; diff --git a/clang/include/clang/Driver/ToolChain.h b/clang/include/clang/Driver/ToolChain.h index 6f3481f328d9..02ce2c628d8a 100644 --- a/clang/include/clang/Driver/ToolChain.h +++ b/clang/include/clang/Driver/ToolChain.h @@ -675,6 +675,7 @@ class ToolChain { AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const; +#ifdef ENABLE_CLASSIC_FLANG /// \brief Add the flang arguments for system include paths. /// /// This routine is responsible for adding the -stdinc argument to @@ -682,6 +683,7 @@ class ToolChain { virtual void AddFlangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &Flang1Args) const { } +#endif /// Add options that need to be passed to cc1 for this target. virtual void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs, @@ -800,10 +802,12 @@ class ToolChain { virtual void AddHIPRuntimeLibArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const {} +#ifdef ENABLE_CLASSIC_FLANG /// AddFortranStdlibLibArgs - Add the system specific linker arguments to use /// for the given Fortran runtime library type. virtual void AddFortranStdlibLibArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const; +#endif /// Return sanitizers which are available in this toolchain. virtual SanitizerMask getSupportedSanitizers() const; diff --git a/clang/lib/Driver/CMakeLists.txt b/clang/lib/Driver/CMakeLists.txt index fbbee65b8d62..d38d1b136987 100644 --- a/clang/lib/Driver/CMakeLists.txt +++ b/clang/lib/Driver/CMakeLists.txt @@ -15,7 +15,9 @@ if(WIN32) endif() if(LLVM_ENABLE_CLASSIC_FLANG) - set(CLASSIC_FLANG_FILES ToolChains/ClassicFlang.cpp) + set(TOOLCHAINS_FLANG_CPP ToolChains/ClassicFlang.cpp) +else() + set(TOOLCHAINS_FLANG_CPP ToolChains/Flang.cpp) endif() add_clang_library(clangDriver @@ -57,7 +59,7 @@ add_clang_library(clangDriver ToolChains/Cuda.cpp ToolChains/Darwin.cpp ToolChains/DragonFly.cpp - ToolChains/Flang.cpp + ${TOOLCHAINS_FLANG_CPP} ToolChains/FreeBSD.cpp ToolChains/Fuchsia.cpp ToolChains/Gnu.cpp @@ -94,7 +96,6 @@ add_clang_library(clangDriver ToolChains/ZOS.cpp Types.cpp XRayArgs.cpp - ${CLASSIC_FLANG_FILES} DEPENDS ClangDriverOptions diff --git a/clang/lib/Driver/ToolChain.cpp b/clang/lib/Driver/ToolChain.cpp index f617b2aa5e88..d6cb5946bb45 100644 --- a/clang/lib/Driver/ToolChain.cpp +++ b/clang/lib/Driver/ToolChain.cpp @@ -556,9 +556,13 @@ Tool *ToolChain::getClang() const { } Tool *ToolChain::getFlang() const { +#ifndef ENABLE_CLASSIC_FLANG if (!Flang) Flang.reset(new tools::Flang(*this)); return Flang.get(); +#else + llvm_unreachable("Flang is not supported by this toolchain"); +#endif } Tool *ToolChain::buildAssembler() const { @@ -1429,6 +1433,7 @@ void ToolChain::AddCCKextLibArgs(const ArgList &Args, CmdArgs.push_back("-lcc_kext"); } +#ifdef ENABLE_CLASSIC_FLANG void ToolChain::AddFortranStdlibLibArgs(const ArgList &Args, ArgStringList &CmdArgs) const { bool staticFlangLibs = false; @@ -1467,6 +1472,7 @@ void ToolChain::AddFortranStdlibLibArgs(const ArgList &Args, // Allways link Fortran executables with Pthreads CmdArgs.push_back("-lpthread"); } +#endif bool ToolChain::isFastMathRuntimeAvailable(const ArgList &Args, std::string &Path) const { diff --git a/clang/lib/Driver/ToolChains/ClassicFlang.cpp b/clang/lib/Driver/ToolChains/ClassicFlang.cpp index bf234f1b93c4..47ba3668249a 100644 --- a/clang/lib/Driver/ToolChains/ClassicFlang.cpp +++ b/clang/lib/Driver/ToolChains/ClassicFlang.cpp @@ -367,10 +367,10 @@ void ClassicFlang::ConstructJob(Compilation &C, const JobAction &JA, // Handle -fdefault-real-8 (and its alias, -r8) and -fno-default-real-8 if (Arg *A = Args.getLastArg(options::OPT_r8, options::OPT_fdefault_real_8, - options::OPT_default_real_8_fno)) { + options::OPT_fno_default_real_8)) { const char * fl; // For -f version add -x flag, for -fno add -y - if (A->getOption().matches(options::OPT_default_real_8_fno)) { + if (A->getOption().matches(options::OPT_fno_default_real_8)) { fl = "-y"; } else { fl = "-x"; @@ -378,7 +378,7 @@ void ClassicFlang::ConstructJob(Compilation &C, const JobAction &JA, for (Arg *A : Args.filtered(options::OPT_r8, options::OPT_fdefault_real_8, - options::OPT_default_real_8_fno)) { + options::OPT_fno_default_real_8)) { A->claim(); } @@ -393,10 +393,10 @@ void ClassicFlang::ConstructJob(Compilation &C, const JobAction &JA, // Process and claim -i8/-fdefault-integer-8/-fno-default-integer-8 argument if (Arg *A = Args.getLastArg(options::OPT_i8, options::OPT_fdefault_integer_8, - options::OPT_default_integer_8_fno)) { + options::OPT_fno_default_integer_8)) { const char * fl; - if (A->getOption().matches(options::OPT_default_integer_8_fno)) { + if (A->getOption().matches(options::OPT_fno_default_integer_8)) { fl = "-y"; } else { fl = "-x"; @@ -404,7 +404,7 @@ void ClassicFlang::ConstructJob(Compilation &C, const JobAction &JA, for (Arg *A : Args.filtered(options::OPT_i8, options::OPT_fdefault_integer_8, - options::OPT_default_integer_8_fno)) { + options::OPT_fno_default_integer_8)) { A->claim(); } @@ -731,14 +731,14 @@ void ClassicFlang::ConstructJob(Compilation &C, const JobAction &JA, default: llvm_unreachable("missed a case"); case options::OPT_ffixed_form: - case options::OPT_free_form_off: + case options::OPT_fno_free_form: case options::OPT_Mfixed: case options::OPT_Mfree_off: case options::OPT_Mfreeform_off: UpperCmdArgs.push_back("-nofreeform"); break; case options::OPT_ffree_form: - case options::OPT_fixed_form_off: + case options::OPT_fno_fixed_form: case options::OPT_Mfree_on: case options::OPT_Mfreeform_on: UpperCmdArgs.push_back("-freeform"); diff --git a/clang/lib/Driver/ToolChains/CommonArgs.cpp b/clang/lib/Driver/ToolChains/CommonArgs.cpp index f3be7bcf08ed..dbad14bc03b8 100644 --- a/clang/lib/Driver/ToolChains/CommonArgs.cpp +++ b/clang/lib/Driver/ToolChains/CommonArgs.cpp @@ -342,6 +342,7 @@ static bool shouldIgnoreUnsupportedTargetFeature(const Arg &TargetFeatureArg, return TargetFeatureArg.getOption().matches(options::OPT_mno_cumode); } +#ifdef ENABLE_CLASSIC_FLANG /// \brief Determine if Fortran "main" object is needed static bool needFortranMain(const Driver &D, const ArgList &Args) { return (needFortranLibs(D, Args) @@ -358,6 +359,7 @@ bool tools::needFortranLibs(const Driver &D, const ArgList &Args) { return false; } +#endif void tools::addPathIfExists(const Driver &D, const Twine &Path, ToolChain::path_list &Paths) { @@ -467,7 +469,9 @@ void tools::AddLinkerInputs(const ToolChain &TC, const InputInfoList &Inputs, const ArgList &Args, ArgStringList &CmdArgs, const JobAction &JA) { const Driver &D = TC.getDriver(); +#ifdef ENABLE_CLASSIC_FLANG bool SeenFirstLinkerInput = false; +#endif // Add extra linker input arguments which are not treated as inputs // (constructed via -Xarch_). @@ -501,6 +505,7 @@ void tools::AddLinkerInputs(const ToolChain &TC, const InputInfoList &Inputs, if (II.isNothing()) continue; +#ifdef ENABLE_CLASSIC_FLANG // Add Fortan "main" before the first linker input if (!SeenFirstLinkerInput) { if (needFortranMain(D, Args)) { @@ -508,7 +513,7 @@ void tools::AddLinkerInputs(const ToolChain &TC, const InputInfoList &Inputs, } SeenFirstLinkerInput = true; } - +#endif // Otherwise, this is a linker input argument. const Arg &A = II.getInputArg(); @@ -553,7 +558,7 @@ void tools::AddLinkerInputs(const ToolChain &TC, const InputInfoList &Inputs, addArchSpecificRPath(TC, Args, CmdArgs); } } - +#ifdef ENABLE_CLASSIC_FLANG if (!SeenFirstLinkerInput && needFortranMain(D, Args)) { CmdArgs.push_back("-lflangmain"); } @@ -562,6 +567,7 @@ void tools::AddLinkerInputs(const ToolChain &TC, const InputInfoList &Inputs, for (auto Arg : Args.filtered(options::OPT_no_fortran_main, options::OPT_Mnomain)) { Arg->claim(); } +#endif } void tools::addLinkerCompressDebugSectionsOption( diff --git a/clang/lib/Driver/ToolChains/CommonArgs.h b/clang/lib/Driver/ToolChains/CommonArgs.h index 27dd91c75670..78708076426f 100644 --- a/clang/lib/Driver/ToolChains/CommonArgs.h +++ b/clang/lib/Driver/ToolChains/CommonArgs.h @@ -24,7 +24,9 @@ namespace clang { namespace driver { namespace tools { +#ifdef ENABLE_CLASSIC_FLANG bool needFortranLibs(const Driver &D, const llvm::opt::ArgList &Args); +#endif void addPathIfExists(const Driver &D, const Twine &Path, ToolChain::path_list &Paths); diff --git a/clang/lib/Driver/ToolChains/Cuda.cpp b/clang/lib/Driver/ToolChains/Cuda.cpp index d2ce20583a14..9cd31fcae396 100644 --- a/clang/lib/Driver/ToolChains/Cuda.cpp +++ b/clang/lib/Driver/ToolChains/Cuda.cpp @@ -1075,6 +1075,7 @@ VersionTuple CudaToolChain::computeMSVCVersion(const Driver *D, return HostTC.computeMSVCVersion(D, Args); } +#ifdef ENABLE_CLASSIC_FLANG static void AddFlangSysIncludeArg(const ArgList &DriverArgs, ArgStringList &Flang1Args, ToolChain::path_list IncludePathList) { @@ -1107,3 +1108,4 @@ void CudaToolChain::AddFlangSystemIncludeArgs(const llvm::opt::ArgList &DriverAr IncludePathList.push_back(P.c_str()); AddFlangSysIncludeArg(DriverArgs, Flang1Args, IncludePathList); } +#endif diff --git a/clang/lib/Driver/ToolChains/Cuda.h b/clang/lib/Driver/ToolChains/Cuda.h index 828538653310..78cc11fe7b66 100644 --- a/clang/lib/Driver/ToolChains/Cuda.h +++ b/clang/lib/Driver/ToolChains/Cuda.h @@ -222,6 +222,11 @@ class LLVM_LIBRARY_VISIBILITY CudaToolChain : public NVPTXToolChain { llvm::opt::ArgStringList &CC1Args) const override; void AddIAMCUIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override; +#ifdef ENABLE_CLASSIC_FLANG + void + AddFlangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, + llvm::opt::ArgStringList &Flang1Args) const override; +#endif SanitizerMask getSupportedSanitizers() const override; @@ -231,12 +236,6 @@ class LLVM_LIBRARY_VISIBILITY CudaToolChain : public NVPTXToolChain { const ToolChain &HostTC; -#ifdef ENABLE_CLASSIC_FLANG - void - AddFlangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, - llvm::opt::ArgStringList &Flang1Args) const override; -#endif - protected: Tool *buildAssembler() const override; // ptxas Tool *buildLinker() const override; // fatbinary (ok, not really a linker) diff --git a/clang/lib/Driver/ToolChains/Gnu.cpp b/clang/lib/Driver/ToolChains/Gnu.cpp index 47391c2175c0..11b15ce5a98e 100644 --- a/clang/lib/Driver/ToolChains/Gnu.cpp +++ b/clang/lib/Driver/ToolChains/Gnu.cpp @@ -548,6 +548,7 @@ void tools::gnutools::Linker::ConstructJob(Compilation &C, const JobAction &JA, // The profile runtime also needs access to system libraries. getToolChain().addProfileRTLibs(Args, CmdArgs); +#ifdef ENABLE_CLASSIC_FLANG // Add Fortran runtime libraries if (needFortranLibs(D, Args)) { ToolChain.AddFortranStdlibLibArgs(Args, CmdArgs); @@ -557,6 +558,7 @@ void tools::gnutools::Linker::ConstructJob(Compilation &C, const JobAction &JA, Arg->claim(); } } +#endif if (D.CCCIsCXX() && !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs, diff --git a/clang/lib/Driver/ToolChains/Linux.cpp b/clang/lib/Driver/ToolChains/Linux.cpp index 9d0a38acec83..b320b8249edb 100644 --- a/clang/lib/Driver/ToolChains/Linux.cpp +++ b/clang/lib/Driver/ToolChains/Linux.cpp @@ -632,6 +632,7 @@ std::string Linux::getDynamicLinker(const ArgList &Args) const { return "/" + LibDir + "/" + Loader; } +#ifdef ENABLE_CLASSIC_FLANG /// Convert path list to Fortran frontend argument static void AddFlangSysIncludeArg(const ArgList &DriverArgs, ArgStringList &Flang1Args, @@ -819,6 +820,7 @@ void Linux::AddFlangSystemIncludeArgs(const ArgList &DriverArgs, AddFlangSysIncludeArg(DriverArgs, Flang1Args, IncludePathList); } +#endif void Linux::AddClangSystemIncludeArgs(const ArgList &DriverArgs, ArgStringList &CC1Args) const { diff --git a/clang/lib/Driver/ToolChains/Linux.h b/clang/lib/Driver/ToolChains/Linux.h index a40eedad1c61..3d64e210a3c0 100644 --- a/clang/lib/Driver/ToolChains/Linux.h +++ b/clang/lib/Driver/ToolChains/Linux.h @@ -27,9 +27,11 @@ class LLVM_LIBRARY_VISIBILITY Linux : public Generic_ELF { const llvm::Triple &TargetTriple, StringRef SysRoot) const override; +#ifdef ENABLE_CLASSIC_FLANG void AddFlangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &Flang1Args) const override; +#endif void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override; From c08dc5ebc3b12f207a3d1cc5b202748a54224cde Mon Sep 17 00:00:00 2001 From: Alok Kumar Sharma <60725621+alokkrsharma@users.noreply.github.com> Date: Sun, 20 Sep 2020 17:21:34 +0530 Subject: [PATCH 03/60] Support for DWARF 4/5 and fix of issues related to -gdwarf-X options (#92) * Support for -gdwarf-5 option in Flang driver. Summary: FLANG driver doesnt pass -gdwarf-4/5 to flang1 in form of xbits, while it passes for -gdwarf-2/3 -gdwarf-2 => -x 120 0x200 -gdwarf-3 => -x 120 0x4000 Due to this -gdwarf-5 is never honored and default option -gdwarf-4 is taken. # flang -gdwarf-5 test.f90 # llvm-dwarfdump a.out | grep version 0x00000000: Compile Unit: length = 0x0000008e version = 0x0004 Now 0x1000000/0x2000000 will be passed for -gdwarf-4/5 -gdwarf-4 => -x 120 0x1000000 -gdwarf-5 => -x 120 0x2000000 Testing: - GNU gdb fortran testsuite - check-llvm - check-debuginfo * Flang doenst choose correct dwarf version when multiple -g/-gdwarfN mentioned Summary: When multiple -g/-gdwarfN options are passed together at compile time, flang chooses the least one. Clang/gfortran etc choose the last one. -gdwarf-5 -gdwarf-3 => flang chooses 5 while clang/gfortran choose 3 -gdwarf-5 -g => flang choses the default while clang/gfortran choose 5 Testing: - check-llvm - check-debuginfo * Default dwarf version should be 4 for -g with flang Currently flang dumps dwarf version 2 for -g and 4 for absence of -g ------------------------- $ flang my.f90 $ llvm-dwarfdump a.out | grep version 0x00000000: Compile Unit: length = 0x0000003d version = 0x0004 abbr_offset = 0x0000 addr_size = 0x08 (next unit at 0x00000041) $ flang -g my.f90 $ llvm-dwarfdump a.out | grep version 0x00000000: Compile Unit: length = 0x00000047 version = 0x0002 abbr_offset = 0x0000 addr_size = 0x08 (next unit at 0x0000004b) ------------------------- It should be 4 for -g as it is the case with clang. --- clang/lib/Driver/ToolChains/ClassicFlang.cpp | 42 +++++++++++--------- 1 file changed, 24 insertions(+), 18 deletions(-) diff --git a/clang/lib/Driver/ToolChains/ClassicFlang.cpp b/clang/lib/Driver/ToolChains/ClassicFlang.cpp index 47ba3668249a..5de494d5cd73 100644 --- a/clang/lib/Driver/ToolChains/ClassicFlang.cpp +++ b/clang/lib/Driver/ToolChains/ClassicFlang.cpp @@ -328,28 +328,34 @@ void ClassicFlang::ConstructJob(Compilation &C, const JobAction &JA, LowerCmdArgs.push_back("0x8"); } - // -g should produce DWARFv2 - for (auto Arg : Args.filtered(options::OPT_g_Flag)) { - Arg->claim(); - CommonCmdArgs.push_back("-x"); - CommonCmdArgs.push_back("120"); - CommonCmdArgs.push_back("0x200"); - } + // Last argument of -g/-gdwarfX should be taken. + Arg *GArg = Args.getLastArg(options::OPT_g_Flag); + Arg *GDwarfArg = Args.getLastArg(options::OPT_gdwarf_2, + options::OPT_gdwarf_3, + options::OPT_gdwarf_4, + options::OPT_gdwarf_5); + + if (GArg || GDwarfArg) { + + for (auto Arg : Args.filtered(options::OPT_g_Flag, options::OPT_gdwarf_2, + options::OPT_gdwarf_3, options::OPT_gdwarf_4, + options::OPT_gdwarf_5)) { + Arg->claim(); + } - // -gdwarf-2 - for (auto Arg : Args.filtered(options::OPT_gdwarf_2)) { - Arg->claim(); CommonCmdArgs.push_back("-x"); CommonCmdArgs.push_back("120"); - CommonCmdArgs.push_back("0x200"); - } - // -gdwarf-3 - for (auto Arg : Args.filtered(options::OPT_gdwarf_3)) { - Arg->claim(); - CommonCmdArgs.push_back("-x"); - CommonCmdArgs.push_back("120"); - CommonCmdArgs.push_back("0x4000"); + if (!GDwarfArg) // -g without -gdwarf-X produces default (DWARFv4) + CommonCmdArgs.push_back("0x1000000"); + else if (GDwarfArg->getOption().matches(options::OPT_gdwarf_2)) // -gdwarf-2 + CommonCmdArgs.push_back("0x200"); + else if (GDwarfArg->getOption().matches(options::OPT_gdwarf_3)) // -gdwarf-3 + CommonCmdArgs.push_back("0x4000"); + else if (GDwarfArg->getOption().matches(options::OPT_gdwarf_4)) // -gdwarf-4 + CommonCmdArgs.push_back("0x1000000"); + else if (GDwarfArg->getOption().matches(options::OPT_gdwarf_5)) // -gdwarf-5 + CommonCmdArgs.push_back("0x2000000"); } // -Mipa has no effect From 7f29058ba206b9b635fca216995eee5aabd47952 Mon Sep 17 00:00:00 2001 From: Bryan Chan Date: Mon, 12 Oct 2020 14:19:48 -0400 Subject: [PATCH 04/60] Reduce downstream delta This commit is motivated by reducing the merge burden by shrinking the diff between llvm upstream and classic-flang-llvm-project. Outside of Flang, Fortran code is fed through the Compile phase, and the appropriate tooling is picked up through ToolChain::SelectTool. Classic Flang introduced a FortranFrontend, but these days this seems unnecessary. Fortran can go through the same machinery as everything else. * Use the Preprocess phase to preprocess Fortran code. This phase is always combined with the Compile phase. * Use the Compile phase to lower Fortran code to LLVM IR, and use the Backend phase to compile and optimize the IR. These phases are never combined. * Remove FortranFrontendJobClass. * Remove FortranFrontend tool (instead it's just the Flang tool, which in Classic Flang mode is Classic Flang). * Update tests which inspect the output of the Classic Flang tooling, and ensures that the driver does the right thing for various types of inputs. Based on a patch from Peter Waller . --- clang/include/clang/Driver/Action.h | 11 ----- clang/include/clang/Driver/Phases.h | 1 - clang/include/clang/Driver/ToolChain.h | 2 - clang/include/clang/Driver/Types.def | 8 +-- clang/lib/Driver/Action.cpp | 7 --- clang/lib/Driver/Driver.cpp | 49 ++++++++----------- clang/lib/Driver/Phases.cpp | 1 - clang/lib/Driver/ToolChain.cpp | 21 ++------ clang/lib/Driver/ToolChains/ClassicFlang.h | 2 +- .../flang/classic-flang-must-preprocess.F | 12 +++++ .../flang/classic-flang-must-preprocess.F95 | 12 +++++ clang/test/Driver/flang/classic-flang.f | 26 ++++++++++ clang/test/Driver/flang/classic-flang.f95 | 43 ++++++++++++++++ clang/test/Driver/flang/classic_flang.f95 | 28 ----------- clang/test/Driver/lit.local.cfg | 3 ++ 15 files changed, 125 insertions(+), 101 deletions(-) create mode 100644 clang/test/Driver/flang/classic-flang-must-preprocess.F create mode 100644 clang/test/Driver/flang/classic-flang-must-preprocess.F95 create mode 100644 clang/test/Driver/flang/classic-flang.f create mode 100644 clang/test/Driver/flang/classic-flang.f95 delete mode 100644 clang/test/Driver/flang/classic_flang.f95 diff --git a/clang/include/clang/Driver/Action.h b/clang/include/clang/Driver/Action.h index 6c9481f7cf59..feeabae89d6b 100644 --- a/clang/include/clang/Driver/Action.h +++ b/clang/include/clang/Driver/Action.h @@ -62,7 +62,6 @@ class Action { AnalyzeJobClass, MigrateJobClass, CompileJobClass, - FortranFrontendJobClass, BackendJobClass, AssembleJobClass, LinkJobClass, @@ -472,16 +471,6 @@ class MigrateJobAction : public JobAction { } }; -class FortranFrontendJobAction : public JobAction { - void anchor() override; -public: - FortranFrontendJobAction(Action *Input, types::ID OutputType); - - static bool classof(const Action *A) { - return A->getKind() == FortranFrontendJobClass; - } -}; - class CompileJobAction : public JobAction { void anchor() override; diff --git a/clang/include/clang/Driver/Phases.h b/clang/include/clang/Driver/Phases.h index f8cac9548d02..9003c5857351 100644 --- a/clang/include/clang/Driver/Phases.h +++ b/clang/include/clang/Driver/Phases.h @@ -17,7 +17,6 @@ namespace phases { enum ID { Preprocess, Precompile, - FortranFrontend, Compile, Backend, Assemble, diff --git a/clang/include/clang/Driver/ToolChain.h b/clang/include/clang/Driver/ToolChain.h index 02ce2c628d8a..f9586e013d02 100644 --- a/clang/include/clang/Driver/ToolChain.h +++ b/clang/include/clang/Driver/ToolChain.h @@ -159,7 +159,6 @@ class ToolChain { mutable std::unique_ptr Clang; mutable std::unique_ptr Flang; - mutable std::unique_ptr FortranFrontend; mutable std::unique_ptr Assemble; mutable std::unique_ptr Link; mutable std::unique_ptr StaticLibTool; @@ -170,7 +169,6 @@ class ToolChain { Tool *getClang() const; Tool *getFlang() const; - Tool *getFortranFrontend() const; Tool *getAssemble() const; Tool *getLink() const; Tool *getStaticLibTool() const; diff --git a/clang/include/clang/Driver/Types.def b/clang/include/clang/Driver/Types.def index d2b763a8fd5b..bd3aa208678a 100644 --- a/clang/include/clang/Driver/Types.def +++ b/clang/include/clang/Driver/Types.def @@ -89,10 +89,10 @@ TYPE("assembler-with-cpp", Asm, PP_Asm, "S", phases // `PP_TYPE` is set to `PP_Fortran` so that the driver is fine with // "pre-processing a pre-processed file". #ifdef ENABLE_CLASSIC_FLANG -TYPE("f77", PP_F_FixedForm, INVALID, "f", phases::FortranFrontend, phases::Backend, phases::Assemble, phases::Link) -TYPE("f77-cpp-input", F_FixedForm, PP_F_FixedForm, "F", phases::FortranFrontend, phases::Backend, phases::Assemble, phases::Link) -TYPE("f95", PP_F_FreeForm, INVALID, "f95", phases::FortranFrontend, phases::Backend, phases::Assemble, phases::Link) -TYPE("f95-cpp-input", F_FreeForm, PP_F_FreeForm, "F95", phases::FortranFrontend, phases::Backend, phases::Assemble, phases::Link) +TYPE("f77", PP_F_FixedForm, INVALID, "f", phases::Compile, phases::Backend, phases::Assemble, phases::Link) +TYPE("f77-cpp-input", F_FixedForm, PP_F_FixedForm, "F", phases::Preprocess, phases::Compile, phases::Backend, phases::Assemble, phases::Link) +TYPE("f95", PP_F_FreeForm, INVALID, "f95", phases::Compile, phases::Backend, phases::Assemble, phases::Link) +TYPE("f95-cpp-input", F_FreeForm, PP_F_FreeForm, "F95", phases::Preprocess, phases::Compile, phases::Backend, phases::Assemble, phases::Link) #else TYPE("f95", PP_Fortran, PP_Fortran, "i", phases::Preprocess, phases::Compile, phases::Backend, phases::Assemble, phases::Link) TYPE("f95-cpp-input", Fortran, PP_Fortran, nullptr, phases::Preprocess, phases::Compile, phases::Backend, phases::Assemble, phases::Link) diff --git a/clang/lib/Driver/Action.cpp b/clang/lib/Driver/Action.cpp index d16aec2d0f85..23dbcebc9a1c 100644 --- a/clang/lib/Driver/Action.cpp +++ b/clang/lib/Driver/Action.cpp @@ -29,7 +29,6 @@ const char *Action::getClassName(ActionClass AC) { return "api-extractor"; case AnalyzeJobClass: return "analyzer"; case MigrateJobClass: return "migrator"; - case FortranFrontendJobClass: return "fortran-frontend"; case CompileJobClass: return "compiler"; case BackendJobClass: return "backend"; case AssembleJobClass: return "assembler"; @@ -379,12 +378,6 @@ void MigrateJobAction::anchor() {} MigrateJobAction::MigrateJobAction(Action *Input, types::ID OutputType) : JobAction(MigrateJobClass, Input, OutputType) {} -void FortranFrontendJobAction::anchor() {} - -FortranFrontendJobAction::FortranFrontendJobAction(Action *Input, - types::ID OutputType) - : JobAction(FortranFrontendJobClass, Input, OutputType) {} - void CompileJobAction::anchor() {} CompileJobAction::CompileJobAction(Action *Input, types::ID OutputType) diff --git a/clang/lib/Driver/Driver.cpp b/clang/lib/Driver/Driver.cpp index 7f3939691219..7a13e19da020 100644 --- a/clang/lib/Driver/Driver.cpp +++ b/clang/lib/Driver/Driver.cpp @@ -396,27 +396,15 @@ phases::ID Driver::getFinalPhase(const DerivedArgList &DAL, // -{E,EP,P,M,MM} only run the preprocessor. if (CCCIsCPP() || (PhaseArg = DAL.getLastArg(options::OPT_E)) || -#ifdef ENABLE_CLASSIC_FLANG - (PhaseArg = DAL.getLastArg(options::OPT_fsyntax_only)) || -#endif (PhaseArg = DAL.getLastArg(options::OPT__SLASH_EP)) || (PhaseArg = DAL.getLastArg(options::OPT_M, options::OPT_MM)) || (PhaseArg = DAL.getLastArg(options::OPT__SLASH_P)) || CCGenDiagnostics) { #ifdef ENABLE_CLASSIC_FLANG - // -fsyntax-only or -E stops Fortran compilation after FortranFrontend - if (IsFlangMode() && (DAL.getLastArg(options::OPT_E) || - DAL.getLastArg(options::OPT_fsyntax_only))) { - FinalPhase = phases::FortranFrontend; - - // if not Fortran, fsyntax_only implies 'Compile' is the FinalPhase - } else if (DAL.getLastArg(options::OPT_fsyntax_only)) { + if (IsFlangMode()) FinalPhase = phases::Compile; - - // everything else has 'Preprocess' as its FinalPhase - } else { + else FinalPhase = phases::Preprocess; - } #else FinalPhase = phases::Preprocess; #endif @@ -430,14 +418,9 @@ phases::ID Driver::getFinalPhase(const DerivedArgList &DAL, options::OPT_fmodule_header_EQ))) { FinalPhase = phases::Precompile; -#ifdef ENABLE_CLASSIC_FLANG - // -{analyze,emit-ast} only run up to the compiler. - } else if ((PhaseArg = DAL.getLastArg(options::OPT_print_supported_cpus)) || -#else // -{fsyntax-only,-analyze,emit-ast} only run up to the compiler. } else if ((PhaseArg = DAL.getLastArg(options::OPT_fsyntax_only)) || (PhaseArg = DAL.getLastArg(options::OPT_print_supported_cpus)) || -#endif (PhaseArg = DAL.getLastArg(options::OPT_print_enabled_extensions)) || (PhaseArg = DAL.getLastArg(options::OPT_module_file_info)) || (PhaseArg = DAL.getLastArg(options::OPT_verify_pch)) || @@ -4288,10 +4271,13 @@ void Driver::handleArguments(Compilation &C, DerivedArgList &Args, if (InputArg->isClaimed()) continue; - // Fortran input is preprocessed using the frontend. - if (InitialPhase == phases::FortranFrontend && +#ifdef ENABLE_CLASSIC_FLANG + // If the input is detected as already preprocessed (e.g. has the .f95 + // extension), and the user specifies -E, preprocess the file anyway. + if (IsFlangMode() && InitialPhase == phases::Compile && FinalPhase == phases::Preprocess) continue; +#endif // Claim here to avoid the more general unused warning. InputArg->claim(); @@ -5102,13 +5088,6 @@ Action *Driver::ConstructPhaseAction( return C.MakeAction(Input, OutputTy); } - case phases::FortranFrontend: { - if (Args.hasArg(options::OPT_fsyntax_only)) - return C.MakeAction(Input, - types::TY_Nothing); - return C.MakeAction(Input, - types::TY_LLVM_IR); - } case phases::Compile: { if (Args.hasArg(options::OPT_fsyntax_only)) return C.MakeAction(Input, types::TY_Nothing); @@ -5131,6 +5110,10 @@ Action *Driver::ConstructPhaseAction( return C.MakeAction(Input, types::TY_Nothing); if (Args.hasArg(options::OPT_extract_api)) return C.MakeAction(Input, types::TY_API_INFO); +#ifdef ENABLE_CLASSIC_FLANG + if (IsFlangMode()) + return C.MakeAction(Input, types::TY_LLVM_IR); +#endif return C.MakeAction(Input, types::TY_LLVM_BC); } case phases::Backend: { @@ -5598,6 +5581,10 @@ class ToolSelector final { if (!T->hasIntegratedBackend() && !(OutputIsLLVM && T->canEmitIR())) return nullptr; + // Classic Flang is not integrated with the backend. + if (C.getDriver().IsFlangMode() && !T->hasIntegratedAssembler()) + return nullptr; + if (T->canEmitIR() && ((SaveTemps && !InputIsBitcode) || EmbedBitcode)) return nullptr; @@ -6897,7 +6884,11 @@ bool Driver::ShouldUseFlangCompiler(const JobAction &JA) const { // And say "no" if this is not a kind of action flang understands. if (!isa(JA) && !isa(JA) && - !isa(JA) && !isa(JA)) + !isa(JA) +#ifndef ENABLE_CLASSIC_FLANG + && !isa(JA) +#endif + ) return false; return true; diff --git a/clang/lib/Driver/Phases.cpp b/clang/lib/Driver/Phases.cpp index f0216c5ab7c2..01598c59bd9e 100644 --- a/clang/lib/Driver/Phases.cpp +++ b/clang/lib/Driver/Phases.cpp @@ -16,7 +16,6 @@ const char *phases::getPhaseName(ID Id) { switch (Id) { case Preprocess: return "preprocessor"; case Precompile: return "precompiler"; - case FortranFrontend: return "fortran-frontend"; case Compile: return "compiler"; case Backend: return "backend"; case Assemble: return "assembler"; diff --git a/clang/lib/Driver/ToolChain.cpp b/clang/lib/Driver/ToolChain.cpp index d6cb5946bb45..f982f75776cc 100644 --- a/clang/lib/Driver/ToolChain.cpp +++ b/clang/lib/Driver/ToolChain.cpp @@ -556,13 +556,13 @@ Tool *ToolChain::getClang() const { } Tool *ToolChain::getFlang() const { -#ifndef ENABLE_CLASSIC_FLANG if (!Flang) - Flang.reset(new tools::Flang(*this)); - return Flang.get(); +#ifdef ENABLE_CLASSIC_FLANG + Flang.reset(new tools::ClassicFlang(*this)); #else - llvm_unreachable("Flang is not supported by this toolchain"); + Flang.reset(new tools::Flang(*this)); #endif + return Flang.get(); } Tool *ToolChain::buildAssembler() const { @@ -583,16 +583,6 @@ Tool *ToolChain::getAssemble() const { return Assemble.get(); } -Tool *ToolChain::getFortranFrontend() const { -#ifdef ENABLE_CLASSIC_FLANG - if (!FortranFrontend) - FortranFrontend.reset(new tools::ClassicFlang(*this)); - return FortranFrontend.get(); -#else - llvm_unreachable("Fortran is not supported by this toolchain"); -#endif -} - Tool *ToolChain::getClangAs() const { if (!Assemble) Assemble.reset(new tools::ClangAs(*this)); @@ -676,9 +666,6 @@ Tool *ToolChain::getTool(Action::ActionClass AC) const { return getOffloadPackager(); case Action::LinkerWrapperJobClass: return getLinkerWrapper(); - - case Action::FortranFrontendJobClass: - return getFortranFrontend(); } llvm_unreachable("Invalid tool kind."); diff --git a/clang/lib/Driver/ToolChains/ClassicFlang.h b/clang/lib/Driver/ToolChains/ClassicFlang.h index 23ea1fe6b95d..5af119c2f79e 100644 --- a/clang/lib/Driver/ToolChains/ClassicFlang.h +++ b/clang/lib/Driver/ToolChains/ClassicFlang.h @@ -33,7 +33,7 @@ class LLVM_LIBRARY_VISIBILITY ClassicFlang : public Tool { bool hasGoodDiagnostics() const override { return true; } bool hasIntegratedAssembler() const override { return false; } - bool hasIntegratedCPP() const override { return false; } + bool hasIntegratedCPP() const override { return true; } void ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, const InputInfoList &Inputs, diff --git a/clang/test/Driver/flang/classic-flang-must-preprocess.F b/clang/test/Driver/flang/classic-flang-must-preprocess.F new file mode 100644 index 000000000000..d52c1cf8d3c0 --- /dev/null +++ b/clang/test/Driver/flang/classic-flang-must-preprocess.F @@ -0,0 +1,12 @@ +! REQUIRES: classic_flang + +! Check that the driver invokes flang1 correctly for fixed-form Fortran code +! which requires preprocessing. + +! RUN: %clang --driver-mode=flang -target x86_64-unknown-linux-gnu -c %s -### 2>&1 \ +! RUN: | FileCheck %s +! CHECK: "flang1" +! CHECK-SAME: "-preprocess" +! CHECK-SAME: "-nofreeform" +! CHECK-NEXT: "flang2" +! CHECK-NEXT: {{clang.* "-cc1"}} diff --git a/clang/test/Driver/flang/classic-flang-must-preprocess.F95 b/clang/test/Driver/flang/classic-flang-must-preprocess.F95 new file mode 100644 index 000000000000..7d452a535784 --- /dev/null +++ b/clang/test/Driver/flang/classic-flang-must-preprocess.F95 @@ -0,0 +1,12 @@ +! REQUIRES: classic_flang + +! Check that the driver invokes flang1 correctly for free-form Fortran code +! which requires preprocessing. + +! RUN: %clang --driver-mode=flang -target x86_64-unknown-linux-gnu -c %s -### 2>&1 \ +! RUN: | FileCheck %s +! CHECK: "flang1" +! CHECK-SAME: "-preprocess" +! CHECK-SAME: "-freeform" +! CHECK-NEXT: "flang2" +! CHECK-NEXT: {{clang.* "-cc1"}} diff --git a/clang/test/Driver/flang/classic-flang.f b/clang/test/Driver/flang/classic-flang.f new file mode 100644 index 000000000000..98f74d9626d7 --- /dev/null +++ b/clang/test/Driver/flang/classic-flang.f @@ -0,0 +1,26 @@ +! REQUIRES: classic_flang + +! Check that the driver invokes flang1 correctly for preprocessed fixed-form +! Fortran code. + +! RUN: %clang --driver-mode=flang -target x86_64-unknown-linux-gnu -c %s -### 2>&1 \ +! RUN: | FileCheck %s +! CHECK: "flang1" +! CHECK-NOT: "-preprocess" +! CHECK-SAME: "-nofreeform" +! CHECK-NEXT: "flang2" +! CHECK-NEXT: {{clang.* "-cc1"}} + +! Check that the driver invokes flang1 correctly when preprocessing is +! explicitly requested. + +! RUN: %clang --driver-mode=flang -target x86_64-unknown-linux-gnu -E %s -### 2>&1 \ +! RUN: | FileCheck --check-prefix=CHECK-PREPROCESS %s +! CHECK-PREPROCESS: "flang1" +! CHECK-PREPROCESS-SAME: "-preprocess" +! CHECK-PREPROCESS-SAME: "-es" +! CHECK-PREPROCESS-SAME: "-pp" +! CHECK-PREPROCESS-NOT: "flang1" +! CHECK-PREPROCESS-NOT: "flang2" +! CHECK-PREPROCESS-NOT: {{clang.* "-cc1"}} +! CHECK-PREPROCESS-NOT: {{clang.* "-cc1as"}} diff --git a/clang/test/Driver/flang/classic-flang.f95 b/clang/test/Driver/flang/classic-flang.f95 new file mode 100644 index 000000000000..0b92c799392a --- /dev/null +++ b/clang/test/Driver/flang/classic-flang.f95 @@ -0,0 +1,43 @@ +! REQUIRES: classic_flang + +! Check that the driver invokes flang1 correctly for preprocessed free-form +! Fortran code. Also check that the backend is invoked correctly. + +! RUN: %clang --driver-mode=flang -target x86_64-unknown-linux-gnu -c %s -### 2>&1 \ +! RUN: | FileCheck --check-prefix=CHECK-OBJECT %s +! CHECK-OBJECT: "flang1" +! CHECK-OBJECT-NOT: "-preprocess" +! CHECK-OBJECT-SAME: "-freeform" +! CHECK-OBJECT-NEXT: "flang2" +! CHECK-OBJECT-SAME: "-asm" [[LLFILE:.*.ll]] +! CHECK-OBJECT-NEXT: {{clang.* "-cc1"}} +! CHECK-OBJECT-SAME: "-o" "classic-flang.o" +! CHECK-OBJECT-SAME: "-x" "ir" +! CHECK-OBJECT-SAME: [[LLFILE]] + +! Check that the driver invokes flang1 correctly when preprocessing is +! explicitly requested. + +! RUN: %clang --driver-mode=flang -target x86_64-unknown-linux-gnu -E %s -### 2>&1 \ +! RUN: | FileCheck --check-prefix=CHECK-PREPROCESS %s +! CHECK-PREPROCESS: "flang1" +! CHECK-PREPROCESS-SAME: "-preprocess" +! CHECK-PREPROCESS-SAME: "-es" +! CHECK-PREPROCESS-SAME: "-pp" +! CHECK-PREPROCESS-NOT: "flang1" +! CHECK-PREPROCESS-NOT: "flang2" +! CHECK-PREPROCESS-NOT: {{clang.* "-cc1"}} +! CHECK-PREPROCESS-NOT: {{clang.* "-cc1as"}} + +! Check that the backend job (clang -cc1) is not combined into the compile job +! (flang2) even if -integrated-as is specified. + +! RUN: %clang --driver-mode=flang -target x86_64-unknown-linux-gnu -integrated-as -S %s -### 2>&1 \ +! RUN: | FileCheck --check-prefix=CHECK-ASM %s +! CHECK-ASM: "flang1" +! CHECK-ASM-NEXT: "flang2" +! CHECK-ASM-SAME: "-asm" [[LLFILE:.*.ll]] +! CHECK-ASM-NEXT: {{clang.* "-cc1"}} +! CHECK-ASM-SAME: "-o" "classic-flang.s" +! CHECK-ASM-SAME: "-x" "ir" +! CHECK-ASM-SAME: [[LLFILE]] diff --git a/clang/test/Driver/flang/classic_flang.f95 b/clang/test/Driver/flang/classic_flang.f95 deleted file mode 100644 index 5d3098786905..000000000000 --- a/clang/test/Driver/flang/classic_flang.f95 +++ /dev/null @@ -1,28 +0,0 @@ -! Check that the driver can invoke flang1 and flang2 to compile Fortran with -! --driver-mode=flang (default when the file extension is .f95). - -! REQUIRES: classic_flang - -! RUN: %clang -target x86_64-unknown-linux-gnu -integrated-as -c %s -### 2>&1 \ -! RUN: | FileCheck --check-prefix=CHECK-OBJECT %s -! CHECK-OBJECT: flang1 -! CHECK-OBJECT: flang2 -! CHECK-OBJECT-SAME: "-asm" [[LLFILE:.*.ll]] -! CHECK-OBJECT-NOT: cc1as -! CHECK-OBJECT: clang -! CHECK-OBJECT-SAME: -cc1 -! CHECK-OBJECT-SAME: "-o" "classic_flang.o" -! CHECK-OBJECT-SAME: "-x" "ir" -! CHECK-OBJECT-SAME: [[LLFILE]] - -! RUN: %clang -target x86_64-unknown-linux-gnu -integrated-as -S %s -### 2>&1 \ -! RUN: | FileCheck --check-prefix=CHECK-ASM %s -! CHECK-ASM: flang1 -! CHECK-ASM: flang2 -! CHECK-ASM-SAME: "-asm" [[LLFILE:.*.ll]] -! CHECK-ASM-NOT: cc1as -! CHECK-ASM: clang -! CHECK-ASM-SAME: -cc1 -! CHECK-ASM-SAME: "-o" "classic_flang.s" -! CHECK-ASM-SAME: "-x" "ir" -! CHECK-ASM-SAME: [[LLFILE]] diff --git a/clang/test/Driver/lit.local.cfg b/clang/test/Driver/lit.local.cfg index 6370e9f92d89..5ec1f9a8fc71 100644 --- a/clang/test/Driver/lit.local.cfg +++ b/clang/test/Driver/lit.local.cfg @@ -12,6 +12,9 @@ config.suffixes = [ ".f90", ".F90", ".f95", + '.F95', + '.f', + '.F', ".cu", ".rs", ".cl", From ac06000cccbfbe330efef390ff3edeb4f854f757 Mon Sep 17 00:00:00 2001 From: michalpasztamobica Date: Wed, 17 Mar 2021 20:27:04 +0100 Subject: [PATCH 05/60] Allow full path to flang1 and flang2 in classic flang tests. --- .../Driver/flang/classic-flang-must-preprocess.F | 4 ++-- .../Driver/flang/classic-flang-must-preprocess.F95 | 4 ++-- clang/test/Driver/flang/classic-flang.f | 10 +++++----- clang/test/Driver/flang/classic-flang.f95 | 14 +++++++------- 4 files changed, 16 insertions(+), 16 deletions(-) diff --git a/clang/test/Driver/flang/classic-flang-must-preprocess.F b/clang/test/Driver/flang/classic-flang-must-preprocess.F index d52c1cf8d3c0..cf2e4207a4a0 100644 --- a/clang/test/Driver/flang/classic-flang-must-preprocess.F +++ b/clang/test/Driver/flang/classic-flang-must-preprocess.F @@ -5,8 +5,8 @@ ! RUN: %clang --driver-mode=flang -target x86_64-unknown-linux-gnu -c %s -### 2>&1 \ ! RUN: | FileCheck %s -! CHECK: "flang1" +! CHECK: "{{.*}}flang1" ! CHECK-SAME: "-preprocess" ! CHECK-SAME: "-nofreeform" -! CHECK-NEXT: "flang2" +! CHECK-NEXT: "{{.*}}flang2" ! CHECK-NEXT: {{clang.* "-cc1"}} diff --git a/clang/test/Driver/flang/classic-flang-must-preprocess.F95 b/clang/test/Driver/flang/classic-flang-must-preprocess.F95 index 7d452a535784..85ec49fe3fab 100644 --- a/clang/test/Driver/flang/classic-flang-must-preprocess.F95 +++ b/clang/test/Driver/flang/classic-flang-must-preprocess.F95 @@ -5,8 +5,8 @@ ! RUN: %clang --driver-mode=flang -target x86_64-unknown-linux-gnu -c %s -### 2>&1 \ ! RUN: | FileCheck %s -! CHECK: "flang1" +! CHECK: "{{.*}}flang1" ! CHECK-SAME: "-preprocess" ! CHECK-SAME: "-freeform" -! CHECK-NEXT: "flang2" +! CHECK-NEXT: "{{.*}}flang2" ! CHECK-NEXT: {{clang.* "-cc1"}} diff --git a/clang/test/Driver/flang/classic-flang.f b/clang/test/Driver/flang/classic-flang.f index 98f74d9626d7..c680abc076ae 100644 --- a/clang/test/Driver/flang/classic-flang.f +++ b/clang/test/Driver/flang/classic-flang.f @@ -5,10 +5,10 @@ ! RUN: %clang --driver-mode=flang -target x86_64-unknown-linux-gnu -c %s -### 2>&1 \ ! RUN: | FileCheck %s -! CHECK: "flang1" +! CHECK: "{{.*}}flang1" ! CHECK-NOT: "-preprocess" ! CHECK-SAME: "-nofreeform" -! CHECK-NEXT: "flang2" +! CHECK-NEXT: "{{.*}}flang2" ! CHECK-NEXT: {{clang.* "-cc1"}} ! Check that the driver invokes flang1 correctly when preprocessing is @@ -16,11 +16,11 @@ ! RUN: %clang --driver-mode=flang -target x86_64-unknown-linux-gnu -E %s -### 2>&1 \ ! RUN: | FileCheck --check-prefix=CHECK-PREPROCESS %s -! CHECK-PREPROCESS: "flang1" +! CHECK-PREPROCESS: "{{.*}}flang1" ! CHECK-PREPROCESS-SAME: "-preprocess" ! CHECK-PREPROCESS-SAME: "-es" ! CHECK-PREPROCESS-SAME: "-pp" -! CHECK-PREPROCESS-NOT: "flang1" -! CHECK-PREPROCESS-NOT: "flang2" +! CHECK-PREPROCESS-NOT: "{{.*}}flang1" +! CHECK-PREPROCESS-NOT: "{{.*}}flang2" ! CHECK-PREPROCESS-NOT: {{clang.* "-cc1"}} ! CHECK-PREPROCESS-NOT: {{clang.* "-cc1as"}} diff --git a/clang/test/Driver/flang/classic-flang.f95 b/clang/test/Driver/flang/classic-flang.f95 index 0b92c799392a..6fce9c61713c 100644 --- a/clang/test/Driver/flang/classic-flang.f95 +++ b/clang/test/Driver/flang/classic-flang.f95 @@ -5,10 +5,10 @@ ! RUN: %clang --driver-mode=flang -target x86_64-unknown-linux-gnu -c %s -### 2>&1 \ ! RUN: | FileCheck --check-prefix=CHECK-OBJECT %s -! CHECK-OBJECT: "flang1" +! CHECK-OBJECT: "{{.*}}flang1" ! CHECK-OBJECT-NOT: "-preprocess" ! CHECK-OBJECT-SAME: "-freeform" -! CHECK-OBJECT-NEXT: "flang2" +! CHECK-OBJECT-NEXT: "{{.*}}flang2" ! CHECK-OBJECT-SAME: "-asm" [[LLFILE:.*.ll]] ! CHECK-OBJECT-NEXT: {{clang.* "-cc1"}} ! CHECK-OBJECT-SAME: "-o" "classic-flang.o" @@ -20,12 +20,12 @@ ! RUN: %clang --driver-mode=flang -target x86_64-unknown-linux-gnu -E %s -### 2>&1 \ ! RUN: | FileCheck --check-prefix=CHECK-PREPROCESS %s -! CHECK-PREPROCESS: "flang1" +! CHECK-PREPROCESS: "{{.*}}flang1" ! CHECK-PREPROCESS-SAME: "-preprocess" ! CHECK-PREPROCESS-SAME: "-es" ! CHECK-PREPROCESS-SAME: "-pp" -! CHECK-PREPROCESS-NOT: "flang1" -! CHECK-PREPROCESS-NOT: "flang2" +! CHECK-PREPROCESS-NOT: "{{.*}}flang1" +! CHECK-PREPROCESS-NOT: "{{.*}}flang2" ! CHECK-PREPROCESS-NOT: {{clang.* "-cc1"}} ! CHECK-PREPROCESS-NOT: {{clang.* "-cc1as"}} @@ -34,8 +34,8 @@ ! RUN: %clang --driver-mode=flang -target x86_64-unknown-linux-gnu -integrated-as -S %s -### 2>&1 \ ! RUN: | FileCheck --check-prefix=CHECK-ASM %s -! CHECK-ASM: "flang1" -! CHECK-ASM-NEXT: "flang2" +! CHECK-ASM: "{{.*}}flang1" +! CHECK-ASM-NEXT: "{{.*}}flang2" ! CHECK-ASM-SAME: "-asm" [[LLFILE:.*.ll]] ! CHECK-ASM-NEXT: {{clang.* "-cc1"}} ! CHECK-ASM-SAME: "-o" "classic-flang.s" From ddc44047ec3d9148640a5bfbd824e8ce38cc5798 Mon Sep 17 00:00:00 2001 From: Sourabh Singh Tomar Date: Fri, 16 Apr 2021 12:29:12 +0530 Subject: [PATCH 06/60] [DebugInfo] Support of `-gpubnames` in Driver --- clang/lib/Driver/ToolChains/ClassicFlang.cpp | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/clang/lib/Driver/ToolChains/ClassicFlang.cpp b/clang/lib/Driver/ToolChains/ClassicFlang.cpp index 5de494d5cd73..c13938074cf2 100644 --- a/clang/lib/Driver/ToolChains/ClassicFlang.cpp +++ b/clang/lib/Driver/ToolChains/ClassicFlang.cpp @@ -356,6 +356,13 @@ void ClassicFlang::ConstructJob(Compilation &C, const JobAction &JA, CommonCmdArgs.push_back("0x1000000"); else if (GDwarfArg->getOption().matches(options::OPT_gdwarf_5)) // -gdwarf-5 CommonCmdArgs.push_back("0x2000000"); + // Handle `-gpubnames` option separately. + for (auto Arg : Args.filtered(options::OPT_gpubnames)) { + Arg->claim(); + CommonCmdArgs.push_back("-x"); + CommonCmdArgs.push_back("120"); + CommonCmdArgs.push_back("0x40000000"); // -gpubnames + } } // -Mipa has no effect From 59567032332a24df17a9b122336ad301c2b4e2d2 Mon Sep 17 00:00:00 2001 From: Isuru Fernando Date: Fri, 6 Aug 2021 05:10:31 -0700 Subject: [PATCH 07/60] [Driver] Support macOS --- clang/lib/Driver/ToolChain.cpp | 4 +++- clang/lib/Driver/ToolChains/Darwin.cpp | 12 ++++++++++++ clang/lib/Driver/ToolChains/Gnu.cpp | 2 +- 3 files changed, 16 insertions(+), 2 deletions(-) diff --git a/clang/lib/Driver/ToolChain.cpp b/clang/lib/Driver/ToolChain.cpp index f982f75776cc..743a7b139b88 100644 --- a/clang/lib/Driver/ToolChain.cpp +++ b/clang/lib/Driver/ToolChain.cpp @@ -1454,7 +1454,9 @@ void ToolChain::AddFortranStdlibLibArgs(const ArgList &Args, CmdArgs.push_back("-Bdynamic"); CmdArgs.push_back("-lm"); - CmdArgs.push_back("-lrt"); + + if (!Triple.isOSDarwin()) + CmdArgs.push_back("-lrt"); // Allways link Fortran executables with Pthreads CmdArgs.push_back("-lpthread"); diff --git a/clang/lib/Driver/ToolChains/Darwin.cpp b/clang/lib/Driver/ToolChains/Darwin.cpp index 55c55bad7393..dabc8c0fe785 100644 --- a/clang/lib/Driver/ToolChains/Darwin.cpp +++ b/clang/lib/Driver/ToolChains/Darwin.cpp @@ -759,6 +759,18 @@ void darwin::Linker::ConstructJob(Compilation &C, const JobAction &JA, if (getToolChain().ShouldLinkCXXStdlib(Args)) getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs); +#ifdef ENABLE_CLASSIC_FLANG + // Add Fortran runtime libraries + if (needFortranLibs(getToolChain().getDriver(), Args)) { + getToolChain().AddFortranStdlibLibArgs(Args, CmdArgs); + } else { + // Claim "no Flang libraries" arguments if any + for (auto Arg : Args.filtered(options::OPT_noFlangLibs)) { + Arg->claim(); + } + } +#endif + bool NoStdOrDefaultLibs = Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs); bool ForceLinkBuiltins = Args.hasArg(options::OPT_fapple_link_rtlib); diff --git a/clang/lib/Driver/ToolChains/Gnu.cpp b/clang/lib/Driver/ToolChains/Gnu.cpp index 11b15ce5a98e..ee057508e84b 100644 --- a/clang/lib/Driver/ToolChains/Gnu.cpp +++ b/clang/lib/Driver/ToolChains/Gnu.cpp @@ -553,7 +553,7 @@ void tools::gnutools::Linker::ConstructJob(Compilation &C, const JobAction &JA, if (needFortranLibs(D, Args)) { ToolChain.AddFortranStdlibLibArgs(Args, CmdArgs); } else { - // Claim "no Flang libraries" arguments if any + // Claim "no Flang libraries" arguments if any for (auto Arg : Args.filtered(options::OPT_noFlangLibs)) { Arg->claim(); } From d8ed7671c1af9e403672b5e2eb2a60ed2b6441c4 Mon Sep 17 00:00:00 2001 From: Itay Bookstein Date: Wed, 22 Sep 2021 16:56:52 +0300 Subject: [PATCH 08/60] [DebugInfo]: Remove dangerous dead function (-Wreturn-stack-address) Signed-off-by: Itay Bookstein --- llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h | 8 -------- llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp | 6 ------ 2 files changed, 14 deletions(-) diff --git a/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h b/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h index 86040db75c97..104039db03c7 100644 --- a/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h +++ b/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h @@ -178,14 +178,6 @@ class DwarfCompileUnit final : public DwarfUnit { std::vector ExprRefedBaseTypes; -private: - DenseMap> *globalVarMap; -public: - void setGlobalVarMap( - DenseMap> *p = nullptr) { - globalVarMap = p; - } - /// Get or create global variable DIE. DIE * getOrCreateGlobalVariableDIE(const DIGlobalVariable *GV, diff --git a/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp b/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp index cb8ac307c181..2b70820e2923 100644 --- a/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp +++ b/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp @@ -1209,17 +1209,11 @@ void DwarfDebug::beginModule(Module *M) { } DenseSet Processed; -#if 0 - CU.setGlobalVarMap(&GVMap); -#endif for (auto *GVE : CUNode->getGlobalVariables()) { DIGlobalVariable *GV = GVE->getVariable(); if (Processed.insert(GV).second) CU.getOrCreateGlobalVariableDIE(GV, sortGlobalExprs(GVMap[GV])); } -#if 0 - CU.setGlobalVarMap(); -#endif for (auto *Ty : CUNode->getEnumTypes()) CU.getOrCreateTypeDIE(cast(Ty)); From 284775b33cc62a191f03013a484885c2ccd04e94 Mon Sep 17 00:00:00 2001 From: Richard Barton Date: Wed, 26 Jan 2022 17:30:32 +0000 Subject: [PATCH 09/60] [driver] Add -emit-flang-llvm option -emit-flang-llvm instructs flang to stop after flang2 and dump the LLVM IR. Can be useful for debugging and also would be a useful option for testing flang output more accurately. Signed-off-by: Richard Barton --- clang/include/clang/Driver/Options.td | 4 ++++ clang/lib/Driver/Driver.cpp | 3 +++ clang/lib/Driver/ToolChains/ClassicFlang.cpp | 7 +++++++ 3 files changed, 14 insertions(+) diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td index dfe37883a7a1..d90313f7df07 100644 --- a/clang/include/clang/Driver/Options.td +++ b/clang/include/clang/Driver/Options.td @@ -1545,6 +1545,10 @@ def d_Joined : Joined<["-"], "d">, Group; def emit_ast : Flag<["-"], "emit-ast">, Visibility<[ClangOption, CLOption, DXCOption]>, HelpText<"Emit Clang AST files for source inputs">; +#ifdef ENABLE_CLASSIC_FLANG +def emit_flang_llvm : Flag<["-"], "emit-flang-llvm">, + HelpText<"Emit Flang LLVM files for source inputs">; +#endif def emit_llvm : Flag<["-"], "emit-llvm">, Visibility<[ClangOption, CC1Option, FC1Option, FlangOption]>, Group, diff --git a/clang/lib/Driver/Driver.cpp b/clang/lib/Driver/Driver.cpp index 7a13e19da020..27bb64768863 100644 --- a/clang/lib/Driver/Driver.cpp +++ b/clang/lib/Driver/Driver.cpp @@ -423,6 +423,9 @@ phases::ID Driver::getFinalPhase(const DerivedArgList &DAL, (PhaseArg = DAL.getLastArg(options::OPT_print_supported_cpus)) || (PhaseArg = DAL.getLastArg(options::OPT_print_enabled_extensions)) || (PhaseArg = DAL.getLastArg(options::OPT_module_file_info)) || +#ifdef ENABLE_CLASSIC_FLANG + (PhaseArg = DAL.getLastArg(options::OPT_emit_flang_llvm)) || +#endif (PhaseArg = DAL.getLastArg(options::OPT_verify_pch)) || (PhaseArg = DAL.getLastArg(options::OPT_rewrite_objc)) || (PhaseArg = DAL.getLastArg(options::OPT_rewrite_legacy_objc)) || diff --git a/clang/lib/Driver/ToolChains/ClassicFlang.cpp b/clang/lib/Driver/ToolChains/ClassicFlang.cpp index c13938074cf2..c6e03bdbb4d3 100644 --- a/clang/lib/Driver/ToolChains/ClassicFlang.cpp +++ b/clang/lib/Driver/ToolChains/ClassicFlang.cpp @@ -87,6 +87,13 @@ void ClassicFlang::ConstructJob(Compilation &C, const JobAction &JA, llvm::sys::path::replace_extension(Stem, ""); } +#ifdef ENABLE_CLASSIC_FLANG + if (Args.hasArg(options::OPT_emit_flang_llvm)) { + // -emit-flang-llvm only supports asm output so claim -S to prevent warning + Args.ClaimAllArgs(options::OPT_S); + } +#endif + // Add input file name to the compilation line UpperCmdArgs.push_back(Input.getBaseInput()); From 797def346bf01b0b4c19ca74bc91c478ef94da1c Mon Sep 17 00:00:00 2001 From: Richard Barton Date: Tue, 1 Feb 2022 08:21:08 +0000 Subject: [PATCH 10/60] [driver] Add regression test --- .../Driver/flang/classic-flang-emit-flang-llvm.f95 | 10 ++++++++++ 1 file changed, 10 insertions(+) create mode 100644 clang/test/Driver/flang/classic-flang-emit-flang-llvm.f95 diff --git a/clang/test/Driver/flang/classic-flang-emit-flang-llvm.f95 b/clang/test/Driver/flang/classic-flang-emit-flang-llvm.f95 new file mode 100644 index 000000000000..225207c85db7 --- /dev/null +++ b/clang/test/Driver/flang/classic-flang-emit-flang-llvm.f95 @@ -0,0 +1,10 @@ +! REQUIRES: classic_flang + +! Check that the -emit-flang-llvm option dumps LLVM IR pre-optimisation + +! RUN: %clang --driver-mode=flang -emit-flang-llvm -S -o %t.ll %s -### 2>&1 \ +! RUN: | FileCheck %s +! CHECK-NOT: argument unused during compilation: '-S' +! CHECK: "{{.*}}flang1" +! CHECK-NEXT: "{{.*}}flang2" +! CHECK-NOT: "{{.*}}clang{{.*}}" "-cc1" From 66a39e795e167f4b9536aac4f2effc03d6aa21bd Mon Sep 17 00:00:00 2001 From: Richard Barton Date: Mon, 15 Nov 2021 09:47:24 +0000 Subject: [PATCH 11/60] [driver] Add infrastructure for testing the flang-driver in lit Add %flang as a tool substitution available in lit tests. This apes the way %clang is defined and adds a $FLANG override in a similar vein. To avoid this being dead code, add a single test to check the flang driver is reporting the correct phases when running under various phase control options. Signed-off-by: Richard Barton --- clang/test/Driver/fortran-phases.f90 | 102 +++++++++++++++++++++++++++ llvm/utils/lit/lit/TestingConfig.py | 1 + llvm/utils/lit/lit/llvm/config.py | 10 +++ 3 files changed, 113 insertions(+) create mode 100644 clang/test/Driver/fortran-phases.f90 diff --git a/clang/test/Driver/fortran-phases.f90 b/clang/test/Driver/fortran-phases.f90 new file mode 100644 index 000000000000..5a79bb26bcde --- /dev/null +++ b/clang/test/Driver/fortran-phases.f90 @@ -0,0 +1,102 @@ +! Test to see that the correct phases are run for the commandline input + +! REQUIRES: classic_flang + +! RUN: %flang -ccc-print-phases 2>&1 %s | FileCheck %s --check-prefix=LINK-NOPP +! RUN: %flang -ccc-print-phases -c 2>&1 %s | FileCheck %s --check-prefix=CONLY-NOPP +! RUN: %flang -ccc-print-phases -S 2>&1 %s | FileCheck %s --check-prefix=AONLY-NOPP +! RUN: %flang -ccc-print-phases -c -emit-llvm 2>&1 %s | FileCheck %s --check-prefix=LLONLY-NOPP +! RUN: %flang -ccc-print-phases -S -emit-llvm 2>&1 %s | FileCheck %s --check-prefix=LLONLY-NOPP +! RUN: %flang -ccc-print-phases -fsyntax-only 2>&1 %s | FileCheck %s --check-prefix=SONLY-NOPP +! RUN: %flang -ccc-print-phases -E 2>&1 %s | FileCheck %s --check-prefix=PPONLY-NOPP + +! RUN: %flang -ccc-print-phases 2>&1 -x f95-cpp-input %s | FileCheck %s --check-prefix=LINK +! RUN: %flang -ccc-print-phases 2>&1 -x f95-cpp-input %s | FileCheck %s --check-prefix=LINK +! RUN: %flang -ccc-print-phases -c 2>&1 -x f95-cpp-input %s | FileCheck %s --check-prefix=CONLY +! RUN: %flang -ccc-print-phases -S 2>&1 -x f95-cpp-input %s | FileCheck %s --check-prefix=AONLY +! RUN: %flang -ccc-print-phases -c -emit-llvm 2>&1 -x f95-cpp-input %s | FileCheck %s --check-prefix=LLONLY +! RUN: %flang -ccc-print-phases -S -emit-llvm 2>&1 -x f95-cpp-input %s | FileCheck %s --check-prefix=LLONLY +! RUN: %flang -ccc-print-phases -fsyntax-only 2>&1 -x f95-cpp-input %s | FileCheck %s --check-prefix=SONLY +! RUN: %flang -ccc-print-phases -E 2>&1 -x f95-cpp-input %s | FileCheck %s --check-prefix=PPONLY + +! LINK-NOPP: 0: input, {{.*}}, f95 +! LINK-NOPP: 1: compiler, {0}, ir +! LINK-NOPP: 2: backend, {1}, assembler +! LINK-NOPP: 3: assembler, {2}, object +! LINK-NOPP: 4: linker, {3}, image + +! CONLY-NOPP: 0: input, {{.*}}, f95 +! CONLY-NOPP: 1: compiler, {0}, ir +! CONLY-NOPP: 2: backend, {1}, assembler +! CONLY-NOPP: 3: assembler, {2}, object +! CONLY-NOPP-NOT: 4: linker, {3}, image + +! AONLY-NOPP: 0: input, {{.*}}, f95 +! AONLY-NOPP: 1: compiler, {0}, ir +! AONLY-NOPP: 2: backend, {1}, assembler +! AONLY-NOPP-NOT: 3: assembler, {2}, object +! AONLY-NOPP-NOT: 4: linker, {3}, image + +! LLONLY-NOPP: 0: input, {{.*}}, f95 +! LLONLY-NOPP: 1: compiler, {0}, ir +! LLONLY-NOPP-NOT: 2: backend, {1}, assembler +! LLONLY-NOPP-NOT: 3: assembler, {2}, object +! LLONLY-NOPP-NOT: 4: linker, {3}, image + +! SONLY-NOPP: 0: input, {{.*}}, f95 +! SONLY-NOPP-NOT: 1: compiler, {0}, ir +! SONLY-NOPP-NOT: 2: backend, {1}, assembler +! SONLY-NOPP-NOT: 3: assembler, {2}, object +! SONLY-NOPP-NOT: 4: linker, {3}, image + +! PPONLY-NOPP: 0: input, {{.*}}, f95 +! PPONLY-NOPP: 1: compiler, {0}, ir +! PPONLY-NOPP-NOT: 2: backend, {1}, assembler +! PPONLY-NOPP-NOT: 3: assembler, {2}, object +! PPONLY-NOPP-NOT: 4: linker, {3}, image + +! LINK: 0: input, {{.*}}, f95-cpp-input +! LINK: 1: preprocessor, {0}, f95 +! LINK: 2: compiler, {1}, ir +! LINK: 3: backend, {2}, assembler +! LINK: 4: assembler, {3}, object +! LINK: 5: linker, {4}, image + +! CONLY: 0: input, {{.*}}, f95-cpp-input +! CONLY: 1: preprocessor, {0}, f95 +! CONLY: 2: compiler, {1}, ir +! CONLY: 3: backend, {2}, assembler +! CONLY: 4: assembler, {3}, object +! CONLY-NOT: 5: linker, {4}, image + +! AONLY: 0: input, {{.*}}, f95-cpp-input +! AONLY: 1: preprocessor, {0}, f95 +! AONLY: 2: compiler, {1}, ir +! AONLY: 3: backend, {2}, assembler +! AONLY-NOT: 4: assembler, {3}, object +! AONLY-NOT: 5: linker, {4}, image + +! LLONLY: 0: input, {{.*}}, f95-cpp-input +! LLONLY: 1: preprocessor, {0}, f95 +! LLONLY: 2: compiler, {1}, ir +! LLONLY-NOT: 3: backend, {2}, assembler +! LLONLY-NOT: 4: assembler, {3}, object +! LLONLY-NOT: 5: linker, {4}, image + +! SONLY: 0: input, {{.*}}, f95-cpp-input +! SONLY: 1: preprocessor, {0}, f95 +! SONLY-NOT: 2: compiler, {1}, ir +! SONLY-NOT: 3: backend, {2}, assembler +! SONLY-NOT: 4: assembler, {3}, object +! SONLY-NOT: 5: linker, {4}, image + +! PPONLY: 0: input, {{.*}}, f95-cpp-input +! PPONLY: 1: preprocessor, {0}, f95 +! PPONLY: 2: compiler, {1}, ir +! PPONLY-NOT: 3: backend, {2}, assembler +! PPONLY-NOT: 4: assembler, {3}, object +! PPONLY-NOT: 5: linker, {4}, image + +program hello + write(*, *) "Hello" +end program hello diff --git a/llvm/utils/lit/lit/TestingConfig.py b/llvm/utils/lit/lit/TestingConfig.py index b0d8e7149e55..291422f9f0ee 100644 --- a/llvm/utils/lit/lit/TestingConfig.py +++ b/llvm/utils/lit/lit/TestingConfig.py @@ -27,6 +27,7 @@ def fromdefaults(litConfig): "TERM", "CLANG", "CLANG_TOOLCHAIN_PROGRAM_TIMEOUT", + "FLANG", "LLDB", "LD_PRELOAD", "LLVM_SYMBOLIZER_PATH", diff --git a/llvm/utils/lit/lit/llvm/config.py b/llvm/utils/lit/lit/llvm/config.py index 5f762ec7f351..f8aaabe08ebf 100644 --- a/llvm/utils/lit/lit/llvm/config.py +++ b/llvm/utils/lit/lit/llvm/config.py @@ -519,6 +519,8 @@ def use_clang( just-built or optionally an installed clang, and add a set of standard substitutions useful to any test suite that makes use of clang. + Also sets up use of flang + """ # Clear some environment variables that might affect Clang. # @@ -653,6 +655,14 @@ def use_clang( self.add_tool_substitutions(tool_substitutions) self.config.substitutions.append(("%resource_dir", builtin_include_dir)) + self.config.flang = self.use_llvm_tool( + 'flang', search_env='FLANG', required=required) + if self.config.flang: + tool_substitutions = [ + ToolSubst('%flang', command=self.config.flang) + ] + self.add_tool_substitutions(tool_substitutions) + # There will be no default target triple if one was not specifically # set, and the host's architecture is not an enabled target. if self.config.target_triple: From efe38d01d86634e6ae4b60d180d02f1185d36868 Mon Sep 17 00:00:00 2001 From: Bryan Chan Date: Mon, 25 Apr 2022 15:18:45 -0400 Subject: [PATCH 12/60] [LoopVectorize] Revert Classic Flang patch causing AArch64 test failure This patch partially reverts the following commit from an early version of Classic Flang LLVM: https://github.com/flang-compiler/llvm/commit/68669092a5ad1fd29f62346dc30973f86cfacbfe When the LoopVectorize.cpp change in that commit is ported to LLVM 14, it causes a failure in the following test: llvm/test/Transforms/LoopVectorize/AArch64/smallest-and-widest-types.ll Reverting the change allows all tests to run cleanly. --- llvm/lib/Transforms/Vectorize/LoopVectorize.cpp | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp index 9b8f31941552..7cd395255163 100644 --- a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp +++ b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp @@ -4816,10 +4816,8 @@ void LoopVectorizationCostModel::collectElementTypesForWidening() { if (ValuesToIgnore.count(&I)) continue; - // Examine Loads, Stores, PHINodes - // Also examine instructions which convert to a float/double - if (!isa(I) && !isa(I) && !isa(I) && - !isa(I) && !isa(I) && !isa(I)) + // Only examine Loads, Stores and PHINodes. + if (!isa(I) && !isa(I) && !isa(I)) continue; // Examine PHI nodes that are reduction variables. Update the type to From 451fb20adcfc3680e0ad44ea0225e1b387817327 Mon Sep 17 00:00:00 2001 From: Richard Barton Date: Fri, 12 Nov 2021 17:10:05 +0000 Subject: [PATCH 13/60] [driver] Pass LLVM target_features to flang Port commit 64bf2a644bba to LLVM 16 and resolve merge conflicts. The original commit message follows: Pass LLVM target features (-mattr strings) to flang to embed in generated .ll files. For normal compilation this won't make much difference as the attributes are passed to clang after flang2 and can be applied there but this is crucial to enable LTO with flang as clang will not apply the attributes when building the flang2 output. libLTO will need to read these out of the object files to apply them. Signed-off-by: Richard Barton --- clang/lib/Driver/ToolChains/ClassicFlang.cpp | 32 +++++++++++++++----- clang/lib/Driver/ToolChains/CommonArgs.cpp | 17 +++++++++++ clang/lib/Driver/ToolChains/CommonArgs.h | 11 +++++++ clang/test/Driver/emit-flang-attrs.f90 | 11 +++++++ 4 files changed, 64 insertions(+), 7 deletions(-) create mode 100644 clang/test/Driver/emit-flang-attrs.f90 diff --git a/clang/lib/Driver/ToolChains/ClassicFlang.cpp b/clang/lib/Driver/ToolChains/ClassicFlang.cpp index c6e03bdbb4d3..daab0407d023 100644 --- a/clang/lib/Driver/ToolChains/ClassicFlang.cpp +++ b/clang/lib/Driver/ToolChains/ClassicFlang.cpp @@ -60,6 +60,8 @@ class ClassicFlangMacroBuilder : public MacroBuilder { void ClassicFlang::ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, const InputInfoList &Inputs, const ArgList &Args, const char *LinkingOutput) const { + const Driver &D = getToolChain().getDriver(); + const llvm::Triple &Triple = getToolChain().getEffectiveTriple(); ArgStringList CommonCmdArgs; ArgStringList UpperCmdArgs; ArgStringList LowerCmdArgs; @@ -374,13 +376,13 @@ void ClassicFlang::ConstructJob(Compilation &C, const JobAction &JA, // -Mipa has no effect if (Arg *A = Args.getLastArg(options::OPT_Mipa)) { - getToolChain().getDriver().Diag(diag::warn_drv_clang_unsupported) + D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args); } // -Minline has no effect if (Arg *A = Args.getLastArg(options::OPT_Minline_on)) { - getToolChain().getDriver().Diag(diag::warn_drv_clang_unsupported) + D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args); } @@ -654,14 +656,14 @@ void ClassicFlang::ConstructJob(Compilation &C, const JobAction &JA, // Use clang's predefined macros DiagnosticsEngine DE(new DiagnosticIDs(), new DiagnosticOptions, new IgnoringDiagConsumer()); std::shared_ptr TO = std::make_shared(); - TO->Triple = getToolChain().getEffectiveTriple().getTriple(); + TO->Triple = Triple.getTriple(); std::shared_ptr TI(clang::TargetInfo::CreateTargetInfo(DE, TO)); std::string PredefineBuffer; llvm::raw_string_ostream Predefines(PredefineBuffer); ClassicFlangMacroBuilder Builder(UpperCmdArgs, Args, Predefines); LangOptions LO; - VersionTuple VT = getToolChain().computeMSVCVersion(&getToolChain().getDriver(), Args); + VersionTuple VT = getToolChain().computeMSVCVersion(&D, Args); if (!VT.empty()) { // Set the MSCompatibility version. Subminor version has 5 decimal digits. // Minor and major versions have 2 decimal digits each. @@ -694,7 +696,7 @@ void ClassicFlang::ConstructJob(Compilation &C, const JobAction &JA, DefineTypeSize("__LONG_MAX__", TargetInfo::SignedLong, *TI, Builder); // Add additional predefined macros - switch (getToolChain().getEffectiveTriple().getArch()) { + switch (Triple.getArch()) { case llvm::Triple::aarch64: UpperCmdArgs.push_back("-def"); UpperCmdArgs.push_back("__ARM_ARCH__=8"); break; @@ -788,7 +790,7 @@ void ClassicFlang::ConstructJob(Compilation &C, const JobAction &JA, Arg->claim(); UpperCmdArgs.push_back("-extend"); } else { - getToolChain().getDriver().Diag(diag::err_drv_unsupported_fixed_line_length) + D.Diag(diag::err_drv_unsupported_fixed_line_length) << Arg->getAsString(Args); } } @@ -832,7 +834,7 @@ void ClassicFlang::ConstructJob(Compilation &C, const JobAction &JA, } else if (Value == "95") { // Enable Fortran 2003 semantics UpperCmdArgs.push_back("-y"); // Unset XBIT } else { - getToolChain().getDriver().Diag(diag::err_drv_invalid_allocatable_mode) + D.Diag(diag::err_drv_invalid_allocatable_mode) << A->getAsString(Args); } } else { // No argument passed @@ -982,6 +984,22 @@ void ClassicFlang::ConstructJob(Compilation &C, const JobAction &JA, // Remove "noinline" attriblute LowerCmdArgs.push_back("-x"); LowerCmdArgs.push_back("183"); LowerCmdArgs.push_back("0x10"); + // Add target features + std::vector Features; + std::string FeatureList = ""; + getTargetFeatureList(D, Triple, Args, UpperCmdArgs, false, Features); + if (!Features.empty()) { + for (unsigned I = 0, N = Features.size(); I < N; ++I) { + StringRef Name = Features[I]; + FeatureList += Name.str(); + if (I < (N - 1)) + FeatureList += ','; + } + + LowerCmdArgs.push_back("-target_features"); + LowerCmdArgs.push_back(Args.MakeArgString(FeatureList)); + } + // Set a -x flag for second part of Fortran frontend for (Arg *A : Args.filtered(options::OPT_Mx_EQ)) { A->claim(); diff --git a/clang/lib/Driver/ToolChains/CommonArgs.cpp b/clang/lib/Driver/ToolChains/CommonArgs.cpp index dbad14bc03b8..35be83d0c03c 100644 --- a/clang/lib/Driver/ToolChains/CommonArgs.cpp +++ b/clang/lib/Driver/ToolChains/CommonArgs.cpp @@ -765,10 +765,18 @@ static void getWebAssemblyTargetFeatures(const Driver &D, options::OPT_m_wasm_Features_Group); } +#ifndef ENABLE_CLASSIC_FLANG void tools::getTargetFeatures(const Driver &D, const llvm::Triple &Triple, const ArgList &Args, ArgStringList &CmdArgs, bool ForAS, bool IsAux) { std::vector Features; +#else +void tools::getTargetFeatureList(const Driver &D, + const llvm::Triple &Triple, + const ArgList &Args, ArgStringList &CmdArgs, + bool ForAS, + std::vector &Features) { +#endif switch (Triple.getArch()) { default: break; @@ -843,6 +851,15 @@ void tools::getTargetFeatures(const Driver &D, const llvm::Triple &Triple, loongarch::getLoongArchTargetFeatures(D, Triple, Args, Features); break; } +#ifdef ENABLE_CLASSIC_FLANG +} + +void tools::getTargetFeatures(const Driver &D, const llvm::Triple &Triple, + const ArgList &Args, ArgStringList &CmdArgs, + bool ForAS, bool IsAux) { + std::vector Features; + getTargetFeatureList(D, Triple, Args, CmdArgs, ForAS, Features); +#endif for (auto Feature : unifyTargetFeatures(Features)) { CmdArgs.push_back(IsAux ? "-aux-target-feature" : "-target-feature"); diff --git a/clang/lib/Driver/ToolChains/CommonArgs.h b/clang/lib/Driver/ToolChains/CommonArgs.h index 78708076426f..37f54403b22c 100644 --- a/clang/lib/Driver/ToolChains/CommonArgs.h +++ b/clang/lib/Driver/ToolChains/CommonArgs.h @@ -174,6 +174,17 @@ void AddTargetFeature(const llvm::opt::ArgList &Args, std::string getCPUName(const Driver &D, const llvm::opt::ArgList &Args, const llvm::Triple &T, bool FromAs = false); +#ifdef ENABLE_CLASSIC_FLANG +// Helper function extracted from upstream getTargetFeatures. Classic Flang +// uses this helper to render the target feature options for the Fortran +// frontend. +void getTargetFeatureList(const Driver &D, + const llvm::Triple &Triple, + const llvm::opt::ArgList &Args, + llvm::opt::ArgStringList &CmdArgs, + bool ForAS, std::vector &Features); +#endif + void getTargetFeatures(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, bool ForAS, diff --git a/clang/test/Driver/emit-flang-attrs.f90 b/clang/test/Driver/emit-flang-attrs.f90 new file mode 100644 index 000000000000..91331ac227fa --- /dev/null +++ b/clang/test/Driver/emit-flang-attrs.f90 @@ -0,0 +1,11 @@ +// REQUIRES: aarch64-registered-target +// REQUIRES: classic_flang +// RUN: %flang -### -target aarch64-linux-gnu -march=armv8-a -c %s 2>&1 | FileCheck --check-prefix=CHECK-ATTRS-NEON %s +// RUN: %flang -### -target aarch64-linux-gnu -march=armv8-a+sve -c %s 2>&1 | FileCheck --check-prefix=CHECK-ATTRS-SVE %s +// RUN: %flang -### -target aarch64-linux-gnu -march=armv8-a+nosve -c %s 2>&1 | FileCheck --check-prefix=CHECK-ATTRS-NOSVE %s +// CHECK-ATTRS-NEON: "{{.*}}flang2" +// CHECK-ATTRS-NEON-SAME: "-target_features" "+neon,+v8a +// CHECK-ATTRS-SVE: "{{.*}}flang2" +// CHECK-ATTRS-SVE-SAME: "-target_features" "+neon,+v8a,+sve +// CHECK-ATTRS-NOSVE: "{{.*}}flang2" +// CHECK-ATTRS-NOSVE-SAME: "-target_features" "+neon,+v8a,-sve From 141720f55af5b6dd63feeab3cb20c8d5c999e8f9 Mon Sep 17 00:00:00 2001 From: Richard Barton Date: Thu, 18 Nov 2021 11:16:20 +0000 Subject: [PATCH 14/60] [flang-driver] Uniquify the target_features string Use existing clang support for uniquifying target feature lists to pass a unique list through to flang. --- clang/lib/Driver/ToolChains/ClassicFlang.cpp | 7 +++---- clang/test/Driver/emit-flang-attrs.f90 | 1 + 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/clang/lib/Driver/ToolChains/ClassicFlang.cpp b/clang/lib/Driver/ToolChains/ClassicFlang.cpp index daab0407d023..e8cf4895d456 100644 --- a/clang/lib/Driver/ToolChains/ClassicFlang.cpp +++ b/clang/lib/Driver/ToolChains/ClassicFlang.cpp @@ -989,11 +989,10 @@ void ClassicFlang::ConstructJob(Compilation &C, const JobAction &JA, std::string FeatureList = ""; getTargetFeatureList(D, Triple, Args, UpperCmdArgs, false, Features); if (!Features.empty()) { - for (unsigned I = 0, N = Features.size(); I < N; ++I) { - StringRef Name = Features[I]; - FeatureList += Name.str(); - if (I < (N - 1)) + for (auto Feature : unifyTargetFeatures(Features)) { + if (!FeatureList.empty()) FeatureList += ','; + FeatureList += Feature; } LowerCmdArgs.push_back("-target_features"); diff --git a/clang/test/Driver/emit-flang-attrs.f90 b/clang/test/Driver/emit-flang-attrs.f90 index 91331ac227fa..d9a2ea954f80 100644 --- a/clang/test/Driver/emit-flang-attrs.f90 +++ b/clang/test/Driver/emit-flang-attrs.f90 @@ -3,6 +3,7 @@ // RUN: %flang -### -target aarch64-linux-gnu -march=armv8-a -c %s 2>&1 | FileCheck --check-prefix=CHECK-ATTRS-NEON %s // RUN: %flang -### -target aarch64-linux-gnu -march=armv8-a+sve -c %s 2>&1 | FileCheck --check-prefix=CHECK-ATTRS-SVE %s // RUN: %flang -### -target aarch64-linux-gnu -march=armv8-a+nosve -c %s 2>&1 | FileCheck --check-prefix=CHECK-ATTRS-NOSVE %s +// RUN: %flang -### -target aarch64-linux-gnu -march=armv8-a+sve+nosve -c %s 2>&1 | FileCheck --check-prefix=CHECK-ATTRS-NOSVE %s // CHECK-ATTRS-NEON: "{{.*}}flang2" // CHECK-ATTRS-NEON-SAME: "-target_features" "+neon,+v8a // CHECK-ATTRS-SVE: "{{.*}}flang2" From fd337753bf7047a77eb567f9d0d21d321e451a31 Mon Sep 17 00:00:00 2001 From: Paul Osmialowski Date: Fri, 21 Jan 2022 10:00:58 +0000 Subject: [PATCH 15/60] [driver] Pass msve-vector-bits to flang as vscale range Signed-off-by: Paul Osmialowski --- clang/lib/Driver/ToolChains/ClassicFlang.cpp | 34 ++++++++++++++++++++ 1 file changed, 34 insertions(+) diff --git a/clang/lib/Driver/ToolChains/ClassicFlang.cpp b/clang/lib/Driver/ToolChains/ClassicFlang.cpp index e8cf4895d456..8cba7adba391 100644 --- a/clang/lib/Driver/ToolChains/ClassicFlang.cpp +++ b/clang/lib/Driver/ToolChains/ClassicFlang.cpp @@ -999,6 +999,40 @@ void ClassicFlang::ConstructJob(Compilation &C, const JobAction &JA, LowerCmdArgs.push_back(Args.MakeArgString(FeatureList)); } + // Add vscale range + unsigned vscaleMin = 1U; + unsigned vscaleMax = 16U; + bool hasVscaleRange = false; + if (Arg *A = Args.getLastArg(options::OPT_msve_vector_bits_EQ)) { + StringRef Val = A->getValue(); + + if (Val == "scalable") + hasVscaleRange = true; + else { + unsigned bits = (std::stoul(Val.str()) >> 7U); + + if ((bits < vscaleMin) || (bits > vscaleMax)) { + D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args); + hasVscaleRange = false; + } else { + vscaleMin = vscaleMax = bits; + hasVscaleRange = true; + } + } + } + for (auto Feature : unifyTargetFeatures(Features)) { + if (Feature.starts_with("+sve")) { + hasVscaleRange = true; + break; + } + } + if (hasVscaleRange) { + LowerCmdArgs.push_back("-vscale_range_min"); + LowerCmdArgs.push_back(Args.MakeArgString(std::to_string(vscaleMin))); + LowerCmdArgs.push_back("-vscale_range_max"); + LowerCmdArgs.push_back(Args.MakeArgString(std::to_string(vscaleMax))); + } + // Set a -x flag for second part of Fortran frontend for (Arg *A : Args.filtered(options::OPT_Mx_EQ)) { A->claim(); From 66c872da0aae71fc9183443f09037cadd473d7d2 Mon Sep 17 00:00:00 2001 From: pwisniewskimobica Date: Thu, 13 Jan 2022 10:11:43 +0100 Subject: [PATCH 16/60] [Driver][Test] Add more variants to test/Driver/emit-flang-attrs.f90 --- clang/test/Driver/emit-flang-attrs.f90 | 70 +++++++++++++++++++++----- 1 file changed, 58 insertions(+), 12 deletions(-) diff --git a/clang/test/Driver/emit-flang-attrs.f90 b/clang/test/Driver/emit-flang-attrs.f90 index d9a2ea954f80..df23a8aa6e87 100644 --- a/clang/test/Driver/emit-flang-attrs.f90 +++ b/clang/test/Driver/emit-flang-attrs.f90 @@ -1,12 +1,58 @@ -// REQUIRES: aarch64-registered-target -// REQUIRES: classic_flang -// RUN: %flang -### -target aarch64-linux-gnu -march=armv8-a -c %s 2>&1 | FileCheck --check-prefix=CHECK-ATTRS-NEON %s -// RUN: %flang -### -target aarch64-linux-gnu -march=armv8-a+sve -c %s 2>&1 | FileCheck --check-prefix=CHECK-ATTRS-SVE %s -// RUN: %flang -### -target aarch64-linux-gnu -march=armv8-a+nosve -c %s 2>&1 | FileCheck --check-prefix=CHECK-ATTRS-NOSVE %s -// RUN: %flang -### -target aarch64-linux-gnu -march=armv8-a+sve+nosve -c %s 2>&1 | FileCheck --check-prefix=CHECK-ATTRS-NOSVE %s -// CHECK-ATTRS-NEON: "{{.*}}flang2" -// CHECK-ATTRS-NEON-SAME: "-target_features" "+neon,+v8a -// CHECK-ATTRS-SVE: "{{.*}}flang2" -// CHECK-ATTRS-SVE-SAME: "-target_features" "+neon,+v8a,+sve -// CHECK-ATTRS-NOSVE: "{{.*}}flang2" -// CHECK-ATTRS-NOSVE-SAME: "-target_features" "+neon,+v8a,-sve +! REQUIRES: aarch64-registered-target +! REQUIRES: classic_flang +! RUN: %flang -### -target aarch64-linux-gnu -march=armv8-a -c %s 2>&1 | FileCheck --check-prefix=CHECK-ATTRS-NEON %s +! RUN: %flang -### -target aarch64-linux-gnu -march=armv8-a+sve -c %s 2>&1 | FileCheck --check-prefix=CHECK-ATTRS-SVE %s +! RUN: %flang -### -target aarch64-linux-gnu -march=armv8-a+nosve -c %s 2>&1 | FileCheck --check-prefix=CHECK-ATTRS-NOSVE %s +! RUN: %flang -### -target aarch64-linux-gnu -march=armv8-a+sve+nosve -c %s 2>&1 | FileCheck --check-prefix=CHECK-ATTRS-NOSVE %s +! RUN: %flang -### -target aarch64-linux-gnu -march=armv8-a+sve2+nosve2 -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-SVE2-REVERT +! RUN: %flang -### -target aarch64-linux-gnu -march=armv8-a+sve2-aes -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-SVE2-AES +! RUN: %flang -### -target aarch64-linux-gnu -march=armv8-a+sve2-sm4 -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-SVE2-SM4 +! RUN: %flang -### -target aarch64-linux-gnu -march=armv8-a+sve2-sha3 -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-SVE2-SHA3 +! RUN: %flang -### -target aarch64-linux-gnu -march=armv8-a+sve2-bitperm+nosve2-bitperm -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-SVE2-BITPERM-REVERT +! RUN: %flang -### -target aarch64-linux-gnu -march=armv8-a+sve2 -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-SVE2-IMPLY +! RUN: %flang -### -target aarch64-linux-gnu -march=armv8-a+nosve+sve2 -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-SVE2-CONFLICT-REV +! RUN: %flang -### -target aarch64-linux-gnu -march=armv8-a+sve+sve2 -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-SVE-SVE2 +! RUN: %flang -### -target aarch64-linux-gnu -march=armv8-a+sve2-bitperm -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-SVE2-BITPERM +! RUN: %flang -### -target aarch64-linux-gnu -march=armv8-a+nosve+sve2-aes -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-SVE-SUBFEATURE-CONFLICT-REV +! RUN: %flang -### -target aarch64-linux-gnu -march=armv8-a+sve2-sm4+nosve2 -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-SVE2-SUBFEATURE-CONFLICT +! RUN: %flang -### -target aarch64-linux-gnu -march=armv8-a+sve2-bitperm+nosve2-aes -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-SVE2-SUBFEATURE-MIX +! RUN: %flang -### -target aarch64-linux-gnu -march=armv8-a+sve2-sm4+nosve2-sm4 -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-SVE2-SM4-REVERT +! RUN: %flang -### -target aarch64-linux-gnu -march=armv8-a+sve2-sha3+nosve2-sha3 %s 2>&1 | FileCheck %s --check-prefix=CHECK-SVE2-SHA3-REVERT +! RUN: %flang -### -target aarch64-linux-gnu -march=armv8-a+sve2-aes+nosve2-aes %s 2>&1 | FileCheck %s --check-prefix=CHECK-SVE2-AES-REVERT + +! CHECK-ATTRS-NEON: "{{.*}}flang2" +! CHECK-ATTRS-NEON-SAME: "-target_features" "+neon,+v8a" +! CHECK-ATTRS-SVE: "{{.*}}flang2" +! CHECK-ATTRS-SVE-SAME: "-target_features" "+neon,+v8a,+sve" +! CHECK-ATTRS-NOSVE: "{{.*}}flang2" +! CHECK-ATTRS-NOSVE-SAME: "-target_features" "+neon,+v8a,-sve,-sve2,-sve2-bitperm,-sve2-sha3,-sve2-aes,-sve2-sm4" +! CHECK-SVE2-REVERT: "{{.*}}flang2" +! CHECK-SVE2-REVERT-SAME: "-target_features" "+neon,+v8a,+sve,-sve2,-sve2-bitperm,-sve2-sha3,-sve2-aes,-sve2-sm4" +! CHECK-SVE2-AES: "{{.*}}flang2" +! CHECK-SVE2-AES-SAME: "-target_features" "+neon,+v8a,+sve2-aes,+sve,+sve2" +! CHECK-SVE2-SM4: "{{.*}}flang2" +! CHECK-SVE2-SM4-SAME: "-target_features" "+neon,+v8a,+sve2-sm4,+sve,+sve2" +! CHECK-SVE2-SHA3: "{{.*}}flang2" +! CHECK-SVE2-SHA3-SAME: "-target_features" "+neon,+v8a,+sve2-sha3,+sve,+sve2" +! CHECK-SVE2-BITPERM-REVERT: "{{.*}}flang2" +! CHECK-SVE2-BITPERM-REVERT-SAME: "-target_features" "+neon,+v8a,+sve,+sve2,-sve2-bitperm" +! CHECK-SVE2-IMPLY: "{{.*}}flang2" +! CHECK-SVE2-IMPLY-SAME: "-target_features" "+neon,+v8a,+sve2,+sve" +! CHECK-SVE2-CONFLICT-REV: "{{.*}}flang2" +! CHECK-SVE2-CONFLICT-REV-SAME: "-target_features" "+neon,+v8a,-sve2-bitperm,-sve2-sha3,-sve2-aes,-sve2-sm4,+sve2,+sve" +! CHECK-SVE-SVE2: "{{.*}}flang2" +! CHECK-SVE-SVE2-SAME: "-target_features" "+neon,+v8a,+sve2,+sve" +! CHECK-SVE2-BITPERM: "{{.*}}flang2" +! CHECK-SVE2-BITPERM-SAME: "-target_features" "+neon,+v8a,+sve2-bitperm,+sve,+sve2" +! CHECK-SVE-SUBFEATURE-CONFLICT-REV: "{{.*}}flang2" +! CHECK-SVE-SUBFEATURE-CONFLICT-REV-SAME: "-target_features" "+neon,+v8a,-sve2-bitperm,-sve2-sha3,-sve2-sm4,+sve2-aes,+sve,+sve2" +! CHECK-SVE2-SUBFEATURE-CONFLICT: "{{.*}}flang2" +! CHECK-SVE2-SUBFEATURE-CONFLICT-SAME: "-target_features" "+neon,+v8a,+sve,-sve2,-sve2-bitperm,-sve2-sha3,-sve2-aes,-sve2-sm4" +! CHECK-SVE2-SUBFEATURE-MIX: "{{.*}}flang2" +! CHECK-SVE2-SUBFEATURE-MIX-SAME: "-target_features" "+neon,+v8a,+sve2-bitperm,+sve,+sve2,-sve2-aes" +! CHECK-SVE2-SM4-REVERT: "{{.*}}flang2" +! CHECK-SVE2-SM4-REVERT-SAME: "-target_features" "+neon,+v8a,+sve,+sve2,-sve2-sm4" +! CHECK-SVE2-SHA3-REVERT: "{{.*}}flang2" +! CHECK-SVE2-SHA3-REVERT-SAME: "-target_features" "+neon,+v8a,+sve,+sve2,-sve2-sha3" +! CHECK-SVE2-AES-REVERT: "{{.*}}flang2" +! CHECK-SVE2-AES-REVERT-SAME: "-target_features" "+neon,+v8a,+sve,+sve2,-sve2-aes" From 233fea2b975b17b9b550625348b836e6c6c146be Mon Sep 17 00:00:00 2001 From: Richard Barton Date: Tue, 22 Mar 2022 09:26:00 +0000 Subject: [PATCH 17/60] Fix classic flang version screen Version screen has been erroneously reporting as flang-new since LLVM 12 Cherry-pick note: Starting with LLVM 20, the --version option reports "flang" out of the box. This commit only adds a test case to ensure that the behaviour does not change for Classic Flang. --- clang/test/Driver/flang/classic-flang-version.f | 3 +++ 1 file changed, 3 insertions(+) create mode 100644 clang/test/Driver/flang/classic-flang-version.f diff --git a/clang/test/Driver/flang/classic-flang-version.f b/clang/test/Driver/flang/classic-flang-version.f new file mode 100644 index 000000000000..c2082d3af8b7 --- /dev/null +++ b/clang/test/Driver/flang/classic-flang-version.f @@ -0,0 +1,3 @@ +! REQUIRES: classic-flang +! RUN: %flang --version | FileCheck %s +! CHECK: flang version {{.*}} ({{.*}}flang-compiler/classic-flang-llvm-project.git {{.*}}) From a2117eca316d1e19487ce8938d64bf93414684e9 Mon Sep 17 00:00:00 2001 From: Richard Barton Date: Fri, 18 Mar 2022 16:47:15 +0000 Subject: [PATCH 18/60] Canonicalize some ENABLE_CLASSIC_FLANG These CMake variables are used to set python variables in the lit config. As such, they need to bet set with a valid CMake boolean value that is also a valid python boolean value (1, True, etc.) and not one that is not (ON, NO, etc.) to work. This is fragile. Call the LLVM cmake helper function on these two downstream CMake --- clang/test/CMakeLists.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/clang/test/CMakeLists.txt b/clang/test/CMakeLists.txt index 5369dc92f69e..b91fcd45de4d 100644 --- a/clang/test/CMakeLists.txt +++ b/clang/test/CMakeLists.txt @@ -13,6 +13,7 @@ llvm_canonicalize_cmake_booleans( ENABLE_BACKTRACES LLVM_BUILD_EXAMPLES LLVM_BYE_LINK_INTO_TOOLS + LLVM_ENABLE_CLASSIC_FLANG LLVM_ENABLE_PLUGINS LLVM_ENABLE_ZLIB LLVM_ENABLE_ZSTD From cf4b2c10492a40b4a6eef60751fb0a4063a611af Mon Sep 17 00:00:00 2001 From: Richard Barton Date: Fri, 18 Mar 2022 16:44:23 +0000 Subject: [PATCH 19/60] [NFC] Add missing ENABLE_CLASSIC_FLANG guard. Signed-off-by: Richard Barton --- clang/lib/Driver/Driver.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/clang/lib/Driver/Driver.cpp b/clang/lib/Driver/Driver.cpp index 27bb64768863..2d8ff694cf7c 100644 --- a/clang/lib/Driver/Driver.cpp +++ b/clang/lib/Driver/Driver.cpp @@ -5584,9 +5584,11 @@ class ToolSelector final { if (!T->hasIntegratedBackend() && !(OutputIsLLVM && T->canEmitIR())) return nullptr; +#ifdef ENABLE_CLASSIC_FLANG // Classic Flang is not integrated with the backend. if (C.getDriver().IsFlangMode() && !T->hasIntegratedAssembler()) return nullptr; +#endif if (T->canEmitIR() && ((SaveTemps && !InputIsBitcode) || EmbedBitcode)) return nullptr; From de121e6361698a66ca54a502fb4a8b3b38cf94f7 Mon Sep 17 00:00:00 2001 From: Richard Barton Date: Tue, 3 May 2022 17:38:49 +0100 Subject: [PATCH 20/60] Fix flang driver preprocessor issue Fix a bug where flang -E -save-temps input.F90 would preprocess the input file twice. Add a new test for preprocessor behaviour that would expose the bug and updated fortran-phases test for new behaviour. Also added -emit-flang-llvm to that test for completeness. Signed-off-by: Richard Barton --- clang/lib/Driver/Driver.cpp | 23 +++--- clang/lib/Driver/ToolChains/ClassicFlang.cpp | 4 +- clang/test/Driver/fortran-phases.f90 | 73 ++++++++++++-------- clang/test/Driver/fortran-preprocessor.f90 | 47 +++++++++++++ 4 files changed, 109 insertions(+), 38 deletions(-) create mode 100644 clang/test/Driver/fortran-preprocessor.f90 diff --git a/clang/lib/Driver/Driver.cpp b/clang/lib/Driver/Driver.cpp index 2d8ff694cf7c..f8dd6898ce2b 100644 --- a/clang/lib/Driver/Driver.cpp +++ b/clang/lib/Driver/Driver.cpp @@ -400,14 +400,7 @@ phases::ID Driver::getFinalPhase(const DerivedArgList &DAL, (PhaseArg = DAL.getLastArg(options::OPT_M, options::OPT_MM)) || (PhaseArg = DAL.getLastArg(options::OPT__SLASH_P)) || CCGenDiagnostics) { -#ifdef ENABLE_CLASSIC_FLANG - if (IsFlangMode()) - FinalPhase = phases::Compile; - else - FinalPhase = phases::Preprocess; -#else FinalPhase = phases::Preprocess; -#endif // --precompile only runs up to precompilation. // Options that cause the output of C++20 compiled module interfaces or @@ -2946,7 +2939,11 @@ void Driver::BuildInputs(const ToolChain &TC, DerivedArgList &Args, if (memcmp(Value, "-", 2) == 0) { if (IsFlangMode()) { #ifdef ENABLE_CLASSIC_FLANG - Ty = types::TY_C; + // If running with -E, treat as needing preprocessing + if (!Args.hasArgNoClaim(options::OPT_E)) + Ty = types::TY_PP_F_FreeForm; + else + Ty = types::TY_F_FreeForm; #else Ty = types::TY_Fortran; #endif @@ -2973,6 +2970,16 @@ void Driver::BuildInputs(const ToolChain &TC, DerivedArgList &Args, // idea of what .s is. if (const char *Ext = strrchr(Value, '.')) Ty = TC.LookupTypeForExtension(Ext + 1); +#ifdef ENABLE_CLASSIC_FLANG + // If called with -E, treat the inputs as needing preprocessing + // regardless of extension + if (IsFlangMode() && Args.hasArgNoClaim(options::OPT_E)) { + if (Ty == types::TY_PP_F_FreeForm) + Ty = types::TY_F_FreeForm; + else if (Ty == types::TY_PP_F_FixedForm) + Ty = types::TY_F_FixedForm; + } +#endif if (Ty == types::TY_INVALID) { if (IsCLMode() && (Args.hasArgNoClaim(options::OPT_E) || CCGenDiagnostics)) diff --git a/clang/lib/Driver/ToolChains/ClassicFlang.cpp b/clang/lib/Driver/ToolChains/ClassicFlang.cpp index 8cba7adba391..39c8d75e7d12 100644 --- a/clang/lib/Driver/ToolChains/ClassicFlang.cpp +++ b/clang/lib/Driver/ToolChains/ClassicFlang.cpp @@ -80,8 +80,8 @@ void ClassicFlang::ConstructJob(Compilation &C, const JobAction &JA, // Check file type sanity assert(types::isAcceptedByFlang(InputType) && "Can only accept Fortran"); - if (Args.hasArg(options::OPT_fsyntax_only)) { - // For -fsyntax-only produce temp files only + if (Args.hasArg(options::OPT_fsyntax_only, options::OPT_E)) { + // For -fsyntax-only and -E produce temp files only Stem = C.getDriver().GetTemporaryPath("", ""); } else { OutFile = Output.getFilename(); diff --git a/clang/test/Driver/fortran-phases.f90 b/clang/test/Driver/fortran-phases.f90 index 5a79bb26bcde..57d5f2c92b78 100644 --- a/clang/test/Driver/fortran-phases.f90 +++ b/clang/test/Driver/fortran-phases.f90 @@ -7,6 +7,7 @@ ! RUN: %flang -ccc-print-phases -S 2>&1 %s | FileCheck %s --check-prefix=AONLY-NOPP ! RUN: %flang -ccc-print-phases -c -emit-llvm 2>&1 %s | FileCheck %s --check-prefix=LLONLY-NOPP ! RUN: %flang -ccc-print-phases -S -emit-llvm 2>&1 %s | FileCheck %s --check-prefix=LLONLY-NOPP +! RUN: %flang -ccc-print-phases -emit-flang-llvm 2>&1 %s | FileCheck %s --check-prefix=FLLONLY-NOPP ! RUN: %flang -ccc-print-phases -fsyntax-only 2>&1 %s | FileCheck %s --check-prefix=SONLY-NOPP ! RUN: %flang -ccc-print-phases -E 2>&1 %s | FileCheck %s --check-prefix=PPONLY-NOPP @@ -16,6 +17,7 @@ ! RUN: %flang -ccc-print-phases -S 2>&1 -x f95-cpp-input %s | FileCheck %s --check-prefix=AONLY ! RUN: %flang -ccc-print-phases -c -emit-llvm 2>&1 -x f95-cpp-input %s | FileCheck %s --check-prefix=LLONLY ! RUN: %flang -ccc-print-phases -S -emit-llvm 2>&1 -x f95-cpp-input %s | FileCheck %s --check-prefix=LLONLY +! RUN: %flang -ccc-print-phases -emit-flang-llvm 2>&1 -x f95-cpp-input %s | FileCheck %s --check-prefix=FLLONLY ! RUN: %flang -ccc-print-phases -fsyntax-only 2>&1 -x f95-cpp-input %s | FileCheck %s --check-prefix=SONLY ! RUN: %flang -ccc-print-phases -E 2>&1 -x f95-cpp-input %s | FileCheck %s --check-prefix=PPONLY @@ -29,31 +31,39 @@ ! CONLY-NOPP: 1: compiler, {0}, ir ! CONLY-NOPP: 2: backend, {1}, assembler ! CONLY-NOPP: 3: assembler, {2}, object -! CONLY-NOPP-NOT: 4: linker, {3}, image +! CONLY-NOPP-NOT: {{.*}}: linker, {{{.*}}}, image ! AONLY-NOPP: 0: input, {{.*}}, f95 ! AONLY-NOPP: 1: compiler, {0}, ir ! AONLY-NOPP: 2: backend, {1}, assembler -! AONLY-NOPP-NOT: 3: assembler, {2}, object -! AONLY-NOPP-NOT: 4: linker, {3}, image +! AONLY-NOPP-NOT: {{.*}}: assembler, {{{.*}}}, object +! AONLY-NOPP-NOT: {{.*}}: linker, {{{.*}}}, image ! LLONLY-NOPP: 0: input, {{.*}}, f95 ! LLONLY-NOPP: 1: compiler, {0}, ir -! LLONLY-NOPP-NOT: 2: backend, {1}, assembler -! LLONLY-NOPP-NOT: 3: assembler, {2}, object -! LLONLY-NOPP-NOT: 4: linker, {3}, image +! LLONLY-NOPP-NOT: {{.*}}: backend, {{{.*}}}, assembler +! LLONLY-NOPP-NOT: {{.*}}: assembler, {{{.*}}}, object +! LLONLY-NOPP-NOT: {{.*}}: linker, {{{.*}}}, image + +! FLLONLY-NOPP: 0: input, {{.*}}, f95 +! FLLONLY-NOPP: 1: compiler, {0}, ir +! FLLONLY-NOPP-NOT: {{.*}}: backend, {{{.*}}}, assembler +! FLLONLY-NOPP-NOT: {{.*}}: assembler, {{{.*}}}, object +! FLLONLY-NOPP-NOT: {{.*}}: linker, {{{.*}}}, image ! SONLY-NOPP: 0: input, {{.*}}, f95 -! SONLY-NOPP-NOT: 1: compiler, {0}, ir -! SONLY-NOPP-NOT: 2: backend, {1}, assembler -! SONLY-NOPP-NOT: 3: assembler, {2}, object -! SONLY-NOPP-NOT: 4: linker, {3}, image +! SONLY-NOPP-NOT: {{.*}}: compiler, {{{.*}}}, ir +! SONLY-NOPP-NOT: {{.*}}: backend, {{{.*}}}, assembler +! SONLY-NOPP-NOT: {{.*}}: assembler, {{{.*}}}, object +! SONLY-NOPP-NOT: {{.*}}: linker, {{{.*}}}, image +! flang always preprocesses with -E regardless of file extension ! PPONLY-NOPP: 0: input, {{.*}}, f95 -! PPONLY-NOPP: 1: compiler, {0}, ir -! PPONLY-NOPP-NOT: 2: backend, {1}, assembler -! PPONLY-NOPP-NOT: 3: assembler, {2}, object -! PPONLY-NOPP-NOT: 4: linker, {3}, image +! PPONLY-NOPP: 1: preprocessor, {0}, f95 +! PPONLY-NOPP-NOT: {{.*}}: compiler, {{{.*}}}, ir +! PPONLY-NOPP-NOT: {{.*}}: backend, {{{.*}}}, assembler +! PPONLY-NOPP-NOT: {{.*}}: assembler, {{{.*}}}, object +! PPONLY-NOPP-NOT: {{.*}}: linker, {{{.*}}}, image ! LINK: 0: input, {{.*}}, f95-cpp-input ! LINK: 1: preprocessor, {0}, f95 @@ -67,35 +77,42 @@ ! CONLY: 2: compiler, {1}, ir ! CONLY: 3: backend, {2}, assembler ! CONLY: 4: assembler, {3}, object -! CONLY-NOT: 5: linker, {4}, image +! CONLY-NOT: {{.*}}: linker, {{{.*}}}, image ! AONLY: 0: input, {{.*}}, f95-cpp-input ! AONLY: 1: preprocessor, {0}, f95 ! AONLY: 2: compiler, {1}, ir ! AONLY: 3: backend, {2}, assembler -! AONLY-NOT: 4: assembler, {3}, object -! AONLY-NOT: 5: linker, {4}, image +! AONLY-NOT: {{.*}}: assembler, {{{.*}}}, object +! AONLY-NOT: {{.*}}: linker, {{{.*}}}, image ! LLONLY: 0: input, {{.*}}, f95-cpp-input ! LLONLY: 1: preprocessor, {0}, f95 ! LLONLY: 2: compiler, {1}, ir -! LLONLY-NOT: 3: backend, {2}, assembler -! LLONLY-NOT: 4: assembler, {3}, object -! LLONLY-NOT: 5: linker, {4}, image +! LLONLY-NOT: {{.*}}: backend, {{{.*}}}, assembler +! LLONLY-NOT: {{.*}}: assembler, {{{.*}}}, object +! LLONLY-NOT: {{.*}}: linker, {{{.*}}}, image + +! FLLONLY: 0: input, {{.*}}, f95-cpp-input +! FLLONLY: 1: preprocessor, {0}, f95 +! FLLONLY: 2: compiler, {1}, ir +! FLLONLY-NOT: {{.*}}: backend, {{{.*}}}, assembler +! FLLONLY-NOT: {{.*}}: assembler, {{{.*}}}, object +! FLLONLY-NOT: {{.*}}: linker, {{{.*}}}, image ! SONLY: 0: input, {{.*}}, f95-cpp-input ! SONLY: 1: preprocessor, {0}, f95 -! SONLY-NOT: 2: compiler, {1}, ir -! SONLY-NOT: 3: backend, {2}, assembler -! SONLY-NOT: 4: assembler, {3}, object -! SONLY-NOT: 5: linker, {4}, image +! SONLY-NOT: {{.*}}: compiler, {{{.*}}}, ir +! SONLY-NOT: {{.*}}: backend, {{{.*}}}, assembler +! SONLY-NOT: {{.*}}: assembler, {{{.*}}}, object +! SONLY-NOT: {{.*}}: linker, {{{.*}}}, image ! PPONLY: 0: input, {{.*}}, f95-cpp-input ! PPONLY: 1: preprocessor, {0}, f95 -! PPONLY: 2: compiler, {1}, ir -! PPONLY-NOT: 3: backend, {2}, assembler -! PPONLY-NOT: 4: assembler, {3}, object -! PPONLY-NOT: 5: linker, {4}, image +! PPONLY-NOT: {{.*}}: compiler, {{{.*}}}, ir +! PPONLY-NOT: {{.*}}: backend, {{{.*}}}, assembler +! PPONLY-NOT: {{.*}}: assembler, {{{.*}}}, object +! PPONLY-NOT: {{.*}}: linker, {{{.*}}}, image program hello write(*, *) "Hello" diff --git a/clang/test/Driver/fortran-preprocessor.f90 b/clang/test/Driver/fortran-preprocessor.f90 new file mode 100644 index 000000000000..99f4186ba83c --- /dev/null +++ b/clang/test/Driver/fortran-preprocessor.f90 @@ -0,0 +1,47 @@ +! REQUIRES: classic_flang + +! -cpp should preprocess as it goes, regardless of input file extension +! RUN: %flang -cpp -c -DHELLO="hello all" -### %s 2>&1 | FileCheck %s --check-prefixes=ALL,CPP,PP +! RUN: %flang -cpp -c -DHELLO="hello all" -### -c f95-cpp-input %s 2>&1 | FileCheck %s --check-prefixes=ALL,CPP,PP +! -E should preprocess then stop, regardless of input file extension +! RUN: %flang -E -DHELLO="hello all" -### %s 2>&1 | FileCheck %s --check-prefixes=ALL,E,PPONLY +! RUN: %flang -E -DHELLO="hello all" -### -x f95-cpp-input %s 2>&1 | FileCheck %s --check-prefixes=ALL,E,PPONLY +! -cpp and -E are redundant +! RUN: %flang -E -cpp -DHELLO="hello all" -### %s 2>&1 | FileCheck %s --check-prefixes=ALL,E,PPONLY + +! Don't link when given linker input +! RUN: %flang -E -cpp -Wl,-rpath=blah -### %s 2>&1 | FileCheck %s --check-prefixes=ALL,E,PPONLY + +! Explicitly test this nonsence case causing a bug with LLVM 13/14 +! RUN: %flang -E -traditional-cpp -DHELLO="hello all" -x f95-cpp-input -### %s 2>&1 | FileCheck %s --check-prefixes=ALL,E,PPONLY + +! Test -save-temps does not break things (same codepath as -traditional-cpp bug above) +! RUN: %flang -E -DHELLO="hello all" -save-temps -### %s 2>&1 | FileCheck %s --check-prefixes=ALL,E,PPONLY +! RUN: %flang -E -DHELLO="hello all" -save-temps -### -c f95-cpp-input %s 2>&1 | FileCheck %s --check-prefixes=ALL,E,PPONLY +! RUN: %flang -cpp -c -DHELLO="hello all" -save-temps -### %s 2>&1 | FileCheck %s --check-prefixes=ALL,CPP +! RUN: %flang -cpp -c -DHELLO="hello all" -save-temps -### -c f95-cpp-input %s 2>&1 | FileCheck %s --check-prefixes=ALL,CPP + +! Test for the correct cmdline flags +! Consume up to flang1 line +! ALL-LABEL: "{{.*}}flang1" +! CPP-NOT: "-es" +! CPP: "-preprocess" +! CPP-NOT: "-es" + +! E-DAG: "-es" +! E-DAG: "-preprocess" + +! flang1 should only be called once! +! ALL-NOT: "{{.*}}flang1" + +! CPP should continue to build object +! PP: "{{.*}}flang2" +! PPONLY-NOT: "{{.*}}flang2" + +! These commands should never call a linker! +! ALL-NOT: "{{.*}}ld" + +program hello + write(*, *) HELLO +end program hello + From 78cb191fb38866685ef9251c00a6cd77ab529e44 Mon Sep 17 00:00:00 2001 From: Paul Osmialowski Date: Fri, 15 Jul 2022 09:17:08 +0100 Subject: [PATCH 21/60] classic flang: enable IEEE by default (and sort Lower/Common inconsistency out) Signed-off-by: Paul Osmialowski --- clang/lib/Driver/ToolChains/ClassicFlang.cpp | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/clang/lib/Driver/ToolChains/ClassicFlang.cpp b/clang/lib/Driver/ToolChains/ClassicFlang.cpp index 39c8d75e7d12..28f4c17a365a 100644 --- a/clang/lib/Driver/ToolChains/ClassicFlang.cpp +++ b/clang/lib/Driver/ToolChains/ClassicFlang.cpp @@ -67,7 +67,7 @@ void ClassicFlang::ConstructJob(Compilation &C, const JobAction &JA, ArgStringList LowerCmdArgs; SmallString<256> Stem; std::string OutFile; - bool NeedIEEE = false; + bool NeedIEEE = true; bool NeedFastMath = false; bool NeedRelaxedMath = false; @@ -556,7 +556,7 @@ void ClassicFlang::ConstructJob(Compilation &C, const JobAction &JA, LowerCmdArgs.push_back("-x"); LowerCmdArgs.push_back("216"); LowerCmdArgs.push_back("1"); - // Lower: -ieee 0 + // Common: -ieee 0 CommonCmdArgs.push_back("-ieee"); CommonCmdArgs.push_back("0"); } else if (NeedIEEE) { @@ -584,7 +584,7 @@ void ClassicFlang::ConstructJob(Compilation &C, const JobAction &JA, LowerCmdArgs.push_back("-y"); LowerCmdArgs.push_back("216"); LowerCmdArgs.push_back("1"); - // Lower: -ieee 1 + // Common: -ieee 1 CommonCmdArgs.push_back("-ieee"); CommonCmdArgs.push_back("1"); } else if (NeedRelaxedMath) { @@ -596,11 +596,11 @@ void ClassicFlang::ConstructJob(Compilation &C, const JobAction &JA, LowerCmdArgs.push_back("-y"); LowerCmdArgs.push_back("216"); LowerCmdArgs.push_back("1"); - // Lower: -ieee 0 + // Common: -ieee 0 CommonCmdArgs.push_back("-ieee"); CommonCmdArgs.push_back("0"); } else { - // Lower: -ieee 0 + // Common: -ieee 0 CommonCmdArgs.push_back("-ieee"); CommonCmdArgs.push_back("0"); } From fb2df47a23d00abba09c2340b6e1f16c2b3fe4fe Mon Sep 17 00:00:00 2001 From: Kiran Chandramohan Date: Tue, 8 May 2018 17:49:59 +0100 Subject: [PATCH 22/60] Changes to flang's fp-contract behaviour 1) All fma and contraction behvaviour follows from the -ffp-contract= flag setting. 2) At optimization level 0, -ffp-contract=fast flag will not be honoured. 3) At all other levels, -ffp-contract=fast will be the default behaviour and the flag is honoured. --- clang/lib/Driver/ToolChains/ClassicFlang.cpp | 75 +++++++++++++------ .../flang/classic-flang-fp-contract.f95 | 27 +++++++ 2 files changed, 80 insertions(+), 22 deletions(-) create mode 100644 clang/test/Driver/flang/classic-flang-fp-contract.f95 diff --git a/clang/lib/Driver/ToolChains/ClassicFlang.cpp b/clang/lib/Driver/ToolChains/ClassicFlang.cpp index 28f4c17a365a..4114ecd09404 100644 --- a/clang/lib/Driver/ToolChains/ClassicFlang.cpp +++ b/clang/lib/Driver/ToolChains/ClassicFlang.cpp @@ -465,28 +465,6 @@ void ClassicFlang::ConstructJob(Compilation &C, const JobAction &JA, } } - // Enable FMA - for (Arg *A: Args.filtered(options::OPT_Mfma_on, options::OPT_fma)) { - A->claim(); - LowerCmdArgs.push_back("-x"); - LowerCmdArgs.push_back("172"); - LowerCmdArgs.push_back("0x40000000"); - LowerCmdArgs.push_back("-x"); - LowerCmdArgs.push_back("179"); - LowerCmdArgs.push_back("1"); - } - - // Disable FMA - for (Arg *A: Args.filtered(options::OPT_Mfma_off, options::OPT_nofma)) { - A->claim(); - LowerCmdArgs.push_back("-x"); - LowerCmdArgs.push_back("171"); - LowerCmdArgs.push_back("0x40000000"); - LowerCmdArgs.push_back("-x"); - LowerCmdArgs.push_back("178"); - LowerCmdArgs.push_back("1"); - } - // For -fPIC set -x 62 8 for second part of Fortran frontend for (Arg *A: Args.filtered(options::OPT_fPIC)) { A->claim(); @@ -551,6 +529,59 @@ void ClassicFlang::ConstructJob(Compilation &C, const JobAction &JA, A->claim(); } + // fp-contract=fast is the default + bool EnableFPContraction = true; + if (Arg *A = Args.getLastArg(options::OPT_ffp_contract, + options::OPT_Mfma_on, + options::OPT_fma, + options::OPT_Mfma_off, + options::OPT_nofma)) { + auto Opt = A->getOption(); + if (Opt.matches(options::OPT_ffp_contract)) { + StringRef Val = A->getValue(); + if ((Val == "fast") || (Val == "on")) { + EnableFPContraction = true; + } else if (Val == "off") { + EnableFPContraction = false; + } else { + D.Diag(diag::err_drv_unsupported_option_argument) + << A->getOption().getName() << Val; + } + } else if(Opt.matches(options::OPT_Mfma_on) || + Opt.matches(options::OPT_fma)) { + EnableFPContraction = true; + } else { + EnableFPContraction = false; + } + } + + if(OptLevel == 0) + EnableFPContraction = false; + + // Emit contract math instructions. + // Step 1 : Generate fma instructions in flang (can override with fma flag) + // Step 2 : Propagate fma contract information to LLVM to further + // exploit contraction opportunities + if (EnableFPContraction) { + LowerCmdArgs.push_back("-x"); + LowerCmdArgs.push_back("172"); + LowerCmdArgs.push_back("0x40000000"); + LowerCmdArgs.push_back("-x"); + LowerCmdArgs.push_back("179"); + LowerCmdArgs.push_back("1"); + // Step 2 + LowerCmdArgs.push_back("-x"); + LowerCmdArgs.push_back("216"); + LowerCmdArgs.push_back("0x1000"); + } else { + LowerCmdArgs.push_back("-x"); + LowerCmdArgs.push_back("171"); + LowerCmdArgs.push_back("0x40000000"); + LowerCmdArgs.push_back("-x"); + LowerCmdArgs.push_back("178"); + LowerCmdArgs.push_back("1"); + } + if (NeedFastMath) { // Lower: -x 216 1 LowerCmdArgs.push_back("-x"); diff --git a/clang/test/Driver/flang/classic-flang-fp-contract.f95 b/clang/test/Driver/flang/classic-flang-fp-contract.f95 new file mode 100644 index 000000000000..b181065d1cac --- /dev/null +++ b/clang/test/Driver/flang/classic-flang-fp-contract.f95 @@ -0,0 +1,27 @@ +! REQUIRES: classic_flang + +! RUN: %flang -c %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-FLANG2-FP-CONTRACT-ABSENCE +! RUN: %flang -O1 -c %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-FLANG2-FP-CONTRACT +! RUN: %flang -O2 -c %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-FLANG2-FP-CONTRACT +! RUN: %flang -O3 -c %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-FLANG2-FP-CONTRACT +! RUN: %flang -Ofast -c %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-FLANG2-FP-CONTRACT +! RUN: %flang -ffp-contract=fast -c %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-FLANG2-FP-CONTRACT-ABSENCE +! RUN: %flang -O1 -ffp-contract=fast -c %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-FLANG2-FP-CONTRACT +! RUN: %flang -O2 -ffp-contract=fast -c %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-FLANG2-FP-CONTRACT +! RUN: %flang -O3 -ffp-contract=fast -c %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-FLANG2-FP-CONTRACT +! RUN: %flang -Ofast -ffp-contract=fast -c %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-FLANG2-FP-CONTRACT +! RUN: %flang -ffp-contract=on -c %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-FLANG2-FP-CONTRACT-ABSENCE +! RUN: %flang -O1 -ffp-contract=on -c %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-FLANG2-FP-CONTRACT +! RUN: %flang -O2 -ffp-contract=on -c %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-FLANG2-FP-CONTRACT +! RUN: %flang -O3 -ffp-contract=on -c %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-FLANG2-FP-CONTRACT +! RUN: %flang -Ofast -ffp-contract=on -c %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-FLANG2-FP-CONTRACT +! RUN: %flang -ffp-contract=off -c %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-FLANG2-FP-CONTRACT-ABSENCE +! RUN: %flang -O1 -ffp-contract=off -c %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-FLANG2-FP-CONTRACT-ABSENCE +! RUN: %flang -O2 -ffp-contract=off -c %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-FLANG2-FP-CONTRACT-ABSENCE +! RUN: %flang -O3 -ffp-contract=off -c %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-FLANG2-FP-CONTRACT-ABSENCE +! RUN: %flang -Ofast -ffp-contract=off -c %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-FLANG2-FP-CONTRACT-ABSENCE + +! CHECK-FLANG2-FP-CONTRACT: "{{.*}}flang2" +! CHECK-FLANG2-FP-CONTRACT-SAME: "-x" "172" "0x40000000" "-x" "179" "1" "-x" "216" "0x1000" +! CHECK-FLANG2-FP-CONTRACT-ABSENCE: "{{.*}}flang2" +! CHECK-FLANG2-FP-CONTRACT-ABSENCE-SAME: "-x" "171" "0x40000000" "-x" "178" "1" From 03c1408905b7df5ba634672bdf3c963f35bebe67 Mon Sep 17 00:00:00 2001 From: Peixin-Qiao Date: Mon, 8 Aug 2022 15:03:08 +0800 Subject: [PATCH 23/60] [Driver] Remove the "-lompstub" in the driver In some workloads, users get "-lompstub" by running "flang -v" and link it explicitly, which may cause failure when compiling programs with OpenMP (flang -fopenmp test.f90 -lompstub). There is no runtime call in ompstub.c generated when "-fopenmp" is not added to compile the program. When "-fopenmp" is added to compile the program, the runtime in llvm/openmp(libomp.so) will be used. If users use some runtime library routines such as "omp_get_thread_num" and compiles it without the option "-fopenmp", both gfortran and ifort report errors of "undefined reference to ...". After remove "-lompstub" in the driver, classic-flang reports the error, too. So, it's safe to remove the "-lompstub" in the driver. --- clang/lib/Driver/ToolChain.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/clang/lib/Driver/ToolChain.cpp b/clang/lib/Driver/ToolChain.cpp index 743a7b139b88..3681188a6b32 100644 --- a/clang/lib/Driver/ToolChain.cpp +++ b/clang/lib/Driver/ToolChain.cpp @@ -1448,8 +1448,6 @@ void ToolChain::AddFortranStdlibLibArgs(const ArgList &Args, CmdArgs.push_back("-lpgmath"); if (useOpenMP) CmdArgs.push_back("-lomp"); - else - CmdArgs.push_back("-lompstub"); if (staticFlangLibs) CmdArgs.push_back("-Bdynamic"); From ce537af27365f00d1a23748d2d41806a1c967a4c Mon Sep 17 00:00:00 2001 From: Bryan Chan Date: Sat, 10 Sep 2022 19:41:06 -0400 Subject: [PATCH 24/60] [Driver] Pass Classic Flang libraries to the linker correctly In LLVM 15, the Fortran and OpenMP runtime libraries are added to the linker command line using common methods (addFortranRuntime* and addOpenMPRuntime*). This commit adds Classic Flang awareness to addFortranRuntime*, so that Classic Flang doesn't attempt to link with LLVM Flang libraries. Re-using the same methods as Clang and LLVM Flang also helps reduce downstream delta. A Classic Flang test is added to ensure that the linker command is constructed correctly. LLVM 19 porting note: This commit has been amended to add back the -fno-fortran-main option that was deleted in upstream commit 8d5386669ed6. --- clang/include/clang/Driver/Options.td | 6 +++ clang/lib/Driver/ToolChain.cpp | 32 ++++----------- clang/lib/Driver/ToolChains/CommonArgs.cpp | 13 +++++- clang/lib/Driver/ToolChains/Darwin.cpp | 12 ------ clang/lib/Driver/ToolChains/Gnu.cpp | 12 ------ clang/test/Driver/flang/classic-flang.f95 | 46 ++++++++++++++++++++++ 6 files changed, 72 insertions(+), 49 deletions(-) diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td index d90313f7df07..1b3ba01441ed 100644 --- a/clang/include/clang/Driver/Options.td +++ b/clang/include/clang/Driver/Options.td @@ -7046,6 +7046,12 @@ def fhermetic_module_files : Flag<["-"], "fhermetic-module-files">, Group, Flags<[RenderJoined]>, Group; + +let Visibility = [FlangOption] in { +def no_fortran_main : Flag<["-"], "fno-fortran-main">, + Visibility<[FlangOption]>, Group, + HelpText<"Do not include Fortran_main.a (provided by Flang) when linking">; +} // let Visibility = [ FlangOption ] #else def J : JoinedOrSeparate<["-"], "J">, Flags<[RenderJoined]>, Visibility<[FlangOption, FC1Option]>, diff --git a/clang/lib/Driver/ToolChain.cpp b/clang/lib/Driver/ToolChain.cpp index 3681188a6b32..a74f3f389427 100644 --- a/clang/lib/Driver/ToolChain.cpp +++ b/clang/lib/Driver/ToolChain.cpp @@ -1422,42 +1422,26 @@ void ToolChain::AddCCKextLibArgs(const ArgList &Args, #ifdef ENABLE_CLASSIC_FLANG void ToolChain::AddFortranStdlibLibArgs(const ArgList &Args, - ArgStringList &CmdArgs) const { - bool staticFlangLibs = false; - bool useOpenMP = false; - + ArgStringList &CmdArgs) const { + bool StaticFlangLibs = false; if (Args.hasArg(options::OPT_staticFlangLibs)) { - for (auto *A: Args.filtered(options::OPT_staticFlangLibs)) { - A->claim(); - staticFlangLibs = true; - } - } - - Arg *A = Args.getLastArg(options::OPT_mp, options::OPT_nomp, - options::OPT_fopenmp, options::OPT_fno_openmp); - if (A && - (A->getOption().matches(options::OPT_mp) || - A->getOption().matches(options::OPT_fopenmp))) { - useOpenMP = true; + StaticFlangLibs = true; + Args.ClaimAllArgs(options::OPT_staticFlangLibs); } - if (staticFlangLibs) + if (StaticFlangLibs && !Args.hasArg(options::OPT_static)) CmdArgs.push_back("-Bstatic"); CmdArgs.push_back("-lflang"); CmdArgs.push_back("-lflangrti"); CmdArgs.push_back("-lpgmath"); - if (useOpenMP) - CmdArgs.push_back("-lomp"); - if (staticFlangLibs) + if (StaticFlangLibs && !Args.hasArg(options::OPT_static)) CmdArgs.push_back("-Bdynamic"); - CmdArgs.push_back("-lm"); + // Always link Fortran executables with pthreads. + CmdArgs.push_back("-lpthread"); if (!Triple.isOSDarwin()) CmdArgs.push_back("-lrt"); - - // Allways link Fortran executables with Pthreads - CmdArgs.push_back("-lpthread"); } #endif diff --git a/clang/lib/Driver/ToolChains/CommonArgs.cpp b/clang/lib/Driver/ToolChains/CommonArgs.cpp index 35be83d0c03c..6146b6ab67ad 100644 --- a/clang/lib/Driver/ToolChains/CommonArgs.cpp +++ b/clang/lib/Driver/ToolChains/CommonArgs.cpp @@ -1307,7 +1307,11 @@ bool tools::addOpenMPRuntime(const Compilation &C, ArgStringList &CmdArgs, bool ForceStaticHostRuntime, bool IsOffloadingHost, bool GompNeedsRT) { if (!Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ, - options::OPT_fno_openmp, false)) { + options::OPT_fno_openmp, false) +#ifdef ENABLE_CLASSIC_FLANG + && !Args.hasFlag(options::OPT_mp, options::OPT_nomp, false) +#endif + ) { // We need libomptarget (liboffload) if it's the choosen offloading runtime. if (Args.hasFlag(options::OPT_foffload_via_llvm, options::OPT_fno_offload_via_llvm, false)) @@ -1379,6 +1383,12 @@ void tools::addOpenMPHostOffloadingArgs(const Compilation &C, /// Add Fortran runtime libs void tools::addFortranRuntimeLibs(const ToolChain &TC, const ArgList &Args, llvm::opt::ArgStringList &CmdArgs) { +#ifdef ENABLE_CLASSIC_FLANG + if (needFortranLibs(TC.getDriver(), Args)) + TC.AddFortranStdlibLibArgs(Args, CmdArgs); + else + Args.ClaimAllArgs(options::OPT_noFlangLibs); +#else // Link FortranRuntime and FortranDecimal // These are handled earlier on Windows by telling the frontend driver to // add the correct libraries to link against as dependents in the object @@ -1414,6 +1424,7 @@ void tools::addFortranRuntimeLibs(const ToolChain &TC, const ArgList &Args, if (OMPRuntime == Driver::OMPRT_OMP && RuntimeLib == ToolChain::RLT_Libgcc) CmdArgs.push_back("-latomic"); } +#endif } void tools::addFortranRuntimeLibraryPath(const ToolChain &TC, diff --git a/clang/lib/Driver/ToolChains/Darwin.cpp b/clang/lib/Driver/ToolChains/Darwin.cpp index dabc8c0fe785..55c55bad7393 100644 --- a/clang/lib/Driver/ToolChains/Darwin.cpp +++ b/clang/lib/Driver/ToolChains/Darwin.cpp @@ -759,18 +759,6 @@ void darwin::Linker::ConstructJob(Compilation &C, const JobAction &JA, if (getToolChain().ShouldLinkCXXStdlib(Args)) getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs); -#ifdef ENABLE_CLASSIC_FLANG - // Add Fortran runtime libraries - if (needFortranLibs(getToolChain().getDriver(), Args)) { - getToolChain().AddFortranStdlibLibArgs(Args, CmdArgs); - } else { - // Claim "no Flang libraries" arguments if any - for (auto Arg : Args.filtered(options::OPT_noFlangLibs)) { - Arg->claim(); - } - } -#endif - bool NoStdOrDefaultLibs = Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs); bool ForceLinkBuiltins = Args.hasArg(options::OPT_fapple_link_rtlib); diff --git a/clang/lib/Driver/ToolChains/Gnu.cpp b/clang/lib/Driver/ToolChains/Gnu.cpp index ee057508e84b..f56eeda3cb5f 100644 --- a/clang/lib/Driver/ToolChains/Gnu.cpp +++ b/clang/lib/Driver/ToolChains/Gnu.cpp @@ -548,18 +548,6 @@ void tools::gnutools::Linker::ConstructJob(Compilation &C, const JobAction &JA, // The profile runtime also needs access to system libraries. getToolChain().addProfileRTLibs(Args, CmdArgs); -#ifdef ENABLE_CLASSIC_FLANG - // Add Fortran runtime libraries - if (needFortranLibs(D, Args)) { - ToolChain.AddFortranStdlibLibArgs(Args, CmdArgs); - } else { - // Claim "no Flang libraries" arguments if any - for (auto Arg : Args.filtered(options::OPT_noFlangLibs)) { - Arg->claim(); - } - } -#endif - if (D.CCCIsCXX() && !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs, options::OPT_r)) { diff --git a/clang/test/Driver/flang/classic-flang.f95 b/clang/test/Driver/flang/classic-flang.f95 index 6fce9c61713c..bc51c6e0c380 100644 --- a/clang/test/Driver/flang/classic-flang.f95 +++ b/clang/test/Driver/flang/classic-flang.f95 @@ -41,3 +41,49 @@ ! CHECK-ASM-SAME: "-o" "classic-flang.s" ! CHECK-ASM-SAME: "-x" "ir" ! CHECK-ASM-SAME: [[LLFILE]] + +! Check that the linker job is given the correct libraries and library paths. + +! RUN: %flang -target x86_64-linux-gnu -ccc-install-dir %S/../Inputs/basic_linux_tree/usr/bin -mp \ +! RUN: %s -lfoo -### 2>&1 | FileCheck --check-prefixes=CHECK-LD,CHECK-DYNAMIC-FLANG,CHECK-DYNAMIC-OMP %s +! RUN: %flang -target x86_64-linux-gnu -ccc-install-dir %S/../Inputs/basic_linux_tree/usr/bin -mp -nomp \ +! RUN: %s -lfoo -### 2>&1 | FileCheck --check-prefixes=CHECK-LD,CHECK-DYNAMIC-FLANG,CHECK-NO-OMP %s +! RUN: %flang -target x86_64-linux-gnu -ccc-install-dir %S/../Inputs/basic_linux_tree/usr/bin -fopenmp \ +! RUN: %s -lfoo -### 2>&1 | FileCheck --check-prefixes=CHECK-LD,CHECK-DYNAMIC-FLANG,CHECK-DYNAMIC-OMP %s +! RUN: %flang -target x86_64-linux-gnu -ccc-install-dir %S/../Inputs/basic_linux_tree/usr/bin -fopenmp -fno-openmp \ +! RUN: %s -lfoo -### 2>&1 | FileCheck --check-prefixes=CHECK-LD,CHECK-DYNAMIC-FLANG,CHECK-NO-OMP %s +! RUN: %flang -target x86_64-linux-gnu -ccc-install-dir %S/../Inputs/basic_linux_tree/usr/bin -fopenmp -static-openmp \ +! RUN: %s -lfoo -### 2>&1 | FileCheck --check-prefixes=CHECK-LD,CHECK-DYNAMIC-FLANG,CHECK-STATIC-OMP %s +! RUN: %flang -target x86_64-linux-gnu -ccc-install-dir %S/../Inputs/basic_linux_tree/usr/bin -fopenmp -static-flang-libs \ +! RUN: %s -lfoo -### 2>&1 | FileCheck --check-prefixes=CHECK-LD,CHECK-STATIC-FLANG,CHECK-DYNAMIC-OMP %s +! RUN: %flang -target x86_64-linux-gnu -ccc-install-dir %S/../Inputs/basic_linux_tree/usr/bin -static-flang-libs \ +! RUN: %s -lfoo -### 2>&1 | FileCheck --check-prefixes=CHECK-LD,CHECK-STATIC-FLANG,CHECK-NO-OMP %s + +! CHECK-LD: "{{.*}}ld" +! CHECK-LD-NOT: "-static" +! CHECK-LD: "{{[^"]*}}classic-flang-{{[^ ]*}}.o" "-lflangmain" "-lfoo" "-L{{[^ ]*}}/basic_linux_tree/usr/lib" +! CHECK-DYNAMIC-FLANG-NOT: "-Bstatic" +! CHECK-DYNAMIC-FLANG: "-lflang" "-lflangrti" "-lpgmath" "-lpthread" "-lrt" "-lm" +! CHECK-DYNAMIC-FLANG-NOT: "-Bdynamic" +! CHECK-STATIC-FLANG: "-Bstatic" "-lflang" "-lflangrti" "-lpgmath" "-Bdynamic" "-lpthread" "-lrt" "-lm" +! CHECK-DYNAMIC-OMP-NOT: "-Bstatic" +! CHECK-DYNAMIC-OMP: "-lomp" "-rpath" "{{[^ ]*}}/basic_linux_tree/usr/lib" +! CHECK-DYNAMIC-OMP-NOT: "-Bdynamic" +! CHECK-STATIC-OMP: "-Bstatic" "-lomp" "-Bdynamic" "-rpath" "{{[^ ]*}}/basic_linux_tree/usr/lib" +! CHECK-NO-OMP-NOT: "-lomp" + +! RUN: %flang -target x86_64-linux-gnu -ccc-install-dir %S/../Inputs/basic_linux_tree/usr/bin -static -static-flang-libs \ +! RUN: %s -lfoo -### 2>&1 | FileCheck --check-prefixes=CHECK-LD-STATIC,CHECK-NO-OMP %s +! RUN: %flang -target x86_64-linux-gnu -ccc-install-dir %S/../Inputs/basic_linux_tree/usr/bin -static -fopenmp \ +! RUN: %s -lfoo -### 2>&1 | FileCheck --check-prefixes=CHECK-LD-STATIC,CHECK-STATIC-BOTH %s +! RUN: %flang -target x86_64-linux-gnu -ccc-install-dir %S/../Inputs/basic_linux_tree/usr/bin -static -fopenmp -static-openmp \ +! RUN: %s -lfoo -### 2>&1 | FileCheck --check-prefixes=CHECK-LD-STATIC,CHECK-STATIC-BOTH %s +! CHECK-LD-STATIC: "{{.*}}ld" +! CHECK-LD-STATIC: "-static" "-o" "a.out" +! CHECK-LD-STATIC: "{{[^"]*}}classic-flang-{{[^ ]*}}.o" "-lflangmain" "-lfoo" "-L{{[^ ]*}}/basic_linux_tree/usr/lib" +! CHECK-LD-STATIC-NOT: "-Bstatic" +! CHECK-LD-STATIC: "-lflang" "-lflangrti" "-lpgmath" "-lpthread" "-lrt" "-lm" +! CHECK-LD-STATIC-NOT: "-Bdynamic" +! CHECK-STATIC-BOTH-NOT: "-Bstatic" +! CHECK-STATIC-BOTH: "-lomp" +! CHECK-STATIC-BOTH-NOT: "-Bdynamic" From d9c5175699884a462718080bbaffe72eaa37d409 Mon Sep 17 00:00:00 2001 From: Bryan Chan Date: Thu, 8 Sep 2022 09:35:31 -0400 Subject: [PATCH 25/60] [OpenMP] Exclude a test that fails on smaller GitHub runners --- openmp/runtime/test/ompt/teams/distribute_dispatch.c | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/openmp/runtime/test/ompt/teams/distribute_dispatch.c b/openmp/runtime/test/ompt/teams/distribute_dispatch.c index 1dcede84f28e..ff1d68f2d697 100644 --- a/openmp/runtime/test/ompt/teams/distribute_dispatch.c +++ b/openmp/runtime/test/ompt/teams/distribute_dispatch.c @@ -4,6 +4,11 @@ /// GCC lowering of distribute results in calls to /// omp_get_num_teams/omp_get_team_num rather than region calls // UNSUPPORTED: gcc + +// This test expects 4 teams of 1 thread each to be created, and fails +// on CI runners with insufficient resources. +// UNSUPPORTED: linux + #include "callback.h" #define WORK_SIZE 64 From 6909deef6b12d47f375108cc92c998ee4deca09f Mon Sep 17 00:00:00 2001 From: Bryan Chan Date: Thu, 3 Nov 2022 08:57:43 -0400 Subject: [PATCH 26/60] [AsmPrinter] Delete dead code; NFC Delete some snippets that had been commented out since commit a10f592d3b027 in release_13x. --- llvm/lib/CodeGen/AsmPrinter/DebugLocEntry.h | 35 ----------- llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp | 70 --------------------- llvm/lib/CodeGen/AsmPrinter/DwarfDebug.h | 8 --- 3 files changed, 113 deletions(-) diff --git a/llvm/lib/CodeGen/AsmPrinter/DebugLocEntry.h b/llvm/lib/CodeGen/AsmPrinter/DebugLocEntry.h index 8adecd02cb72..462ca6fb1f0b 100644 --- a/llvm/lib/CodeGen/AsmPrinter/DebugLocEntry.h +++ b/llvm/lib/CodeGen/AsmPrinter/DebugLocEntry.h @@ -226,15 +226,6 @@ class DbgValueLoc { LLVM_DUMP_METHOD void dump() const { for (const DbgValueLocEntry &DV : ValueLocEntries) DV.dump(); -// if (isLocation()) { -// llvm::dbgs() << "Loc = { reg=" << Loc.getReg() << " "; -// if (Loc.isIndirect()) -// llvm::dbgs() << "+0"; -// llvm::dbgs() << "} "; -// } else if (isConstantInt()) -// Constant.CIP->dump(); -// else if (isConstantFP()) -// Constant.CFP->dump(); if (Expression) Expression->dump(); } @@ -311,9 +302,6 @@ class DebugLocEntry { DebugLocStream::ListBuilder &List, const DIBasicType *BT, DwarfCompileUnit &TheCU); - -// void finalize(const AsmPrinter &AP, DebugLocStream::ListBuilder &List, -// const DIStringType *ST, DwarfCompileUnit &TheCU); }; /// Compare two DbgValueLocEntries for equality. @@ -342,29 +330,6 @@ inline bool operator==(const DbgValueLoc &A, const DbgValueLoc &B) { A.Expression == B.Expression && A.IsVariadic == B.IsVariadic; } -//inline bool operator==(const DbgValueLoc &A, -// const DbgValueLoc &B) { -// if (A.EntryKind != B.EntryKind) -// return false; -// -// if (A.Expression != B.Expression) -// return false; -// -// switch (A.EntryKind) { -// case DbgValueLoc::E_Location: -// return A.Loc == B.Loc; -// case DbgValueLoc::E_TargetIndexLocation: -// return A.TIL == B.TIL; -// case DbgValueLoc::E_Integer: -// return A.Constant.Int == B.Constant.Int; -// case DbgValueLoc::E_ConstantFP: -// return A.Constant.CFP == B.Constant.CFP; -// case DbgValueLoc::E_ConstantInt: -// return A.Constant.CIP == B.Constant.CIP; -// } -// llvm_unreachable("unhandled EntryKind"); -//} - /// Compare two fragments based on their offset. inline bool operator<(const DbgValueLoc &A, const DbgValueLoc &B) { diff --git a/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp b/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp index 2b70820e2923..60d911d0383e 100644 --- a/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp +++ b/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp @@ -1873,28 +1873,10 @@ DbgEntity *DwarfDebug::createConcreteEntity(DwarfCompileUnit &TheCU, return ConcreteEntities.back().get(); } -#if 0 -void DwarfDebug::populateDependentTypeMap() { - for (const auto &I : DbgValues) { - InlinedEntity IV = I.first; - if (I.second.empty()) - continue; - if (const DIVariable *DIV = dyn_cast(IV.first)) { - if (const DIStringType *ST = dyn_cast( - static_cast(DIV->getType()))) - if (const DIVariable *LV = ST->getStringLength()) - VariableInDependentType[LV] = ST; - } - } -} -#endif - // Find variables for each lexical scope. void DwarfDebug::collectEntityInfo(DwarfCompileUnit &TheCU, const DISubprogram *SP, DenseSet &Processed) { -// clearDependentTracking(); -// populateDependentTypeMap(); // Grab the variable info that was squirreled away in the MMI side-table. collectVariableInfoFromMFTable(TheCU, Processed); @@ -1913,11 +1895,6 @@ void DwarfDebug::collectEntityInfo(DwarfCompileUnit &TheCU, LexicalScope *Scope = nullptr; const DILocalVariable *LocalVar = cast(IV.first); -#if 0 - const DILocalVariable *LocalVar = dyn_cast(IV.first); - if (!LocalVar) - continue; -#endif if (const DILocation *IA = IV.second) Scope = LScopes.findInlinedScope(LocalVar->getScope(), IA); else @@ -1972,24 +1949,6 @@ void DwarfDebug::collectEntityInfo(DwarfCompileUnit &TheCU, // Finalize the entry by lowering it into a DWARF bytestream. for (auto &Entry : Entries) Entry.finalize(*Asm, List, BT, TheCU); -#if 0 - List.finalize(); - - if (VariableInDependentType.count(LocalVar)) { - const DIType *DT = VariableInDependentType[LocalVar]; - if (const DIStringType *ST = dyn_cast(DT)) { - unsigned Offset; - DbgVariable TVar = {LocalVar, IV.second}; - DebugLocStream::ListBuilder LB(DebugLocs, TheCU, *Asm, TVar, *MInsn); - for (auto &Entry : Entries) - Entry.finalize(*Asm, LB, ST, TheCU); - LB.finalize(); - Offset = TVar.getDebugLocListIndex(); - if (Offset != ~0u) - addStringTypeLoc(ST, Offset); - } - } -#endif } // For each InlinedEntity collected from DBG_LABEL instructions, convert to @@ -3059,35 +3018,6 @@ void DebugLocEntry::finalize(const AsmPrinter &AP, List.setTagOffset(*DwarfExpr.TagOffset); } -#if 0 -inline static DbgValueLoc mkDbgValueLoc(const DIExpression *expr, - DbgValueLoc &value) { - if (value.isInt()) - return DbgValueLoc(expr, value.getInt()); - if (value.isLocation()) - return DbgValueLoc(expr, value.getLoc()); - if (value.isConstantInt()) - return DbgValueLoc(expr, value.getConstantInt()); - assert(value.isConstantFP()); - return DbgValueLoc(expr, value.getConstantFP()); -} - -void DebugLocEntry::finalize(const AsmPrinter &AP, - DebugLocStream::ListBuilder &List, - const DIStringType *ST, - DwarfCompileUnit &TheCU) { - DebugLocStream::EntryBuilder Entry(List, Begin, End); - BufferByteStreamer Streamer = Entry.getStreamer(); - DebugLocDwarfExpression DwarfExpr(AP.getDwarfVersion(), Streamer, TheCU); - DbgValueLoc &Value = Values[0]; - assert(!Value.isFragment()); - assert(Values.size() == 1 && "only fragments may have >1 value"); - Value = mkDbgValueLoc(ST->getStringLengthExp(), Value); - DwarfDebug::emitDebugLocValue(AP, nullptr, Value, DwarfExpr); - DwarfExpr.finalize(); -} -#endif - void DwarfDebug::emitDebugLocEntryLocation(const DebugLocStream::Entry &Entry, const DwarfCompileUnit *CU) { // Emit the size. diff --git a/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.h b/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.h index 27b2519d879d..9538cd0d46d9 100644 --- a/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.h +++ b/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.h @@ -705,14 +705,6 @@ class DwarfDebug : public DebugHandlerBase { void findForceIsStmtInstrs(const MachineFunction *MF); -#if 0 - /// Populate dependent type variable map - void populateDependentTypeMap(); -#endif - - /// Clear dependent type tracking map - void clearDependentTracking() { VariableInDependentType.clear(); } - protected: /// Gather pre-function debug information. void beginFunctionImpl(const MachineFunction *MF) override; From 144a0a27dd8c4e76933c4b893e32991a9617a47e Mon Sep 17 00:00:00 2001 From: wangfangcao Date: Wed, 2 Nov 2022 10:13:53 +0800 Subject: [PATCH 27/60] [driver] Allow -msve-vector-bits=+ syntax to mean no maximum vscale --- clang/lib/Driver/ToolChains/ClassicFlang.cpp | 50 ++++++++++++------- .../flang/classic-flang-vscale-mbits.f95 | 28 +++++++++++ .../Driver/flang/classic-flang-vscale.f95 | 28 +++++++++++ 3 files changed, 87 insertions(+), 19 deletions(-) create mode 100644 clang/test/Driver/flang/classic-flang-vscale-mbits.f95 create mode 100644 clang/test/Driver/flang/classic-flang-vscale.f95 diff --git a/clang/lib/Driver/ToolChains/ClassicFlang.cpp b/clang/lib/Driver/ToolChains/ClassicFlang.cpp index 4114ecd09404..9a29985739fa 100644 --- a/clang/lib/Driver/ToolChains/ClassicFlang.cpp +++ b/clang/lib/Driver/ToolChains/ClassicFlang.cpp @@ -1031,37 +1031,49 @@ void ClassicFlang::ConstructJob(Compilation &C, const JobAction &JA, } // Add vscale range - unsigned vscaleMin = 1U; - unsigned vscaleMax = 16U; - bool hasVscaleRange = false; + unsigned vscaleMin = 0; + unsigned vscaleMax = 0; + bool hasSVE = false; if (Arg *A = Args.getLastArg(options::OPT_msve_vector_bits_EQ)) { StringRef Val = A->getValue(); - - if (Val == "scalable") - hasVscaleRange = true; - else { - unsigned bits = (std::stoul(Val.str()) >> 7U); - - if ((bits < vscaleMin) || (bits > vscaleMax)) { - D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args); - hasVscaleRange = false; - } else { - vscaleMin = vscaleMax = bits; - hasVscaleRange = true; + if (Val == "128" || Val == "256" || Val == "512" || Val == "1024" || + Val == "2048" || Val == "128+" || Val == "256+" || Val == "512+" || + Val == "1024+" || Val == "2048+") { + unsigned Bits = 0; + if (Val.ends_with("+")) + Val = Val.substr(0, Val.size() - 1); + else { + bool Invalid = Val.getAsInteger(10, Bits); (void)Invalid; + assert(!Invalid && "Failed to parse value"); + vscaleMax = Bits / 128; } - } + + bool Invalid = Val.getAsInteger(10, Bits); (void)Invalid; + assert(!Invalid && "Failed to parse value"); + vscaleMin = Bits / 128; + } else if (Val != "scalable") + getToolChain().getDriver().Diag(diag::warn_drv_clang_unsupported) + << A->getOption().getName() << Val; } for (auto Feature : unifyTargetFeatures(Features)) { if (Feature.starts_with("+sve")) { - hasVscaleRange = true; + hasSVE = true; break; } } - if (hasVscaleRange) { + if (vscaleMin || vscaleMax) { LowerCmdArgs.push_back("-vscale_range_min"); - LowerCmdArgs.push_back(Args.MakeArgString(std::to_string(vscaleMin))); + LowerCmdArgs.push_back(Args.MakeArgString( + std::to_string(vscaleMin ? vscaleMin : 1))); LowerCmdArgs.push_back("-vscale_range_max"); LowerCmdArgs.push_back(Args.MakeArgString(std::to_string(vscaleMax))); + } else { + if (hasSVE) { + LowerCmdArgs.push_back("-vscale_range_min"); + LowerCmdArgs.push_back(Args.MakeArgString(std::to_string(1))); + LowerCmdArgs.push_back("-vscale_range_max"); + LowerCmdArgs.push_back(Args.MakeArgString(std::to_string(16))); + } } // Set a -x flag for second part of Fortran frontend diff --git a/clang/test/Driver/flang/classic-flang-vscale-mbits.f95 b/clang/test/Driver/flang/classic-flang-vscale-mbits.f95 new file mode 100644 index 000000000000..f0ed43aa027a --- /dev/null +++ b/clang/test/Driver/flang/classic-flang-vscale-mbits.f95 @@ -0,0 +1,28 @@ +// RUN: %clang --driver-mode=flang -### -S --target=aarch64 -march=armv8-a+sve -msve-vector-bits=128 %s 2>&1 | FileCheck -check-prefix=CHECK-SVE-128 %s +// RUN: %clang --driver-mode=flang -### -S --target=aarch64 -march=armv8-a+sve -msve-vector-bits=128+ %s 2>&1 | FileCheck -check-prefix=CHECK-SVE-128PLUS %s +// RUN: %clang --driver-mode=flang -### -S --target=aarch64 -march=armv8-a+sve -msve-vector-bits=256 %s 2>&1 | FileCheck -check-prefix=CHECK-SVE-256 %s +// RUN: %clang --driver-mode=flang -### -S --target=aarch64 -march=armv8-a+sve -msve-vector-bits=256+ %s 2>&1 | FileCheck -check-prefix=CHECK-SVE-256PLUS %s +// RUN: %clang --driver-mode=flang -### -S --target=aarch64 -march=armv8-a+sve2 -msve-vector-bits=512 %s 2>&1 | FileCheck -check-prefix=CHECK-SVE2-512 %s +// RUN: %clang --driver-mode=flang -### -S --target=aarch64 -march=armv8-a+sve2 -msve-vector-bits=512+ %s 2>&1 | FileCheck -check-prefix=CHECK-SVE2-512PLUS %s +// RUN: %clang --driver-mode=flang -### -S --target=aarch64 -march=armv8-a+sve2-sha3 -msve-vector-bits=2048 %s 2>&1 | FileCheck -check-prefix=CHECK-SVE2SHA3-2048 %s +// RUN: %clang --driver-mode=flang -### -S --target=aarch64 -march=armv8-a+sve2-sha3 -msve-vector-bits=2048+ %s 2>&1 | FileCheck -check-prefix=CHECK-SVE2SHA3-2048PLUS %s +// RUN: %clang --driver-mode=flang -### -S --target=aarch64 -march=armv8-a+sve2 -msve-vector-bits=scalable %s 2>&1 | FileCheck -check-prefix=CHECK-SVE2-SCALABLE %s + +// CHECK-SVE-128: "-target_features" "+neon,+v8a,+sve" +// CHECK-SVE-128-DAG: "-vscale_range_min" "1" "-vscale_range_max" "1" +// CHECK-SVE-128PLUS: "-target_features" "+neon,+v8a,+sve" +// CHECK-SVE-128PLUS-DAG: "-vscale_range_min" "1" "-vscale_range_max" "0" +// CHECK-SVE-256: "-target_features" "+neon,+v8a,+sve" +// CHECK-SVE-256-DAG: "-vscale_range_min" "2" "-vscale_range_max" "2" +// CHECK-SVE-256PLUS: "-target_features" "+neon,+v8a,+sve" +// CHECK-SVE-256PLUS-DAG: "-vscale_range_min" "2" "-vscale_range_max" "0" +// CHECK-SVE2-512: "-target_features" "+neon,+v8a,+sve2,+sve" +// CHECK-SVE2-512-DAG: "-vscale_range_min" "4" "-vscale_range_max" "4" +// CHECK-SVE2-512PLUS: "-target_features" "+neon,+v8a,+sve2,+sve" +// CHECK-SVE2-512PLUS-DAG: "-vscale_range_min" "4" "-vscale_range_max" "0" +// CHECK-SVE2SHA3-2048: "-target_features" "+neon,+v8a,+sve2-sha3,+sve,+sve2" +// CHECK-SVE2SHA3-2048-DAG: "-vscale_range_min" "16" "-vscale_range_max" "16" +// CHECK-SVE2SHA3-2048PLUS: "-target_features" "+neon,+v8a,+sve2-sha3,+sve,+sve2" +// CHECK-SVE2SHA3-2048PLUS-DAG: "-vscale_range_min" "16" "-vscale_range_max" "0" +// CHECK-SVE2-SCALABLE: "-target_features" "+neon,+v8a,+sve2,+sve" +// CHECK-SVE2-SCALABLE-DAG: "-vscale_range_min" "1" "-vscale_range_max" "16" diff --git a/clang/test/Driver/flang/classic-flang-vscale.f95 b/clang/test/Driver/flang/classic-flang-vscale.f95 new file mode 100644 index 000000000000..8110be594db5 --- /dev/null +++ b/clang/test/Driver/flang/classic-flang-vscale.f95 @@ -0,0 +1,28 @@ +// RUN: %clang --driver-mode=flang -### -S --target=aarch64 -march=armv8-a %s 2>&1 | FileCheck -check-prefix=CHECK-NEON %s +// RUN: %clang --driver-mode=flang -### -S --target=aarch64 -march=armv8-a+sve %s 2>&1 | FileCheck -check-prefix=CHECK-SVE %s +// RUN: %clang --driver-mode=flang -### -S --target=aarch64 -march=armv8-a+sve2 %s 2>&1 | FileCheck -check-prefix=CHECK-SVE2 %s +// RUN: %clang --driver-mode=flang -### -S --target=aarch64 -march=armv8-a+sve2-sha3 %s 2>&1 | FileCheck -check-prefix=CHECK-SVE2SHA3 %s +// RUN: %clang --driver-mode=flang -### -S --target=aarch64 -march=armv8-a+sve+nosve %s 2>&1 | FileCheck -check-prefix=CHECK-SVE-NOSVE %s +// RUN: %clang --driver-mode=flang -### -S --target=aarch64 -march=armv8-a+sve2+nosve2-sha3 %s 2>&1 | FileCheck -check-prefix=CHECK-SVE2-NOSVE2SHA3 %s +// RUN: %clang --driver-mode=flang -### -S --target=aarch64 -march=armv8-a+sve2-sha3+nosve2 %s 2>&1 | FileCheck -check-prefix=CHECK-SVE2SHA3-NOSVE2 %s +// RUN: %clang --driver-mode=flang -### -S --target=aarch64 -march=armv8-a+sve2-sha3+nosve %s 2>&1 | FileCheck -check-prefix=CHECK-SVE2SHA3-NOSVE %s + +// CHECK-NEON: "-target_features" "+neon,+v8a" +// CHECK-NEON-NOT: "-vscale_range_min" +// CHECK-NEON-NOT: "-vscale_range_max" +// CHECK-SVE: "-target_features" "+neon,+v8a,+sve" +// CHECK-SVE-DAG: "-vscale_range_min" "1" "-vscale_range_max" "16" +// CHECK-SVE2: "-target_features" "+neon,+v8a,+sve2,+sve" +// CHECK-SVE2-DAG: "-vscale_range_min" "1" "-vscale_range_max" "16" +// CHECK-SVE2SHA3: "-target_features" "+neon,+v8a,+sve2-sha3,+sve,+sve2" +// CHECK-SVE2SHA3-DAG: "-vscale_range_min" "1" "-vscale_range_max" "16" +// CHECK-SVE-NOSVE: "-target_features" "+neon,+v8a,-sve,-sve2,-sve2-bitperm,-sve2-sha3,-sve2-aes,-sve2-sm4" +// CHECK-SVE-NOSVE-NOT: "-vscale_range_min" +// CHECK-SVE-NOSVE-NOT: "-vscale_range_max" +// CHECK-SVE2-NOSVE2SHA3: "-target_features" "+neon,+v8a,+sve2,+sve,-sve2-sha3" +// CHECK-SVE2-NOSVE2SHA3-DAG: "-vscale_range_min" "1" "-vscale_range_max" "16" +// CHECK-SVE2SHA3-NOSVE2: "-target_features" "+neon,+v8a,+sve,-sve2,-sve2-bitperm,-sve2-sha3,-sve2-aes,-sve2-sm4" +// CHECK-SVE2SHA3-NOSVE2-DAG: "-vscale_range_min" "1" "-vscale_range_max" "16" +// CHECK-SVE2SHA3-NOSVE: "-target_features" "+neon,+v8a,-sve,-sve2,-sve2-bitperm,-sve2-sha3,-sve2-aes,-sve2-sm4" +// CHECK-SVE2SHA3-NOSVE-NOT: "-vscale_range_min" +// CHECK-SVE2SHA3-NOSVE-NOT: "-vscale_range_max" From 0a0e78be73382409ead2976fd98bdc02a7a1f967 Mon Sep 17 00:00:00 2001 From: Kiran Chandramohan Date: Tue, 21 Jan 2020 23:37:22 +0000 Subject: [PATCH 28/60] Changes for reassoc attributes This patch adds code to generate the driver flags so that llvm bridge in flang2 can generate the nsz, reassoc attributes to arithmetic instructions. Also included is a testcase. --- clang/lib/Driver/ToolChains/ClassicFlang.cpp | 33 ++++++++++- clang/test/Driver/flang/reassoc.f90 | 59 ++++++++++++++++++++ 2 files changed, 89 insertions(+), 3 deletions(-) create mode 100644 clang/test/Driver/flang/reassoc.f90 diff --git a/clang/lib/Driver/ToolChains/ClassicFlang.cpp b/clang/lib/Driver/ToolChains/ClassicFlang.cpp index 9a29985739fa..eba1fd6b2e97 100644 --- a/clang/lib/Driver/ToolChains/ClassicFlang.cpp +++ b/clang/lib/Driver/ToolChains/ClassicFlang.cpp @@ -70,6 +70,8 @@ void ClassicFlang::ConstructJob(Compilation &C, const JobAction &JA, bool NeedIEEE = true; bool NeedFastMath = false; bool NeedRelaxedMath = false; + bool AssociativeMath = false; + bool SignedZeros = true; // Check number of inputs for sanity. We need at least one input. assert(Inputs.size() >= 1 && "Must have at least one input."); @@ -510,14 +512,18 @@ void ClassicFlang::ConstructJob(Compilation &C, const JobAction &JA, */ for(Arg *A: Args.filtered(options::OPT_ffast_math, options::OPT_fno_fast_math, options::OPT_Ofast, options::OPT_Kieee_off, - options::OPT_Kieee_on, options::OPT_frelaxed_math)) { + options::OPT_Kieee_on, options::OPT_frelaxed_math, + options::OPT_fassociative_math, + options::OPT_fno_associative_math, + options::OPT_fsigned_zeros, + options::OPT_fno_signed_zeros)) { if (A->getOption().matches(options::OPT_ffast_math) || A->getOption().matches(options::OPT_Ofast)) { NeedIEEE = NeedRelaxedMath = false; NeedFastMath = true; } else if (A->getOption().matches(options::OPT_Kieee_on)) { - NeedFastMath = NeedRelaxedMath = false; - NeedIEEE = true; + NeedFastMath = NeedRelaxedMath = AssociativeMath = false; + NeedIEEE = SignedZeros = true; } else if (A->getOption().matches(options::OPT_frelaxed_math)) { NeedFastMath = NeedIEEE = false; NeedRelaxedMath = true; @@ -525,6 +531,16 @@ void ClassicFlang::ConstructJob(Compilation &C, const JobAction &JA, NeedFastMath = false; } else if (A->getOption().matches(options::OPT_Kieee_off)) { NeedIEEE = false; + } else if (A->getOption().matches(options::OPT_fassociative_math)) { + AssociativeMath = true; + NeedIEEE = SignedZeros = false; + } else if (A->getOption().matches(options::OPT_fno_associative_math)) { + AssociativeMath = false; + } else if (A->getOption().matches(options::OPT_fsigned_zeros)) { + SignedZeros = true; + AssociativeMath = false; + } else if (A->getOption().matches(options::OPT_fno_signed_zeros)) { + SignedZeros = NeedIEEE = false; } A->claim(); } @@ -1012,6 +1028,17 @@ void ClassicFlang::ConstructJob(Compilation &C, const JobAction &JA, LowerCmdArgs.push_back("-x"); LowerCmdArgs.push_back("189"); LowerCmdArgs.push_back("0x10"); LowerCmdArgs.push_back("-y"); LowerCmdArgs.push_back("189"); LowerCmdArgs.push_back("0x4000000"); + if (!SignedZeros) { + LowerCmdArgs.push_back("-x"); + LowerCmdArgs.push_back("216"); + LowerCmdArgs.push_back("0x8"); + } + if (AssociativeMath) { + LowerCmdArgs.push_back("-x"); + LowerCmdArgs.push_back("216"); + LowerCmdArgs.push_back("0x10"); + } + // Remove "noinline" attriblute LowerCmdArgs.push_back("-x"); LowerCmdArgs.push_back("183"); LowerCmdArgs.push_back("0x10"); diff --git a/clang/test/Driver/flang/reassoc.f90 b/clang/test/Driver/flang/reassoc.f90 new file mode 100644 index 000000000000..fe42087f7070 --- /dev/null +++ b/clang/test/Driver/flang/reassoc.f90 @@ -0,0 +1,59 @@ +! REQUIRES: classic_flang + +! Tests for flags which generate nsw, reassoc attributes + +! RUN: %flang -Kieee %s -### 2>&1 | FileCheck --check-prefixes=IEEE,NO_FAST,NO_RELAXED,NO_REASSOC,NO_NSZ %s +! RUN: %flang -Knoieee %s -### 2>&1 | FileCheck --check-prefixes=NO_IEEE,NO_FAST,NO_RELAXED,NO_REASSOC,NO_NSZ %s +! RUN: %flang -ffast-math %s -### 2>&1 | FileCheck --check-prefixes=NO_IEEE,FAST,NO_RELAXED,NO_REASSOC,NO_NSZ %s +! RUN: %flang -fno-fast-math %s -### 2>&1 | FileCheck --check-prefixes=NO_FAST,NO_RELAXED,NO_REASSOC,NO_NSZ %s +! RUN: %flang -frelaxed-math %s -### 2>&1 | FileCheck --check-prefixes=NO_IEEE,NO_FAST,RELAXED,NO_REASSOC,NO_NSZ %s +! RUN: %flang -fassociative-math %s -### 2>&1 | FileCheck --check-prefixes=NO_IEEE,NO_FAST,NO_RELAXED,REASSOC_NSZ %s +! RUN: %flang -fno-associative-math %s -### 2>&1 | FileCheck --check-prefixes=NO_FAST,NO_RELAXED,NO_REASSOC,NO_NSZ %s +! RUN: %flang -fsigned-zeros %s -### 2>&1 | FileCheck --check-prefixes=NO_FAST,NO_RELAXED,NO_REASSOC,NO_NSZ %s +! RUN: %flang -fno-signed-zeros %s -### 2>&1 | FileCheck --check-prefixes=NO_IEEE,NO_FAST,NO_RELAXED,NO_REASSOC,NSZ %s + +! RUN: %flang -fno-associative-math -fno-signed-zeros %s -### 2>&1 | FileCheck --check-prefixes=NO_IEEE,NO_FAST,NO_RELAXED,NO_REASSOC,NSZ %s +! RUN: %flang -fno-associative-math -fsigned-zeros %s -### 2>&1 | FileCheck --check-prefixes=NO_FAST,NO_RELAXED,NO_REASSOC,NO_NSZ %s +! RUN: %flang -fassociative-math -fno-signed-zeros %s -### 2>&1 | FileCheck --check-prefixes=NO_IEEE,NO_FAST,NO_RELAXED,REASSOC_NSZ %s +! RUN: %flang -fassociative-math -fsigned-zeros %s -### 2>&1 | FileCheck --check-prefixes=NO_IEEE,NO_FAST,NO_RELAXED,NO_REASSOC,NO_NSZ %s + +! RUN: %flang -Kieee -fassociative-math %s -### 2>&1 | FileCheck --check-prefixes=NO_IEEE,NO_FAST,NO_RELAXED,REASSOC_NSZ %s +! RUN: %flang -Kieee -fno-associative-math %s -### 2>&1 | FileCheck --check-prefixes=IEEE,NO_FAST,NO_RELAXED,NO_REASSOC,NO_NSZ %s +! RUN: %flang -Kieee -fsigned-zeros %s -### 2>&1 | FileCheck --check-prefixes=IEEE,NO_FAST,NO_RELAXED,NO_REASSOC,NO_NSZ %s +! RUN: %flang -Kieee -fno-signed-zeros %s -### 2>&1 | FileCheck --check-prefixes=NO_IEEE,NO_FAST,NO_RELAXED,NO_REASSOC,NSZ %s +! RUN: %flang -ffast-math -fassociative-math %s -### 2>&1 | FileCheck --check-prefixes=NO_IEEE,NO_RELAXED,REASSOC_NSZ %s +! RUN: %flang -ffast-math -fno-associative-math %s -### 2>&1 | FileCheck --check-prefixes=NO_IEEE,FAST,NO_RELAXED,NO_REASSOC,NO_NSZ %s +! RUN: %flang -ffast-math -fsigned-zeros %s -### 2>&1 | FileCheck --check-prefixes=NO_IEEE,FAST,NO_RELAXED,NO_REASSOC,NO_NSZ %s +! RUN: %flang -ffast-math -fno-signed-zeros %s -### 2>&1 | FileCheck --check-prefixes=NO_IEEE,NO_RELAXED,NO_REASSOC,NSZ %s +! RUN: %flang -frelaxed-math -fassociative-math %s -### 2>&1 | FileCheck --check-prefixes=NO_IEEE,NO_FAST,REASSOC_NSZ %s +! RUN: %flang -frelaxed-math -fno-associative-math %s -### 2>&1 | FileCheck --check-prefixes=NO_IEEE,NO_FAST,RELAXED,NO_REASSOC,NO_NSZ %s +! RUN: %flang -frelaxed-math -fsigned-zeros %s -### 2>&1 | FileCheck --check-prefixes=NO_IEEE,NO_FAST,RELAXED,NO_REASSOC,NO_NSZ %s +! RUN: %flang -frelaxed-math -fno-signed-zeros %s -### 2>&1 | FileCheck --check-prefixes=NO_IEEE,NO_FAST,NO_REASSOC,NSZ %s + +! RUN: %flang -fassociative-math -Kieee %s -### 2>&1 | FileCheck --check-prefixes=IEEE,NO_FAST,NO_RELAXED,NO_REASSOC,NO_NSZ %s +! RUN: %flang -fno-associative-math -Kieee %s -### 2>&1 | FileCheck --check-prefixes=IEEE,NO_FAST,NO_RELAXED,NO_REASSOC,NO_NSZ %s +! RUN: %flang -fsigned-zeros -Kieee %s -### 2>&1 | FileCheck --check-prefixes=IEEE,NO_FAST,NO_RELAXED,NO_REASSOC,NO_NSZ %s +! RUN: %flang -fno-signed-zeros -Kieee %s -### 2>&1 | FileCheck --check-prefixes=IEEE,NO_FAST,NO_RELAXED,NO_REASSOC,NO_NSZ %s +! RUN: %flang -fassociative-math -ffast-math %s -### 2>&1 | FileCheck --check-prefixes=NO_IEEE,NO_RELAXED,REASSOC_NSZ %s +! RUN: %flang -fno-associative-math -ffast-math %s -### 2>&1 | FileCheck --check-prefixes=NO_IEEE,FAST,NO_RELAXED,NO_REASSOC,NO_NSZ %s +! RUN: %flang -fsigned-zeros -ffast-math %s -### 2>&1 | FileCheck --check-prefixes=NO_IEEE,FAST,NO_RELAXED,NO_REASSOC,NO_NSZ %s +! RUN: %flang -fno-signed-zeros -ffast-math %s -### 2>&1 | FileCheck --check-prefixes=NO_IEEE,NO_RELAXED,NO_REASSOC,NSZ %s +! RUN: %flang -fassociative-math -frelaxed-math %s -### 2>&1 | FileCheck --check-prefixes=NO_IEEE,NO_FAST,REASSOC_NSZ %s +! RUN: %flang -fno-associative-math -frelaxed-math %s -### 2>&1 | FileCheck --check-prefixes=NO_IEEE,NO_FAST,RELAXED,NO_REASSOC,NO_NSZ %s +! RUN: %flang -fsigned-zeros -frelaxed-math %s -### 2>&1 | FileCheck --check-prefixes=NO_IEEE,NO_FAST,RELAXED,NO_REASSOC,NO_NSZ %s +! RUN: %flang -fno-signed-zeros -frelaxed-math %s -### 2>&1 | FileCheck --check-prefixes=NO_IEEE,NO_FAST,NO_REASSOC,NSZ %s + +! IEEE: {{.*}}flang2{{.*}} "-ieee" "1" +! NO_IEEE-NOT: {{.*}}flang2{{.*}} "-ieee" "1" + +! FAST: {{.*}}flang2{{.*}} "-x" "216" "1" +! NO_FAST-NOT: {{.*}}flang2{{.*}} "-x" "216" "1" + +! RELAXED: {{.*}}flang2{{.*}} "-x" "15" "0x400" +! NO_RELAXED-NOT: {{.*}}flang2{{.*}} "-x" "15" "0x400" + +! REASSOC_NSZ: {{.*}}flang2{{.*}} "-x" "216" "0x8" "-x" "216" "0x10" +! NO_REASSOC-NOT: {{.*}}flang2{{.*}} "-x" "216" "0x10" + +! NSZ: {{.*}}flang2{{.*}} "-x" "216" "0x8" +! NO_NSZ-NOT: {{.*}}flang2{{.*}} "-x" "216" "0x8" From 7166c248cecb46773a8e810105772666deba77ab Mon Sep 17 00:00:00 2001 From: Paul Osmialowski Date: Mon, 1 Aug 2022 22:12:35 +0100 Subject: [PATCH 29/60] [llvm] Provide separate veclib mapping of PGMATH functions for AArch64 This patch fixes link-time issues experienced while compiling some more obscure Fortran workloads. For those programs, calls to the libpgmath functions not defined for AArch64 were generated, e.g. `__pg_log_4` or `__fd_log_4`. This patch eliminates such possibility. Signed-off-by: Paul Osmialowski --- .../test/CodeGen/libpgmath-logfun-aarch64.ll | 60 ++ clang/test/CodeGen/libpgmath-logfun-x86_64.ll | 57 ++ .../include/llvm/Analysis/TargetLibraryInfo.h | 2 + llvm/include/llvm/Analysis/VecFuncs.def | 614 ++++++++++++++++++ llvm/lib/Analysis/TargetLibraryInfo.cpp | 469 +------------ 5 files changed, 755 insertions(+), 447 deletions(-) create mode 100644 clang/test/CodeGen/libpgmath-logfun-aarch64.ll create mode 100644 clang/test/CodeGen/libpgmath-logfun-x86_64.ll diff --git a/clang/test/CodeGen/libpgmath-logfun-aarch64.ll b/clang/test/CodeGen/libpgmath-logfun-aarch64.ll new file mode 100644 index 000000000000..045d14fdf407 --- /dev/null +++ b/clang/test/CodeGen/libpgmath-logfun-aarch64.ll @@ -0,0 +1,60 @@ +; REQUIRES: aarch64-registered-target + +; RUN: %clang -target aarch64-unknown-linux-gnu -Ofast -S %s -o - | FileCheck %s + +target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" + +define void @fun_(i64* nocapture %z) local_unnamed_addr #0 { +L.entry: + %0 = bitcast i64* %z to i8* + %1 = bitcast i64* %z to float* + %2 = load float, float* %1, align 4 + %3 = fpext float %2 to double + %4 = fadd double %3, 5.000000e-01 + %5 = tail call double @__pd_log_1(double %4) #1 + %6 = fptrunc double %5 to float + %7 = tail call float @__ps_exp_1(float %6) #2 + store float %7, float* %1, align 4 + %8 = getelementptr i8, i8* %0, i64 4 + %9 = bitcast i8* %8 to float* + %10 = load float, float* %9, align 4 + %11 = fpext float %10 to double + %12 = fadd double %11, 5.000000e-01 + %13 = tail call double @__pd_log_1(double %12) #1 + %14 = fptrunc double %13 to float + %15 = tail call float @__ps_exp_1(float %14) #2 + store float %15, float* %9, align 4 + %16 = getelementptr i64, i64* %z, i64 1 + %17 = bitcast i64* %16 to float* + %18 = load float, float* %17, align 4 + %19 = fpext float %18 to double + %20 = fadd double %19, 5.000000e-01 + %21 = tail call double @__pd_log_1(double %20) #1 + %22 = fptrunc double %21 to float + %23 = tail call float @__ps_exp_1(float %22) #2 + store float %23, float* %17, align 4 + %24 = getelementptr i8, i8* %0, i64 12 + %25 = bitcast i8* %24 to float* + %26 = load float, float* %25, align 4 + %27 = fpext float %26 to double + %28 = fadd double %27, 5.000000e-01 + %29 = tail call double @__pd_log_1(double %28) #1 + %30 = fptrunc double %29 to float + %31 = tail call float @__ps_exp_1(float %30) #2 + store float %31, float* %25, align 4 + ret void + +; CHECK-NOT: __pd_log_4 +; CHECK: __pd_log_1 +; CHECK: __pd_log_1 +; CHECK: __pd_log_1 +; CHECK: __pd_log_1 +} + +; Function Attrs: nounwind readnone willreturn +declare float @__ps_exp_1(float) #0 + +; Function Attrs: nounwind readnone willreturn +declare double @__pd_log_1(double) #0 + +attributes #0 = { nounwind readnone willreturn } diff --git a/clang/test/CodeGen/libpgmath-logfun-x86_64.ll b/clang/test/CodeGen/libpgmath-logfun-x86_64.ll new file mode 100644 index 000000000000..3ce1d910947f --- /dev/null +++ b/clang/test/CodeGen/libpgmath-logfun-x86_64.ll @@ -0,0 +1,57 @@ +; REQUIRES: x86-registered-target + +; RUN: %clang -target x86_64-unknown-linux-gnu -msse -Ofast -S %s -o - | FileCheck %s + +target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" + +define void @fun_(i64* nocapture %z) local_unnamed_addr #0 { +L.entry: + %0 = bitcast i64* %z to i8* + %1 = bitcast i64* %z to float* + %2 = load float, float* %1, align 4 + %3 = fpext float %2 to double + %4 = fadd double %3, 5.000000e-01 + %5 = tail call double @__pd_log_1(double %4) #1 + %6 = fptrunc double %5 to float + %7 = tail call float @__ps_exp_1(float %6) #2 + store float %7, float* %1, align 4 + %8 = getelementptr i8, i8* %0, i64 4 + %9 = bitcast i8* %8 to float* + %10 = load float, float* %9, align 4 + %11 = fpext float %10 to double + %12 = fadd double %11, 5.000000e-01 + %13 = tail call double @__pd_log_1(double %12) #1 + %14 = fptrunc double %13 to float + %15 = tail call float @__ps_exp_1(float %14) #2 + store float %15, float* %9, align 4 + %16 = getelementptr i64, i64* %z, i64 1 + %17 = bitcast i64* %16 to float* + %18 = load float, float* %17, align 4 + %19 = fpext float %18 to double + %20 = fadd double %19, 5.000000e-01 + %21 = tail call double @__pd_log_1(double %20) #1 + %22 = fptrunc double %21 to float + %23 = tail call float @__ps_exp_1(float %22) #2 + store float %23, float* %17, align 4 + %24 = getelementptr i8, i8* %0, i64 12 + %25 = bitcast i8* %24 to float* + %26 = load float, float* %25, align 4 + %27 = fpext float %26 to double + %28 = fadd double %27, 5.000000e-01 + %29 = tail call double @__pd_log_1(double %28) #1 + %30 = fptrunc double %29 to float + %31 = tail call float @__ps_exp_1(float %30) #2 + store float %31, float* %25, align 4 + ret void + +; CHECK-NOT: __pd_log_1 +; CHECK: __pd_log_4 +} + +; Function Attrs: nounwind readnone willreturn +declare float @__ps_exp_1(float) #0 + +; Function Attrs: nounwind readnone willreturn +declare double @__pd_log_1(double) #0 + +attributes #0 = { nounwind readnone willreturn } diff --git a/llvm/include/llvm/Analysis/TargetLibraryInfo.h b/llvm/include/llvm/Analysis/TargetLibraryInfo.h index ba813c02f41a..5d5c2e3d88f0 100644 --- a/llvm/include/llvm/Analysis/TargetLibraryInfo.h +++ b/llvm/include/llvm/Analysis/TargetLibraryInfo.h @@ -112,6 +112,8 @@ class TargetLibraryInfoImpl { bool isValidProtoForLibFunc(const FunctionType &FTy, LibFunc F, const Module &M) const; + Triple T; + public: /// List of known vector-functions libraries. /// diff --git a/llvm/include/llvm/Analysis/VecFuncs.def b/llvm/include/llvm/Analysis/VecFuncs.def index 251331b9f860..79720b224d5c 100644 --- a/llvm/include/llvm/Analysis/VecFuncs.def +++ b/llvm/include/llvm/Analysis/VecFuncs.def @@ -1618,6 +1618,620 @@ TLI_DEFINE_VECFUNC("sincos", "amd_vrd8_sincos", FIXED(8), NOMASK, "_ZGV_LLVM_N8v TLI_DEFINE_VECFUNC("sincosf", "amd_vrs4_sincosf", FIXED(4), NOMASK, "_ZGV_LLVM_N4vl4l4") TLI_DEFINE_VECFUNC("sincosf", "amd_vrs8_sincosf", FIXED(8), NOMASK, "_ZGV_LLVM_N8vl4l4") TLI_DEFINE_VECFUNC("sincosf", "amd_vrs16_sincosf", FIXED(16), NOMASK, "_ZGV_LLVM_N16vl4l4") +#elif defined(TLI_DEFINE_PGMATH_AARCH64_VECFUNCS) +// Classic flang libpgmath library's Vector Functions for AArch64 + +TLI_DEFINE_VECFUNC("__fd_sin_1", "__fd_sin_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__fs_sin_1", "__fs_sin_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__pd_sin_1", "__pd_sin_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__ps_sin_1", "__ps_sin_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__rd_sin_1", "__rd_sin_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__rs_sin_1", "__rs_sin_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__fd_cos_1", "__fd_cos_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__fs_cos_1", "__fs_cos_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__pd_cos_1", "__pd_cos_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__ps_cos_1", "__ps_cos_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__rd_cos_1", "__rd_cos_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__rs_cos_1", "__rs_cos_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__fd_sincos_1", "__fd_sincos_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__fs_sincos_1", "__fs_sincos_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__pd_sincos_1", "__pd_sincos_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__ps_sincos_1", "__ps_sincos_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__rd_sincos_1", "__rd_sincos_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__rs_sincos_1", "__rs_sincos_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__fd_tan_1", "__fd_tan_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__fs_tan_1", "__fs_tan_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__pd_tan_1", "__pd_tan_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__ps_tan_1", "__ps_tan_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__rd_tan_1", "__rd_tan_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__rs_tan_1", "__rs_tan_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__fd_sinh_1", "__fd_sinh_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__fs_sinh_1", "__fs_sinh_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__pd_sinh_1", "__pd_sinh_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__ps_sinh_1", "__ps_sinh_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__rd_sinh_1", "__rd_sinh_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__rs_sinh_1", "__rs_sinh_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__fd_cosh_1", "__fd_cosh_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__fs_cosh_1", "__fs_cosh_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__pd_cosh_1", "__pd_cosh_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__ps_cosh_1", "__ps_cosh_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__rd_cosh_1", "__rd_cosh_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__rs_cosh_1", "__rs_cosh_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__fd_tanh_1", "__fd_tanh_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__fs_tanh_1", "__fs_tanh_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__pd_tanh_1", "__pd_tanh_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__ps_tanh_1", "__ps_tanh_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__rd_tanh_1", "__rd_tanh_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__rs_tanh_1", "__rs_tanh_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__fd_asin_1", "__fd_asin_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__fs_asin_1", "__fs_asin_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__pd_asin_1", "__pd_asin_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__ps_asin_1", "__ps_asin_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__rd_asin_1", "__rd_asin_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__rs_asin_1", "__rs_asin_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__fd_acos_1", "__fd_acos_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__fs_acos_1", "__fs_acos_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__pd_acos_1", "__pd_acos_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__ps_acos_1", "__ps_acos_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__rd_acos_1", "__rd_acos_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__rs_acos_1", "__rs_acos_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__fd_atan_1", "__fd_atan_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__fs_atan_1", "__fs_atan_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__pd_atan_1", "__pd_atan_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__ps_atan_1", "__ps_atan_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__rd_atan_1", "__rd_atan_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__rs_atan_1", "__rs_atan_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__fd_atan2_1", "__fd_atan2_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__fs_atan2_1", "__fs_atan2_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__pd_atan2_1", "__pd_atan2_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__ps_atan2_1", "__ps_atan2_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__rd_atan2_1", "__rd_atan2_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__rs_atan2_1", "__rs_atan2_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__fd_pow_1", "__fd_pow_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__fs_pow_1", "__fs_pow_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__pd_pow_1", "__pd_pow_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__ps_pow_1", "__ps_pow_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__rd_pow_1", "__rd_pow_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__rs_pow_1", "__rs_pow_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__fs_powi_1", "__fs_powi_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__ps_powi_1", "__ps_powi_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__rs_powi_1", "__rs_powi_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__fd_powi1_1", "__fd_powi1_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__fs_powi1_1", "__fs_powi1_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__pd_powi1_1", "__pd_powi1_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__ps_powi1_1", "__ps_powi1_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__rd_powi1_1", "__rd_powi1_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__rs_powi1_1", "__rs_powi1_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__fd_powk_1", "__fd_powk_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__fs_powk_1", "__fs_powk_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__pd_powk_1", "__pd_powk_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__ps_powk_1", "__ps_powk_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__rd_powk_1", "__rd_powk_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__rs_powk_1", "__rs_powk_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__fd_powk1_1", "__fd_powk1_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__fs_powk1_1", "__fs_powk1_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__pd_powk1_1", "__pd_powk1_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__ps_powk1_1", "__ps_powk1_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__rd_powk1_1", "__rd_powk1_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__rs_powk1_1", "__rs_powk1_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__fd_log10_1", "__fd_log10_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__fs_log10_1", "__fs_log10_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__pd_log10_1", "__pd_log10_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__ps_log10_1", "__ps_log10_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__rd_log10_1", "__rd_log10_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__rs_log10_1", "__rs_log10_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__fd_log_1", "__fd_log_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__fs_log_1", "__fs_log_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__pd_log_1", "__pd_log_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__ps_log_1", "__ps_log_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__rd_log_1", "__rd_log_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__rs_log_1", "__rs_log_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__fd_exp_1", "__fd_exp_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__fs_exp_1", "__fs_exp_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__pd_exp_1", "__pd_exp_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__ps_exp_1", "__ps_exp_4", FIXED(4)) + +TLI_DEFINE_VECFUNC("__rd_exp_1", "__rd_exp_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__rs_exp_1", "__rs_exp_4", FIXED(4)) + +#elif defined(TLI_DEFINE_PGMATH_X86_VECFUNCS) +// Classic flang libpgmath library's Vector Functions for X86 + +TLI_DEFINE_VECFUNC("__fd_sin_1", "__fd_sin_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__fd_sin_1", "__fd_sin_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fd_sin_1", "__fd_sin_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__fs_sin_1", "__fs_sin_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fs_sin_1", "__fs_sin_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__fs_sin_1", "__fs_sin_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__pd_sin_1", "__pd_sin_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__pd_sin_1", "__pd_sin_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__pd_sin_1", "__pd_sin_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__ps_sin_1", "__ps_sin_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__ps_sin_1", "__ps_sin_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__ps_sin_1", "__ps_sin_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__rd_sin_1", "__rd_sin_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__rd_sin_1", "__rd_sin_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rd_sin_1", "__rd_sin_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__rs_sin_1", "__rs_sin_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rs_sin_1", "__rs_sin_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__rs_sin_1", "__rs_sin_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__fd_cos_1", "__fd_cos_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__fd_cos_1", "__fd_cos_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fd_cos_1", "__fd_cos_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__fs_cos_1", "__fs_cos_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fs_cos_1", "__fs_cos_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__fs_cos_1", "__fs_cos_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__pd_cos_1", "__pd_cos_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__pd_cos_1", "__pd_cos_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__pd_cos_1", "__pd_cos_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__ps_cos_1", "__ps_cos_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__ps_cos_1", "__ps_cos_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__ps_cos_1", "__ps_cos_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__rd_cos_1", "__rd_cos_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__rd_cos_1", "__rd_cos_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rd_cos_1", "__rd_cos_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__rs_cos_1", "__rs_cos_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rs_cos_1", "__rs_cos_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__rs_cos_1", "__rs_cos_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__fd_sincos_1", "__fd_sincos_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__fd_sincos_1", "__fd_sincos_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fd_sincos_1", "__fd_sincos_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__fs_sincos_1", "__fs_sincos_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fs_sincos_1", "__fs_sincos_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__fs_sincos_1", "__fs_sincos_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__pd_sincos_1", "__pd_sincos_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__pd_sincos_1", "__pd_sincos_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__pd_sincos_1", "__pd_sincos_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__ps_sincos_1", "__ps_sincos_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__ps_sincos_1", "__ps_sincos_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__ps_sincos_1", "__ps_sincos_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__rd_sincos_1", "__rd_sincos_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__rd_sincos_1", "__rd_sincos_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rd_sincos_1", "__rd_sincos_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__rs_sincos_1", "__rs_sincos_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rs_sincos_1", "__rs_sincos_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__rs_sincos_1", "__rs_sincos_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__fd_tan_1", "__fd_tan_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__fd_tan_1", "__fd_tan_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fd_tan_1", "__fd_tan_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__fs_tan_1", "__fs_tan_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fs_tan_1", "__fs_tan_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__fs_tan_1", "__fs_tan_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__pd_tan_1", "__pd_tan_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__pd_tan_1", "__pd_tan_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__pd_tan_1", "__pd_tan_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__ps_tan_1", "__ps_tan_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__ps_tan_1", "__ps_tan_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__ps_tan_1", "__ps_tan_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__rd_tan_1", "__rd_tan_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__rd_tan_1", "__rd_tan_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rd_tan_1", "__rd_tan_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__rs_tan_1", "__rs_tan_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rs_tan_1", "__rs_tan_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__rs_tan_1", "__rs_tan_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__fd_sinh_1", "__fd_sinh_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__fd_sinh_1", "__fd_sinh_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fd_sinh_1", "__fd_sinh_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__fs_sinh_1", "__fs_sinh_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fs_sinh_1", "__fs_sinh_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__fs_sinh_1", "__fs_sinh_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__pd_sinh_1", "__pd_sinh_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__pd_sinh_1", "__pd_sinh_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__pd_sinh_1", "__pd_sinh_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__ps_sinh_1", "__ps_sinh_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__ps_sinh_1", "__ps_sinh_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__ps_sinh_1", "__ps_sinh_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__rd_sinh_1", "__rd_sinh_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__rd_sinh_1", "__rd_sinh_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rd_sinh_1", "__rd_sinh_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__rs_sinh_1", "__rs_sinh_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rs_sinh_1", "__rs_sinh_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__rs_sinh_1", "__rs_sinh_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__fd_cosh_1", "__fd_cosh_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__fd_cosh_1", "__fd_cosh_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fd_cosh_1", "__fd_cosh_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__fs_cosh_1", "__fs_cosh_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fs_cosh_1", "__fs_cosh_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__fs_cosh_1", "__fs_cosh_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__pd_cosh_1", "__pd_cosh_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__pd_cosh_1", "__pd_cosh_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__pd_cosh_1", "__pd_cosh_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__ps_cosh_1", "__ps_cosh_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__ps_cosh_1", "__ps_cosh_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__ps_cosh_1", "__ps_cosh_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__rd_cosh_1", "__rd_cosh_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__rd_cosh_1", "__rd_cosh_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rd_cosh_1", "__rd_cosh_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__rs_cosh_1", "__rs_cosh_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rs_cosh_1", "__rs_cosh_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__rs_cosh_1", "__rs_cosh_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__fd_tanh_1", "__fd_tanh_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__fd_tanh_1", "__fd_tanh_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fd_tanh_1", "__fd_tanh_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__fs_tanh_1", "__fs_tanh_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fs_tanh_1", "__fs_tanh_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__fs_tanh_1", "__fs_tanh_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__pd_tanh_1", "__pd_tanh_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__pd_tanh_1", "__pd_tanh_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__pd_tanh_1", "__pd_tanh_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__ps_tanh_1", "__ps_tanh_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__ps_tanh_1", "__ps_tanh_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__ps_tanh_1", "__ps_tanh_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__rd_tanh_1", "__rd_tanh_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__rd_tanh_1", "__rd_tanh_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rd_tanh_1", "__rd_tanh_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__rs_tanh_1", "__rs_tanh_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rs_tanh_1", "__rs_tanh_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__rs_tanh_1", "__rs_tanh_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__fd_asin_1", "__fd_asin_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__fd_asin_1", "__fd_asin_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fd_asin_1", "__fd_asin_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__fs_asin_1", "__fs_asin_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fs_asin_1", "__fs_asin_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__fs_asin_1", "__fs_asin_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__pd_asin_1", "__pd_asin_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__pd_asin_1", "__pd_asin_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__pd_asin_1", "__pd_asin_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__ps_asin_1", "__ps_asin_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__ps_asin_1", "__ps_asin_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__ps_asin_1", "__ps_asin_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__rd_asin_1", "__rd_asin_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__rd_asin_1", "__rd_asin_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rd_asin_1", "__rd_asin_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__rs_asin_1", "__rs_asin_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rs_asin_1", "__rs_asin_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__rs_asin_1", "__rs_asin_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__fd_acos_1", "__fd_acos_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__fd_acos_1", "__fd_acos_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fd_acos_1", "__fd_acos_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__fs_acos_1", "__fs_acos_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fs_acos_1", "__fs_acos_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__fs_acos_1", "__fs_acos_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__pd_acos_1", "__pd_acos_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__pd_acos_1", "__pd_acos_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__pd_acos_1", "__pd_acos_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__ps_acos_1", "__ps_acos_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__ps_acos_1", "__ps_acos_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__ps_acos_1", "__ps_acos_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__rd_acos_1", "__rd_acos_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__rd_acos_1", "__rd_acos_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rd_acos_1", "__rd_acos_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__rs_acos_1", "__rs_acos_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rs_acos_1", "__rs_acos_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__rs_acos_1", "__rs_acos_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__fd_atan_1", "__fd_atan_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__fd_atan_1", "__fd_atan_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fd_atan_1", "__fd_atan_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__fs_atan_1", "__fs_atan_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fs_atan_1", "__fs_atan_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__fs_atan_1", "__fs_atan_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__pd_atan_1", "__pd_atan_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__pd_atan_1", "__pd_atan_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__pd_atan_1", "__pd_atan_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__ps_atan_1", "__ps_atan_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__ps_atan_1", "__ps_atan_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__ps_atan_1", "__ps_atan_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__rd_atan_1", "__rd_atan_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__rd_atan_1", "__rd_atan_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rd_atan_1", "__rd_atan_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__rs_atan_1", "__rs_atan_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rs_atan_1", "__rs_atan_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__rs_atan_1", "__rs_atan_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__fd_atan2_1", "__fd_atan2_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__fd_atan2_1", "__fd_atan2_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fd_atan2_1", "__fd_atan2_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__fs_atan2_1", "__fs_atan2_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fs_atan2_1", "__fs_atan2_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__fs_atan2_1", "__fs_atan2_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__pd_atan2_1", "__pd_atan2_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__pd_atan2_1", "__pd_atan2_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__pd_atan2_1", "__pd_atan2_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__ps_atan2_1", "__ps_atan2_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__ps_atan2_1", "__ps_atan2_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__ps_atan2_1", "__ps_atan2_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__rd_atan2_1", "__rd_atan2_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__rd_atan2_1", "__rd_atan2_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rd_atan2_1", "__rd_atan2_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__rs_atan2_1", "__rs_atan2_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rs_atan2_1", "__rs_atan2_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__rs_atan2_1", "__rs_atan2_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__fd_pow_1", "__fd_pow_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__fd_pow_1", "__fd_pow_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fd_pow_1", "__fd_pow_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__fs_pow_1", "__fs_pow_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fs_pow_1", "__fs_pow_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__fs_pow_1", "__fs_pow_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__pd_pow_1", "__pd_pow_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__pd_pow_1", "__pd_pow_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__pd_pow_1", "__pd_pow_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__ps_pow_1", "__ps_pow_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__ps_pow_1", "__ps_pow_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__ps_pow_1", "__ps_pow_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__rd_pow_1", "__rd_pow_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__rd_pow_1", "__rd_pow_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rd_pow_1", "__rd_pow_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__rs_pow_1", "__rs_pow_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rs_pow_1", "__rs_pow_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__rs_pow_1", "__rs_pow_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__fs_powi_1", "__fs_powi_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fs_powi_1", "__fs_powi_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__fs_powi_1", "__fs_powi_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__ps_powi_1", "__ps_powi_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__ps_powi_1", "__ps_powi_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__ps_powi_1", "__ps_powi_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__rs_powi_1", "__rs_powi_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rs_powi_1", "__rs_powi_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__rs_powi_1", "__rs_powi_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__fd_powi1_1", "__fd_powi1_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__fd_powi1_1", "__fd_powi1_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fd_powi1_1", "__fd_powi1_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__fs_powi1_1", "__fs_powi1_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fs_powi1_1", "__fs_powi1_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__fs_powi1_1", "__fs_powi1_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__pd_powi1_1", "__pd_powi1_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__pd_powi1_1", "__pd_powi1_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__pd_powi1_1", "__pd_powi1_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__ps_powi1_1", "__ps_powi1_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__ps_powi1_1", "__ps_powi1_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__ps_powi1_1", "__ps_powi1_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__rd_powi1_1", "__rd_powi1_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__rd_powi1_1", "__rd_powi1_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rd_powi1_1", "__rd_powi1_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__rs_powi1_1", "__rs_powi1_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rs_powi1_1", "__rs_powi1_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__rs_powi1_1", "__rs_powi1_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__fd_powk_1", "__fd_powk_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__fd_powk_1", "__fd_powk_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fd_powk_1", "__fd_powk_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__fs_powk_1", "__fs_powk_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fs_powk_1", "__fs_powk_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__fs_powk_1", "__fs_powk_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__pd_powk_1", "__pd_powk_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__pd_powk_1", "__pd_powk_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__pd_powk_1", "__pd_powk_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__ps_powk_1", "__ps_powk_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__ps_powk_1", "__ps_powk_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__ps_powk_1", "__ps_powk_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__rd_powk_1", "__rd_powk_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__rd_powk_1", "__rd_powk_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rd_powk_1", "__rd_powk_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__rs_powk_1", "__rs_powk_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rs_powk_1", "__rs_powk_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__rs_powk_1", "__rs_powk_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__fd_powk1_1", "__fd_powk1_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__fd_powk1_1", "__fd_powk1_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fd_powk1_1", "__fd_powk1_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__fs_powk1_1", "__fs_powk1_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fs_powk1_1", "__fs_powk1_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__fs_powk1_1", "__fs_powk1_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__pd_powk1_1", "__pd_powk1_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__pd_powk1_1", "__pd_powk1_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__pd_powk1_1", "__pd_powk1_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__ps_powk1_1", "__ps_powk1_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__ps_powk1_1", "__ps_powk1_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__ps_powk1_1", "__ps_powk1_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__rd_powk1_1", "__rd_powk1_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__rd_powk1_1", "__rd_powk1_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rd_powk1_1", "__rd_powk1_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__rs_powk1_1", "__rs_powk1_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rs_powk1_1", "__rs_powk1_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__rs_powk1_1", "__rs_powk1_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__fd_log10_1", "__fd_log10_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__fd_log10_1", "__fd_log10_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fd_log10_1", "__fd_log10_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__fs_log10_1", "__fs_log10_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fs_log10_1", "__fs_log10_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__fs_log10_1", "__fs_log10_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__pd_log10_1", "__pd_log10_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__pd_log10_1", "__pd_log10_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__pd_log10_1", "__pd_log10_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__ps_log10_1", "__ps_log10_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__ps_log10_1", "__ps_log10_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__ps_log10_1", "__ps_log10_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__rd_log10_1", "__rd_log10_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__rd_log10_1", "__rd_log10_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rd_log10_1", "__rd_log10_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__rs_log10_1", "__rs_log10_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rs_log10_1", "__rs_log10_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__rs_log10_1", "__rs_log10_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__fd_log_1", "__fd_log_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__fd_log_1", "__fd_log_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fd_log_1", "__fd_log_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__fs_log_1", "__fs_log_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fs_log_1", "__fs_log_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__fs_log_1", "__fs_log_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__pd_log_1", "__pd_log_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__pd_log_1", "__pd_log_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__pd_log_1", "__pd_log_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__ps_log_1", "__ps_log_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__ps_log_1", "__ps_log_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__ps_log_1", "__ps_log_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__rd_log_1", "__rd_log_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__rd_log_1", "__rd_log_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rd_log_1", "__rd_log_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__rs_log_1", "__rs_log_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rs_log_1", "__rs_log_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__rs_log_1", "__rs_log_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__fs_exp_1", "__fs_exp_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fs_exp_1", "__fs_exp_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__fs_exp_1", "__fs_exp_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__pd_exp_1", "__pd_exp_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__pd_exp_1", "__pd_exp_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__pd_exp_1", "__pd_exp_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__ps_exp_1", "__ps_exp_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__ps_exp_1", "__ps_exp_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__ps_exp_1", "__ps_exp_16", FIXED(16)) + +TLI_DEFINE_VECFUNC("__rd_exp_1", "__rd_exp_2", FIXED(2)) +TLI_DEFINE_VECFUNC("__rd_exp_1", "__rd_exp_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rd_exp_1", "__rd_exp_8", FIXED(8)) + +TLI_DEFINE_VECFUNC("__rs_exp_1", "__rs_exp_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rs_exp_1", "__rs_exp_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__rs_exp_1", "__rs_exp_16", FIXED(16)) + #else #error "Must choose which vector library functions are to be defined." #endif diff --git a/llvm/lib/Analysis/TargetLibraryInfo.cpp b/llvm/lib/Analysis/TargetLibraryInfo.cpp index 214f5d53550f..6a983e2a7064 100644 --- a/llvm/lib/Analysis/TargetLibraryInfo.cpp +++ b/llvm/lib/Analysis/TargetLibraryInfo.cpp @@ -924,13 +924,13 @@ static void initialize(TargetLibraryInfoImpl &TLI, const Triple &T, initializeLibCalls(TLI, T, StandardNames); } -TargetLibraryInfoImpl::TargetLibraryInfoImpl() { +TargetLibraryInfoImpl::TargetLibraryInfoImpl() : T(Triple()) { // Default to nothing being available. memset(AvailableArray, 0, sizeof(AvailableArray)); - initializeBase(*this, Triple()); + initializeBase(*this, T); } -TargetLibraryInfoImpl::TargetLibraryInfoImpl(const Triple &T) { +TargetLibraryInfoImpl::TargetLibraryInfoImpl(const Triple &T) : T(T) { // Default to everything being available. memset(AvailableArray, -1, sizeof(AvailableArray)); @@ -942,7 +942,7 @@ TargetLibraryInfoImpl::TargetLibraryInfoImpl(const TargetLibraryInfoImpl &TLI) ShouldExtI32Return(TLI.ShouldExtI32Return), ShouldSignExtI32Param(TLI.ShouldSignExtI32Param), ShouldSignExtI32Return(TLI.ShouldSignExtI32Return), - SizeOfInt(TLI.SizeOfInt) { + SizeOfInt(TLI.SizeOfInt), T(TLI.T) { memcpy(AvailableArray, TLI.AvailableArray, sizeof(AvailableArray)); VectorDescs = TLI.VectorDescs; ScalarDescs = TLI.ScalarDescs; @@ -954,7 +954,7 @@ TargetLibraryInfoImpl::TargetLibraryInfoImpl(TargetLibraryInfoImpl &&TLI) ShouldExtI32Return(TLI.ShouldExtI32Return), ShouldSignExtI32Param(TLI.ShouldSignExtI32Param), ShouldSignExtI32Return(TLI.ShouldSignExtI32Return), - SizeOfInt(TLI.SizeOfInt) { + SizeOfInt(TLI.SizeOfInt), T(TLI.T) { std::move(std::begin(TLI.AvailableArray), std::end(TLI.AvailableArray), AvailableArray); VectorDescs = TLI.VectorDescs; @@ -968,6 +968,7 @@ TargetLibraryInfoImpl &TargetLibraryInfoImpl::operator=(const TargetLibraryInfoI ShouldSignExtI32Param = TLI.ShouldSignExtI32Param; ShouldSignExtI32Return = TLI.ShouldSignExtI32Return; SizeOfInt = TLI.SizeOfInt; + T = TLI.T; memcpy(AvailableArray, TLI.AvailableArray, sizeof(AvailableArray)); return *this; } @@ -979,6 +980,7 @@ TargetLibraryInfoImpl &TargetLibraryInfoImpl::operator=(TargetLibraryInfoImpl && ShouldSignExtI32Param = TLI.ShouldSignExtI32Param; ShouldSignExtI32Return = TLI.ShouldSignExtI32Return; SizeOfInt = TLI.SizeOfInt; + T = TLI.T; std::move(std::begin(TLI.AvailableArray), std::end(TLI.AvailableArray), AvailableArray); return *this; @@ -1412,448 +1414,21 @@ void TargetLibraryInfoImpl::addVectorizableFunctionsFromVecLib( // Based on the size of vector registers available and the size of data, the // vector width should be chosen correctly. case PGMATH: { - const VecDesc VecFuncs[] = { - {"__fd_sin_1", "__fd_sin_2", FIXED(2)}, - {"__fd_sin_1", "__fd_sin_4", FIXED(4)}, - {"__fd_sin_1", "__fd_sin_8", FIXED(8)}, - - {"__fs_sin_1", "__fs_sin_4", FIXED(4)}, - {"__fs_sin_1", "__fs_sin_8", FIXED(8)}, - {"__fs_sin_1", "__fs_sin_16", FIXED(16)}, - - {"__pd_sin_1", "__pd_sin_2", FIXED(2)}, - {"__pd_sin_1", "__pd_sin_4", FIXED(4)}, - {"__pd_sin_1", "__pd_sin_8", FIXED(8)}, - - {"__ps_sin_1", "__ps_sin_4", FIXED(4)}, - {"__ps_sin_1", "__ps_sin_8", FIXED(8)}, - {"__ps_sin_1", "__ps_sin_16", FIXED(16)}, - - {"__rd_sin_1", "__rd_sin_2", FIXED(2)}, - {"__rd_sin_1", "__rd_sin_4", FIXED(4)}, - {"__rd_sin_1", "__rd_sin_8", FIXED(8)}, - - {"__rs_sin_1", "__rs_sin_4", FIXED(4)}, - {"__rs_sin_1", "__rs_sin_8", FIXED(8)}, - {"__rs_sin_1", "__rs_sin_16", FIXED(16)}, - - {"__fd_cos_1", "__fd_cos_2", FIXED(2)}, - {"__fd_cos_1", "__fd_cos_4", FIXED(4)}, - {"__fd_cos_1", "__fd_cos_8", FIXED(8)}, - - {"__fs_cos_1", "__fs_cos_4", FIXED(4)}, - {"__fs_cos_1", "__fs_cos_8", FIXED(8)}, - {"__fs_cos_1", "__fs_cos_16", FIXED(16)}, - - {"__pd_cos_1", "__pd_cos_2", FIXED(2)}, - {"__pd_cos_1", "__pd_cos_4", FIXED(4)}, - {"__pd_cos_1", "__pd_cos_8", FIXED(8)}, - - {"__ps_cos_1", "__ps_cos_4", FIXED(4)}, - {"__ps_cos_1", "__ps_cos_8", FIXED(8)}, - {"__ps_cos_1", "__ps_cos_16", FIXED(16)}, - - {"__rd_cos_1", "__rd_cos_2", FIXED(2)}, - {"__rd_cos_1", "__rd_cos_4", FIXED(4)}, - {"__rd_cos_1", "__rd_cos_8", FIXED(8)}, - - {"__rs_cos_1", "__rs_cos_4", FIXED(4)}, - {"__rs_cos_1", "__rs_cos_8", FIXED(8)}, - {"__rs_cos_1", "__rs_cos_16", FIXED(16)}, - - {"__fd_sincos_1", "__fd_sincos_2", FIXED(2)}, - {"__fd_sincos_1", "__fd_sincos_4", FIXED(4)}, - {"__fd_sincos_1", "__fd_sincos_8", FIXED(8)}, - - {"__fs_sincos_1", "__fs_sincos_4", FIXED(4)}, - {"__fs_sincos_1", "__fs_sincos_8", FIXED(8)}, - {"__fs_sincos_1", "__fs_sincos_16", FIXED(16)}, - - {"__pd_sincos_1", "__pd_sincos_2", FIXED(2)}, - {"__pd_sincos_1", "__pd_sincos_4", FIXED(4)}, - {"__pd_sincos_1", "__pd_sincos_8", FIXED(8)}, - - {"__ps_sincos_1", "__ps_sincos_4", FIXED(4)}, - {"__ps_sincos_1", "__ps_sincos_8", FIXED(8)}, - {"__ps_sincos_1", "__ps_sincos_16", FIXED(16)}, - - {"__rd_sincos_1", "__rd_sincos_2", FIXED(2)}, - {"__rd_sincos_1", "__rd_sincos_4", FIXED(4)}, - {"__rd_sincos_1", "__rd_sincos_8", FIXED(8)}, - - {"__rs_sincos_1", "__rs_sincos_4", FIXED(4)}, - {"__rs_sincos_1", "__rs_sincos_8", FIXED(8)}, - {"__rs_sincos_1", "__rs_sincos_16", FIXED(16)}, - - {"__fd_tan_1", "__fd_tan_2", FIXED(2)}, - {"__fd_tan_1", "__fd_tan_4", FIXED(4)}, - {"__fd_tan_1", "__fd_tan_8", FIXED(8)}, - - {"__fs_tan_1", "__fs_tan_4", FIXED(4)}, - {"__fs_tan_1", "__fs_tan_8", FIXED(8)}, - {"__fs_tan_1", "__fs_tan_16", FIXED(16)}, - - {"__pd_tan_1", "__pd_tan_2", FIXED(2)}, - {"__pd_tan_1", "__pd_tan_4", FIXED(4)}, - {"__pd_tan_1", "__pd_tan_8", FIXED(8)}, - - {"__ps_tan_1", "__ps_tan_4", FIXED(4)}, - {"__ps_tan_1", "__ps_tan_8", FIXED(8)}, - {"__ps_tan_1", "__ps_tan_16", FIXED(16)}, - - {"__rd_tan_1", "__rd_tan_2", FIXED(2)}, - {"__rd_tan_1", "__rd_tan_4", FIXED(4)}, - {"__rd_tan_1", "__rd_tan_8", FIXED(8)}, - - {"__rs_tan_1", "__rs_tan_4", FIXED(4)}, - {"__rs_tan_1", "__rs_tan_8", FIXED(8)}, - {"__rs_tan_1", "__rs_tan_16", FIXED(16)}, - - {"__fd_sinh_1", "__fd_sinh_2", FIXED(2)}, - {"__fd_sinh_1", "__fd_sinh_4", FIXED(4)}, - {"__fd_sinh_1", "__fd_sinh_8", FIXED(8)}, - - {"__fs_sinh_1", "__fs_sinh_4", FIXED(4)}, - {"__fs_sinh_1", "__fs_sinh_8", FIXED(8)}, - {"__fs_sinh_1", "__fs_sinh_16", FIXED(16)}, - - {"__pd_sinh_1", "__pd_sinh_2", FIXED(2)}, - {"__pd_sinh_1", "__pd_sinh_4", FIXED(4)}, - {"__pd_sinh_1", "__pd_sinh_8", FIXED(8)}, - - {"__ps_sinh_1", "__ps_sinh_4", FIXED(4)}, - {"__ps_sinh_1", "__ps_sinh_8", FIXED(8)}, - {"__ps_sinh_1", "__ps_sinh_16", FIXED(16)}, - - {"__rd_sinh_1", "__rd_sinh_2", FIXED(2)}, - {"__rd_sinh_1", "__rd_sinh_4", FIXED(4)}, - {"__rd_sinh_1", "__rd_sinh_8", FIXED(8)}, - - {"__rs_sinh_1", "__rs_sinh_4", FIXED(4)}, - {"__rs_sinh_1", "__rs_sinh_8", FIXED(8)}, - {"__rs_sinh_1", "__rs_sinh_16", FIXED(16)}, - - {"__fd_cosh_1", "__fd_cosh_2", FIXED(2)}, - {"__fd_cosh_1", "__fd_cosh_4", FIXED(4)}, - {"__fd_cosh_1", "__fd_cosh_8", FIXED(8)}, - - {"__fs_cosh_1", "__fs_cosh_4", FIXED(4)}, - {"__fs_cosh_1", "__fs_cosh_8", FIXED(8)}, - {"__fs_cosh_1", "__fs_cosh_16", FIXED(16)}, - - {"__pd_cosh_1", "__pd_cosh_2", FIXED(2)}, - {"__pd_cosh_1", "__pd_cosh_4", FIXED(4)}, - {"__pd_cosh_1", "__pd_cosh_8", FIXED(8)}, - - {"__ps_cosh_1", "__ps_cosh_4", FIXED(4)}, - {"__ps_cosh_1", "__ps_cosh_8", FIXED(8)}, - {"__ps_cosh_1", "__ps_cosh_16", FIXED(16)}, - - {"__rd_cosh_1", "__rd_cosh_2", FIXED(2)}, - {"__rd_cosh_1", "__rd_cosh_4", FIXED(4)}, - {"__rd_cosh_1", "__rd_cosh_8", FIXED(8)}, - - {"__rs_cosh_1", "__rs_cosh_4", FIXED(4)}, - {"__rs_cosh_1", "__rs_cosh_8", FIXED(8)}, - {"__rs_cosh_1", "__rs_cosh_16", FIXED(16)}, - - {"__fd_tanh_1", "__fd_tanh_2", FIXED(2)}, - {"__fd_tanh_1", "__fd_tanh_4", FIXED(4)}, - {"__fd_tanh_1", "__fd_tanh_8", FIXED(8)}, - - {"__fs_tanh_1", "__fs_tanh_4", FIXED(4)}, - {"__fs_tanh_1", "__fs_tanh_8", FIXED(8)}, - {"__fs_tanh_1", "__fs_tanh_16", FIXED(16)}, - - {"__pd_tanh_1", "__pd_tanh_2", FIXED(2)}, - {"__pd_tanh_1", "__pd_tanh_4", FIXED(4)}, - {"__pd_tanh_1", "__pd_tanh_8", FIXED(8)}, - - {"__ps_tanh_1", "__ps_tanh_4", FIXED(4)}, - {"__ps_tanh_1", "__ps_tanh_8", FIXED(8)}, - {"__ps_tanh_1", "__ps_tanh_16", FIXED(16)}, - - {"__rd_tanh_1", "__rd_tanh_2", FIXED(2)}, - {"__rd_tanh_1", "__rd_tanh_4", FIXED(4)}, - {"__rd_tanh_1", "__rd_tanh_8", FIXED(8)}, - - {"__rs_tanh_1", "__rs_tanh_4", FIXED(4)}, - {"__rs_tanh_1", "__rs_tanh_8", FIXED(8)}, - {"__rs_tanh_1", "__rs_tanh_16", FIXED(16)}, - - {"__fd_asin_1", "__fd_asin_2", FIXED(2)}, - {"__fd_asin_1", "__fd_asin_4", FIXED(4)}, - {"__fd_asin_1", "__fd_asin_8", FIXED(8)}, - - {"__fs_asin_1", "__fs_asin_4", FIXED(4)}, - {"__fs_asin_1", "__fs_asin_8", FIXED(8)}, - {"__fs_asin_1", "__fs_asin_16", FIXED(16)}, - - {"__pd_asin_1", "__pd_asin_2", FIXED(2)}, - {"__pd_asin_1", "__pd_asin_4", FIXED(4)}, - {"__pd_asin_1", "__pd_asin_8", FIXED(8)}, - - {"__ps_asin_1", "__ps_asin_4", FIXED(4)}, - {"__ps_asin_1", "__ps_asin_8", FIXED(8)}, - {"__ps_asin_1", "__ps_asin_16", FIXED(16)}, - - {"__rd_asin_1", "__rd_asin_2", FIXED(2)}, - {"__rd_asin_1", "__rd_asin_4", FIXED(4)}, - {"__rd_asin_1", "__rd_asin_8", FIXED(8)}, - - {"__rs_asin_1", "__rs_asin_4", FIXED(4)}, - {"__rs_asin_1", "__rs_asin_8", FIXED(8)}, - {"__rs_asin_1", "__rs_asin_16", FIXED(16)}, - - {"__fd_acos_1", "__fd_acos_2", FIXED(2)}, - {"__fd_acos_1", "__fd_acos_4", FIXED(4)}, - {"__fd_acos_1", "__fd_acos_8", FIXED(8)}, - - {"__fs_acos_1", "__fs_acos_4", FIXED(4)}, - {"__fs_acos_1", "__fs_acos_8", FIXED(8)}, - {"__fs_acos_1", "__fs_acos_16", FIXED(16)}, - - {"__pd_acos_1", "__pd_acos_2", FIXED(2)}, - {"__pd_acos_1", "__pd_acos_4", FIXED(4)}, - {"__pd_acos_1", "__pd_acos_8", FIXED(8)}, - - {"__ps_acos_1", "__ps_acos_4", FIXED(4)}, - {"__ps_acos_1", "__ps_acos_8", FIXED(8)}, - {"__ps_acos_1", "__ps_acos_16", FIXED(16)}, - - {"__rd_acos_1", "__rd_acos_2", FIXED(2)}, - {"__rd_acos_1", "__rd_acos_4", FIXED(4)}, - {"__rd_acos_1", "__rd_acos_8", FIXED(8)}, - - {"__rs_acos_1", "__rs_acos_4", FIXED(4)}, - {"__rs_acos_1", "__rs_acos_8", FIXED(8)}, - {"__rs_acos_1", "__rs_acos_16", FIXED(16)}, - - {"__fd_atan_1", "__fd_atan_2", FIXED(2)}, - {"__fd_atan_1", "__fd_atan_4", FIXED(4)}, - {"__fd_atan_1", "__fd_atan_8", FIXED(8)}, - - {"__fs_atan_1", "__fs_atan_4", FIXED(4)}, - {"__fs_atan_1", "__fs_atan_8", FIXED(8)}, - {"__fs_atan_1", "__fs_atan_16", FIXED(16)}, - - {"__pd_atan_1", "__pd_atan_2", FIXED(2)}, - {"__pd_atan_1", "__pd_atan_4", FIXED(4)}, - {"__pd_atan_1", "__pd_atan_8", FIXED(8)}, - - {"__ps_atan_1", "__ps_atan_4", FIXED(4)}, - {"__ps_atan_1", "__ps_atan_8", FIXED(8)}, - {"__ps_atan_1", "__ps_atan_16", FIXED(16)}, - - {"__rd_atan_1", "__rd_atan_2", FIXED(2)}, - {"__rd_atan_1", "__rd_atan_4", FIXED(4)}, - {"__rd_atan_1", "__rd_atan_8", FIXED(8)}, - - {"__rs_atan_1", "__rs_atan_4", FIXED(4)}, - {"__rs_atan_1", "__rs_atan_8", FIXED(8)}, - {"__rs_atan_1", "__rs_atan_16", FIXED(16)}, - - {"__fd_atan2_1", "__fd_atan2_2", FIXED(2)}, - {"__fd_atan2_1", "__fd_atan2_4", FIXED(4)}, - {"__fd_atan2_1", "__fd_atan2_8", FIXED(8)}, - - {"__fs_atan2_1", "__fs_atan2_4", FIXED(4)}, - {"__fs_atan2_1", "__fs_atan2_8", FIXED(8)}, - {"__fs_atan2_1", "__fs_atan2_16", FIXED(16)}, - - {"__pd_atan2_1", "__pd_atan2_2", FIXED(2)}, - {"__pd_atan2_1", "__pd_atan2_4", FIXED(4)}, - {"__pd_atan2_1", "__pd_atan2_8", FIXED(8)}, - - {"__ps_atan2_1", "__ps_atan2_4", FIXED(4)}, - {"__ps_atan2_1", "__ps_atan2_8", FIXED(8)}, - {"__ps_atan2_1", "__ps_atan2_16", FIXED(16)}, - - {"__rd_atan2_1", "__rd_atan2_2", FIXED(2)}, - {"__rd_atan2_1", "__rd_atan2_4", FIXED(4)}, - {"__rd_atan2_1", "__rd_atan2_8", FIXED(8)}, - - {"__rs_atan2_1", "__rs_atan2_4", FIXED(4)}, - {"__rs_atan2_1", "__rs_atan2_8", FIXED(8)}, - {"__rs_atan2_1", "__rs_atan2_16", FIXED(16)}, - - {"__fd_pow_1", "__fd_pow_2", FIXED(2)}, - {"__fd_pow_1", "__fd_pow_4", FIXED(4)}, - {"__fd_pow_1", "__fd_pow_8", FIXED(8)}, - - {"__fs_pow_1", "__fs_pow_4", FIXED(4)}, - {"__fs_pow_1", "__fs_pow_8", FIXED(8)}, - {"__fs_pow_1", "__fs_pow_16", FIXED(16)}, - - {"__pd_pow_1", "__pd_pow_2", FIXED(2)}, - {"__pd_pow_1", "__pd_pow_4", FIXED(4)}, - {"__pd_pow_1", "__pd_pow_8", FIXED(8)}, - - {"__ps_pow_1", "__ps_pow_4", FIXED(4)}, - {"__ps_pow_1", "__ps_pow_8", FIXED(8)}, - {"__ps_pow_1", "__ps_pow_16", FIXED(16)}, - - {"__rd_pow_1", "__rd_pow_2", FIXED(2)}, - {"__rd_pow_1", "__rd_pow_4", FIXED(4)}, - {"__rd_pow_1", "__rd_pow_8", FIXED(8)}, - - {"__rs_pow_1", "__rs_pow_4", FIXED(4)}, - {"__rs_pow_1", "__rs_pow_8", FIXED(8)}, - {"__rs_pow_1", "__rs_pow_16", FIXED(16)}, - - {"__fs_powi_1", "__fs_powi_4", FIXED(4)}, - {"__fs_powi_1", "__fs_powi_8", FIXED(8)}, - {"__fs_powi_1", "__fs_powi_16", FIXED(16)}, - - {"__ps_powi_1", "__ps_powi_4", FIXED(4)}, - {"__ps_powi_1", "__ps_powi_8", FIXED(8)}, - {"__ps_powi_1", "__ps_powi_16", FIXED(16)}, - - {"__rs_powi_1", "__rs_powi_4", FIXED(4)}, - {"__rs_powi_1", "__rs_powi_8", FIXED(8)}, - {"__rs_powi_1", "__rs_powi_16", FIXED(16)}, - - {"__fd_powi1_1", "__fd_powi1_2", FIXED(2)}, - {"__fd_powi1_1", "__fd_powi1_4", FIXED(4)}, - {"__fd_powi1_1", "__fd_powi1_8", FIXED(8)}, - - {"__fs_powi1_1", "__fs_powi1_4", FIXED(4)}, - {"__fs_powi1_1", "__fs_powi1_8", FIXED(8)}, - {"__fs_powi1_1", "__fs_powi1_16", FIXED(16)}, - - {"__pd_powi1_1", "__pd_powi1_2", FIXED(2)}, - {"__pd_powi1_1", "__pd_powi1_4", FIXED(4)}, - {"__pd_powi1_1", "__pd_powi1_8", FIXED(8)}, - - {"__ps_powi1_1", "__ps_powi1_4", FIXED(4)}, - {"__ps_powi1_1", "__ps_powi1_8", FIXED(8)}, - {"__ps_powi1_1", "__ps_powi1_16", FIXED(16)}, - - {"__rd_powi1_1", "__rd_powi1_2", FIXED(2)}, - {"__rd_powi1_1", "__rd_powi1_4", FIXED(4)}, - {"__rd_powi1_1", "__rd_powi1_8", FIXED(8)}, - - {"__rs_powi1_1", "__rs_powi1_4", FIXED(4)}, - {"__rs_powi1_1", "__rs_powi1_8", FIXED(8)}, - {"__rs_powi1_1", "__rs_powi1_16", FIXED(16)}, - - {"__fd_powk_1", "__fd_powk_2", FIXED(2)}, - {"__fd_powk_1", "__fd_powk_4", FIXED(4)}, - {"__fd_powk_1", "__fd_powk_8", FIXED(8)}, - - {"__fs_powk_1", "__fs_powk_4", FIXED(4)}, - {"__fs_powk_1", "__fs_powk_8", FIXED(8)}, - {"__fs_powk_1", "__fs_powk_16", FIXED(16)}, - - {"__pd_powk_1", "__pd_powk_2", FIXED(2)}, - {"__pd_powk_1", "__pd_powk_4", FIXED(4)}, - {"__pd_powk_1", "__pd_powk_8", FIXED(8)}, - - {"__ps_powk_1", "__ps_powk_4", FIXED(4)}, - {"__ps_powk_1", "__ps_powk_8", FIXED(8)}, - {"__ps_powk_1", "__ps_powk_16", FIXED(16)}, - - {"__rd_powk_1", "__rd_powk_2", FIXED(2)}, - {"__rd_powk_1", "__rd_powk_4", FIXED(4)}, - {"__rd_powk_1", "__rd_powk_8", FIXED(8)}, - - {"__rs_powk_1", "__rs_powk_4", FIXED(4)}, - {"__rs_powk_1", "__rs_powk_8", FIXED(8)}, - {"__rs_powk_1", "__rs_powk_16", FIXED(16)}, - - {"__fd_powk1_1", "__fd_powk1_2", FIXED(2)}, - {"__fd_powk1_1", "__fd_powk1_4", FIXED(4)}, - {"__fd_powk1_1", "__fd_powk1_8", FIXED(8)}, - - {"__fs_powk1_1", "__fs_powk1_4", FIXED(4)}, - {"__fs_powk1_1", "__fs_powk1_8", FIXED(8)}, - {"__fs_powk1_1", "__fs_powk1_16", FIXED(16)}, - - {"__pd_powk1_1", "__pd_powk1_2", FIXED(2)}, - {"__pd_powk1_1", "__pd_powk1_4", FIXED(4)}, - {"__pd_powk1_1", "__pd_powk1_8", FIXED(8)}, - - {"__ps_powk1_1", "__ps_powk1_4", FIXED(4)}, - {"__ps_powk1_1", "__ps_powk1_8", FIXED(8)}, - {"__ps_powk1_1", "__ps_powk1_16", FIXED(16)}, - - {"__rd_powk1_1", "__rd_powk1_2", FIXED(2)}, - {"__rd_powk1_1", "__rd_powk1_4", FIXED(4)}, - {"__rd_powk1_1", "__rd_powk1_8", FIXED(8)}, - - {"__rs_powk1_1", "__rs_powk1_4", FIXED(4)}, - {"__rs_powk1_1", "__rs_powk1_8", FIXED(8)}, - {"__rs_powk1_1", "__rs_powk1_16", FIXED(16)}, - - {"__fd_log10_1", "__fd_log10_2", FIXED(2)}, - {"__fd_log10_1", "__fd_log10_4", FIXED(4)}, - {"__fd_log10_1", "__fd_log10_8", FIXED(8)}, - - {"__fs_log10_1", "__fs_log10_4", FIXED(4)}, - {"__fs_log10_1", "__fs_log10_8", FIXED(8)}, - {"__fs_log10_1", "__fs_log10_16", FIXED(16)}, - - {"__pd_log10_1", "__pd_log10_2", FIXED(2)}, - {"__pd_log10_1", "__pd_log10_4", FIXED(4)}, - {"__pd_log10_1", "__pd_log10_8", FIXED(8)}, - - {"__ps_log10_1", "__ps_log10_4", FIXED(4)}, - {"__ps_log10_1", "__ps_log10_8", FIXED(8)}, - {"__ps_log10_1", "__ps_log10_16", FIXED(16)}, - - {"__rd_log10_1", "__rd_log10_2", FIXED(2)}, - {"__rd_log10_1", "__rd_log10_4", FIXED(4)}, - {"__rd_log10_1", "__rd_log10_8", FIXED(8)}, - - {"__rs_log10_1", "__rs_log10_4", FIXED(4)}, - {"__rs_log10_1", "__rs_log10_8", FIXED(8)}, - {"__rs_log10_1", "__rs_log10_16", FIXED(16)}, - - {"__fd_log_1", "__fd_log_2", FIXED(2)}, - {"__fd_log_1", "__fd_log_4", FIXED(4)}, - {"__fd_log_1", "__fd_log_8", FIXED(8)}, - - {"__fs_log_1", "__fs_log_4", FIXED(4)}, - {"__fs_log_1", "__fs_log_8", FIXED(8)}, - {"__fs_log_1", "__fs_log_16", FIXED(16)}, - - {"__pd_log_1", "__pd_log_2", FIXED(2)}, - {"__pd_log_1", "__pd_log_4", FIXED(4)}, - {"__pd_log_1", "__pd_log_8", FIXED(8)}, - - {"__ps_log_1", "__ps_log_4", FIXED(4)}, - {"__ps_log_1", "__ps_log_8", FIXED(8)}, - {"__ps_log_1", "__ps_log_16", FIXED(16)}, - - {"__rd_log_1", "__rd_log_2", FIXED(2)}, - {"__rd_log_1", "__rd_log_4", FIXED(4)}, - {"__rd_log_1", "__rd_log_8", FIXED(8)}, - - {"__rs_log_1", "__rs_log_4", FIXED(4)}, - {"__rs_log_1", "__rs_log_8", FIXED(8)}, - {"__rs_log_1", "__rs_log_16", FIXED(16)}, - - {"__fs_exp_1", "__fs_exp_4", FIXED(4)}, - {"__fs_exp_1", "__fs_exp_8", FIXED(8)}, - {"__fs_exp_1", "__fs_exp_16", FIXED(16)}, - - {"__pd_exp_1", "__pd_exp_2", FIXED(2)}, - {"__pd_exp_1", "__pd_exp_4", FIXED(4)}, - {"__pd_exp_1", "__pd_exp_8", FIXED(8)}, - - {"__ps_exp_1", "__ps_exp_4", FIXED(4)}, - {"__ps_exp_1", "__ps_exp_8", FIXED(8)}, - {"__ps_exp_1", "__ps_exp_16", FIXED(16)}, - - {"__rd_exp_1", "__rd_exp_2", FIXED(2)}, - {"__rd_exp_1", "__rd_exp_4", FIXED(4)}, - {"__rd_exp_1", "__rd_exp_8", FIXED(8)}, - - {"__rs_exp_1", "__rs_exp_4", FIXED(4)}, - {"__rs_exp_1", "__rs_exp_8", FIXED(8)}, - {"__rs_exp_1", "__rs_exp_16", FIXED(16)} - }; - addVectorizableFunctions(VecFuncs); + if (T.getArch() == Triple::aarch64) { + const VecDesc VecFuncs[] = { + #define TLI_DEFINE_PGMATH_AARCH64_VECFUNCS + #include "llvm/Analysis/VecFuncs.def" + #undef TLI_DEFINE_PGMATH_AARCH64_VECFUNCS + }; + addVectorizableFunctions(VecFuncs); + } else if (T.getArch() == Triple::x86_64) { + const VecDesc VecFuncs[] = { + #define TLI_DEFINE_PGMATH_X86_VECFUNCS + #include "llvm/Analysis/VecFuncs.def" + #undef TLI_DEFINE_PGMATH_X86_VECFUNCS + }; + addVectorizableFunctions(VecFuncs); + } break; } #endif From 76ce456d52b2416645870238651e6ef41e28b6a4 Mon Sep 17 00:00:00 2001 From: Gabriel Baraldi Date: Wed, 30 Nov 2022 16:33:35 -0300 Subject: [PATCH 30/60] Delete libpgmath veclib definitions for sincos As noted in flang-compiler#11, flang currently crashes when lowering a sincos reference into a libpgmath runtime function call. The issue is that `__fd_sincos_1` is defined as returning a `<{ double, double }>` struct and there is no LLVM support for automatically vectorizing target functions of this form. In particular, it is somewhat ambiguous how to vectorize such functions, i.e. how they pack their return values into the vector registers. libpgmath itself also has a somewhat questionable implementation of the vector forms of `sincos`, relying on this beauty: https://github.com/flang-compiler/flang/blob/master/runtime/libpgmath/lib/common/mth_vreturns.c#L8-L47 This may sometimes work in practice, but it is not particularly robust. For example, this will definitely break in any sort of LTO or instrumentation setting. I think until libpgmath is updated and LLVM upstream has a consensus on how to vectorize these functions, we just need to stop trying to vectorize these functions. As noted, since LLVM was crashing anyway, no performance and functionality is lost here over current master. Fixes flang-compiler#11. Originally By: Keno Fischer --- llvm/include/llvm/Analysis/VecFuncs.def | 24 ------------------------ 1 file changed, 24 deletions(-) diff --git a/llvm/include/llvm/Analysis/VecFuncs.def b/llvm/include/llvm/Analysis/VecFuncs.def index 79720b224d5c..d427e4213d34 100644 --- a/llvm/include/llvm/Analysis/VecFuncs.def +++ b/llvm/include/llvm/Analysis/VecFuncs.def @@ -1840,30 +1840,6 @@ TLI_DEFINE_VECFUNC("__rs_cos_1", "__rs_cos_4", FIXED(4)) TLI_DEFINE_VECFUNC("__rs_cos_1", "__rs_cos_8", FIXED(8)) TLI_DEFINE_VECFUNC("__rs_cos_1", "__rs_cos_16", FIXED(16)) -TLI_DEFINE_VECFUNC("__fd_sincos_1", "__fd_sincos_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__fd_sincos_1", "__fd_sincos_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__fd_sincos_1", "__fd_sincos_8", FIXED(8)) - -TLI_DEFINE_VECFUNC("__fs_sincos_1", "__fs_sincos_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__fs_sincos_1", "__fs_sincos_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__fs_sincos_1", "__fs_sincos_16", FIXED(16)) - -TLI_DEFINE_VECFUNC("__pd_sincos_1", "__pd_sincos_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__pd_sincos_1", "__pd_sincos_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__pd_sincos_1", "__pd_sincos_8", FIXED(8)) - -TLI_DEFINE_VECFUNC("__ps_sincos_1", "__ps_sincos_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__ps_sincos_1", "__ps_sincos_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__ps_sincos_1", "__ps_sincos_16", FIXED(16)) - -TLI_DEFINE_VECFUNC("__rd_sincos_1", "__rd_sincos_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__rd_sincos_1", "__rd_sincos_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__rd_sincos_1", "__rd_sincos_8", FIXED(8)) - -TLI_DEFINE_VECFUNC("__rs_sincos_1", "__rs_sincos_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__rs_sincos_1", "__rs_sincos_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__rs_sincos_1", "__rs_sincos_16", FIXED(16)) - TLI_DEFINE_VECFUNC("__fd_tan_1", "__fd_tan_2", FIXED(2)) TLI_DEFINE_VECFUNC("__fd_tan_1", "__fd_tan_4", FIXED(4)) TLI_DEFINE_VECFUNC("__fd_tan_1", "__fd_tan_8", FIXED(8)) From df999d3e1e5fc2d4c85db19d835da12d0c39d948 Mon Sep 17 00:00:00 2001 From: Tibor Dusnoki Date: Wed, 30 Nov 2022 18:07:20 +0100 Subject: [PATCH 31/60] Add platform independent build script for LLVM (release_15x) --- scripts/build_llvm_project.py | 151 ++++++++++++++++++++ scripts/cmake/toolchain_linux_x86_64.cmake | 2 + scripts/cmake/toolchain_windows_amd64.cmake | 2 + scripts/cmake/toolchain_windows_arm64.cmake | 6 + scripts/settings.py | 5 + 5 files changed, 166 insertions(+) create mode 100644 scripts/build_llvm_project.py create mode 100644 scripts/cmake/toolchain_linux_x86_64.cmake create mode 100644 scripts/cmake/toolchain_windows_amd64.cmake create mode 100644 scripts/cmake/toolchain_windows_arm64.cmake create mode 100644 scripts/settings.py diff --git a/scripts/build_llvm_project.py b/scripts/build_llvm_project.py new file mode 100644 index 000000000000..4ac1e8b63b2a --- /dev/null +++ b/scripts/build_llvm_project.py @@ -0,0 +1,151 @@ +#!/usr/bin/env python + +import argparse +import os +import platform +import settings +import shutil +import subprocess +import sys + +from pathlib import Path, PurePath + +def default_toolchain(): + system = platform.uname()[0] + machine = platform.uname()[4] + toolchain = Path(settings.THIS_DIR, + 'cmake', + f'toolchain_{system.lower()}_{machine.lower()}.cmake') + return toolchain if toolchain.is_file else None + +def get_arguments(): + parser = argparse.ArgumentParser( + description="Help configure and build classic-flang-llvm-project") + + buildopt = parser.add_argument_group('general build options') + buildopt.add_argument('-t', '--target', metavar='ARCH', choices=['X86', 'AArch64', 'PowerPC'], default='X86', + help='Control which targets are enabled (%(choices)s) (default: %(default)s)') + buildopt.add_argument('-p', '--install-prefix', metavar='PATH', nargs='?', default=Path(settings.LLVM_DIR,'..','install'), const=False, + help='install directory (default: %(default)s) ') + buildopt.add_argument('-j', '--jobs', metavar='N', type=int, default=os.cpu_count(), + help='number of parallel build jobs (default: %(default)s)') + buildopt.add_argument('--toolchain', metavar='FILE', default=default_toolchain().as_posix(), + help='specify toolchain file (default: %(default)s)') + buildopt.add_argument('-d', '--builddir', metavar='DIR', default='build', + help=f'specify build directory (default: {settings.LLVM_DIR}/%(default)s)') + buildopt.add_argument('--clean', action='store_true', default=False, + help='clean build') + buildopt.add_argument('-b', '--build-type', metavar='TYPE', default='Release', + help='set build type (default: %(default)s)') + buildopt.add_argument('-x', '--cmake-param', metavar='OPT', action='append', default=[], + help='add custom argument to CMake') + buildopt.add_argument('-e', '--llvm-enable-projects', metavar='OPT', action='append', default=['clang'] if sys.platform == 'win32' else ['clang', 'openmp'], + help='enable llvm projects to build (in quotation marks separated by semicolons e.g.: "clang;openmp")') + buildopt.add_argument('-c', '--use-ccache', action="store_true", default=False, + help='Using ccache during the build (default: %(default)s)') + buildopt.add_argument('--cc', metavar='OPT', default=None, + help='use specific C compiler') + buildopt.add_argument('--cxx', metavar='OPT', default=None, + help='use specific C++ compiler') + buildopt.add_argument('-v', '--verbose', action='store_true', default=False, + help='Verbose build (default: %(default)s') + arguments = parser.parse_args() + return arguments + +def generate_buildoptions(arguments): + install_root = Path(arguments.install_prefix) + + base_cmake_args = [ + f'-DCMAKE_INSTALL_PREFIX={install_root.as_posix()}', + f'-DCMAKE_BUILD_TYPE={arguments.build_type}', + f'-DCMAKE_TOOLCHAIN_FILE={arguments.toolchain}' + ] + if sys.platform == 'win32' and platform.uname()[4].lower() == 'arm64': + base_cmake_args.append('-GNMake Makefiles') + else: + generator = 'Ninja' if sys.platform == 'win32' else 'Unix Makefiles' + base_cmake_args.append(f'-G{generator}') + + if arguments.use_ccache: + base_cmake_args.append('-DCMAKE_C_COMPILER_LAUNCHER=ccache') + base_cmake_args.append('-DCMAKE_CXX_COMPILER_LAUNCHER=ccache') + + if arguments.cmake_param: + base_cmake_args.extend(arguments.cmake_param) + + if arguments.cc: + base_cmake_args.append(f'-DCMAKE_C_COMPILER={arguments.cc}') + + if arguments.cxx: + base_cmake_args.append(f'-DCMAKE_CXX_COMPILER={arguments.cxx}') + + if arguments.verbose: + base_cmake_args.extend('-DCMAKE_VERBOSE_MAKEFILE=ON') + + return base_cmake_args + +def normalize_builddir(project_srcdir, builddir, clean): + build_path = '' + if PurePath(builddir).is_absolute(): + build_path = Path(builddir, PurePath(project_srcdir).name) + else: + build_path = Path(project_srcdir, builddir) + + if clean and build_path.exists(): + shutil.rmtree(build_path) + + return build_path.as_posix() + +def configure_llvm(arguments): + build_path = normalize_builddir( + settings.LLVM_DIR, arguments.builddir, arguments.clean) + + build_options = generate_buildoptions(arguments) + additional_options = [ + f'-DLLVM_TARGETS_TO_BUILD={arguments.target}', + '-DLLVM_ENABLE_CLASSIC_FLANG=ON', + ] + if(arguments.llvm_enable_projects): + additional_options.append(f'-DLLVM_ENABLE_PROJECTS={";".join(x for x in arguments.llvm_enable_projects)}') + build_options.extend(additional_options) + cmake_cmd = ['cmake', '-B', build_path, '-S', Path.joinpath(settings.LLVM_DIR,'llvm')] + cmake_cmd.extend(build_options) + subprocess.run(cmake_cmd, check=True) + + return build_path + +def build_project(build_path, arguments): + build_cmd = ['cmake', '--build', build_path, '--config', + arguments.build_type, '-j', str(arguments.jobs)] + subprocess.run(build_cmd, check=True) + +def install_project(build_path, arguments): + install_cmd = ['cmake', '--build', build_path, '--config', + arguments.build_type, '--target', 'install'] + subprocess.run(install_cmd, check=True) + +def print_success(): + print() + print('=' * 30) + print('Build succeeded!') + print('=' * 30) + print() + +def print_header(title): + print() + print('*' * 30) + print(f'{title}...') + print('*' * 30) + print() + +def main(): + arguments = get_arguments() + + print_header('Building classic llvm') + build_path = configure_llvm(arguments) + build_project(build_path, arguments) + install_project(build_path, arguments) + +if __name__ == "__main__": + main() + print_success() diff --git a/scripts/cmake/toolchain_linux_x86_64.cmake b/scripts/cmake/toolchain_linux_x86_64.cmake new file mode 100644 index 000000000000..daa8f7bba151 --- /dev/null +++ b/scripts/cmake/toolchain_linux_x86_64.cmake @@ -0,0 +1,2 @@ +set(CMAKE_C_COMPILER clang) +set(CMAKE_CXX_COMPILER clang++) diff --git a/scripts/cmake/toolchain_windows_amd64.cmake b/scripts/cmake/toolchain_windows_amd64.cmake new file mode 100644 index 000000000000..2457d64e5595 --- /dev/null +++ b/scripts/cmake/toolchain_windows_amd64.cmake @@ -0,0 +1,2 @@ +set(CMAKE_C_COMPILER "clang-cl") +set(CMAKE_CXX_COMPILER "clang-cl") diff --git a/scripts/cmake/toolchain_windows_arm64.cmake b/scripts/cmake/toolchain_windows_arm64.cmake new file mode 100644 index 000000000000..3edd83a2d72d --- /dev/null +++ b/scripts/cmake/toolchain_windows_arm64.cmake @@ -0,0 +1,6 @@ +set(triple arm64-windows) + +set(CMAKE_C_COMPILER clang-cl) +set(CMAKE_C_COMPILER_TARGET ${triple}) +set(CMAKE_CXX_COMPILER clang-cl) +set(CMAKE_CXX_COMPILER_TARGET ${triple}) diff --git a/scripts/settings.py b/scripts/settings.py new file mode 100644 index 000000000000..d24f8b521af3 --- /dev/null +++ b/scripts/settings.py @@ -0,0 +1,5 @@ +from pathlib import Path + +THIS_DIR = Path(__file__).resolve().parent +LLVM_DIR = THIS_DIR.parent +TOOLCHAIN_DIR = THIS_DIR.joinpath('cmake') From e4f32d0f4f44307936353358f2bbb0ad785b1261 Mon Sep 17 00:00:00 2001 From: Adam Kallai Date: Thu, 26 Jan 2023 17:30:15 +0100 Subject: [PATCH 32/60] win: Fix the build with verbose options The 'append' method should be used instead of extend, since the 'extend' method treats the arguments as an iterable object, so extends the current list with list of characters. --- scripts/build_llvm_project.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/build_llvm_project.py b/scripts/build_llvm_project.py index 4ac1e8b63b2a..6f08a0ce601d 100644 --- a/scripts/build_llvm_project.py +++ b/scripts/build_llvm_project.py @@ -80,7 +80,7 @@ def generate_buildoptions(arguments): base_cmake_args.append(f'-DCMAKE_CXX_COMPILER={arguments.cxx}') if arguments.verbose: - base_cmake_args.extend('-DCMAKE_VERBOSE_MAKEFILE=ON') + base_cmake_args.append('-DCMAKE_VERBOSE_MAKEFILE=ON') return base_cmake_args From 8d6e1a3724ed56a086da9aedbff97d72a5ec9f3f Mon Sep 17 00:00:00 2001 From: Adam Kallai Date: Tue, 24 Jan 2023 11:22:55 +0100 Subject: [PATCH 33/60] win: Don't install llvm by default The 'llvm_build_project' build script installs llvm after the build by default. It is not necessary, if the user doesn't want. --- scripts/build_llvm_project.py | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-) diff --git a/scripts/build_llvm_project.py b/scripts/build_llvm_project.py index 6f08a0ce601d..a2b8422fcfa7 100644 --- a/scripts/build_llvm_project.py +++ b/scripts/build_llvm_project.py @@ -25,8 +25,8 @@ def get_arguments(): buildopt = parser.add_argument_group('general build options') buildopt.add_argument('-t', '--target', metavar='ARCH', choices=['X86', 'AArch64', 'PowerPC'], default='X86', help='Control which targets are enabled (%(choices)s) (default: %(default)s)') - buildopt.add_argument('-p', '--install-prefix', metavar='PATH', nargs='?', default=Path(settings.LLVM_DIR,'..','install'), const=False, - help='install directory (default: %(default)s) ') + buildopt.add_argument('-p', '--install-prefix', metavar='PATH', nargs='?', default=None, const=False, + help='Install directory (default: do not install)') buildopt.add_argument('-j', '--jobs', metavar='N', type=int, default=os.cpu_count(), help='number of parallel build jobs (default: %(default)s)') buildopt.add_argument('--toolchain', metavar='FILE', default=default_toolchain().as_posix(), @@ -53,19 +53,21 @@ def get_arguments(): return arguments def generate_buildoptions(arguments): - install_root = Path(arguments.install_prefix) - base_cmake_args = [ - f'-DCMAKE_INSTALL_PREFIX={install_root.as_posix()}', f'-DCMAKE_BUILD_TYPE={arguments.build_type}', f'-DCMAKE_TOOLCHAIN_FILE={arguments.toolchain}' ] + if sys.platform == 'win32' and platform.uname()[4].lower() == 'arm64': base_cmake_args.append('-GNMake Makefiles') else: generator = 'Ninja' if sys.platform == 'win32' else 'Unix Makefiles' base_cmake_args.append(f'-G{generator}') + if arguments.install_prefix: + install_root = Path(arguments.install_prefix) + base_cmake_args.append(f'-DCMAKE_INSTALL_PREFIX={install_root.as_posix()}') + if arguments.use_ccache: base_cmake_args.append('-DCMAKE_C_COMPILER_LAUNCHER=ccache') base_cmake_args.append('-DCMAKE_CXX_COMPILER_LAUNCHER=ccache') @@ -144,7 +146,8 @@ def main(): print_header('Building classic llvm') build_path = configure_llvm(arguments) build_project(build_path, arguments) - install_project(build_path, arguments) + if arguments.install_prefix is not None: + install_project(build_path, arguments) if __name__ == "__main__": main() From da16f156107bbed4428abe11fd2b34aa72f90468 Mon Sep 17 00:00:00 2001 From: Peixin Qiao Date: Sat, 4 Mar 2023 01:47:47 +0800 Subject: [PATCH 34/60] [Driver][ClassicFlang] Add options -fno-automatic and -f(no-)implicit-none These three options are added in release_12. When compiling programs with them using Classic Flang, there are only warnings generated. They are removed now so that the errors of "unknown argument" are reported. Add these options in Driver for compatibility reason. Please note that these options are not implemented yet in Classic Flang. --- clang/include/clang/Driver/Options.td | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td index 1b3ba01441ed..91522abd3a97 100644 --- a/clang/include/clang/Driver/Options.td +++ b/clang/include/clang/Driver/Options.td @@ -7010,6 +7010,10 @@ def fbackslash : Flag<["-"], "fbackslash">, Group, DocBrief<[{Change the interpretation of backslashes in string literals from a single backslash character to "C-style" escape characters.}]>; def fno_backslash : Flag<["-"], "fno-backslash">, Group; +// Add the options -f(no-)implicit-none and -f(no-)automatic for compatibility +// reason. They are not implemented yet in Classic Flang for now. +defm implicit_none : BooleanFFlag<"implicit-none">, Group; +def fno_automatic : Flag<["-"], "fno-automatic">, Group; #else defm backslash : OptInFC1FFlag<"backslash", "Specify that backslash in string introduces an escape character">; defm xor_operator : OptInFC1FFlag<"xor-operator", "Enable .XOR. as a synonym of .NEQV.">; From dee15fa433c7fe680d9428eef04aad26fcae2575 Mon Sep 17 00:00:00 2001 From: Bryan Chan Date: Tue, 28 Feb 2023 18:27:35 -0500 Subject: [PATCH 35/60] [Driver] Don't use Classic Flang tools for LLVM IR input LLVM IR input should not be acceptable for Classic Flang tools. This bug was caused by an incorrect merge conflict resolution when upgrading to LLVM 15. --- clang/lib/Driver/Types.cpp | 3 ++- clang/test/Driver/flang/Inputs/llvm-ir-input.ll | 0 clang/test/Driver/flang/llvm-ir-input.f | 7 +++++++ 3 files changed, 9 insertions(+), 1 deletion(-) create mode 100644 clang/test/Driver/flang/Inputs/llvm-ir-input.ll create mode 100644 clang/test/Driver/flang/llvm-ir-input.f diff --git a/clang/lib/Driver/Types.cpp b/clang/lib/Driver/Types.cpp index 4de13b7fb52b..e8d828f1b729 100755 --- a/clang/lib/Driver/Types.cpp +++ b/clang/lib/Driver/Types.cpp @@ -172,10 +172,10 @@ bool types::isAcceptedByFlang(ID Id) { case TY_PP_F_FreeForm: case TY_F_FixedForm: case TY_PP_F_FixedForm: + return true; #else case TY_Fortran: case TY_PP_Fortran: -#endif return true; case TY_LLVM_IR: case TY_LLVM_BC: @@ -183,6 +183,7 @@ bool types::isAcceptedByFlang(ID Id) { case TY_PP_CUDA: case TY_CUDA: return true; +#endif } } diff --git a/clang/test/Driver/flang/Inputs/llvm-ir-input.ll b/clang/test/Driver/flang/Inputs/llvm-ir-input.ll new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/clang/test/Driver/flang/llvm-ir-input.f b/clang/test/Driver/flang/llvm-ir-input.f new file mode 100644 index 000000000000..c34bf28328cb --- /dev/null +++ b/clang/test/Driver/flang/llvm-ir-input.f @@ -0,0 +1,7 @@ +! Check that LLVM IR input is passed to clang instead of flang1. + +! REQUIRES: classic_flang +! RUN: %clang --driver-mode=flang -S %S/Inputs/llvm-ir-input.ll -### 2>&1 | FileCheck %s + +! CHECK-NOT: flang1 +! CHECK: "{{.*}}clang{{.*}}" "-cc1" From 3ecb4f3a2fc5bc3aca99617d2b4eb59c1de1564b Mon Sep 17 00:00:00 2001 From: Adam Kallai Date: Wed, 4 Jan 2023 16:49:46 +0100 Subject: [PATCH 36/60] Added Windows support to 'classic-flang.f95' driver test Modified FileCheck regex pattern to match Windows path separator as well as binary suffix. --- clang/test/Driver/flang/classic-flang.f95 | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/clang/test/Driver/flang/classic-flang.f95 b/clang/test/Driver/flang/classic-flang.f95 index bc51c6e0c380..c331e99bed76 100644 --- a/clang/test/Driver/flang/classic-flang.f95 +++ b/clang/test/Driver/flang/classic-flang.f95 @@ -59,17 +59,17 @@ ! RUN: %flang -target x86_64-linux-gnu -ccc-install-dir %S/../Inputs/basic_linux_tree/usr/bin -static-flang-libs \ ! RUN: %s -lfoo -### 2>&1 | FileCheck --check-prefixes=CHECK-LD,CHECK-STATIC-FLANG,CHECK-NO-OMP %s -! CHECK-LD: "{{.*}}ld" +! CHECK-LD: "{{.*}}ld{{(.exe)?}}" ! CHECK-LD-NOT: "-static" -! CHECK-LD: "{{[^"]*}}classic-flang-{{[^ ]*}}.o" "-lflangmain" "-lfoo" "-L{{[^ ]*}}/basic_linux_tree/usr/lib" +! CHECK-LD: "{{[^"]*}}classic-flang-{{[^ ]*}}.o" "-lflangmain" "-lfoo" "-L{{[^ ]*[/\\]+}}basic_linux_tree{{[/\\]+}}usr{{[/\\]+}}lib" ! CHECK-DYNAMIC-FLANG-NOT: "-Bstatic" ! CHECK-DYNAMIC-FLANG: "-lflang" "-lflangrti" "-lpgmath" "-lpthread" "-lrt" "-lm" ! CHECK-DYNAMIC-FLANG-NOT: "-Bdynamic" ! CHECK-STATIC-FLANG: "-Bstatic" "-lflang" "-lflangrti" "-lpgmath" "-Bdynamic" "-lpthread" "-lrt" "-lm" ! CHECK-DYNAMIC-OMP-NOT: "-Bstatic" -! CHECK-DYNAMIC-OMP: "-lomp" "-rpath" "{{[^ ]*}}/basic_linux_tree/usr/lib" +! CHECK-DYNAMIC-OMP: "-lomp" "-rpath" "{{[^ ]*[/\\]+}}basic_linux_tree{{[/\\]+}}usr{{[/\\]+}}lib" ! CHECK-DYNAMIC-OMP-NOT: "-Bdynamic" -! CHECK-STATIC-OMP: "-Bstatic" "-lomp" "-Bdynamic" "-rpath" "{{[^ ]*}}/basic_linux_tree/usr/lib" +! CHECK-STATIC-OMP: "-Bstatic" "-lomp" "-Bdynamic" "-rpath" "{{[^ ]*[/\\]+}}basic_linux_tree{{[/\\]+}}usr{{[/\\]+}}lib" ! CHECK-NO-OMP-NOT: "-lomp" ! RUN: %flang -target x86_64-linux-gnu -ccc-install-dir %S/../Inputs/basic_linux_tree/usr/bin -static -static-flang-libs \ @@ -78,9 +78,9 @@ ! RUN: %s -lfoo -### 2>&1 | FileCheck --check-prefixes=CHECK-LD-STATIC,CHECK-STATIC-BOTH %s ! RUN: %flang -target x86_64-linux-gnu -ccc-install-dir %S/../Inputs/basic_linux_tree/usr/bin -static -fopenmp -static-openmp \ ! RUN: %s -lfoo -### 2>&1 | FileCheck --check-prefixes=CHECK-LD-STATIC,CHECK-STATIC-BOTH %s -! CHECK-LD-STATIC: "{{.*}}ld" +! CHECK-LD-STATIC: "{{.*}}ld{{(.exe)?}}" ! CHECK-LD-STATIC: "-static" "-o" "a.out" -! CHECK-LD-STATIC: "{{[^"]*}}classic-flang-{{[^ ]*}}.o" "-lflangmain" "-lfoo" "-L{{[^ ]*}}/basic_linux_tree/usr/lib" +! CHECK-LD-STATIC: "{{[^"]*}}classic-flang-{{[^ ]*}}.o" "-lflangmain" "-lfoo" "-L{{[^ ]*[/\\]+}}basic_linux_tree{{[/\\]+}}usr{{[/\\]+}}lib" ! CHECK-LD-STATIC-NOT: "-Bstatic" ! CHECK-LD-STATIC: "-lflang" "-lflangrti" "-lpgmath" "-lpthread" "-lrt" "-lm" ! CHECK-LD-STATIC-NOT: "-Bdynamic" From d22a89e17149ab9b2c0c129c0ce3462d26fa3ebf Mon Sep 17 00:00:00 2001 From: Adam Kallai Date: Thu, 16 Mar 2023 10:35:37 +0100 Subject: [PATCH 37/60] script: update llvm build script * Native Ninja is already available for Windows on ARM, so we can use it on both Windows platform. * Introduced a new '-i' build option to trigger whether the user wants to install LLVM or not. Previously the script relies on install_prefix option which was wrong approach. In this case we still could not defer the install for a later time if install directory was set. With this change the python build script will be consistent with official bash script. --- scripts/build_llvm_project.py | 33 ++++++++++++++++----------------- 1 file changed, 16 insertions(+), 17 deletions(-) diff --git a/scripts/build_llvm_project.py b/scripts/build_llvm_project.py index a2b8422fcfa7..86a4fea61cff 100644 --- a/scripts/build_llvm_project.py +++ b/scripts/build_llvm_project.py @@ -26,27 +26,29 @@ def get_arguments(): buildopt.add_argument('-t', '--target', metavar='ARCH', choices=['X86', 'AArch64', 'PowerPC'], default='X86', help='Control which targets are enabled (%(choices)s) (default: %(default)s)') buildopt.add_argument('-p', '--install-prefix', metavar='PATH', nargs='?', default=None, const=False, - help='Install directory (default: do not install)') + help='Specify installation directory (default: platform-specific location)') + buildopt.add_argument('-i', '--install', action='store_true', default=False, + help='Install LLVM (default: do not install)') buildopt.add_argument('-j', '--jobs', metavar='N', type=int, default=os.cpu_count(), - help='number of parallel build jobs (default: %(default)s)') + help='Number of parallel build jobs (default: %(default)s)') buildopt.add_argument('--toolchain', metavar='FILE', default=default_toolchain().as_posix(), - help='specify toolchain file (default: %(default)s)') + help='Specify toolchain file (default: %(default)s)') buildopt.add_argument('-d', '--builddir', metavar='DIR', default='build', - help=f'specify build directory (default: {settings.LLVM_DIR}/%(default)s)') + help=f'Specify build directory (default: {settings.LLVM_DIR}/%(default)s)') buildopt.add_argument('--clean', action='store_true', default=False, - help='clean build') + help='Clean build') buildopt.add_argument('-b', '--build-type', metavar='TYPE', default='Release', - help='set build type (default: %(default)s)') + help='Set build type (default: %(default)s)') buildopt.add_argument('-x', '--cmake-param', metavar='OPT', action='append', default=[], - help='add custom argument to CMake') + help='Add custom argument to CMake') buildopt.add_argument('-e', '--llvm-enable-projects', metavar='OPT', action='append', default=['clang'] if sys.platform == 'win32' else ['clang', 'openmp'], - help='enable llvm projects to build (in quotation marks separated by semicolons e.g.: "clang;openmp")') + help='Enable LLVM projects to build (in quotation marks separated by semicolons e.g.: "clang;openmp")') buildopt.add_argument('-c', '--use-ccache', action="store_true", default=False, help='Using ccache during the build (default: %(default)s)') buildopt.add_argument('--cc', metavar='OPT', default=None, - help='use specific C compiler') + help='Use specific C compiler') buildopt.add_argument('--cxx', metavar='OPT', default=None, - help='use specific C++ compiler') + help='Use specific C++ compiler') buildopt.add_argument('-v', '--verbose', action='store_true', default=False, help='Verbose build (default: %(default)s') arguments = parser.parse_args() @@ -58,11 +60,8 @@ def generate_buildoptions(arguments): f'-DCMAKE_TOOLCHAIN_FILE={arguments.toolchain}' ] - if sys.platform == 'win32' and platform.uname()[4].lower() == 'arm64': - base_cmake_args.append('-GNMake Makefiles') - else: - generator = 'Ninja' if sys.platform == 'win32' else 'Unix Makefiles' - base_cmake_args.append(f'-G{generator}') + generator = 'Ninja' if sys.platform == 'win32' else 'Unix Makefiles' + base_cmake_args.append(f'-G{generator}') if arguments.install_prefix: install_root = Path(arguments.install_prefix) @@ -143,10 +142,10 @@ def print_header(title): def main(): arguments = get_arguments() - print_header('Building classic llvm') + print_header('Building classic LLVM') build_path = configure_llvm(arguments) build_project(build_path, arguments) - if arguments.install_prefix is not None: + if arguments.install: install_project(build_path, arguments) if __name__ == "__main__": From 79c77f25fab5cc97623fefb28a2ba5d2254aea96 Mon Sep 17 00:00:00 2001 From: Bryan Chan Date: Mon, 3 Jul 2023 12:24:44 -0400 Subject: [PATCH 38/60] [build] Specify LLVM_MAIN_SRC_DIR when running build-flang.sh Otherwise Classic Flang's CMakeLists.txt will be unable to find llvm-lit and cannot generate test-related goals, e.g. `check-all`. --- .github/workflows/flang-arm64-tests.yml | 2 +- .github/workflows/flang-tests.yml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/flang-arm64-tests.yml b/.github/workflows/flang-arm64-tests.yml index b4f2a2c955c2..792187c438d5 100644 --- a/.github/workflows/flang-arm64-tests.yml +++ b/.github/workflows/flang-arm64-tests.yml @@ -57,7 +57,7 @@ jobs: - name: Build and install libpgmath & flang run: | cd ${{ env.build_path }}/flang - ./build-flang.sh -t ${{ matrix.target }} -p ${{ env.install_prefix }} -n $(nproc) + ./build-flang.sh -t ${{ matrix.target }} -p ${{ env.install_prefix }} -n $(nproc) -l ${{ env.build_path }}/classic-flang-llvm-project/llvm - name: Copy llvm-lit run: | diff --git a/.github/workflows/flang-tests.yml b/.github/workflows/flang-tests.yml index 279dccc78b96..216d5711e8d0 100644 --- a/.github/workflows/flang-tests.yml +++ b/.github/workflows/flang-tests.yml @@ -63,7 +63,7 @@ jobs: - name: Build and install libpgmath & flang run: | cd ../../flang - ./build-flang.sh -t ${{ matrix.target }} -p ${{ env.install_prefix }} -n $(nproc) -c -s + ./build-flang.sh -t ${{ matrix.target }} -p ${{ env.install_prefix }} -n $(nproc) -c -s -l $(realpath ../classic-flang-llvm-project/classic-flang-llvm-project/llvm) - name: Copy llvm-lit run: | From 27370f59a628688975ed1e2fabbac7473abc5adb Mon Sep 17 00:00:00 2001 From: Isuru Fernando Date: Wed, 20 Oct 2021 20:56:05 -0700 Subject: [PATCH 39/60] Pass Flang libraries to MSVC linker correctly The orignal PR was created by Isuruf #65 --- clang/lib/Driver/ToolChains/ClassicFlang.cpp | 8 +++ clang/lib/Driver/ToolChains/CommonArgs.cpp | 2 +- clang/lib/Driver/ToolChains/CommonArgs.h | 2 + clang/lib/Driver/ToolChains/MSVC.cpp | 75 ++++++++++++++++++++ clang/lib/Driver/ToolChains/MSVC.h | 5 ++ 5 files changed, 91 insertions(+), 1 deletion(-) diff --git a/clang/lib/Driver/ToolChains/ClassicFlang.cpp b/clang/lib/Driver/ToolChains/ClassicFlang.cpp index eba1fd6b2e97..99288f8f4eb9 100644 --- a/clang/lib/Driver/ToolChains/ClassicFlang.cpp +++ b/clang/lib/Driver/ToolChains/ClassicFlang.cpp @@ -1204,6 +1204,14 @@ void ClassicFlang::ConstructJob(Compilation &C, const JobAction &JA, LowerCmdArgs.push_back(Args.MakeArgString(OutFile)); } + bool IsWindowsMSVC = getToolChain().getTriple().isWindowsMSVCEnvironment(); + if (IsWindowsMSVC && !Args.hasArg(options::OPT_noFlangLibs)) { + getToolChain().AddFortranStdlibLibArgs(Args, LowerCmdArgs); + for (auto Arg : Args.filtered(options::OPT_noFlangLibs)) { + Arg->claim(); + } + } + C.addCommand(std::make_unique(JA, *this, ResponseFileSupport::AtFileUTF8(), LowerExec, LowerCmdArgs, Inputs)); } diff --git a/clang/lib/Driver/ToolChains/CommonArgs.cpp b/clang/lib/Driver/ToolChains/CommonArgs.cpp index 6146b6ab67ad..78cd7fcc8597 100644 --- a/clang/lib/Driver/ToolChains/CommonArgs.cpp +++ b/clang/lib/Driver/ToolChains/CommonArgs.cpp @@ -344,7 +344,7 @@ static bool shouldIgnoreUnsupportedTargetFeature(const Arg &TargetFeatureArg, #ifdef ENABLE_CLASSIC_FLANG /// \brief Determine if Fortran "main" object is needed -static bool needFortranMain(const Driver &D, const ArgList &Args) { +bool tools::needFortranMain(const Driver &D, const ArgList &Args) { return (needFortranLibs(D, Args) && (!Args.hasArg(options::OPT_Mnomain) || !Args.hasArg(options::OPT_no_fortran_main))); diff --git a/clang/lib/Driver/ToolChains/CommonArgs.h b/clang/lib/Driver/ToolChains/CommonArgs.h index 37f54403b22c..0bdff7d9ad78 100644 --- a/clang/lib/Driver/ToolChains/CommonArgs.h +++ b/clang/lib/Driver/ToolChains/CommonArgs.h @@ -26,6 +26,8 @@ namespace tools { #ifdef ENABLE_CLASSIC_FLANG bool needFortranLibs(const Driver &D, const llvm::opt::ArgList &Args); + +bool needFortranMain(const Driver &D, const llvm::opt::ArgList &Args); #endif void addPathIfExists(const Driver &D, const Twine &Path, diff --git a/clang/lib/Driver/ToolChains/MSVC.cpp b/clang/lib/Driver/ToolChains/MSVC.cpp index bae41fc06c03..da9e8d1e23c0 100644 --- a/clang/lib/Driver/ToolChains/MSVC.cpp +++ b/clang/lib/Driver/ToolChains/MSVC.cpp @@ -271,6 +271,13 @@ void visualstudio::Linker::ConstructJob(Compilation &C, const JobAction &JA, } } +#ifdef ENABLE_CLASSIC_FLANG + if (C.getDriver().IsFlangMode()) { + CmdArgs.push_back(Args.MakeArgString(std::string("-libpath:") + + TC.getDriver().Dir + "/../lib")); + } +#endif + // Add compiler-rt lib in case if it was explicitly // specified as an argument for --rtlib option. if (!Args.hasArg(options::OPT_nostdlib)) { @@ -521,6 +528,74 @@ void MSVCToolChain::AddHIPRuntimeLibArgs(const ArgList &Args, "amdhip64.lib"}); } +#ifdef ENABLE_CLASSIC_FLANG +void MSVCToolChain::AddFortranStdlibLibArgs(const ArgList &Args, + ArgStringList &CmdArgs) const { + bool staticFlangLibs = false; + bool useOpenMP = false; + + if (Args.hasArg(options::OPT_staticFlangLibs)) { + for (auto *A: Args.filtered(options::OPT_staticFlangLibs)) { + A->claim(); + staticFlangLibs = true; + } + } + + Arg *A = Args.getLastArg(options::OPT_mp, options::OPT_nomp, + options::OPT_fopenmp, options::OPT_fno_openmp); + if (A && + (A->getOption().matches(options::OPT_mp) || + A->getOption().matches(options::OPT_fopenmp))) { + useOpenMP = true; + } + + if (needFortranMain(getDriver(), Args)) { + // flangmain is always static + CmdArgs.push_back("-linker"); + CmdArgs.push_back("/subsystem:console"); + CmdArgs.push_back("-linker"); + CmdArgs.push_back("/defaultlib:flangmain.lib"); + } + + if (staticFlangLibs) { + CmdArgs.push_back("-linker"); + CmdArgs.push_back("/defaultlib:libflang.lib"); + CmdArgs.push_back("-linker"); + CmdArgs.push_back("/defaultlib:libflangrti.lib"); + CmdArgs.push_back("-linker"); + CmdArgs.push_back("/defaultlib:libpgmath.lib"); + } else { + CmdArgs.push_back("-linker"); + CmdArgs.push_back("/defaultlib:flang.lib"); + CmdArgs.push_back("-linker"); + CmdArgs.push_back("/defaultlib:flangrti.lib"); + CmdArgs.push_back("-linker"); + CmdArgs.push_back("/defaultlib:pgmath.lib"); + } + if (useOpenMP) { + CmdArgs.push_back("-linker"); + CmdArgs.push_back("/nodefaultlib:vcomp.lib"); + CmdArgs.push_back("-linker"); + CmdArgs.push_back("/nodefaultlib:vcompd.lib"); + CmdArgs.push_back("-linker"); + CmdArgs.push_back("/defaultlib:libomp.lib"); + } + + // Allways link Fortran executables with Pthreads + // CmdArgs.push_back("-lpthread"); + + // These options are added clang-cl in Clang.cpp for C/C++ + // In clang-cl.exe -MD and -MT control these options, but in + // flang.exe like clang.exe these are different options for + // dependency tracking. Let's assume that if somebody needs + // static flang libs, they don't need static C runtime libs. + // FIXME: Use LLVM_USE_CRT_ variable + // to use libcmt.lib or msvcrt.lib + CmdArgs.push_back("-linker"); + CmdArgs.push_back("/defaultlib:libcmt.lib"); +} +#endif + void MSVCToolChain::printVerboseInfo(raw_ostream &OS) const { CudaInstallation->print(OS); RocmInstallation->print(OS); diff --git a/clang/lib/Driver/ToolChains/MSVC.h b/clang/lib/Driver/ToolChains/MSVC.h index b35390c52a04..830ce3fe12aa 100644 --- a/clang/lib/Driver/ToolChains/MSVC.h +++ b/clang/lib/Driver/ToolChains/MSVC.h @@ -95,6 +95,11 @@ class LLVM_LIBRARY_VISIBILITY MSVCToolChain : public ToolChain { void AddCudaIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override; +#ifdef ENABLE_CLASSIC_FLANG + void AddFortranStdlibLibArgs(const llvm::opt::ArgList &Args, + llvm::opt::ArgStringList &CmdArgs) const override; +#endif + void AddHIPIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override; From c5aa14cac2722f28682e23ef1a0b4b8a320ea2ec Mon Sep 17 00:00:00 2001 From: Adam Kallai Date: Wed, 12 Jul 2023 17:59:28 +0200 Subject: [PATCH 40/60] Add Flang include directory to MSVC toolchain --- clang/lib/Driver/ToolChains/MSVC.cpp | 36 ++++++++++++++++++++++++++++ clang/lib/Driver/ToolChains/MSVC.h | 6 +++++ 2 files changed, 42 insertions(+) diff --git a/clang/lib/Driver/ToolChains/MSVC.cpp b/clang/lib/Driver/ToolChains/MSVC.cpp index da9e8d1e23c0..7f9f98169ec7 100644 --- a/clang/lib/Driver/ToolChains/MSVC.cpp +++ b/clang/lib/Driver/ToolChains/MSVC.cpp @@ -720,6 +720,42 @@ void MSVCToolChain::AddSystemIncludeWithSubfolder( addSystemInclude(DriverArgs, CC1Args, path); } +#ifdef ENABLE_CLASSIC_FLANG +/// Convert path list to Fortran frontend argument +static void AddFlangSysIncludeArg(const ArgList &DriverArgs, + ArgStringList &Flang1Args, + ToolChain::path_list IncludePathList) { + std::string ArgValue; // Path argument value + + // Make up argument value consisting of paths separated by colons + bool first = true; + for (auto P : IncludePathList) { + if (first) { + first = false; + } else { + ArgValue += ";"; + } + ArgValue += P; + } + + // Add the argument + Flang1Args.push_back("-stdinc"); + Flang1Args.push_back(DriverArgs.MakeArgString(ArgValue)); +} + +void MSVCToolChain::AddFlangSystemIncludeArgs(const ArgList &DriverArgs, + ArgStringList &Flang1Args) const { +path_list IncludePathList; + const Driver &D = getDriver(); + if (DriverArgs.hasArg(options::OPT_nostdinc)) + return; + SmallString<128> P(D.Dir); + llvm::sys::path::append(P, "../include"); + IncludePathList.push_back(P.c_str()); + AddFlangSysIncludeArg(DriverArgs, Flang1Args, IncludePathList); +} +#endif + void MSVCToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs, ArgStringList &CC1Args) const { if (DriverArgs.hasArg(options::OPT_nostdinc)) diff --git a/clang/lib/Driver/ToolChains/MSVC.h b/clang/lib/Driver/ToolChains/MSVC.h index 830ce3fe12aa..530d8f3cf121 100644 --- a/clang/lib/Driver/ToolChains/MSVC.h +++ b/clang/lib/Driver/ToolChains/MSVC.h @@ -85,6 +85,12 @@ class LLVM_LIBRARY_VISIBILITY MSVCToolChain : public ToolChain { return VSLayout == llvm::ToolsetLayout::VS2017OrNewer; } +#ifdef ENABLE_CLASSIC_FLANG + void + AddFlangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, + llvm::opt::ArgStringList &Flang1Args) const override; +#endif + void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override; From d2a98c772b72e17b642273c841c80cb18aca7c8d Mon Sep 17 00:00:00 2001 From: Bryan Chan Date: Fri, 15 Sep 2023 18:05:31 -0400 Subject: [PATCH 41/60] [Driver] Fix flang driver preprocessor issue The -save-temps option has been causing the driver to run flang1/flang2 on the input file twice, and the fortran-preprocessor.f90 test was unable to detect the error, because it had used -c instead of -x in a couple of RUN commands. This patch fixes the test and the driver to make sure that the frontend is not invoked multiple times with -save-temps. --- clang/lib/Driver/Driver.cpp | 9 +++++++++ clang/lib/Driver/ToolChains/ClassicFlang.h | 2 +- clang/test/Driver/fortran-preprocessor.f90 | 15 ++++++++------- 3 files changed, 18 insertions(+), 8 deletions(-) diff --git a/clang/lib/Driver/Driver.cpp b/clang/lib/Driver/Driver.cpp index f8dd6898ce2b..20e9bb6b8cde 100644 --- a/clang/lib/Driver/Driver.cpp +++ b/clang/lib/Driver/Driver.cpp @@ -5612,8 +5612,17 @@ class ToolSelector final { /// are appended to \a CollapsedOffloadAction. void combineWithPreprocessor(const Tool *T, ActionList &Inputs, ActionList &CollapsedOffloadAction) { +#ifdef ENABLE_CLASSIC_FLANG + // flang1 always combines preprocessing and compilation. + // Do not return early even when -save-temps is used. + if (!T || !T->hasIntegratedCPP() || + (strcmp(T->getName(), "classic-flang") && + !canCollapsePreprocessorAction())) + return; +#else if (!T || !canCollapsePreprocessorAction() || !T->hasIntegratedCPP()) return; +#endif // Attempt to get a preprocessor action dependence. ActionList PreprocessJobOffloadActions; diff --git a/clang/lib/Driver/ToolChains/ClassicFlang.h b/clang/lib/Driver/ToolChains/ClassicFlang.h index 5af119c2f79e..cc9d7c3c22f7 100644 --- a/clang/lib/Driver/ToolChains/ClassicFlang.h +++ b/clang/lib/Driver/ToolChains/ClassicFlang.h @@ -28,7 +28,7 @@ namespace tools { class LLVM_LIBRARY_VISIBILITY ClassicFlang : public Tool { public: ClassicFlang(const ToolChain &TC) - : Tool("flang:frontend", + : Tool("classic-flang", "Fortran frontend to LLVM", TC) {} bool hasGoodDiagnostics() const override { return true; } diff --git a/clang/test/Driver/fortran-preprocessor.f90 b/clang/test/Driver/fortran-preprocessor.f90 index 99f4186ba83c..d9e5620145ac 100644 --- a/clang/test/Driver/fortran-preprocessor.f90 +++ b/clang/test/Driver/fortran-preprocessor.f90 @@ -2,7 +2,7 @@ ! -cpp should preprocess as it goes, regardless of input file extension ! RUN: %flang -cpp -c -DHELLO="hello all" -### %s 2>&1 | FileCheck %s --check-prefixes=ALL,CPP,PP -! RUN: %flang -cpp -c -DHELLO="hello all" -### -c f95-cpp-input %s 2>&1 | FileCheck %s --check-prefixes=ALL,CPP,PP +! RUN: %flang -cpp -c -DHELLO="hello all" -### -x f95-cpp-input %s 2>&1 | FileCheck %s --check-prefixes=ALL,CPP,PP ! -E should preprocess then stop, regardless of input file extension ! RUN: %flang -E -DHELLO="hello all" -### %s 2>&1 | FileCheck %s --check-prefixes=ALL,E,PPONLY ! RUN: %flang -E -DHELLO="hello all" -### -x f95-cpp-input %s 2>&1 | FileCheck %s --check-prefixes=ALL,E,PPONLY @@ -17,9 +17,9 @@ ! Test -save-temps does not break things (same codepath as -traditional-cpp bug above) ! RUN: %flang -E -DHELLO="hello all" -save-temps -### %s 2>&1 | FileCheck %s --check-prefixes=ALL,E,PPONLY -! RUN: %flang -E -DHELLO="hello all" -save-temps -### -c f95-cpp-input %s 2>&1 | FileCheck %s --check-prefixes=ALL,E,PPONLY -! RUN: %flang -cpp -c -DHELLO="hello all" -save-temps -### %s 2>&1 | FileCheck %s --check-prefixes=ALL,CPP -! RUN: %flang -cpp -c -DHELLO="hello all" -save-temps -### -c f95-cpp-input %s 2>&1 | FileCheck %s --check-prefixes=ALL,CPP +! RUN: %flang -E -DHELLO="hello all" -save-temps -### -x f95-cpp-input %s 2>&1 | FileCheck %s --check-prefixes=ALL,E,PPONLY +! RUN: %flang -cpp -c -DHELLO="hello all" -save-temps -### %s 2>&1 | FileCheck %s --check-prefixes=ALL,CPP,PP +! RUN: %flang -cpp -c -DHELLO="hello all" -save-temps -### -x f95-cpp-input %s 2>&1 | FileCheck %s --check-prefixes=ALL,CPP,PP ! Test for the correct cmdline flags ! Consume up to flang1 line @@ -31,13 +31,14 @@ ! E-DAG: "-es" ! E-DAG: "-preprocess" -! flang1 should only be called once! -! ALL-NOT: "{{.*}}flang1" - ! CPP should continue to build object ! PP: "{{.*}}flang2" ! PPONLY-NOT: "{{.*}}flang2" +! flang1 and flang2 should only be called at most once! +! ALL-NOT: "{{.*}}flang1" +! ALL-NOT: "{{.*}}flang2" + ! These commands should never call a linker! ! ALL-NOT: "{{.*}}ld" From 51625baba333f4355eafdb2c9019b4cb1da78a9c Mon Sep 17 00:00:00 2001 From: Bryan Chan Date: Wed, 19 Feb 2025 11:47:22 -0500 Subject: [PATCH 42/60] [ClassicFlang] Update LLVM version number passed to the frontend --- clang/lib/Driver/ToolChains/ClassicFlang.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/clang/lib/Driver/ToolChains/ClassicFlang.cpp b/clang/lib/Driver/ToolChains/ClassicFlang.cpp index 99288f8f4eb9..e8c05816baa2 100644 --- a/clang/lib/Driver/ToolChains/ClassicFlang.cpp +++ b/clang/lib/Driver/ToolChains/ClassicFlang.cpp @@ -1022,7 +1022,7 @@ void ClassicFlang::ConstructJob(Compilation &C, const JobAction &JA, LowerCmdArgs.push_back("-x"); LowerCmdArgs.push_back("121"); LowerCmdArgs.push_back("0x800"); LowerCmdArgs.push_back("-x"); LowerCmdArgs.push_back("54"); LowerCmdArgs.push_back("0x10"); LowerCmdArgs.push_back("-x"); LowerCmdArgs.push_back("70"); LowerCmdArgs.push_back("0x40000000"); - LowerCmdArgs.push_back("-x"); LowerCmdArgs.push_back("249"); LowerCmdArgs.push_back("150"); // LLVM version + LowerCmdArgs.push_back("-x"); LowerCmdArgs.push_back("249"); LowerCmdArgs.push_back("200"); // LLVM version LowerCmdArgs.push_back("-x"); LowerCmdArgs.push_back("124"); LowerCmdArgs.push_back("1"); LowerCmdArgs.push_back("-y"); LowerCmdArgs.push_back("163"); LowerCmdArgs.push_back("0xc0000000"); LowerCmdArgs.push_back("-x"); LowerCmdArgs.push_back("189"); LowerCmdArgs.push_back("0x10"); From d629433c224ac01b93f2e630effd80bee5f87154 Mon Sep 17 00:00:00 2001 From: Bryan Chan Date: Wed, 4 Oct 2023 20:50:59 -0400 Subject: [PATCH 43/60] [ClassicFlang] Adapt header include paths Some header files have been moved to new directories in LLVM 17. StringExtras.h is no longer included transitively since D155178, and now needs to be included explicitly by clang/Frontend/Utils.h. --- clang/include/clang/Frontend/Utils.h | 1 + clang/lib/Driver/ToolChains/ClassicFlang.cpp | 2 +- clang/lib/Driver/ToolChains/ClassicFlang.h | 4 ++-- 3 files changed, 4 insertions(+), 3 deletions(-) diff --git a/clang/include/clang/Frontend/Utils.h b/clang/include/clang/Frontend/Utils.h index 9f74cc0501e6..25811b66d0ad 100644 --- a/clang/include/clang/Frontend/Utils.h +++ b/clang/include/clang/Frontend/Utils.h @@ -21,6 +21,7 @@ #include "llvm/ADT/APInt.h" #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/IntrusiveRefCntPtr.h" +#include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringMap.h" #include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringSet.h" diff --git a/clang/lib/Driver/ToolChains/ClassicFlang.cpp b/clang/lib/Driver/ToolChains/ClassicFlang.cpp index e8c05816baa2..af6ad3107a19 100644 --- a/clang/lib/Driver/ToolChains/ClassicFlang.cpp +++ b/clang/lib/Driver/ToolChains/ClassicFlang.cpp @@ -31,8 +31,8 @@ #include "llvm/Support/FileSystem.h" #include "llvm/Support/Path.h" #include "llvm/Support/Process.h" -#include "llvm/Support/TargetParser.h" #include "llvm/Support/YAMLParser.h" +#include "llvm/TargetParser/TargetParser.h" #ifdef LLVM_ON_UNIX #include // For getuid(). diff --git a/clang/lib/Driver/ToolChains/ClassicFlang.h b/clang/lib/Driver/ToolChains/ClassicFlang.h index cc9d7c3c22f7..5864e0776601 100644 --- a/clang/lib/Driver/ToolChains/ClassicFlang.h +++ b/clang/lib/Driver/ToolChains/ClassicFlang.h @@ -11,13 +11,13 @@ #define LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_ClassicFlang_H #include "MSVC.h" -#include "clang/Basic/DebugInfoOptions.h" #include "clang/Driver/Driver.h" #include "clang/Driver/Tool.h" #include "clang/Driver/Types.h" -#include "llvm/ADT/Triple.h" +#include "llvm/Frontend/Debug/Options.h" #include "llvm/Option/Option.h" #include "llvm/Support/raw_ostream.h" +#include "llvm/TargetParser/Triple.h" namespace clang { namespace driver { From 3994d1ea5c7762e19d598897d25a426ffbd83adb Mon Sep 17 00:00:00 2001 From: Bryan Chan Date: Wed, 4 Oct 2023 21:37:56 -0400 Subject: [PATCH 44/60] [Driver] Update test to not expect -rpath for -lomp Upstream commit 555b572e3f40 had reverted D118493, which let Clang add a toolchain-specific -rpath option to the linker command for the OpenMP library. This patch fixes up a Classic Flang driver test which is impacted by the revert. --- clang/test/Driver/flang/classic-flang.f95 | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/clang/test/Driver/flang/classic-flang.f95 b/clang/test/Driver/flang/classic-flang.f95 index c331e99bed76..0319a11358f9 100644 --- a/clang/test/Driver/flang/classic-flang.f95 +++ b/clang/test/Driver/flang/classic-flang.f95 @@ -67,9 +67,9 @@ ! CHECK-DYNAMIC-FLANG-NOT: "-Bdynamic" ! CHECK-STATIC-FLANG: "-Bstatic" "-lflang" "-lflangrti" "-lpgmath" "-Bdynamic" "-lpthread" "-lrt" "-lm" ! CHECK-DYNAMIC-OMP-NOT: "-Bstatic" -! CHECK-DYNAMIC-OMP: "-lomp" "-rpath" "{{[^ ]*[/\\]+}}basic_linux_tree{{[/\\]+}}usr{{[/\\]+}}lib" +! CHECK-DYNAMIC-OMP: "-lomp" "-L{{[^ ]*[/\\]+}}basic_linux_tree{{[/\\]+}}usr{{[/\\]+}}lib" ! CHECK-DYNAMIC-OMP-NOT: "-Bdynamic" -! CHECK-STATIC-OMP: "-Bstatic" "-lomp" "-Bdynamic" "-rpath" "{{[^ ]*[/\\]+}}basic_linux_tree{{[/\\]+}}usr{{[/\\]+}}lib" +! CHECK-STATIC-OMP: "-Bstatic" "-lomp" "-Bdynamic" "-L{{[^ ]*[/\\]+}}basic_linux_tree{{[/\\]+}}usr{{[/\\]+}}lib" ! CHECK-NO-OMP-NOT: "-lomp" ! RUN: %flang -target x86_64-linux-gnu -ccc-install-dir %S/../Inputs/basic_linux_tree/usr/bin -static -static-flang-libs \ From 1253080bedb3c05599077818816858cb6551a708 Mon Sep 17 00:00:00 2001 From: Bryan Chan Date: Wed, 4 Oct 2023 21:43:59 -0400 Subject: [PATCH 45/60] [VecLib] Update test case to match new vectorizer behaviour The IR in clang/test/CodeGen/libpgmath-logfun-aarch64.ll can now be vectorized by a factor of two. The IR still does not call the unsupported libpgmath functions, as per the intention of the test. --- clang/test/CodeGen/libpgmath-logfun-aarch64.ll | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/clang/test/CodeGen/libpgmath-logfun-aarch64.ll b/clang/test/CodeGen/libpgmath-logfun-aarch64.ll index 045d14fdf407..141fed29ccd1 100644 --- a/clang/test/CodeGen/libpgmath-logfun-aarch64.ll +++ b/clang/test/CodeGen/libpgmath-logfun-aarch64.ll @@ -45,10 +45,8 @@ L.entry: ret void ; CHECK-NOT: __pd_log_4 -; CHECK: __pd_log_1 -; CHECK: __pd_log_1 -; CHECK: __pd_log_1 -; CHECK: __pd_log_1 +; CHECK: __pd_log_2 +; CHECK: __pd_log_2 } ; Function Attrs: nounwind readnone willreturn From 42115e7cadb1971a30d327f940ca1be9bb775754 Mon Sep 17 00:00:00 2001 From: Bryan Chan Date: Sat, 21 Oct 2023 12:49:13 -0400 Subject: [PATCH 46/60] [Driver] Handle -Mnomain and -fno-fortran-main correctly -Mnomain and -fno-fortran-main were ineffective unless they were both used at the same time. This patch fixes the bug, formats needFortranMain and needFortranLibs, and adds some test cases for the logic. --- clang/lib/Driver/ToolChains/CommonArgs.cpp | 13 ++---- clang/test/Driver/flang/classic-flang.f95 | 49 ++++++++++++++++++---- 2 files changed, 44 insertions(+), 18 deletions(-) diff --git a/clang/lib/Driver/ToolChains/CommonArgs.cpp b/clang/lib/Driver/ToolChains/CommonArgs.cpp index 78cd7fcc8597..7e9e139888aa 100644 --- a/clang/lib/Driver/ToolChains/CommonArgs.cpp +++ b/clang/lib/Driver/ToolChains/CommonArgs.cpp @@ -345,19 +345,14 @@ static bool shouldIgnoreUnsupportedTargetFeature(const Arg &TargetFeatureArg, #ifdef ENABLE_CLASSIC_FLANG /// \brief Determine if Fortran "main" object is needed bool tools::needFortranMain(const Driver &D, const ArgList &Args) { - return (needFortranLibs(D, Args) - && (!Args.hasArg(options::OPT_Mnomain) || - !Args.hasArg(options::OPT_no_fortran_main))); + return (needFortranLibs(D, Args) && !Args.hasArg(options::OPT_Mnomain) && + !Args.hasArg(options::OPT_no_fortran_main)); } /// \brief Determine if Fortran link libraies are needed bool tools::needFortranLibs(const Driver &D, const ArgList &Args) { - if (D.IsFlangMode() && !Args.hasArg(options::OPT_nostdlib) && - !Args.hasArg(options::OPT_noFlangLibs)) { - return true; - } - - return false; + return (D.IsFlangMode() && !Args.hasArg(options::OPT_nostdlib) && + !Args.hasArg(options::OPT_noFlangLibs)); } #endif diff --git a/clang/test/Driver/flang/classic-flang.f95 b/clang/test/Driver/flang/classic-flang.f95 index 0319a11358f9..b953ca15e9be 100644 --- a/clang/test/Driver/flang/classic-flang.f95 +++ b/clang/test/Driver/flang/classic-flang.f95 @@ -45,23 +45,29 @@ ! Check that the linker job is given the correct libraries and library paths. ! RUN: %flang -target x86_64-linux-gnu -ccc-install-dir %S/../Inputs/basic_linux_tree/usr/bin -mp \ -! RUN: %s -lfoo -### 2>&1 | FileCheck --check-prefixes=CHECK-LD,CHECK-DYNAMIC-FLANG,CHECK-DYNAMIC-OMP %s +! RUN: %s -lfoo -### 2>&1 | FileCheck --check-prefixes=CHECK-LD,CHECK-MAIN,CHECK-DYNAMIC-FLANG,CHECK-DYNAMIC-OMP %s ! RUN: %flang -target x86_64-linux-gnu -ccc-install-dir %S/../Inputs/basic_linux_tree/usr/bin -mp -nomp \ -! RUN: %s -lfoo -### 2>&1 | FileCheck --check-prefixes=CHECK-LD,CHECK-DYNAMIC-FLANG,CHECK-NO-OMP %s +! RUN: %s -lfoo -### 2>&1 | FileCheck --check-prefixes=CHECK-LD,CHECK-MAIN,CHECK-DYNAMIC-FLANG,CHECK-NO-OMP %s ! RUN: %flang -target x86_64-linux-gnu -ccc-install-dir %S/../Inputs/basic_linux_tree/usr/bin -fopenmp \ -! RUN: %s -lfoo -### 2>&1 | FileCheck --check-prefixes=CHECK-LD,CHECK-DYNAMIC-FLANG,CHECK-DYNAMIC-OMP %s +! RUN: %s -lfoo -### 2>&1 | FileCheck --check-prefixes=CHECK-LD,CHECK-MAIN,CHECK-DYNAMIC-FLANG,CHECK-DYNAMIC-OMP %s ! RUN: %flang -target x86_64-linux-gnu -ccc-install-dir %S/../Inputs/basic_linux_tree/usr/bin -fopenmp -fno-openmp \ -! RUN: %s -lfoo -### 2>&1 | FileCheck --check-prefixes=CHECK-LD,CHECK-DYNAMIC-FLANG,CHECK-NO-OMP %s +! RUN: %s -lfoo -### 2>&1 | FileCheck --check-prefixes=CHECK-LD,CHECK-MAIN,CHECK-DYNAMIC-FLANG,CHECK-NO-OMP %s ! RUN: %flang -target x86_64-linux-gnu -ccc-install-dir %S/../Inputs/basic_linux_tree/usr/bin -fopenmp -static-openmp \ -! RUN: %s -lfoo -### 2>&1 | FileCheck --check-prefixes=CHECK-LD,CHECK-DYNAMIC-FLANG,CHECK-STATIC-OMP %s +! RUN: %s -lfoo -### 2>&1 | FileCheck --check-prefixes=CHECK-LD,CHECK-MAIN,CHECK-DYNAMIC-FLANG,CHECK-STATIC-OMP %s ! RUN: %flang -target x86_64-linux-gnu -ccc-install-dir %S/../Inputs/basic_linux_tree/usr/bin -fopenmp -static-flang-libs \ -! RUN: %s -lfoo -### 2>&1 | FileCheck --check-prefixes=CHECK-LD,CHECK-STATIC-FLANG,CHECK-DYNAMIC-OMP %s +! RUN: %s -lfoo -### 2>&1 | FileCheck --check-prefixes=CHECK-LD,CHECK-MAIN,CHECK-STATIC-FLANG,CHECK-DYNAMIC-OMP %s ! RUN: %flang -target x86_64-linux-gnu -ccc-install-dir %S/../Inputs/basic_linux_tree/usr/bin -static-flang-libs \ -! RUN: %s -lfoo -### 2>&1 | FileCheck --check-prefixes=CHECK-LD,CHECK-STATIC-FLANG,CHECK-NO-OMP %s - +! RUN: %s -lfoo -### 2>&1 | FileCheck --check-prefixes=CHECK-LD,CHECK-MAIN,CHECK-STATIC-FLANG,CHECK-NO-OMP %s +! RUN: %flang -target x86_64-linux-gnu -ccc-install-dir %S/../Inputs/basic_linux_tree/usr/bin -Mnomain \ +! RUN: %s -lfoo -### 2>&1 | FileCheck --check-prefixes=CHECK-LD,CHECK-NOMAIN,CHECK-DYNAMIC-FLANG %s +! RUN: %flang -target x86_64-linux-gnu -ccc-install-dir %S/../Inputs/basic_linux_tree/usr/bin -fno-fortran-main \ +! RUN: %s -lfoo -### 2>&1 | FileCheck --check-prefixes=CHECK-LD,CHECK-NOMAIN,CHECK-DYNAMIC-FLANG %s ! CHECK-LD: "{{.*}}ld{{(.exe)?}}" ! CHECK-LD-NOT: "-static" -! CHECK-LD: "{{[^"]*}}classic-flang-{{[^ ]*}}.o" "-lflangmain" "-lfoo" "-L{{[^ ]*[/\\]+}}basic_linux_tree{{[/\\]+}}usr{{[/\\]+}}lib" +! CHECK-LD-SAME: "{{[^"]*}}classic-flang-{{[^ ]*}}.o" +! CHECK-MAIN-SAME: "-lflangmain" +! CHECK-NOMAIN-NOT: "-lflangmain" +! CHECK-LD-SAME: "-lfoo" "-L{{[^ ]*[/\\]+}}basic_linux_tree{{[/\\]+}}usr{{[/\\]+}}lib" ! CHECK-DYNAMIC-FLANG-NOT: "-Bstatic" ! CHECK-DYNAMIC-FLANG: "-lflang" "-lflangrti" "-lpgmath" "-lpthread" "-lrt" "-lm" ! CHECK-DYNAMIC-FLANG-NOT: "-Bdynamic" @@ -87,3 +93,28 @@ ! CHECK-STATIC-BOTH-NOT: "-Bstatic" ! CHECK-STATIC-BOTH: "-lomp" ! CHECK-STATIC-BOTH-NOT: "-Bdynamic" + +! RUN: %flang -target x86_64-linux-gnu -ccc-install-dir %S/../Inputs/basic_linux_tree/usr/bin -no-flang-libs \ +! RUN: %s -lfoo -### 2>&1 | FileCheck --check-prefixes=CHECK-NOFLANGLIBS %s +! CHECK-NOFLANGLIBS: "{{.*}}ld{{(.exe)?}}" +! CHECK-NOFLANGLIBS-SAME: "{{[^"]*}}classic-flang-{{[^ ]*}}.o" +! CHECK-NOFLANGLIBS-NOT: "-lflangmain" +! CHECK-NOFLANGLIBS-SAME: "-lfoo" "-L{{[^ ]*[/\\]+}}basic_linux_tree{{[/\\]+}}usr{{[/\\]+}}lib" +! CHECK-NOFLANGLIBS-NOT: "-lflang" "-lflangrti" "-lpgmath" +! CHECK-NOFLANGLIBS: "-lm" "-lgcc" +! CHECK-NOFLANGLIBS: "-lgcc_s" +! CHECK-NOFLANGLIBS: "-lc" + +! In Flang mode, we always link with libm, even with -nostdlib. +! RUN: %flang -target x86_64-linux-gnu -ccc-install-dir %S/../Inputs/basic_linux_tree/usr/bin -nostdlib \ +! RUN: %s -lfoo -### 2>&1 | FileCheck --check-prefixes=CHECK-NOSTDLIB %s +! CHECK-NOSTDLIB: "{{.*}}ld{{(.exe)?}}" +! CHECK-NOSTDLIB-SAME: "{{[^"]*}}classic-flang-{{[^ ]*}}.o" +! CHECK-NOSTDLIB-NOT: "-lflangmain" +! CHECK-NOSTDLIB-SAME: "-lfoo" "-L{{[^ ]*[/\\]+}}basic_linux_tree{{[/\\]+}}usr{{[/\\]+}}lib" +! CHECK-NOSTDLIB-NOT: "-lflang" "-lflangrti" "-lpgmath" +! CHECK-NOSTDLIB-NOT: "-lpthread" "-lrt" +! CHECK-NOSTDLIB: "-lm" +! CHECK-NOSTDLIB-NOT: "-lgcc" +! CHECK-NOSTDLIB-NOT: "-lgcc_s" +! CHECK-NOSTDLIB-NOT: "-lc" From 41c61f5cc2f8d1b6bd59998be410389b3c5a7926 Mon Sep 17 00:00:00 2001 From: Bryan Chan Date: Wed, 3 Jan 2024 13:46:57 -0500 Subject: [PATCH 47/60] [OpenMP] Exclude affinity tests that fail on GitHub runners --- openmp/runtime/test/affinity/kmp-affinity.c | 5 +++++ openmp/runtime/test/affinity/omp-places.c | 5 +++++ 2 files changed, 10 insertions(+) diff --git a/openmp/runtime/test/affinity/kmp-affinity.c b/openmp/runtime/test/affinity/kmp-affinity.c index 5ee492f5441c..2064a82303e1 100644 --- a/openmp/runtime/test/affinity/kmp-affinity.c +++ b/openmp/runtime/test/affinity/kmp-affinity.c @@ -4,6 +4,11 @@ // RUN: env KMP_AFFINITY=granularity=socket,compact %libomp-run // REQUIRES: linux +// This test currently fails on GitHub runners. See: +// https://github.com/flang-compiler/classic-flang-llvm-project/issues/171 +// +// XFAIL: linux + #include #include #include diff --git a/openmp/runtime/test/affinity/omp-places.c b/openmp/runtime/test/affinity/omp-places.c index cf9780890c17..92a9a2130d2b 100644 --- a/openmp/runtime/test/affinity/omp-places.c +++ b/openmp/runtime/test/affinity/omp-places.c @@ -4,6 +4,11 @@ // RUN: env OMP_PLACES=sockets %libomp-run // REQUIRES: linux +// This test currently fails on GitHub runners. See: +// https://github.com/flang-compiler/classic-flang-llvm-project/issues/171 +// +// XFAIL: linux + #include #include #include From 1d903c5d3db68d81c27d73bc2f40daaac34380f2 Mon Sep 17 00:00:00 2001 From: Bryan Chan Date: Wed, 20 Mar 2024 07:28:32 -0400 Subject: [PATCH 48/60] [TLI] Adapt libpgmath function mappings for LLVM 18 Upstream commit 01797dad8686 had added a new VABIPrefix field to the VecDesc structure; modify the downstream libpgmath mappings accordingly. --- llvm/include/llvm/Analysis/VecFuncs.def | 846 ++++++++++++------------ 1 file changed, 423 insertions(+), 423 deletions(-) diff --git a/llvm/include/llvm/Analysis/VecFuncs.def b/llvm/include/llvm/Analysis/VecFuncs.def index d427e4213d34..0e650c86d634 100644 --- a/llvm/include/llvm/Analysis/VecFuncs.def +++ b/llvm/include/llvm/Analysis/VecFuncs.def @@ -1621,592 +1621,592 @@ TLI_DEFINE_VECFUNC("sincosf", "amd_vrs16_sincosf", FIXED(16), NOMASK, "_ZGV_LLVM #elif defined(TLI_DEFINE_PGMATH_AARCH64_VECFUNCS) // Classic flang libpgmath library's Vector Functions for AArch64 -TLI_DEFINE_VECFUNC("__fd_sin_1", "__fd_sin_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__fs_sin_1", "__fs_sin_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fd_sin_1", "__fd_sin_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__fs_sin_1", "__fs_sin_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__pd_sin_1", "__pd_sin_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__ps_sin_1", "__ps_sin_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__pd_sin_1", "__pd_sin_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__ps_sin_1", "__ps_sin_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__rd_sin_1", "__rd_sin_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__rs_sin_1", "__rs_sin_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rd_sin_1", "__rd_sin_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__rs_sin_1", "__rs_sin_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__fd_cos_1", "__fd_cos_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__fs_cos_1", "__fs_cos_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fd_cos_1", "__fd_cos_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__fs_cos_1", "__fs_cos_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__pd_cos_1", "__pd_cos_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__ps_cos_1", "__ps_cos_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__pd_cos_1", "__pd_cos_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__ps_cos_1", "__ps_cos_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__rd_cos_1", "__rd_cos_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__rs_cos_1", "__rs_cos_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rd_cos_1", "__rd_cos_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__rs_cos_1", "__rs_cos_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__fd_sincos_1", "__fd_sincos_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__fs_sincos_1", "__fs_sincos_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fd_sincos_1", "__fd_sincos_2", FIXED(2), "_ZGV_LLVM_N2vl8l8") +TLI_DEFINE_VECFUNC("__fs_sincos_1", "__fs_sincos_4", FIXED(4), "_ZGV_LLVM_N4vl4l4") -TLI_DEFINE_VECFUNC("__pd_sincos_1", "__pd_sincos_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__ps_sincos_1", "__ps_sincos_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__pd_sincos_1", "__pd_sincos_2", FIXED(2), "_ZGV_LLVM_N2vl8l8") +TLI_DEFINE_VECFUNC("__ps_sincos_1", "__ps_sincos_4", FIXED(4), "_ZGV_LLVM_N4vl4l4") -TLI_DEFINE_VECFUNC("__rd_sincos_1", "__rd_sincos_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__rs_sincos_1", "__rs_sincos_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rd_sincos_1", "__rd_sincos_2", FIXED(2), "_ZGV_LLVM_N2vl8l8") +TLI_DEFINE_VECFUNC("__rs_sincos_1", "__rs_sincos_4", FIXED(4), "_ZGV_LLVM_N4vl4l4") -TLI_DEFINE_VECFUNC("__fd_tan_1", "__fd_tan_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__fs_tan_1", "__fs_tan_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fd_tan_1", "__fd_tan_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__fs_tan_1", "__fs_tan_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__pd_tan_1", "__pd_tan_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__ps_tan_1", "__ps_tan_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__pd_tan_1", "__pd_tan_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__ps_tan_1", "__ps_tan_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__rd_tan_1", "__rd_tan_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__rs_tan_1", "__rs_tan_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rd_tan_1", "__rd_tan_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__rs_tan_1", "__rs_tan_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__fd_sinh_1", "__fd_sinh_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__fs_sinh_1", "__fs_sinh_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fd_sinh_1", "__fd_sinh_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__fs_sinh_1", "__fs_sinh_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__pd_sinh_1", "__pd_sinh_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__ps_sinh_1", "__ps_sinh_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__pd_sinh_1", "__pd_sinh_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__ps_sinh_1", "__ps_sinh_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__rd_sinh_1", "__rd_sinh_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__rs_sinh_1", "__rs_sinh_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rd_sinh_1", "__rd_sinh_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__rs_sinh_1", "__rs_sinh_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__fd_cosh_1", "__fd_cosh_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__fs_cosh_1", "__fs_cosh_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fd_cosh_1", "__fd_cosh_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__fs_cosh_1", "__fs_cosh_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__pd_cosh_1", "__pd_cosh_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__ps_cosh_1", "__ps_cosh_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__pd_cosh_1", "__pd_cosh_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__ps_cosh_1", "__ps_cosh_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__rd_cosh_1", "__rd_cosh_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__rs_cosh_1", "__rs_cosh_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rd_cosh_1", "__rd_cosh_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__rs_cosh_1", "__rs_cosh_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__fd_tanh_1", "__fd_tanh_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__fs_tanh_1", "__fs_tanh_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fd_tanh_1", "__fd_tanh_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__fs_tanh_1", "__fs_tanh_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__pd_tanh_1", "__pd_tanh_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__ps_tanh_1", "__ps_tanh_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__pd_tanh_1", "__pd_tanh_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__ps_tanh_1", "__ps_tanh_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__rd_tanh_1", "__rd_tanh_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__rs_tanh_1", "__rs_tanh_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rd_tanh_1", "__rd_tanh_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__rs_tanh_1", "__rs_tanh_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__fd_asin_1", "__fd_asin_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__fs_asin_1", "__fs_asin_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fd_asin_1", "__fd_asin_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__fs_asin_1", "__fs_asin_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__pd_asin_1", "__pd_asin_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__ps_asin_1", "__ps_asin_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__pd_asin_1", "__pd_asin_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__ps_asin_1", "__ps_asin_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__rd_asin_1", "__rd_asin_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__rs_asin_1", "__rs_asin_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rd_asin_1", "__rd_asin_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__rs_asin_1", "__rs_asin_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__fd_acos_1", "__fd_acos_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__fs_acos_1", "__fs_acos_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fd_acos_1", "__fd_acos_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__fs_acos_1", "__fs_acos_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__pd_acos_1", "__pd_acos_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__ps_acos_1", "__ps_acos_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__pd_acos_1", "__pd_acos_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__ps_acos_1", "__ps_acos_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__rd_acos_1", "__rd_acos_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__rs_acos_1", "__rs_acos_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rd_acos_1", "__rd_acos_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__rs_acos_1", "__rs_acos_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__fd_atan_1", "__fd_atan_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__fs_atan_1", "__fs_atan_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fd_atan_1", "__fd_atan_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__fs_atan_1", "__fs_atan_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__pd_atan_1", "__pd_atan_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__ps_atan_1", "__ps_atan_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__pd_atan_1", "__pd_atan_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__ps_atan_1", "__ps_atan_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__rd_atan_1", "__rd_atan_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__rs_atan_1", "__rs_atan_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rd_atan_1", "__rd_atan_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__rs_atan_1", "__rs_atan_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__fd_atan2_1", "__fd_atan2_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__fs_atan2_1", "__fs_atan2_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fd_atan2_1", "__fd_atan2_2", FIXED(2), "_ZGV_LLVM_N2vv") +TLI_DEFINE_VECFUNC("__fs_atan2_1", "__fs_atan2_4", FIXED(4), "_ZGV_LLVM_N4vv") -TLI_DEFINE_VECFUNC("__pd_atan2_1", "__pd_atan2_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__ps_atan2_1", "__ps_atan2_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__pd_atan2_1", "__pd_atan2_2", FIXED(2), "_ZGV_LLVM_N2vv") +TLI_DEFINE_VECFUNC("__ps_atan2_1", "__ps_atan2_4", FIXED(4), "_ZGV_LLVM_N4vv") -TLI_DEFINE_VECFUNC("__rd_atan2_1", "__rd_atan2_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__rs_atan2_1", "__rs_atan2_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rd_atan2_1", "__rd_atan2_2", FIXED(2), "_ZGV_LLVM_N2vv") +TLI_DEFINE_VECFUNC("__rs_atan2_1", "__rs_atan2_4", FIXED(4), "_ZGV_LLVM_N4vv") -TLI_DEFINE_VECFUNC("__fd_pow_1", "__fd_pow_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__fs_pow_1", "__fs_pow_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fd_pow_1", "__fd_pow_2", FIXED(2), "_ZGV_LLVM_N2vv") +TLI_DEFINE_VECFUNC("__fs_pow_1", "__fs_pow_4", FIXED(4), "_ZGV_LLVM_N4vv") -TLI_DEFINE_VECFUNC("__pd_pow_1", "__pd_pow_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__ps_pow_1", "__ps_pow_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__pd_pow_1", "__pd_pow_2", FIXED(2), "_ZGV_LLVM_N2vv") +TLI_DEFINE_VECFUNC("__ps_pow_1", "__ps_pow_4", FIXED(4), "_ZGV_LLVM_N4vv") -TLI_DEFINE_VECFUNC("__rd_pow_1", "__rd_pow_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__rs_pow_1", "__rs_pow_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rd_pow_1", "__rd_pow_2", FIXED(2), "_ZGV_LLVM_N2vv") +TLI_DEFINE_VECFUNC("__rs_pow_1", "__rs_pow_4", FIXED(4), "_ZGV_LLVM_N4vv") -TLI_DEFINE_VECFUNC("__fs_powi_1", "__fs_powi_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fs_powi_1", "__fs_powi_4", FIXED(4), "_ZGV_LLVM_N4vv") -TLI_DEFINE_VECFUNC("__ps_powi_1", "__ps_powi_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__ps_powi_1", "__ps_powi_4", FIXED(4), "_ZGV_LLVM_N4vv") -TLI_DEFINE_VECFUNC("__rs_powi_1", "__rs_powi_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rs_powi_1", "__rs_powi_4", FIXED(4), "_ZGV_LLVM_N4vv") -TLI_DEFINE_VECFUNC("__fd_powi1_1", "__fd_powi1_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__fs_powi1_1", "__fs_powi1_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fd_powi1_1", "__fd_powi1_2", FIXED(2), "_ZGV_LLVM_N2vv") +TLI_DEFINE_VECFUNC("__fs_powi1_1", "__fs_powi1_4", FIXED(4), "_ZGV_LLVM_N4vv") -TLI_DEFINE_VECFUNC("__pd_powi1_1", "__pd_powi1_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__ps_powi1_1", "__ps_powi1_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__pd_powi1_1", "__pd_powi1_2", FIXED(2), "_ZGV_LLVM_N2vv") +TLI_DEFINE_VECFUNC("__ps_powi1_1", "__ps_powi1_4", FIXED(4), "_ZGV_LLVM_N4vv") -TLI_DEFINE_VECFUNC("__rd_powi1_1", "__rd_powi1_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__rs_powi1_1", "__rs_powi1_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rd_powi1_1", "__rd_powi1_2", FIXED(2), "_ZGV_LLVM_N2vv") +TLI_DEFINE_VECFUNC("__rs_powi1_1", "__rs_powi1_4", FIXED(4), "_ZGV_LLVM_N4vv") -TLI_DEFINE_VECFUNC("__fd_powk_1", "__fd_powk_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__fs_powk_1", "__fs_powk_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fd_powk_1", "__fd_powk_2", FIXED(2), "_ZGV_LLVM_N2vv") +TLI_DEFINE_VECFUNC("__fs_powk_1", "__fs_powk_4", FIXED(4), "_ZGV_LLVM_N4vv") -TLI_DEFINE_VECFUNC("__pd_powk_1", "__pd_powk_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__ps_powk_1", "__ps_powk_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__pd_powk_1", "__pd_powk_2", FIXED(2), "_ZGV_LLVM_N2vv") +TLI_DEFINE_VECFUNC("__ps_powk_1", "__ps_powk_4", FIXED(4), "_ZGV_LLVM_N4vv") -TLI_DEFINE_VECFUNC("__rd_powk_1", "__rd_powk_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__rs_powk_1", "__rs_powk_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rd_powk_1", "__rd_powk_2", FIXED(2), "_ZGV_LLVM_N2vv") +TLI_DEFINE_VECFUNC("__rs_powk_1", "__rs_powk_4", FIXED(4), "_ZGV_LLVM_N4vv") -TLI_DEFINE_VECFUNC("__fd_powk1_1", "__fd_powk1_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__fs_powk1_1", "__fs_powk1_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fd_powk1_1", "__fd_powk1_2", FIXED(2), "_ZGV_LLVM_N2vv") +TLI_DEFINE_VECFUNC("__fs_powk1_1", "__fs_powk1_4", FIXED(4), "_ZGV_LLVM_N4vv") -TLI_DEFINE_VECFUNC("__pd_powk1_1", "__pd_powk1_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__ps_powk1_1", "__ps_powk1_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__pd_powk1_1", "__pd_powk1_2", FIXED(2), "_ZGV_LLVM_N2vv") +TLI_DEFINE_VECFUNC("__ps_powk1_1", "__ps_powk1_4", FIXED(4), "_ZGV_LLVM_N4vv") -TLI_DEFINE_VECFUNC("__rd_powk1_1", "__rd_powk1_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__rs_powk1_1", "__rs_powk1_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rd_powk1_1", "__rd_powk1_2", FIXED(2), "_ZGV_LLVM_N2vv") +TLI_DEFINE_VECFUNC("__rs_powk1_1", "__rs_powk1_4", FIXED(4), "_ZGV_LLVM_N4vv") -TLI_DEFINE_VECFUNC("__fd_log10_1", "__fd_log10_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__fs_log10_1", "__fs_log10_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fd_log10_1", "__fd_log10_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__fs_log10_1", "__fs_log10_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__pd_log10_1", "__pd_log10_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__ps_log10_1", "__ps_log10_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__pd_log10_1", "__pd_log10_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__ps_log10_1", "__ps_log10_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__rd_log10_1", "__rd_log10_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__rs_log10_1", "__rs_log10_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rd_log10_1", "__rd_log10_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__rs_log10_1", "__rs_log10_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__fd_log_1", "__fd_log_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__fs_log_1", "__fs_log_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fd_log_1", "__fd_log_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__fs_log_1", "__fs_log_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__pd_log_1", "__pd_log_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__ps_log_1", "__ps_log_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__pd_log_1", "__pd_log_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__ps_log_1", "__ps_log_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__rd_log_1", "__rd_log_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__rs_log_1", "__rs_log_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rd_log_1", "__rd_log_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__rs_log_1", "__rs_log_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__fd_exp_1", "__fd_exp_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__fs_exp_1", "__fs_exp_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__fd_exp_1", "__fd_exp_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__fs_exp_1", "__fs_exp_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__pd_exp_1", "__pd_exp_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__ps_exp_1", "__ps_exp_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__pd_exp_1", "__pd_exp_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__ps_exp_1", "__ps_exp_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__rd_exp_1", "__rd_exp_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__rs_exp_1", "__rs_exp_4", FIXED(4)) +TLI_DEFINE_VECFUNC("__rd_exp_1", "__rd_exp_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__rs_exp_1", "__rs_exp_4", FIXED(4), "_ZGV_LLVM_N4v") #elif defined(TLI_DEFINE_PGMATH_X86_VECFUNCS) // Classic flang libpgmath library's Vector Functions for X86 -TLI_DEFINE_VECFUNC("__fd_sin_1", "__fd_sin_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__fd_sin_1", "__fd_sin_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__fd_sin_1", "__fd_sin_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__fd_sin_1", "__fd_sin_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__fd_sin_1", "__fd_sin_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__fd_sin_1", "__fd_sin_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__fs_sin_1", "__fs_sin_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__fs_sin_1", "__fs_sin_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__fs_sin_1", "__fs_sin_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__fs_sin_1", "__fs_sin_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__fs_sin_1", "__fs_sin_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__fs_sin_1", "__fs_sin_16", FIXED(16), "_ZGV_LLVM_N16v") -TLI_DEFINE_VECFUNC("__pd_sin_1", "__pd_sin_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__pd_sin_1", "__pd_sin_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__pd_sin_1", "__pd_sin_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__pd_sin_1", "__pd_sin_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__pd_sin_1", "__pd_sin_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__pd_sin_1", "__pd_sin_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__ps_sin_1", "__ps_sin_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__ps_sin_1", "__ps_sin_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__ps_sin_1", "__ps_sin_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__ps_sin_1", "__ps_sin_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__ps_sin_1", "__ps_sin_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__ps_sin_1", "__ps_sin_16", FIXED(16), "_ZGV_LLVM_N16v") -TLI_DEFINE_VECFUNC("__rd_sin_1", "__rd_sin_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__rd_sin_1", "__rd_sin_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__rd_sin_1", "__rd_sin_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__rd_sin_1", "__rd_sin_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__rd_sin_1", "__rd_sin_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__rd_sin_1", "__rd_sin_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__rs_sin_1", "__rs_sin_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__rs_sin_1", "__rs_sin_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__rs_sin_1", "__rs_sin_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__rs_sin_1", "__rs_sin_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__rs_sin_1", "__rs_sin_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__rs_sin_1", "__rs_sin_16", FIXED(16), "_ZGV_LLVM_N16v") -TLI_DEFINE_VECFUNC("__fd_cos_1", "__fd_cos_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__fd_cos_1", "__fd_cos_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__fd_cos_1", "__fd_cos_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__fd_cos_1", "__fd_cos_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__fd_cos_1", "__fd_cos_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__fd_cos_1", "__fd_cos_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__fs_cos_1", "__fs_cos_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__fs_cos_1", "__fs_cos_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__fs_cos_1", "__fs_cos_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__fs_cos_1", "__fs_cos_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__fs_cos_1", "__fs_cos_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__fs_cos_1", "__fs_cos_16", FIXED(16), "_ZGV_LLVM_N16v") -TLI_DEFINE_VECFUNC("__pd_cos_1", "__pd_cos_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__pd_cos_1", "__pd_cos_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__pd_cos_1", "__pd_cos_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__pd_cos_1", "__pd_cos_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__pd_cos_1", "__pd_cos_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__pd_cos_1", "__pd_cos_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__ps_cos_1", "__ps_cos_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__ps_cos_1", "__ps_cos_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__ps_cos_1", "__ps_cos_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__ps_cos_1", "__ps_cos_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__ps_cos_1", "__ps_cos_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__ps_cos_1", "__ps_cos_16", FIXED(16), "_ZGV_LLVM_N16v") -TLI_DEFINE_VECFUNC("__rd_cos_1", "__rd_cos_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__rd_cos_1", "__rd_cos_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__rd_cos_1", "__rd_cos_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__rd_cos_1", "__rd_cos_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__rd_cos_1", "__rd_cos_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__rd_cos_1", "__rd_cos_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__rs_cos_1", "__rs_cos_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__rs_cos_1", "__rs_cos_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__rs_cos_1", "__rs_cos_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__rs_cos_1", "__rs_cos_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__rs_cos_1", "__rs_cos_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__rs_cos_1", "__rs_cos_16", FIXED(16), "_ZGV_LLVM_N16v") -TLI_DEFINE_VECFUNC("__fd_tan_1", "__fd_tan_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__fd_tan_1", "__fd_tan_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__fd_tan_1", "__fd_tan_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__fd_tan_1", "__fd_tan_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__fd_tan_1", "__fd_tan_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__fd_tan_1", "__fd_tan_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__fs_tan_1", "__fs_tan_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__fs_tan_1", "__fs_tan_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__fs_tan_1", "__fs_tan_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__fs_tan_1", "__fs_tan_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__fs_tan_1", "__fs_tan_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__fs_tan_1", "__fs_tan_16", FIXED(16), "_ZGV_LLVM_N16v") -TLI_DEFINE_VECFUNC("__pd_tan_1", "__pd_tan_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__pd_tan_1", "__pd_tan_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__pd_tan_1", "__pd_tan_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__pd_tan_1", "__pd_tan_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__pd_tan_1", "__pd_tan_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__pd_tan_1", "__pd_tan_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__ps_tan_1", "__ps_tan_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__ps_tan_1", "__ps_tan_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__ps_tan_1", "__ps_tan_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__ps_tan_1", "__ps_tan_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__ps_tan_1", "__ps_tan_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__ps_tan_1", "__ps_tan_16", FIXED(16), "_ZGV_LLVM_N16v") -TLI_DEFINE_VECFUNC("__rd_tan_1", "__rd_tan_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__rd_tan_1", "__rd_tan_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__rd_tan_1", "__rd_tan_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__rd_tan_1", "__rd_tan_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__rd_tan_1", "__rd_tan_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__rd_tan_1", "__rd_tan_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__rs_tan_1", "__rs_tan_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__rs_tan_1", "__rs_tan_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__rs_tan_1", "__rs_tan_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__rs_tan_1", "__rs_tan_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__rs_tan_1", "__rs_tan_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__rs_tan_1", "__rs_tan_16", FIXED(16), "_ZGV_LLVM_N16v") -TLI_DEFINE_VECFUNC("__fd_sinh_1", "__fd_sinh_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__fd_sinh_1", "__fd_sinh_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__fd_sinh_1", "__fd_sinh_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__fd_sinh_1", "__fd_sinh_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__fd_sinh_1", "__fd_sinh_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__fd_sinh_1", "__fd_sinh_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__fs_sinh_1", "__fs_sinh_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__fs_sinh_1", "__fs_sinh_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__fs_sinh_1", "__fs_sinh_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__fs_sinh_1", "__fs_sinh_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__fs_sinh_1", "__fs_sinh_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__fs_sinh_1", "__fs_sinh_16", FIXED(16), "_ZGV_LLVM_N16v") -TLI_DEFINE_VECFUNC("__pd_sinh_1", "__pd_sinh_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__pd_sinh_1", "__pd_sinh_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__pd_sinh_1", "__pd_sinh_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__pd_sinh_1", "__pd_sinh_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__pd_sinh_1", "__pd_sinh_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__pd_sinh_1", "__pd_sinh_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__ps_sinh_1", "__ps_sinh_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__ps_sinh_1", "__ps_sinh_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__ps_sinh_1", "__ps_sinh_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__ps_sinh_1", "__ps_sinh_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__ps_sinh_1", "__ps_sinh_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__ps_sinh_1", "__ps_sinh_16", FIXED(16), "_ZGV_LLVM_N16v") -TLI_DEFINE_VECFUNC("__rd_sinh_1", "__rd_sinh_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__rd_sinh_1", "__rd_sinh_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__rd_sinh_1", "__rd_sinh_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__rd_sinh_1", "__rd_sinh_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__rd_sinh_1", "__rd_sinh_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__rd_sinh_1", "__rd_sinh_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__rs_sinh_1", "__rs_sinh_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__rs_sinh_1", "__rs_sinh_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__rs_sinh_1", "__rs_sinh_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__rs_sinh_1", "__rs_sinh_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__rs_sinh_1", "__rs_sinh_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__rs_sinh_1", "__rs_sinh_16", FIXED(16), "_ZGV_LLVM_N16v") -TLI_DEFINE_VECFUNC("__fd_cosh_1", "__fd_cosh_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__fd_cosh_1", "__fd_cosh_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__fd_cosh_1", "__fd_cosh_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__fd_cosh_1", "__fd_cosh_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__fd_cosh_1", "__fd_cosh_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__fd_cosh_1", "__fd_cosh_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__fs_cosh_1", "__fs_cosh_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__fs_cosh_1", "__fs_cosh_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__fs_cosh_1", "__fs_cosh_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__fs_cosh_1", "__fs_cosh_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__fs_cosh_1", "__fs_cosh_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__fs_cosh_1", "__fs_cosh_16", FIXED(16), "_ZGV_LLVM_N16v") -TLI_DEFINE_VECFUNC("__pd_cosh_1", "__pd_cosh_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__pd_cosh_1", "__pd_cosh_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__pd_cosh_1", "__pd_cosh_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__pd_cosh_1", "__pd_cosh_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__pd_cosh_1", "__pd_cosh_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__pd_cosh_1", "__pd_cosh_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__ps_cosh_1", "__ps_cosh_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__ps_cosh_1", "__ps_cosh_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__ps_cosh_1", "__ps_cosh_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__ps_cosh_1", "__ps_cosh_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__ps_cosh_1", "__ps_cosh_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__ps_cosh_1", "__ps_cosh_16", FIXED(16), "_ZGV_LLVM_N16v") -TLI_DEFINE_VECFUNC("__rd_cosh_1", "__rd_cosh_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__rd_cosh_1", "__rd_cosh_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__rd_cosh_1", "__rd_cosh_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__rd_cosh_1", "__rd_cosh_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__rd_cosh_1", "__rd_cosh_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__rd_cosh_1", "__rd_cosh_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__rs_cosh_1", "__rs_cosh_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__rs_cosh_1", "__rs_cosh_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__rs_cosh_1", "__rs_cosh_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__rs_cosh_1", "__rs_cosh_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__rs_cosh_1", "__rs_cosh_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__rs_cosh_1", "__rs_cosh_16", FIXED(16), "_ZGV_LLVM_N16v") -TLI_DEFINE_VECFUNC("__fd_tanh_1", "__fd_tanh_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__fd_tanh_1", "__fd_tanh_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__fd_tanh_1", "__fd_tanh_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__fd_tanh_1", "__fd_tanh_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__fd_tanh_1", "__fd_tanh_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__fd_tanh_1", "__fd_tanh_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__fs_tanh_1", "__fs_tanh_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__fs_tanh_1", "__fs_tanh_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__fs_tanh_1", "__fs_tanh_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__fs_tanh_1", "__fs_tanh_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__fs_tanh_1", "__fs_tanh_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__fs_tanh_1", "__fs_tanh_16", FIXED(16), "_ZGV_LLVM_N16v") -TLI_DEFINE_VECFUNC("__pd_tanh_1", "__pd_tanh_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__pd_tanh_1", "__pd_tanh_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__pd_tanh_1", "__pd_tanh_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__pd_tanh_1", "__pd_tanh_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__pd_tanh_1", "__pd_tanh_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__pd_tanh_1", "__pd_tanh_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__ps_tanh_1", "__ps_tanh_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__ps_tanh_1", "__ps_tanh_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__ps_tanh_1", "__ps_tanh_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__ps_tanh_1", "__ps_tanh_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__ps_tanh_1", "__ps_tanh_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__ps_tanh_1", "__ps_tanh_16", FIXED(16), "_ZGV_LLVM_N16v") -TLI_DEFINE_VECFUNC("__rd_tanh_1", "__rd_tanh_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__rd_tanh_1", "__rd_tanh_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__rd_tanh_1", "__rd_tanh_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__rd_tanh_1", "__rd_tanh_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__rd_tanh_1", "__rd_tanh_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__rd_tanh_1", "__rd_tanh_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__rs_tanh_1", "__rs_tanh_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__rs_tanh_1", "__rs_tanh_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__rs_tanh_1", "__rs_tanh_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__rs_tanh_1", "__rs_tanh_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__rs_tanh_1", "__rs_tanh_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__rs_tanh_1", "__rs_tanh_16", FIXED(16), "_ZGV_LLVM_N16v") -TLI_DEFINE_VECFUNC("__fd_asin_1", "__fd_asin_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__fd_asin_1", "__fd_asin_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__fd_asin_1", "__fd_asin_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__fd_asin_1", "__fd_asin_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__fd_asin_1", "__fd_asin_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__fd_asin_1", "__fd_asin_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__fs_asin_1", "__fs_asin_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__fs_asin_1", "__fs_asin_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__fs_asin_1", "__fs_asin_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__fs_asin_1", "__fs_asin_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__fs_asin_1", "__fs_asin_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__fs_asin_1", "__fs_asin_16", FIXED(16), "_ZGV_LLVM_N16v") -TLI_DEFINE_VECFUNC("__pd_asin_1", "__pd_asin_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__pd_asin_1", "__pd_asin_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__pd_asin_1", "__pd_asin_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__pd_asin_1", "__pd_asin_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__pd_asin_1", "__pd_asin_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__pd_asin_1", "__pd_asin_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__ps_asin_1", "__ps_asin_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__ps_asin_1", "__ps_asin_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__ps_asin_1", "__ps_asin_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__ps_asin_1", "__ps_asin_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__ps_asin_1", "__ps_asin_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__ps_asin_1", "__ps_asin_16", FIXED(16), "_ZGV_LLVM_N16v") -TLI_DEFINE_VECFUNC("__rd_asin_1", "__rd_asin_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__rd_asin_1", "__rd_asin_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__rd_asin_1", "__rd_asin_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__rd_asin_1", "__rd_asin_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__rd_asin_1", "__rd_asin_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__rd_asin_1", "__rd_asin_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__rs_asin_1", "__rs_asin_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__rs_asin_1", "__rs_asin_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__rs_asin_1", "__rs_asin_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__rs_asin_1", "__rs_asin_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__rs_asin_1", "__rs_asin_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__rs_asin_1", "__rs_asin_16", FIXED(16), "_ZGV_LLVM_N16v") -TLI_DEFINE_VECFUNC("__fd_acos_1", "__fd_acos_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__fd_acos_1", "__fd_acos_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__fd_acos_1", "__fd_acos_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__fd_acos_1", "__fd_acos_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__fd_acos_1", "__fd_acos_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__fd_acos_1", "__fd_acos_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__fs_acos_1", "__fs_acos_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__fs_acos_1", "__fs_acos_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__fs_acos_1", "__fs_acos_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__fs_acos_1", "__fs_acos_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__fs_acos_1", "__fs_acos_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__fs_acos_1", "__fs_acos_16", FIXED(16), "_ZGV_LLVM_N16v") -TLI_DEFINE_VECFUNC("__pd_acos_1", "__pd_acos_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__pd_acos_1", "__pd_acos_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__pd_acos_1", "__pd_acos_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__pd_acos_1", "__pd_acos_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__pd_acos_1", "__pd_acos_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__pd_acos_1", "__pd_acos_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__ps_acos_1", "__ps_acos_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__ps_acos_1", "__ps_acos_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__ps_acos_1", "__ps_acos_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__ps_acos_1", "__ps_acos_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__ps_acos_1", "__ps_acos_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__ps_acos_1", "__ps_acos_16", FIXED(16), "_ZGV_LLVM_N16v") -TLI_DEFINE_VECFUNC("__rd_acos_1", "__rd_acos_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__rd_acos_1", "__rd_acos_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__rd_acos_1", "__rd_acos_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__rd_acos_1", "__rd_acos_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__rd_acos_1", "__rd_acos_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__rd_acos_1", "__rd_acos_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__rs_acos_1", "__rs_acos_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__rs_acos_1", "__rs_acos_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__rs_acos_1", "__rs_acos_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__rs_acos_1", "__rs_acos_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__rs_acos_1", "__rs_acos_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__rs_acos_1", "__rs_acos_16", FIXED(16), "_ZGV_LLVM_N16v") -TLI_DEFINE_VECFUNC("__fd_atan_1", "__fd_atan_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__fd_atan_1", "__fd_atan_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__fd_atan_1", "__fd_atan_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__fd_atan_1", "__fd_atan_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__fd_atan_1", "__fd_atan_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__fd_atan_1", "__fd_atan_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__fs_atan_1", "__fs_atan_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__fs_atan_1", "__fs_atan_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__fs_atan_1", "__fs_atan_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__fs_atan_1", "__fs_atan_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__fs_atan_1", "__fs_atan_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__fs_atan_1", "__fs_atan_16", FIXED(16), "_ZGV_LLVM_N16v") -TLI_DEFINE_VECFUNC("__pd_atan_1", "__pd_atan_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__pd_atan_1", "__pd_atan_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__pd_atan_1", "__pd_atan_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__pd_atan_1", "__pd_atan_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__pd_atan_1", "__pd_atan_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__pd_atan_1", "__pd_atan_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__ps_atan_1", "__ps_atan_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__ps_atan_1", "__ps_atan_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__ps_atan_1", "__ps_atan_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__ps_atan_1", "__ps_atan_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__ps_atan_1", "__ps_atan_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__ps_atan_1", "__ps_atan_16", FIXED(16), "_ZGV_LLVM_N16v") -TLI_DEFINE_VECFUNC("__rd_atan_1", "__rd_atan_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__rd_atan_1", "__rd_atan_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__rd_atan_1", "__rd_atan_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__rd_atan_1", "__rd_atan_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__rd_atan_1", "__rd_atan_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__rd_atan_1", "__rd_atan_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__rs_atan_1", "__rs_atan_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__rs_atan_1", "__rs_atan_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__rs_atan_1", "__rs_atan_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__rs_atan_1", "__rs_atan_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__rs_atan_1", "__rs_atan_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__rs_atan_1", "__rs_atan_16", FIXED(16), "_ZGV_LLVM_N16v") -TLI_DEFINE_VECFUNC("__fd_atan2_1", "__fd_atan2_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__fd_atan2_1", "__fd_atan2_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__fd_atan2_1", "__fd_atan2_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__fd_atan2_1", "__fd_atan2_2", FIXED(2), "_ZGV_LLVM_N2vv") +TLI_DEFINE_VECFUNC("__fd_atan2_1", "__fd_atan2_4", FIXED(4), "_ZGV_LLVM_N4vv") +TLI_DEFINE_VECFUNC("__fd_atan2_1", "__fd_atan2_8", FIXED(8), "_ZGV_LLVM_N8vv") -TLI_DEFINE_VECFUNC("__fs_atan2_1", "__fs_atan2_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__fs_atan2_1", "__fs_atan2_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__fs_atan2_1", "__fs_atan2_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__fs_atan2_1", "__fs_atan2_4", FIXED(4), "_ZGV_LLVM_N4vv") +TLI_DEFINE_VECFUNC("__fs_atan2_1", "__fs_atan2_8", FIXED(8), "_ZGV_LLVM_N8vv") +TLI_DEFINE_VECFUNC("__fs_atan2_1", "__fs_atan2_16", FIXED(16), "_ZGV_LLVM_N16vv") -TLI_DEFINE_VECFUNC("__pd_atan2_1", "__pd_atan2_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__pd_atan2_1", "__pd_atan2_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__pd_atan2_1", "__pd_atan2_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__pd_atan2_1", "__pd_atan2_2", FIXED(2), "_ZGV_LLVM_N2vv") +TLI_DEFINE_VECFUNC("__pd_atan2_1", "__pd_atan2_4", FIXED(4), "_ZGV_LLVM_N4vv") +TLI_DEFINE_VECFUNC("__pd_atan2_1", "__pd_atan2_8", FIXED(8), "_ZGV_LLVM_N8vv") -TLI_DEFINE_VECFUNC("__ps_atan2_1", "__ps_atan2_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__ps_atan2_1", "__ps_atan2_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__ps_atan2_1", "__ps_atan2_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__ps_atan2_1", "__ps_atan2_4", FIXED(4), "_ZGV_LLVM_N4vv") +TLI_DEFINE_VECFUNC("__ps_atan2_1", "__ps_atan2_8", FIXED(8), "_ZGV_LLVM_N8vv") +TLI_DEFINE_VECFUNC("__ps_atan2_1", "__ps_atan2_16", FIXED(16), "_ZGV_LLVM_N16vv") -TLI_DEFINE_VECFUNC("__rd_atan2_1", "__rd_atan2_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__rd_atan2_1", "__rd_atan2_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__rd_atan2_1", "__rd_atan2_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__rd_atan2_1", "__rd_atan2_2", FIXED(2), "_ZGV_LLVM_N2vv") +TLI_DEFINE_VECFUNC("__rd_atan2_1", "__rd_atan2_4", FIXED(4), "_ZGV_LLVM_N4vv") +TLI_DEFINE_VECFUNC("__rd_atan2_1", "__rd_atan2_8", FIXED(8), "_ZGV_LLVM_N8vv") -TLI_DEFINE_VECFUNC("__rs_atan2_1", "__rs_atan2_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__rs_atan2_1", "__rs_atan2_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__rs_atan2_1", "__rs_atan2_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__rs_atan2_1", "__rs_atan2_4", FIXED(4), "_ZGV_LLVM_N4vv") +TLI_DEFINE_VECFUNC("__rs_atan2_1", "__rs_atan2_8", FIXED(8), "_ZGV_LLVM_N8vv") +TLI_DEFINE_VECFUNC("__rs_atan2_1", "__rs_atan2_16", FIXED(16), "_ZGV_LLVM_N16vv") -TLI_DEFINE_VECFUNC("__fd_pow_1", "__fd_pow_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__fd_pow_1", "__fd_pow_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__fd_pow_1", "__fd_pow_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__fd_pow_1", "__fd_pow_2", FIXED(2), "_ZGV_LLVM_N2vv") +TLI_DEFINE_VECFUNC("__fd_pow_1", "__fd_pow_4", FIXED(4), "_ZGV_LLVM_N4vv") +TLI_DEFINE_VECFUNC("__fd_pow_1", "__fd_pow_8", FIXED(8), "_ZGV_LLVM_N8vv") -TLI_DEFINE_VECFUNC("__fs_pow_1", "__fs_pow_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__fs_pow_1", "__fs_pow_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__fs_pow_1", "__fs_pow_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__fs_pow_1", "__fs_pow_4", FIXED(4), "_ZGV_LLVM_N4vv") +TLI_DEFINE_VECFUNC("__fs_pow_1", "__fs_pow_8", FIXED(8), "_ZGV_LLVM_N8vv") +TLI_DEFINE_VECFUNC("__fs_pow_1", "__fs_pow_16", FIXED(16), "_ZGV_LLVM_N16vv") -TLI_DEFINE_VECFUNC("__pd_pow_1", "__pd_pow_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__pd_pow_1", "__pd_pow_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__pd_pow_1", "__pd_pow_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__pd_pow_1", "__pd_pow_2", FIXED(2), "_ZGV_LLVM_N2vv") +TLI_DEFINE_VECFUNC("__pd_pow_1", "__pd_pow_4", FIXED(4), "_ZGV_LLVM_N4vv") +TLI_DEFINE_VECFUNC("__pd_pow_1", "__pd_pow_8", FIXED(8), "_ZGV_LLVM_N8vv") -TLI_DEFINE_VECFUNC("__ps_pow_1", "__ps_pow_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__ps_pow_1", "__ps_pow_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__ps_pow_1", "__ps_pow_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__ps_pow_1", "__ps_pow_4", FIXED(4), "_ZGV_LLVM_N4vv") +TLI_DEFINE_VECFUNC("__ps_pow_1", "__ps_pow_8", FIXED(8), "_ZGV_LLVM_N8vv") +TLI_DEFINE_VECFUNC("__ps_pow_1", "__ps_pow_16", FIXED(16), "_ZGV_LLVM_N16vv") -TLI_DEFINE_VECFUNC("__rd_pow_1", "__rd_pow_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__rd_pow_1", "__rd_pow_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__rd_pow_1", "__rd_pow_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__rd_pow_1", "__rd_pow_2", FIXED(2), "_ZGV_LLVM_N2vv") +TLI_DEFINE_VECFUNC("__rd_pow_1", "__rd_pow_4", FIXED(4), "_ZGV_LLVM_N4vv") +TLI_DEFINE_VECFUNC("__rd_pow_1", "__rd_pow_8", FIXED(8), "_ZGV_LLVM_N8vv") -TLI_DEFINE_VECFUNC("__rs_pow_1", "__rs_pow_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__rs_pow_1", "__rs_pow_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__rs_pow_1", "__rs_pow_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__rs_pow_1", "__rs_pow_4", FIXED(4), "_ZGV_LLVM_N4vv") +TLI_DEFINE_VECFUNC("__rs_pow_1", "__rs_pow_8", FIXED(8), "_ZGV_LLVM_N8vv") +TLI_DEFINE_VECFUNC("__rs_pow_1", "__rs_pow_16", FIXED(16), "_ZGV_LLVM_N16vv") -TLI_DEFINE_VECFUNC("__fs_powi_1", "__fs_powi_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__fs_powi_1", "__fs_powi_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__fs_powi_1", "__fs_powi_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__fs_powi_1", "__fs_powi_4", FIXED(4), "_ZGV_LLVM_N4vv") +TLI_DEFINE_VECFUNC("__fs_powi_1", "__fs_powi_8", FIXED(8), "_ZGV_LLVM_N8vv") +TLI_DEFINE_VECFUNC("__fs_powi_1", "__fs_powi_16", FIXED(16), "_ZGV_LLVM_N16vv") -TLI_DEFINE_VECFUNC("__ps_powi_1", "__ps_powi_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__ps_powi_1", "__ps_powi_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__ps_powi_1", "__ps_powi_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__ps_powi_1", "__ps_powi_4", FIXED(4), "_ZGV_LLVM_N4vv") +TLI_DEFINE_VECFUNC("__ps_powi_1", "__ps_powi_8", FIXED(8), "_ZGV_LLVM_N8vv") +TLI_DEFINE_VECFUNC("__ps_powi_1", "__ps_powi_16", FIXED(16), "_ZGV_LLVM_N16vv") -TLI_DEFINE_VECFUNC("__rs_powi_1", "__rs_powi_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__rs_powi_1", "__rs_powi_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__rs_powi_1", "__rs_powi_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__rs_powi_1", "__rs_powi_4", FIXED(4), "_ZGV_LLVM_N4vv") +TLI_DEFINE_VECFUNC("__rs_powi_1", "__rs_powi_8", FIXED(8), "_ZGV_LLVM_N8vv") +TLI_DEFINE_VECFUNC("__rs_powi_1", "__rs_powi_16", FIXED(16), "_ZGV_LLVM_N16vv") -TLI_DEFINE_VECFUNC("__fd_powi1_1", "__fd_powi1_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__fd_powi1_1", "__fd_powi1_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__fd_powi1_1", "__fd_powi1_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__fd_powi1_1", "__fd_powi1_2", FIXED(2), "_ZGV_LLVM_N2vv") +TLI_DEFINE_VECFUNC("__fd_powi1_1", "__fd_powi1_4", FIXED(4), "_ZGV_LLVM_N4vv") +TLI_DEFINE_VECFUNC("__fd_powi1_1", "__fd_powi1_8", FIXED(8), "_ZGV_LLVM_N8vv") -TLI_DEFINE_VECFUNC("__fs_powi1_1", "__fs_powi1_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__fs_powi1_1", "__fs_powi1_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__fs_powi1_1", "__fs_powi1_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__fs_powi1_1", "__fs_powi1_4", FIXED(4), "_ZGV_LLVM_N4vv") +TLI_DEFINE_VECFUNC("__fs_powi1_1", "__fs_powi1_8", FIXED(8), "_ZGV_LLVM_N8vv") +TLI_DEFINE_VECFUNC("__fs_powi1_1", "__fs_powi1_16", FIXED(16), "_ZGV_LLVM_N16vv") -TLI_DEFINE_VECFUNC("__pd_powi1_1", "__pd_powi1_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__pd_powi1_1", "__pd_powi1_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__pd_powi1_1", "__pd_powi1_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__pd_powi1_1", "__pd_powi1_2", FIXED(2), "_ZGV_LLVM_N2vv") +TLI_DEFINE_VECFUNC("__pd_powi1_1", "__pd_powi1_4", FIXED(4), "_ZGV_LLVM_N4vv") +TLI_DEFINE_VECFUNC("__pd_powi1_1", "__pd_powi1_8", FIXED(8), "_ZGV_LLVM_N8vv") -TLI_DEFINE_VECFUNC("__ps_powi1_1", "__ps_powi1_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__ps_powi1_1", "__ps_powi1_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__ps_powi1_1", "__ps_powi1_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__ps_powi1_1", "__ps_powi1_4", FIXED(4), "_ZGV_LLVM_N4vv") +TLI_DEFINE_VECFUNC("__ps_powi1_1", "__ps_powi1_8", FIXED(8), "_ZGV_LLVM_N8vv") +TLI_DEFINE_VECFUNC("__ps_powi1_1", "__ps_powi1_16", FIXED(16), "_ZGV_LLVM_N16vv") -TLI_DEFINE_VECFUNC("__rd_powi1_1", "__rd_powi1_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__rd_powi1_1", "__rd_powi1_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__rd_powi1_1", "__rd_powi1_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__rd_powi1_1", "__rd_powi1_2", FIXED(2), "_ZGV_LLVM_N2vv") +TLI_DEFINE_VECFUNC("__rd_powi1_1", "__rd_powi1_4", FIXED(4), "_ZGV_LLVM_N4vv") +TLI_DEFINE_VECFUNC("__rd_powi1_1", "__rd_powi1_8", FIXED(8), "_ZGV_LLVM_N8vv") -TLI_DEFINE_VECFUNC("__rs_powi1_1", "__rs_powi1_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__rs_powi1_1", "__rs_powi1_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__rs_powi1_1", "__rs_powi1_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__rs_powi1_1", "__rs_powi1_4", FIXED(4), "_ZGV_LLVM_N4vv") +TLI_DEFINE_VECFUNC("__rs_powi1_1", "__rs_powi1_8", FIXED(8), "_ZGV_LLVM_N8vv") +TLI_DEFINE_VECFUNC("__rs_powi1_1", "__rs_powi1_16", FIXED(16), "_ZGV_LLVM_N16vv") -TLI_DEFINE_VECFUNC("__fd_powk_1", "__fd_powk_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__fd_powk_1", "__fd_powk_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__fd_powk_1", "__fd_powk_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__fd_powk_1", "__fd_powk_2", FIXED(2), "_ZGV_LLVM_N2vv") +TLI_DEFINE_VECFUNC("__fd_powk_1", "__fd_powk_4", FIXED(4), "_ZGV_LLVM_N4vv") +TLI_DEFINE_VECFUNC("__fd_powk_1", "__fd_powk_8", FIXED(8), "_ZGV_LLVM_N8vv") -TLI_DEFINE_VECFUNC("__fs_powk_1", "__fs_powk_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__fs_powk_1", "__fs_powk_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__fs_powk_1", "__fs_powk_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__fs_powk_1", "__fs_powk_4", FIXED(4), "_ZGV_LLVM_N4vv") +TLI_DEFINE_VECFUNC("__fs_powk_1", "__fs_powk_8", FIXED(8), "_ZGV_LLVM_N8vv") +TLI_DEFINE_VECFUNC("__fs_powk_1", "__fs_powk_16", FIXED(16), "_ZGV_LLVM_N16vv") -TLI_DEFINE_VECFUNC("__pd_powk_1", "__pd_powk_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__pd_powk_1", "__pd_powk_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__pd_powk_1", "__pd_powk_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__pd_powk_1", "__pd_powk_2", FIXED(2), "_ZGV_LLVM_N2vv") +TLI_DEFINE_VECFUNC("__pd_powk_1", "__pd_powk_4", FIXED(4), "_ZGV_LLVM_N4vv") +TLI_DEFINE_VECFUNC("__pd_powk_1", "__pd_powk_8", FIXED(8), "_ZGV_LLVM_N8vv") -TLI_DEFINE_VECFUNC("__ps_powk_1", "__ps_powk_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__ps_powk_1", "__ps_powk_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__ps_powk_1", "__ps_powk_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__ps_powk_1", "__ps_powk_4", FIXED(4), "_ZGV_LLVM_N4vv") +TLI_DEFINE_VECFUNC("__ps_powk_1", "__ps_powk_8", FIXED(8), "_ZGV_LLVM_N8vv") +TLI_DEFINE_VECFUNC("__ps_powk_1", "__ps_powk_16", FIXED(16), "_ZGV_LLVM_N16vv") -TLI_DEFINE_VECFUNC("__rd_powk_1", "__rd_powk_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__rd_powk_1", "__rd_powk_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__rd_powk_1", "__rd_powk_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__rd_powk_1", "__rd_powk_2", FIXED(2), "_ZGV_LLVM_N2vv") +TLI_DEFINE_VECFUNC("__rd_powk_1", "__rd_powk_4", FIXED(4), "_ZGV_LLVM_N4vv") +TLI_DEFINE_VECFUNC("__rd_powk_1", "__rd_powk_8", FIXED(8), "_ZGV_LLVM_N8vv") -TLI_DEFINE_VECFUNC("__rs_powk_1", "__rs_powk_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__rs_powk_1", "__rs_powk_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__rs_powk_1", "__rs_powk_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__rs_powk_1", "__rs_powk_4", FIXED(4), "_ZGV_LLVM_N4vv") +TLI_DEFINE_VECFUNC("__rs_powk_1", "__rs_powk_8", FIXED(8), "_ZGV_LLVM_N8vv") +TLI_DEFINE_VECFUNC("__rs_powk_1", "__rs_powk_16", FIXED(16), "_ZGV_LLVM_N16vv") -TLI_DEFINE_VECFUNC("__fd_powk1_1", "__fd_powk1_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__fd_powk1_1", "__fd_powk1_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__fd_powk1_1", "__fd_powk1_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__fd_powk1_1", "__fd_powk1_2", FIXED(2), "_ZGV_LLVM_N2vv") +TLI_DEFINE_VECFUNC("__fd_powk1_1", "__fd_powk1_4", FIXED(4), "_ZGV_LLVM_N4vv") +TLI_DEFINE_VECFUNC("__fd_powk1_1", "__fd_powk1_8", FIXED(8), "_ZGV_LLVM_N8vv") -TLI_DEFINE_VECFUNC("__fs_powk1_1", "__fs_powk1_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__fs_powk1_1", "__fs_powk1_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__fs_powk1_1", "__fs_powk1_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__fs_powk1_1", "__fs_powk1_4", FIXED(4), "_ZGV_LLVM_N4vv") +TLI_DEFINE_VECFUNC("__fs_powk1_1", "__fs_powk1_8", FIXED(8), "_ZGV_LLVM_N8vv") +TLI_DEFINE_VECFUNC("__fs_powk1_1", "__fs_powk1_16", FIXED(16), "_ZGV_LLVM_N16vv") -TLI_DEFINE_VECFUNC("__pd_powk1_1", "__pd_powk1_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__pd_powk1_1", "__pd_powk1_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__pd_powk1_1", "__pd_powk1_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__pd_powk1_1", "__pd_powk1_2", FIXED(2), "_ZGV_LLVM_N2vv") +TLI_DEFINE_VECFUNC("__pd_powk1_1", "__pd_powk1_4", FIXED(4), "_ZGV_LLVM_N4vv") +TLI_DEFINE_VECFUNC("__pd_powk1_1", "__pd_powk1_8", FIXED(8), "_ZGV_LLVM_N8vv") -TLI_DEFINE_VECFUNC("__ps_powk1_1", "__ps_powk1_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__ps_powk1_1", "__ps_powk1_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__ps_powk1_1", "__ps_powk1_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__ps_powk1_1", "__ps_powk1_4", FIXED(4), "_ZGV_LLVM_N4vv") +TLI_DEFINE_VECFUNC("__ps_powk1_1", "__ps_powk1_8", FIXED(8), "_ZGV_LLVM_N8vv") +TLI_DEFINE_VECFUNC("__ps_powk1_1", "__ps_powk1_16", FIXED(16), "_ZGV_LLVM_N16vv") -TLI_DEFINE_VECFUNC("__rd_powk1_1", "__rd_powk1_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__rd_powk1_1", "__rd_powk1_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__rd_powk1_1", "__rd_powk1_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__rd_powk1_1", "__rd_powk1_2", FIXED(2), "_ZGV_LLVM_N2vv") +TLI_DEFINE_VECFUNC("__rd_powk1_1", "__rd_powk1_4", FIXED(4), "_ZGV_LLVM_N4vv") +TLI_DEFINE_VECFUNC("__rd_powk1_1", "__rd_powk1_8", FIXED(8), "_ZGV_LLVM_N8vv") -TLI_DEFINE_VECFUNC("__rs_powk1_1", "__rs_powk1_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__rs_powk1_1", "__rs_powk1_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__rs_powk1_1", "__rs_powk1_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__rs_powk1_1", "__rs_powk1_4", FIXED(4), "_ZGV_LLVM_N4vv") +TLI_DEFINE_VECFUNC("__rs_powk1_1", "__rs_powk1_8", FIXED(8), "_ZGV_LLVM_N8vv") +TLI_DEFINE_VECFUNC("__rs_powk1_1", "__rs_powk1_16", FIXED(16), "_ZGV_LLVM_N16vv") -TLI_DEFINE_VECFUNC("__fd_log10_1", "__fd_log10_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__fd_log10_1", "__fd_log10_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__fd_log10_1", "__fd_log10_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__fd_log10_1", "__fd_log10_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__fd_log10_1", "__fd_log10_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__fd_log10_1", "__fd_log10_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__fs_log10_1", "__fs_log10_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__fs_log10_1", "__fs_log10_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__fs_log10_1", "__fs_log10_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__fs_log10_1", "__fs_log10_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__fs_log10_1", "__fs_log10_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__fs_log10_1", "__fs_log10_16", FIXED(16), "_ZGV_LLVM_N16v") -TLI_DEFINE_VECFUNC("__pd_log10_1", "__pd_log10_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__pd_log10_1", "__pd_log10_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__pd_log10_1", "__pd_log10_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__pd_log10_1", "__pd_log10_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__pd_log10_1", "__pd_log10_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__pd_log10_1", "__pd_log10_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__ps_log10_1", "__ps_log10_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__ps_log10_1", "__ps_log10_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__ps_log10_1", "__ps_log10_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__ps_log10_1", "__ps_log10_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__ps_log10_1", "__ps_log10_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__ps_log10_1", "__ps_log10_16", FIXED(16), "_ZGV_LLVM_N16v") -TLI_DEFINE_VECFUNC("__rd_log10_1", "__rd_log10_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__rd_log10_1", "__rd_log10_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__rd_log10_1", "__rd_log10_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__rd_log10_1", "__rd_log10_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__rd_log10_1", "__rd_log10_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__rd_log10_1", "__rd_log10_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__rs_log10_1", "__rs_log10_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__rs_log10_1", "__rs_log10_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__rs_log10_1", "__rs_log10_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__rs_log10_1", "__rs_log10_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__rs_log10_1", "__rs_log10_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__rs_log10_1", "__rs_log10_16", FIXED(16), "_ZGV_LLVM_N16v") -TLI_DEFINE_VECFUNC("__fd_log_1", "__fd_log_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__fd_log_1", "__fd_log_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__fd_log_1", "__fd_log_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__fd_log_1", "__fd_log_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__fd_log_1", "__fd_log_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__fd_log_1", "__fd_log_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__fs_log_1", "__fs_log_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__fs_log_1", "__fs_log_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__fs_log_1", "__fs_log_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__fs_log_1", "__fs_log_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__fs_log_1", "__fs_log_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__fs_log_1", "__fs_log_16", FIXED(16), "_ZGV_LLVM_N16v") -TLI_DEFINE_VECFUNC("__pd_log_1", "__pd_log_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__pd_log_1", "__pd_log_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__pd_log_1", "__pd_log_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__pd_log_1", "__pd_log_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__pd_log_1", "__pd_log_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__pd_log_1", "__pd_log_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__ps_log_1", "__ps_log_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__ps_log_1", "__ps_log_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__ps_log_1", "__ps_log_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__ps_log_1", "__ps_log_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__ps_log_1", "__ps_log_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__ps_log_1", "__ps_log_16", FIXED(16), "_ZGV_LLVM_N16v") -TLI_DEFINE_VECFUNC("__rd_log_1", "__rd_log_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__rd_log_1", "__rd_log_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__rd_log_1", "__rd_log_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__rd_log_1", "__rd_log_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__rd_log_1", "__rd_log_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__rd_log_1", "__rd_log_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__rs_log_1", "__rs_log_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__rs_log_1", "__rs_log_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__rs_log_1", "__rs_log_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__rs_log_1", "__rs_log_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__rs_log_1", "__rs_log_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__rs_log_1", "__rs_log_16", FIXED(16), "_ZGV_LLVM_N16v") -TLI_DEFINE_VECFUNC("__fs_exp_1", "__fs_exp_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__fs_exp_1", "__fs_exp_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__fs_exp_1", "__fs_exp_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__fs_exp_1", "__fs_exp_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__fs_exp_1", "__fs_exp_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__fs_exp_1", "__fs_exp_16", FIXED(16), "_ZGV_LLVM_N16v") -TLI_DEFINE_VECFUNC("__pd_exp_1", "__pd_exp_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__pd_exp_1", "__pd_exp_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__pd_exp_1", "__pd_exp_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__pd_exp_1", "__pd_exp_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__pd_exp_1", "__pd_exp_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__pd_exp_1", "__pd_exp_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__ps_exp_1", "__ps_exp_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__ps_exp_1", "__ps_exp_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__ps_exp_1", "__ps_exp_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__ps_exp_1", "__ps_exp_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__ps_exp_1", "__ps_exp_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__ps_exp_1", "__ps_exp_16", FIXED(16), "_ZGV_LLVM_N16v") -TLI_DEFINE_VECFUNC("__rd_exp_1", "__rd_exp_2", FIXED(2)) -TLI_DEFINE_VECFUNC("__rd_exp_1", "__rd_exp_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__rd_exp_1", "__rd_exp_8", FIXED(8)) +TLI_DEFINE_VECFUNC("__rd_exp_1", "__rd_exp_2", FIXED(2), "_ZGV_LLVM_N2v") +TLI_DEFINE_VECFUNC("__rd_exp_1", "__rd_exp_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__rd_exp_1", "__rd_exp_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__rs_exp_1", "__rs_exp_4", FIXED(4)) -TLI_DEFINE_VECFUNC("__rs_exp_1", "__rs_exp_8", FIXED(8)) -TLI_DEFINE_VECFUNC("__rs_exp_1", "__rs_exp_16", FIXED(16)) +TLI_DEFINE_VECFUNC("__rs_exp_1", "__rs_exp_4", FIXED(4), "_ZGV_LLVM_N4v") +TLI_DEFINE_VECFUNC("__rs_exp_1", "__rs_exp_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__rs_exp_1", "__rs_exp_16", FIXED(16), "_ZGV_LLVM_N16v") #else #error "Must choose which vector library functions are to be defined." From f8819756cfe3fc9ccb93c92501038da8c9317d81 Mon Sep 17 00:00:00 2001 From: Bryan Chan Date: Wed, 3 Apr 2024 08:09:13 -0400 Subject: [PATCH 49/60] [libomptarget] Exclude omp3d_x tests that fail on GitHub runners ...because the runners do not have enough threads. --- offload/test/api/ompx_3d.c | 5 +++++ offload/test/api/ompx_3d.cpp | 5 +++++ 2 files changed, 10 insertions(+) diff --git a/offload/test/api/ompx_3d.c b/offload/test/api/ompx_3d.c index 2ae17c226f3a..d9aeb03be673 100644 --- a/offload/test/api/ompx_3d.c +++ b/offload/test/api/ompx_3d.c @@ -1,5 +1,10 @@ // RUN: %libomptarget-compile-run-and-check-generic +// This test currently fails on GitHub runners which do not have enough +// CPUs to allow the creation of the number of threads needed. +// +// XFAIL: * + #include #include #include diff --git a/offload/test/api/ompx_3d.cpp b/offload/test/api/ompx_3d.cpp index 5b5491263a91..877d25636b7b 100644 --- a/offload/test/api/ompx_3d.cpp +++ b/offload/test/api/ompx_3d.cpp @@ -1,5 +1,10 @@ // RUN: %libomptarget-compilexx-run-and-check-generic +// This test currently fails on GitHub runners which do not have enough +// CPUs to allow the creation of the number of threads needed. +// +// XFAIL: * + #include #include #include From 998ca6ffca9c7cb54c061524c392a701f455a4fb Mon Sep 17 00:00:00 2001 From: Bryan Chan Date: Wed, 3 Apr 2024 08:19:20 -0400 Subject: [PATCH 50/60] [Driver] Make supported Clang options visible to Classic Flang Classic Flang accepts some Clang options that LLVM Flang (F18) does not. The Visibility of such options are modified to include "FlangOption". --- clang/include/clang/Driver/Options.td | 46 ++++++++++++++++++++++++++- 1 file changed, 45 insertions(+), 1 deletion(-) diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td index 91522abd3a97..4779a0b51e41 100644 --- a/clang/include/clang/Driver/Options.td +++ b/clang/include/clang/Driver/Options.td @@ -684,7 +684,11 @@ def ccc_gcc_name : Separate<["-"], "ccc-gcc-name">, InternalDriverOpt, class InternalDebugOpt : Group, Flags<[NoXarchOption, HelpHidden]>, +#ifdef ENABLE_CLASSIC_FLANG + Visibility<[ClangOption, CLOption, DXCOption, FlangOption]>; +#else Visibility<[ClangOption, CLOption, DXCOption]>; +#endif def ccc_install_dir : Separate<["-"], "ccc-install-dir">, InternalDebugOpt, HelpText<"Simulate installation in the given directory">; def ccc_print_phases : Flag<["-"], "ccc-print-phases">, @@ -1547,6 +1551,7 @@ def emit_ast : Flag<["-"], "emit-ast">, HelpText<"Emit Clang AST files for source inputs">; #ifdef ENABLE_CLASSIC_FLANG def emit_flang_llvm : Flag<["-"], "emit-flang-llvm">, + Visibility<[FlangOption]>, HelpText<"Emit Flang LLVM files for source inputs">; #endif def emit_llvm : Flag<["-"], "emit-llvm">, @@ -3783,6 +3788,9 @@ defm openmp_optimistic_collapse : BoolFOption<"openmp-optimistic-collapse", PosFlag, NegFlag, BothFlags<[NoArgumentUnused, HelpHidden], []>>; def static_openmp: Flag<["-"], "static-openmp">, +#ifdef ENABLE_CLASSIC_FLANG + Visibility<[ClangOption, FlangOption]>, +#endif HelpText<"Use the static host OpenMP runtime while linking.">; def fopenmp_new_driver : Flag<["-"], "fopenmp-new-driver">, Flags<[HelpHidden]>, HelpText<"Use the new driver for OpenMP offloading.">; @@ -4529,15 +4537,31 @@ def gdbx : Flag<["-"], "gdbx">, Group; // Equivalent to our default dwarf version. Forces usual dwarf emission when // CodeView is enabled. def gdwarf : Flag<["-"], "gdwarf">, Group, +#ifdef ENABLE_CLASSIC_FLANG + Visibility<[ClangOption, CLOption, DXCOption, FlangOption]>, +#else Visibility<[ClangOption, CLOption, DXCOption]>, +#endif HelpText<"Generate source-level debug information with the default dwarf version">; def gdwarf_2 : Flag<["-"], "gdwarf-2">, Group, +#ifdef ENABLE_CLASSIC_FLANG + Visibility<[ClangOption, FlangOption]>, +#endif HelpText<"Generate source-level debug information with dwarf version 2">; def gdwarf_3 : Flag<["-"], "gdwarf-3">, Group, +#ifdef ENABLE_CLASSIC_FLANG + Visibility<[ClangOption, FlangOption]>, +#endif HelpText<"Generate source-level debug information with dwarf version 3">; def gdwarf_4 : Flag<["-"], "gdwarf-4">, Group, +#ifdef ENABLE_CLASSIC_FLANG + Visibility<[ClangOption, FlangOption]>, +#endif HelpText<"Generate source-level debug information with dwarf version 4">; def gdwarf_5 : Flag<["-"], "gdwarf-5">, Group, +#ifdef ENABLE_CLASSIC_FLANG + Visibility<[ClangOption, FlangOption]>, +#endif HelpText<"Generate source-level debug information with dwarf version 5">; def gdwarf64 : Flag<["-"], "gdwarf64">, Group, Visibility<[ClangOption, CC1Option, CC1AsOption]>, @@ -4623,9 +4647,16 @@ def gno_simple_template_names : Flag<["-"], "gno-simple-template-names">, def ggnu_pubnames : Flag<["-"], "ggnu-pubnames">, Group, Visibility<[ClangOption, CC1Option]>; def gno_gnu_pubnames : Flag<["-"], "gno-gnu-pubnames">, Group; +#ifdef ENABLE_CLASSIC_FLANG +def gpubnames : Flag<["-"], "gpubnames">, Group, + Visibility<[ClangOption, CC1Option, FlangOption]>; +def gno_pubnames : Flag<["-"], "gno-pubnames">, Group, + Visibility<[ClangOption, CC1Option, FlangOption]>; +#else def gpubnames : Flag<["-"], "gpubnames">, Group, Visibility<[ClangOption, CC1Option]>; def gno_pubnames : Flag<["-"], "gno-pubnames">, Group; +#endif def gdwarf_aranges : Flag<["-"], "gdwarf-aranges">, Group; def gmodules : Flag <["-"], "gmodules">, Group, HelpText<"Generate debug info with external references to clang modules" @@ -6011,7 +6042,11 @@ def print_enabled_extensions : Flag<["-", "--"], "print-enabled-extensions">, def time : Flag<["-"], "time">, HelpText<"Time individual commands">; def traditional_cpp : Flag<["-", "--"], "traditional-cpp">, +#ifdef ENABLE_CLASSIC_FLANG + Visibility<[ClangOption, CC1Option, FlangOption]>, +#else Visibility<[ClangOption, CC1Option]>, +#endif HelpText<"Enable some traditional CPP emulation">, MarshallingInfoFlag>; def traditional : Flag<["-", "--"], "traditional">; @@ -6088,7 +6123,12 @@ def fno_integrated_objemitter : Flag<["-"], "fno-integrated-objemitter">, Group, HelpText<"Use external machine object code emitter.">; +#ifdef ENABLE_CLASSIC_FLANG +def : Flag<["-"], "integrated-as">, Alias, + Visibility<[ClangOption, CC1Option, FlangOption]>; +#else def : Flag<["-"], "integrated-as">, Alias; +#endif def : Flag<["-"], "no-integrated-as">, Alias, Visibility<[ClangOption, CC1Option, FlangOption]>; @@ -7048,7 +7088,7 @@ def fhermetic_module_files : Flag<["-"], "fhermetic-module-files">, Group, - Flags<[RenderJoined]>, + Flags<[RenderJoined]>, Visibility<[FlangOption, FC1Option]>, Group; let Visibility = [FlangOption] in { @@ -9211,6 +9251,8 @@ multiclass BooleanMFlag { def _off : Flag<["-"], "Mno"#name>; } +let Visibility = [FlangOption] in { + def Mfixed : Flag<["-"], "Mfixed">, Group, HelpText<"Force fixed-form format Fortran">, Flags<[HelpHidden]>; @@ -9330,4 +9372,6 @@ def Hq_EQ : Joined<["-"], "Hq,">, Group; def Mqq_EQ : Joined<["-"], "Mqq,">, Group; def Hqq_EQ : Joined<["-"], "Hqq,">, Group; def Wh_EQ : Joined<["-"], "Wh,">, Group; + +} // let Visibility = [FlangOption] #endif From 04f4c90ce023eadacde2cb5a52ecb7ca1017e673 Mon Sep 17 00:00:00 2001 From: Bryan Chan Date: Wed, 3 Apr 2024 10:22:35 -0400 Subject: [PATCH 51/60] [Driver] Update FileCheck patterns for AArch64 target features ...after upstream commit 13e977d1738261487d8157918f14497517d75821 changed how target feature dependencies are handled. --- clang/test/Driver/emit-flang-attrs.f90 | 40 ++++++++++--------- .../flang/classic-flang-vscale-mbits.f95 | 18 ++++----- .../Driver/flang/classic-flang-vscale.f95 | 16 ++++---- 3 files changed, 38 insertions(+), 36 deletions(-) diff --git a/clang/test/Driver/emit-flang-attrs.f90 b/clang/test/Driver/emit-flang-attrs.f90 index df23a8aa6e87..7a455a9a9551 100644 --- a/clang/test/Driver/emit-flang-attrs.f90 +++ b/clang/test/Driver/emit-flang-attrs.f90 @@ -3,7 +3,7 @@ ! RUN: %flang -### -target aarch64-linux-gnu -march=armv8-a -c %s 2>&1 | FileCheck --check-prefix=CHECK-ATTRS-NEON %s ! RUN: %flang -### -target aarch64-linux-gnu -march=armv8-a+sve -c %s 2>&1 | FileCheck --check-prefix=CHECK-ATTRS-SVE %s ! RUN: %flang -### -target aarch64-linux-gnu -march=armv8-a+nosve -c %s 2>&1 | FileCheck --check-prefix=CHECK-ATTRS-NOSVE %s -! RUN: %flang -### -target aarch64-linux-gnu -march=armv8-a+sve+nosve -c %s 2>&1 | FileCheck --check-prefix=CHECK-ATTRS-NOSVE %s +! RUN: %flang -### -target aarch64-linux-gnu -march=armv8-a+sve+nosve -c %s 2>&1 | FileCheck --check-prefix=CHECK-ATTRS-SVE-REVERT %s ! RUN: %flang -### -target aarch64-linux-gnu -march=armv8-a+sve2+nosve2 -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-SVE2-REVERT ! RUN: %flang -### -target aarch64-linux-gnu -march=armv8-a+sve2-aes -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-SVE2-AES ! RUN: %flang -### -target aarch64-linux-gnu -march=armv8-a+sve2-sm4 -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-SVE2-SM4 @@ -21,38 +21,40 @@ ! RUN: %flang -### -target aarch64-linux-gnu -march=armv8-a+sve2-aes+nosve2-aes %s 2>&1 | FileCheck %s --check-prefix=CHECK-SVE2-AES-REVERT ! CHECK-ATTRS-NEON: "{{.*}}flang2" -! CHECK-ATTRS-NEON-SAME: "-target_features" "+neon,+v8a" +! CHECK-ATTRS-NEON-SAME: "-target_features" "+v8a,+fp-armv8,+neon" ! CHECK-ATTRS-SVE: "{{.*}}flang2" -! CHECK-ATTRS-SVE-SAME: "-target_features" "+neon,+v8a,+sve" +! CHECK-ATTRS-SVE-SAME: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sve" ! CHECK-ATTRS-NOSVE: "{{.*}}flang2" -! CHECK-ATTRS-NOSVE-SAME: "-target_features" "+neon,+v8a,-sve,-sve2,-sve2-bitperm,-sve2-sha3,-sve2-aes,-sve2-sm4" +! CHECK-ATTRS-NOSVE-SAME: "-target_features" "+v8a,+fp-armv8,+neon" +! CHECK-ATTRS-SVE-REVERT: "{{.*}}flang2" +! CHECK-ATTRS-SVE-REVERT-SAME: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,-sve" ! CHECK-SVE2-REVERT: "{{.*}}flang2" -! CHECK-SVE2-REVERT-SAME: "-target_features" "+neon,+v8a,+sve,-sve2,-sve2-bitperm,-sve2-sha3,-sve2-aes,-sve2-sm4" +! CHECK-SVE2-REVERT-SAME: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sve,-sve2" ! CHECK-SVE2-AES: "{{.*}}flang2" -! CHECK-SVE2-AES-SAME: "-target_features" "+neon,+v8a,+sve2-aes,+sve,+sve2" +! CHECK-SVE2-AES-SAME: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sve,+sve2-aes,+sve2" ! CHECK-SVE2-SM4: "{{.*}}flang2" -! CHECK-SVE2-SM4-SAME: "-target_features" "+neon,+v8a,+sve2-sm4,+sve,+sve2" +! CHECK-SVE2-SM4-SAME: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sve,+sve2-sm4,+sve2" ! CHECK-SVE2-SHA3: "{{.*}}flang2" -! CHECK-SVE2-SHA3-SAME: "-target_features" "+neon,+v8a,+sve2-sha3,+sve,+sve2" +! CHECK-SVE2-SHA3-SAME: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sve,+sve2-sha3,+sve2" ! CHECK-SVE2-BITPERM-REVERT: "{{.*}}flang2" -! CHECK-SVE2-BITPERM-REVERT-SAME: "-target_features" "+neon,+v8a,+sve,+sve2,-sve2-bitperm" +! CHECK-SVE2-BITPERM-REVERT-SAME: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sve,-sve2-bitperm,+sve2" ! CHECK-SVE2-IMPLY: "{{.*}}flang2" -! CHECK-SVE2-IMPLY-SAME: "-target_features" "+neon,+v8a,+sve2,+sve" +! CHECK-SVE2-IMPLY-SAME: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sve,+sve2" ! CHECK-SVE2-CONFLICT-REV: "{{.*}}flang2" -! CHECK-SVE2-CONFLICT-REV-SAME: "-target_features" "+neon,+v8a,-sve2-bitperm,-sve2-sha3,-sve2-aes,-sve2-sm4,+sve2,+sve" +! CHECK-SVE2-CONFLICT-REV-SAME: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sve,+sve2" ! CHECK-SVE-SVE2: "{{.*}}flang2" -! CHECK-SVE-SVE2-SAME: "-target_features" "+neon,+v8a,+sve2,+sve" +! CHECK-SVE-SVE2-SAME: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sve,+sve2" ! CHECK-SVE2-BITPERM: "{{.*}}flang2" -! CHECK-SVE2-BITPERM-SAME: "-target_features" "+neon,+v8a,+sve2-bitperm,+sve,+sve2" +! CHECK-SVE2-BITPERM-SAME: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sve,+sve2-bitperm,+sve2" ! CHECK-SVE-SUBFEATURE-CONFLICT-REV: "{{.*}}flang2" -! CHECK-SVE-SUBFEATURE-CONFLICT-REV-SAME: "-target_features" "+neon,+v8a,-sve2-bitperm,-sve2-sha3,-sve2-sm4,+sve2-aes,+sve,+sve2" +! CHECK-SVE-SUBFEATURE-CONFLICT-REV-SAME: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sve,+sve2-aes,+sve2" ! CHECK-SVE2-SUBFEATURE-CONFLICT: "{{.*}}flang2" -! CHECK-SVE2-SUBFEATURE-CONFLICT-SAME: "-target_features" "+neon,+v8a,+sve,-sve2,-sve2-bitperm,-sve2-sha3,-sve2-aes,-sve2-sm4" +! CHECK-SVE2-SUBFEATURE-CONFLICT-SAME: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sve,-sve2-sm4,-sve2" ! CHECK-SVE2-SUBFEATURE-MIX: "{{.*}}flang2" -! CHECK-SVE2-SUBFEATURE-MIX-SAME: "-target_features" "+neon,+v8a,+sve2-bitperm,+sve,+sve2,-sve2-aes" +! CHECK-SVE2-SUBFEATURE-MIX-SAME: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sve,+sve2-bitperm,+sve2" ! CHECK-SVE2-SM4-REVERT: "{{.*}}flang2" -! CHECK-SVE2-SM4-REVERT-SAME: "-target_features" "+neon,+v8a,+sve,+sve2,-sve2-sm4" +! CHECK-SVE2-SM4-REVERT-SAME: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sve,-sve2-sm4,+sve2" ! CHECK-SVE2-SHA3-REVERT: "{{.*}}flang2" -! CHECK-SVE2-SHA3-REVERT-SAME: "-target_features" "+neon,+v8a,+sve,+sve2,-sve2-sha3" +! CHECK-SVE2-SHA3-REVERT-SAME: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sve,-sve2-sha3,+sve2" ! CHECK-SVE2-AES-REVERT: "{{.*}}flang2" -! CHECK-SVE2-AES-REVERT-SAME: "-target_features" "+neon,+v8a,+sve,+sve2,-sve2-aes" +! CHECK-SVE2-AES-REVERT-SAME: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sve,-sve2-aes,+sve2" diff --git a/clang/test/Driver/flang/classic-flang-vscale-mbits.f95 b/clang/test/Driver/flang/classic-flang-vscale-mbits.f95 index f0ed43aa027a..40a20baa1c1b 100644 --- a/clang/test/Driver/flang/classic-flang-vscale-mbits.f95 +++ b/clang/test/Driver/flang/classic-flang-vscale-mbits.f95 @@ -8,21 +8,21 @@ // RUN: %clang --driver-mode=flang -### -S --target=aarch64 -march=armv8-a+sve2-sha3 -msve-vector-bits=2048+ %s 2>&1 | FileCheck -check-prefix=CHECK-SVE2SHA3-2048PLUS %s // RUN: %clang --driver-mode=flang -### -S --target=aarch64 -march=armv8-a+sve2 -msve-vector-bits=scalable %s 2>&1 | FileCheck -check-prefix=CHECK-SVE2-SCALABLE %s -// CHECK-SVE-128: "-target_features" "+neon,+v8a,+sve" +// CHECK-SVE-128: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sve" // CHECK-SVE-128-DAG: "-vscale_range_min" "1" "-vscale_range_max" "1" -// CHECK-SVE-128PLUS: "-target_features" "+neon,+v8a,+sve" +// CHECK-SVE-128PLUS: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sve" // CHECK-SVE-128PLUS-DAG: "-vscale_range_min" "1" "-vscale_range_max" "0" -// CHECK-SVE-256: "-target_features" "+neon,+v8a,+sve" +// CHECK-SVE-256: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sve" // CHECK-SVE-256-DAG: "-vscale_range_min" "2" "-vscale_range_max" "2" -// CHECK-SVE-256PLUS: "-target_features" "+neon,+v8a,+sve" +// CHECK-SVE-256PLUS: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sve" // CHECK-SVE-256PLUS-DAG: "-vscale_range_min" "2" "-vscale_range_max" "0" -// CHECK-SVE2-512: "-target_features" "+neon,+v8a,+sve2,+sve" +// CHECK-SVE2-512: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sve,+sve2" // CHECK-SVE2-512-DAG: "-vscale_range_min" "4" "-vscale_range_max" "4" -// CHECK-SVE2-512PLUS: "-target_features" "+neon,+v8a,+sve2,+sve" +// CHECK-SVE2-512PLUS: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sve,+sve2" // CHECK-SVE2-512PLUS-DAG: "-vscale_range_min" "4" "-vscale_range_max" "0" -// CHECK-SVE2SHA3-2048: "-target_features" "+neon,+v8a,+sve2-sha3,+sve,+sve2" +// CHECK-SVE2SHA3-2048: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sve,+sve2-sha3,+sve2" // CHECK-SVE2SHA3-2048-DAG: "-vscale_range_min" "16" "-vscale_range_max" "16" -// CHECK-SVE2SHA3-2048PLUS: "-target_features" "+neon,+v8a,+sve2-sha3,+sve,+sve2" +// CHECK-SVE2SHA3-2048PLUS: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sve,+sve2-sha3,+sve2" // CHECK-SVE2SHA3-2048PLUS-DAG: "-vscale_range_min" "16" "-vscale_range_max" "0" -// CHECK-SVE2-SCALABLE: "-target_features" "+neon,+v8a,+sve2,+sve" +// CHECK-SVE2-SCALABLE: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sve,+sve2" // CHECK-SVE2-SCALABLE-DAG: "-vscale_range_min" "1" "-vscale_range_max" "16" diff --git a/clang/test/Driver/flang/classic-flang-vscale.f95 b/clang/test/Driver/flang/classic-flang-vscale.f95 index 8110be594db5..a59dbf9c3327 100644 --- a/clang/test/Driver/flang/classic-flang-vscale.f95 +++ b/clang/test/Driver/flang/classic-flang-vscale.f95 @@ -7,22 +7,22 @@ // RUN: %clang --driver-mode=flang -### -S --target=aarch64 -march=armv8-a+sve2-sha3+nosve2 %s 2>&1 | FileCheck -check-prefix=CHECK-SVE2SHA3-NOSVE2 %s // RUN: %clang --driver-mode=flang -### -S --target=aarch64 -march=armv8-a+sve2-sha3+nosve %s 2>&1 | FileCheck -check-prefix=CHECK-SVE2SHA3-NOSVE %s -// CHECK-NEON: "-target_features" "+neon,+v8a" +// CHECK-NEON: "-target_features" "+v8a,+fp-armv8,+neon" // CHECK-NEON-NOT: "-vscale_range_min" // CHECK-NEON-NOT: "-vscale_range_max" -// CHECK-SVE: "-target_features" "+neon,+v8a,+sve" +// CHECK-SVE: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sve" // CHECK-SVE-DAG: "-vscale_range_min" "1" "-vscale_range_max" "16" -// CHECK-SVE2: "-target_features" "+neon,+v8a,+sve2,+sve" +// CHECK-SVE2: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sve,+sve2" // CHECK-SVE2-DAG: "-vscale_range_min" "1" "-vscale_range_max" "16" -// CHECK-SVE2SHA3: "-target_features" "+neon,+v8a,+sve2-sha3,+sve,+sve2" +// CHECK-SVE2SHA3: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sve,+sve2-sha3,+sve2" // CHECK-SVE2SHA3-DAG: "-vscale_range_min" "1" "-vscale_range_max" "16" -// CHECK-SVE-NOSVE: "-target_features" "+neon,+v8a,-sve,-sve2,-sve2-bitperm,-sve2-sha3,-sve2-aes,-sve2-sm4" +// CHECK-SVE-NOSVE: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,-sve" // CHECK-SVE-NOSVE-NOT: "-vscale_range_min" // CHECK-SVE-NOSVE-NOT: "-vscale_range_max" -// CHECK-SVE2-NOSVE2SHA3: "-target_features" "+neon,+v8a,+sve2,+sve,-sve2-sha3" +// CHECK-SVE2-NOSVE2SHA3: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sve,+sve2" // CHECK-SVE2-NOSVE2SHA3-DAG: "-vscale_range_min" "1" "-vscale_range_max" "16" -// CHECK-SVE2SHA3-NOSVE2: "-target_features" "+neon,+v8a,+sve,-sve2,-sve2-bitperm,-sve2-sha3,-sve2-aes,-sve2-sm4" +// CHECK-SVE2SHA3-NOSVE2: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sve,-sve2-sha3,-sve2" // CHECK-SVE2SHA3-NOSVE2-DAG: "-vscale_range_min" "1" "-vscale_range_max" "16" -// CHECK-SVE2SHA3-NOSVE: "-target_features" "+neon,+v8a,-sve,-sve2,-sve2-bitperm,-sve2-sha3,-sve2-aes,-sve2-sm4" +// CHECK-SVE2SHA3-NOSVE: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,-sve,-sve2-sha3,-sve2" // CHECK-SVE2SHA3-NOSVE-NOT: "-vscale_range_min" // CHECK-SVE2SHA3-NOSVE-NOT: "-vscale_range_max" From c52951362e5b17fea1d34526d44999399dbcc333 Mon Sep 17 00:00:00 2001 From: Bryan Chan Date: Wed, 10 Jul 2024 20:08:15 -0400 Subject: [PATCH 52/60] [Driver] Allow Classic Flang driver to accept more Clang options This patch cherry-picks a number of Visibility changes from the tip of trunk upstream, to make selected Clang options visible to Classic Flang. It also makes target-specific codegen options (-mxxxx) visible to Flang by default. Note that accepting the option does not imply support; Classic Flang may simply ignore certain options for backward compatibility. --- clang/include/clang/Driver/Options.td | 16 ++++++++++++++++ clang/test/Driver/flang/classic-flang.f95 | 22 ++++++++++++++++++++-- 2 files changed, 36 insertions(+), 2 deletions(-) diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td index 4779a0b51e41..1462b4cc4f5d 100644 --- a/clang/include/clang/Driver/Options.td +++ b/clang/include/clang/Driver/Options.td @@ -195,7 +195,11 @@ def hip_Group : OptionGroup<"">, Group, def m_Group : OptionGroup<"">, Group, DocName<"Target-dependent compilation options">, +#ifdef ENABLE_CLASSIC_FLANG + Visibility<[ClangOption, CLOption, FlangOption]>; +#else Visibility<[ClangOption, CLOption]>; +#endif def hlsl_Group : OptionGroup<"">, Group, DocName<"HLSL options">, @@ -231,10 +235,18 @@ def m_wasm_Features_Group : OptionGroup<"">, def m_wasm_Features_Driver_Group : OptionGroup<"">, Group, DocName<"WebAssembly Driver">; def m_x86_Features_Group : OptionGroup<"">, +#ifdef ENABLE_CLASSIC_FLANG + Group, Visibility<[ClangOption, CLOption, FlangOption]>, +#else Group, Visibility<[ClangOption, CLOption]>, +#endif DocName<"X86">; def m_x86_AVX10_Features_Group : OptionGroup<"">, +#ifdef ENABLE_CLASSIC_FLANG + Group, Visibility<[ClangOption, CLOption, FlangOption]>, +#else Group, Visibility<[ClangOption, CLOption]>, +#endif DocName<"X86 AVX10">; def m_riscv_Features_Group : OptionGroup<"">, Group, DocName<"RISC-V">; @@ -3516,7 +3528,11 @@ def fno_realloc_lhs : Flag<["-"], "fno-realloc-lhs">, Group, def fno_stack_protector : Flag<["-"], "fno-stack-protector">, Group, HelpText<"Disable the use of stack protectors">; def fno_strict_aliasing : Flag<["-"], "fno-strict-aliasing">, Group, +#ifdef ENABLE_CLASSIC_FLANG + Visibility<[ClangOption, CLOption, DXCOption, FlangOption]>, +#else Visibility<[ClangOption, CLOption, DXCOption]>, +#endif HelpText<"Disable optimizations based on strict aliasing rules">; def fstruct_path_tbaa : Flag<["-"], "fstruct-path-tbaa">, Group; def fno_struct_path_tbaa : Flag<["-"], "fno-struct-path-tbaa">, Group; diff --git a/clang/test/Driver/flang/classic-flang.f95 b/clang/test/Driver/flang/classic-flang.f95 index b953ca15e9be..f19e1e7ae1fe 100644 --- a/clang/test/Driver/flang/classic-flang.f95 +++ b/clang/test/Driver/flang/classic-flang.f95 @@ -2,8 +2,9 @@ ! Check that the driver invokes flang1 correctly for preprocessed free-form ! Fortran code. Also check that the backend is invoked correctly. +! In particular, target-dependent flags (e.g. -mavx for x86_64) should be visible. -! RUN: %clang --driver-mode=flang -target x86_64-unknown-linux-gnu -c %s -### 2>&1 \ +! RUN: %clang --driver-mode=flang -target x86_64-unknown-linux-gnu -mavx -c %s -### 2>&1 \ ! RUN: | FileCheck --check-prefix=CHECK-OBJECT %s ! CHECK-OBJECT: "{{.*}}flang1" ! CHECK-OBJECT-NOT: "-preprocess" @@ -11,6 +12,7 @@ ! CHECK-OBJECT-NEXT: "{{.*}}flang2" ! CHECK-OBJECT-SAME: "-asm" [[LLFILE:.*.ll]] ! CHECK-OBJECT-NEXT: {{clang.* "-cc1"}} +! CHECK-OBJECT-SAME: "-target-feature" "+avx" ! CHECK-OBJECT-SAME: "-o" "classic-flang.o" ! CHECK-OBJECT-SAME: "-x" "ir" ! CHECK-OBJECT-SAME: [[LLFILE]] @@ -31,17 +33,33 @@ ! Check that the backend job (clang -cc1) is not combined into the compile job ! (flang2) even if -integrated-as is specified. +! Also, check that AArch64-specific target-dependent flags are visible. -! RUN: %clang --driver-mode=flang -target x86_64-unknown-linux-gnu -integrated-as -S %s -### 2>&1 \ +! RUN: %clang --driver-mode=flang -target aarch64-unknown-linux-gnu -integrated-as -mno-outline-atomics -S %s -### 2>&1 \ ! RUN: | FileCheck --check-prefix=CHECK-ASM %s ! CHECK-ASM: "{{.*}}flang1" ! CHECK-ASM-NEXT: "{{.*}}flang2" ! CHECK-ASM-SAME: "-asm" [[LLFILE:.*.ll]] ! CHECK-ASM-NEXT: {{clang.* "-cc1"}} +! CHECK-ASM-SAME: "-target-feature" "-outline-atomics" ! CHECK-ASM-SAME: "-o" "classic-flang.s" ! CHECK-ASM-SAME: "-x" "ir" ! CHECK-ASM-SAME: [[LLFILE]] +! Check that other target-independent compiler flags are visible. +! RUN: %clang --driver-mode=flang -target x86_64-unknown-linux-gnu --gcc-install-dir=%S/../Inputs/debian_multiarch_tree/usr/lib/gcc/x86_64-linux-gnu/10/ -fno-strict-aliasing -funroll-loops %s -### 2>&1 \ +! RUN: | FileCheck --check-prefix=CHECK-FFLAGS %s +! CHECK-FFLAGS: "{{.*}}flang1" +! CHECK-FFLAGS-NEXT: "{{.*}}flang2" +! CHECK-FFLAGS-SAME: "-asm" [[LLFILE:.*.ll]] +! CHECK-FFLAGS-NEXT: {{clang.* "-cc1"}} +! CHECK-FFLAGS-SAME: "-relaxed-aliasing" +! CHECK-FFLAGS-SAME: "-funroll-loops" +! CHECK-FFLAGS-SAME: "-x" "ir" +! CHECK-FFLAGS-SAME: [[LLFILE]] +! CHECK-FFLAGS-NEXT: "{{.*}}ld{{(.exe)?}}" +! CHECK-FFLAGS-SAME: "-L{{[^ ]*[/\\]+}}debian_multiarch_tree/usr/lib/gcc/x86_64-linux-gnu/10" + ! Check that the linker job is given the correct libraries and library paths. ! RUN: %flang -target x86_64-linux-gnu -ccc-install-dir %S/../Inputs/basic_linux_tree/usr/bin -mp \ From 7aa40d92e52c84c2dfccd3caba808b8d5a17862c Mon Sep 17 00:00:00 2001 From: shivaramaarao <58245296+shivaramaarao@users.noreply.github.com> Date: Wed, 7 Aug 2024 17:35:13 +0530 Subject: [PATCH 53/60] Fix for issue 1440 (#180) (#187) Through this commit Mbackslash will be the default option. By default, escape characters are treated as regular characters unless Mnobackslash is specified. There is also the issue of treating both Mbackslash and Mnobackslash options independently. This is addressed in this patch and the testcases in flang repository will test this feature. --- clang/lib/Driver/ToolChains/ClassicFlang.cpp | 35 ++++++++++++++------ 1 file changed, 24 insertions(+), 11 deletions(-) diff --git a/clang/lib/Driver/ToolChains/ClassicFlang.cpp b/clang/lib/Driver/ToolChains/ClassicFlang.cpp index af6ad3107a19..7c99ac70fcf2 100644 --- a/clang/lib/Driver/ToolChains/ClassicFlang.cpp +++ b/clang/lib/Driver/ToolChains/ClassicFlang.cpp @@ -241,22 +241,35 @@ void ClassicFlang::ConstructJob(Compilation &C, const JobAction &JA, } } - // Treat backslashes as regular characters - for (auto Arg : Args.filtered(options::OPT_fno_backslash, options::OPT_Mbackslash)) { - Arg->claim(); + if (auto *A = + Args.getLastArg(options::OPT_fno_backslash, options::OPT_Mbackslash, + options::OPT_fbackslash, options::OPT_Mnobackslash)) { + for (auto Arg : + Args.filtered(options::OPT_fno_backslash, options::OPT_Mbackslash, + options::OPT_fbackslash, options::OPT_Mnobackslash)) { + Arg->claim(); + } + // Treat backslashes as regular characters + if (A->getOption().matches(options::OPT_fno_backslash) || + A->getOption().matches(options::OPT_Mbackslash)) { + CommonCmdArgs.push_back("-x"); + CommonCmdArgs.push_back("124"); + CommonCmdArgs.push_back("0x40"); + } + // Treat backslashes as C-style escape characters + if (A->getOption().matches(options::OPT_fbackslash) || + A->getOption().matches(options::OPT_Mnobackslash)) { + CommonCmdArgs.push_back("-y"); + CommonCmdArgs.push_back("124"); + CommonCmdArgs.push_back("0x40"); + } + } else { + // By default treat backslashes as regular characters CommonCmdArgs.push_back("-x"); CommonCmdArgs.push_back("124"); CommonCmdArgs.push_back("0x40"); } - // Treat backslashes as C-style escape characters - for (auto Arg : Args.filtered(options::OPT_fbackslash, options::OPT_Mnobackslash)) { - Arg->claim(); - CommonCmdArgs.push_back("-y"); - CommonCmdArgs.push_back("124"); - CommonCmdArgs.push_back("0x40"); - } - // handle OpemMP options if (auto *A = Args.getLastArg(options::OPT_mp, options::OPT_nomp, options::OPT_fopenmp, options::OPT_fno_openmp)) { From 16c9e692791cc5202fbbfeee55d09459cac3f435 Mon Sep 17 00:00:00 2001 From: shivaramaarao <58245296+shivaramaarao@users.noreply.github.com> Date: Tue, 13 Aug 2024 15:05:37 +0530 Subject: [PATCH 54/60] Fix for Issue #1413 (cherry-pick #179 to release_18x) (#185) PGMATH has AVX512 runtime functions and can be executed only when the application is compiled in avx512 mode. The VecFuncs.def has no information about the TargetOptions and avx512 functions are selected even in avx2 mode. This issue is fixed by creating separate table for AVX512 functions and using them only when avx512 mode is specified. --- clang/lib/CodeGen/BackendUtil.cpp | 14 +- .../include/llvm/Analysis/TargetLibraryInfo.h | 1 + llvm/include/llvm/Analysis/VecFuncs.def | 225 ++++++++++-------- .../llvm/Frontend/Driver/CodeGenOptions.h | 3 +- llvm/lib/Analysis/TargetLibraryInfo.cpp | 11 + llvm/lib/Frontend/Driver/CodeGenOptions.cpp | 6 +- 6 files changed, 151 insertions(+), 109 deletions(-) diff --git a/clang/lib/CodeGen/BackendUtil.cpp b/clang/lib/CodeGen/BackendUtil.cpp index 3e65eeb3755d..f74ecd177fcc 100644 --- a/clang/lib/CodeGen/BackendUtil.cpp +++ b/clang/lib/CodeGen/BackendUtil.cpp @@ -613,8 +613,11 @@ bool EmitAssemblyHelper::AddEmitPasses(legacy::PassManager &CodeGenPasses, raw_pwrite_stream &OS, raw_pwrite_stream *DwoOS) { // Add LibraryInfo. - std::unique_ptr TLII( - llvm::driver::createTLII(TargetTriple, CodeGenOpts.getVecLib())); + bool TargetHasAVX512 = + std::find(TargetOpts.Features.begin(), TargetOpts.Features.end(), + "+avx512f") != TargetOpts.Features.end(); + std::unique_ptr TLII(llvm::driver::createTLII( + TargetTriple, CodeGenOpts.getVecLib(), TargetHasAVX512)); CodeGenPasses.add(new TargetLibraryInfoWrapperPass(*TLII)); // Normal mode, emit a .s or .o file by running the code generator. Note, @@ -964,8 +967,11 @@ void EmitAssemblyHelper::RunOptimizationPipeline( // Register the target library analysis directly and give it a customized // preset TLI. - std::unique_ptr TLII( - llvm::driver::createTLII(TargetTriple, CodeGenOpts.getVecLib())); + bool TargetHasAVX512 = + std::find(TargetOpts.Features.begin(), TargetOpts.Features.end(), + "+avx512f") != TargetOpts.Features.end(); + std::unique_ptr TLII(llvm::driver::createTLII( + TargetTriple, CodeGenOpts.getVecLib(), TargetHasAVX512)); FAM.registerPass([&] { return TargetLibraryAnalysis(*TLII); }); // Register all the basic analyses with the managers. diff --git a/llvm/include/llvm/Analysis/TargetLibraryInfo.h b/llvm/include/llvm/Analysis/TargetLibraryInfo.h index 5d5c2e3d88f0..02c37cf401f4 100644 --- a/llvm/include/llvm/Analysis/TargetLibraryInfo.h +++ b/llvm/include/llvm/Analysis/TargetLibraryInfo.h @@ -130,6 +130,7 @@ class TargetLibraryInfoImpl { MASSV, // IBM MASS vector library. #ifdef ENABLE_CLASSIC_FLANG PGMATH, // PGI math library. + PGMATH_AVX512, // PGI math library (AVX512 subset). #endif SVML, // Intel short vector math library. SLEEFGNUABI, // SLEEF - SIMD Library for Evaluating Elementary Functions. diff --git a/llvm/include/llvm/Analysis/VecFuncs.def b/llvm/include/llvm/Analysis/VecFuncs.def index 0e650c86d634..2cbd41162ff4 100644 --- a/llvm/include/llvm/Analysis/VecFuncs.def +++ b/llvm/include/llvm/Analysis/VecFuncs.def @@ -1794,418 +1794,437 @@ TLI_DEFINE_VECFUNC("__rs_exp_1", "__rs_exp_4", FIXED(4), "_ZGV_LLVM_N4v") TLI_DEFINE_VECFUNC("__fd_sin_1", "__fd_sin_2", FIXED(2), "_ZGV_LLVM_N2v") TLI_DEFINE_VECFUNC("__fd_sin_1", "__fd_sin_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__fd_sin_1", "__fd_sin_8", FIXED(8), "_ZGV_LLVM_N8v") TLI_DEFINE_VECFUNC("__fs_sin_1", "__fs_sin_4", FIXED(4), "_ZGV_LLVM_N4v") TLI_DEFINE_VECFUNC("__fs_sin_1", "__fs_sin_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__fs_sin_1", "__fs_sin_16", FIXED(16), "_ZGV_LLVM_N16v") TLI_DEFINE_VECFUNC("__pd_sin_1", "__pd_sin_2", FIXED(2), "_ZGV_LLVM_N2v") TLI_DEFINE_VECFUNC("__pd_sin_1", "__pd_sin_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__pd_sin_1", "__pd_sin_8", FIXED(8), "_ZGV_LLVM_N8v") TLI_DEFINE_VECFUNC("__ps_sin_1", "__ps_sin_4", FIXED(4), "_ZGV_LLVM_N4v") TLI_DEFINE_VECFUNC("__ps_sin_1", "__ps_sin_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__ps_sin_1", "__ps_sin_16", FIXED(16), "_ZGV_LLVM_N16v") TLI_DEFINE_VECFUNC("__rd_sin_1", "__rd_sin_2", FIXED(2), "_ZGV_LLVM_N2v") TLI_DEFINE_VECFUNC("__rd_sin_1", "__rd_sin_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__rd_sin_1", "__rd_sin_8", FIXED(8), "_ZGV_LLVM_N8v") TLI_DEFINE_VECFUNC("__rs_sin_1", "__rs_sin_4", FIXED(4), "_ZGV_LLVM_N4v") TLI_DEFINE_VECFUNC("__rs_sin_1", "__rs_sin_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__rs_sin_1", "__rs_sin_16", FIXED(16), "_ZGV_LLVM_N16v") TLI_DEFINE_VECFUNC("__fd_cos_1", "__fd_cos_2", FIXED(2), "_ZGV_LLVM_N2v") TLI_DEFINE_VECFUNC("__fd_cos_1", "__fd_cos_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__fd_cos_1", "__fd_cos_8", FIXED(8), "_ZGV_LLVM_N8v") TLI_DEFINE_VECFUNC("__fs_cos_1", "__fs_cos_4", FIXED(4), "_ZGV_LLVM_N4v") TLI_DEFINE_VECFUNC("__fs_cos_1", "__fs_cos_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__fs_cos_1", "__fs_cos_16", FIXED(16), "_ZGV_LLVM_N16v") TLI_DEFINE_VECFUNC("__pd_cos_1", "__pd_cos_2", FIXED(2), "_ZGV_LLVM_N2v") TLI_DEFINE_VECFUNC("__pd_cos_1", "__pd_cos_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__pd_cos_1", "__pd_cos_8", FIXED(8), "_ZGV_LLVM_N8v") TLI_DEFINE_VECFUNC("__ps_cos_1", "__ps_cos_4", FIXED(4), "_ZGV_LLVM_N4v") TLI_DEFINE_VECFUNC("__ps_cos_1", "__ps_cos_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__ps_cos_1", "__ps_cos_16", FIXED(16), "_ZGV_LLVM_N16v") TLI_DEFINE_VECFUNC("__rd_cos_1", "__rd_cos_2", FIXED(2), "_ZGV_LLVM_N2v") TLI_DEFINE_VECFUNC("__rd_cos_1", "__rd_cos_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__rd_cos_1", "__rd_cos_8", FIXED(8), "_ZGV_LLVM_N8v") TLI_DEFINE_VECFUNC("__rs_cos_1", "__rs_cos_4", FIXED(4), "_ZGV_LLVM_N4v") TLI_DEFINE_VECFUNC("__rs_cos_1", "__rs_cos_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__rs_cos_1", "__rs_cos_16", FIXED(16), "_ZGV_LLVM_N16v") TLI_DEFINE_VECFUNC("__fd_tan_1", "__fd_tan_2", FIXED(2), "_ZGV_LLVM_N2v") TLI_DEFINE_VECFUNC("__fd_tan_1", "__fd_tan_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__fd_tan_1", "__fd_tan_8", FIXED(8), "_ZGV_LLVM_N8v") TLI_DEFINE_VECFUNC("__fs_tan_1", "__fs_tan_4", FIXED(4), "_ZGV_LLVM_N4v") TLI_DEFINE_VECFUNC("__fs_tan_1", "__fs_tan_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__fs_tan_1", "__fs_tan_16", FIXED(16), "_ZGV_LLVM_N16v") TLI_DEFINE_VECFUNC("__pd_tan_1", "__pd_tan_2", FIXED(2), "_ZGV_LLVM_N2v") TLI_DEFINE_VECFUNC("__pd_tan_1", "__pd_tan_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__pd_tan_1", "__pd_tan_8", FIXED(8), "_ZGV_LLVM_N8v") TLI_DEFINE_VECFUNC("__ps_tan_1", "__ps_tan_4", FIXED(4), "_ZGV_LLVM_N4v") TLI_DEFINE_VECFUNC("__ps_tan_1", "__ps_tan_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__ps_tan_1", "__ps_tan_16", FIXED(16), "_ZGV_LLVM_N16v") TLI_DEFINE_VECFUNC("__rd_tan_1", "__rd_tan_2", FIXED(2), "_ZGV_LLVM_N2v") TLI_DEFINE_VECFUNC("__rd_tan_1", "__rd_tan_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__rd_tan_1", "__rd_tan_8", FIXED(8), "_ZGV_LLVM_N8v") TLI_DEFINE_VECFUNC("__rs_tan_1", "__rs_tan_4", FIXED(4), "_ZGV_LLVM_N4v") TLI_DEFINE_VECFUNC("__rs_tan_1", "__rs_tan_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__rs_tan_1", "__rs_tan_16", FIXED(16), "_ZGV_LLVM_N16v") TLI_DEFINE_VECFUNC("__fd_sinh_1", "__fd_sinh_2", FIXED(2), "_ZGV_LLVM_N2v") TLI_DEFINE_VECFUNC("__fd_sinh_1", "__fd_sinh_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__fd_sinh_1", "__fd_sinh_8", FIXED(8), "_ZGV_LLVM_N8v") TLI_DEFINE_VECFUNC("__fs_sinh_1", "__fs_sinh_4", FIXED(4), "_ZGV_LLVM_N4v") TLI_DEFINE_VECFUNC("__fs_sinh_1", "__fs_sinh_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__fs_sinh_1", "__fs_sinh_16", FIXED(16), "_ZGV_LLVM_N16v") TLI_DEFINE_VECFUNC("__pd_sinh_1", "__pd_sinh_2", FIXED(2), "_ZGV_LLVM_N2v") TLI_DEFINE_VECFUNC("__pd_sinh_1", "__pd_sinh_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__pd_sinh_1", "__pd_sinh_8", FIXED(8), "_ZGV_LLVM_N8v") TLI_DEFINE_VECFUNC("__ps_sinh_1", "__ps_sinh_4", FIXED(4), "_ZGV_LLVM_N4v") TLI_DEFINE_VECFUNC("__ps_sinh_1", "__ps_sinh_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__ps_sinh_1", "__ps_sinh_16", FIXED(16), "_ZGV_LLVM_N16v") TLI_DEFINE_VECFUNC("__rd_sinh_1", "__rd_sinh_2", FIXED(2), "_ZGV_LLVM_N2v") TLI_DEFINE_VECFUNC("__rd_sinh_1", "__rd_sinh_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__rd_sinh_1", "__rd_sinh_8", FIXED(8), "_ZGV_LLVM_N8v") TLI_DEFINE_VECFUNC("__rs_sinh_1", "__rs_sinh_4", FIXED(4), "_ZGV_LLVM_N4v") TLI_DEFINE_VECFUNC("__rs_sinh_1", "__rs_sinh_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__rs_sinh_1", "__rs_sinh_16", FIXED(16), "_ZGV_LLVM_N16v") TLI_DEFINE_VECFUNC("__fd_cosh_1", "__fd_cosh_2", FIXED(2), "_ZGV_LLVM_N2v") TLI_DEFINE_VECFUNC("__fd_cosh_1", "__fd_cosh_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__fd_cosh_1", "__fd_cosh_8", FIXED(8), "_ZGV_LLVM_N8v") TLI_DEFINE_VECFUNC("__fs_cosh_1", "__fs_cosh_4", FIXED(4), "_ZGV_LLVM_N4v") TLI_DEFINE_VECFUNC("__fs_cosh_1", "__fs_cosh_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__fs_cosh_1", "__fs_cosh_16", FIXED(16), "_ZGV_LLVM_N16v") TLI_DEFINE_VECFUNC("__pd_cosh_1", "__pd_cosh_2", FIXED(2), "_ZGV_LLVM_N2v") TLI_DEFINE_VECFUNC("__pd_cosh_1", "__pd_cosh_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__pd_cosh_1", "__pd_cosh_8", FIXED(8), "_ZGV_LLVM_N8v") TLI_DEFINE_VECFUNC("__ps_cosh_1", "__ps_cosh_4", FIXED(4), "_ZGV_LLVM_N4v") TLI_DEFINE_VECFUNC("__ps_cosh_1", "__ps_cosh_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__ps_cosh_1", "__ps_cosh_16", FIXED(16), "_ZGV_LLVM_N16v") TLI_DEFINE_VECFUNC("__rd_cosh_1", "__rd_cosh_2", FIXED(2), "_ZGV_LLVM_N2v") TLI_DEFINE_VECFUNC("__rd_cosh_1", "__rd_cosh_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__rd_cosh_1", "__rd_cosh_8", FIXED(8), "_ZGV_LLVM_N8v") TLI_DEFINE_VECFUNC("__rs_cosh_1", "__rs_cosh_4", FIXED(4), "_ZGV_LLVM_N4v") TLI_DEFINE_VECFUNC("__rs_cosh_1", "__rs_cosh_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__rs_cosh_1", "__rs_cosh_16", FIXED(16), "_ZGV_LLVM_N16v") TLI_DEFINE_VECFUNC("__fd_tanh_1", "__fd_tanh_2", FIXED(2), "_ZGV_LLVM_N2v") TLI_DEFINE_VECFUNC("__fd_tanh_1", "__fd_tanh_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__fd_tanh_1", "__fd_tanh_8", FIXED(8), "_ZGV_LLVM_N8v") TLI_DEFINE_VECFUNC("__fs_tanh_1", "__fs_tanh_4", FIXED(4), "_ZGV_LLVM_N4v") TLI_DEFINE_VECFUNC("__fs_tanh_1", "__fs_tanh_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__fs_tanh_1", "__fs_tanh_16", FIXED(16), "_ZGV_LLVM_N16v") TLI_DEFINE_VECFUNC("__pd_tanh_1", "__pd_tanh_2", FIXED(2), "_ZGV_LLVM_N2v") TLI_DEFINE_VECFUNC("__pd_tanh_1", "__pd_tanh_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__pd_tanh_1", "__pd_tanh_8", FIXED(8), "_ZGV_LLVM_N8v") TLI_DEFINE_VECFUNC("__ps_tanh_1", "__ps_tanh_4", FIXED(4), "_ZGV_LLVM_N4v") TLI_DEFINE_VECFUNC("__ps_tanh_1", "__ps_tanh_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__ps_tanh_1", "__ps_tanh_16", FIXED(16), "_ZGV_LLVM_N16v") TLI_DEFINE_VECFUNC("__rd_tanh_1", "__rd_tanh_2", FIXED(2), "_ZGV_LLVM_N2v") TLI_DEFINE_VECFUNC("__rd_tanh_1", "__rd_tanh_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__rd_tanh_1", "__rd_tanh_8", FIXED(8), "_ZGV_LLVM_N8v") TLI_DEFINE_VECFUNC("__rs_tanh_1", "__rs_tanh_4", FIXED(4), "_ZGV_LLVM_N4v") TLI_DEFINE_VECFUNC("__rs_tanh_1", "__rs_tanh_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__rs_tanh_1", "__rs_tanh_16", FIXED(16), "_ZGV_LLVM_N16v") TLI_DEFINE_VECFUNC("__fd_asin_1", "__fd_asin_2", FIXED(2), "_ZGV_LLVM_N2v") TLI_DEFINE_VECFUNC("__fd_asin_1", "__fd_asin_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__fd_asin_1", "__fd_asin_8", FIXED(8), "_ZGV_LLVM_N8v") TLI_DEFINE_VECFUNC("__fs_asin_1", "__fs_asin_4", FIXED(4), "_ZGV_LLVM_N4v") TLI_DEFINE_VECFUNC("__fs_asin_1", "__fs_asin_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__fs_asin_1", "__fs_asin_16", FIXED(16), "_ZGV_LLVM_N16v") TLI_DEFINE_VECFUNC("__pd_asin_1", "__pd_asin_2", FIXED(2), "_ZGV_LLVM_N2v") TLI_DEFINE_VECFUNC("__pd_asin_1", "__pd_asin_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__pd_asin_1", "__pd_asin_8", FIXED(8), "_ZGV_LLVM_N8v") TLI_DEFINE_VECFUNC("__ps_asin_1", "__ps_asin_4", FIXED(4), "_ZGV_LLVM_N4v") TLI_DEFINE_VECFUNC("__ps_asin_1", "__ps_asin_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__ps_asin_1", "__ps_asin_16", FIXED(16), "_ZGV_LLVM_N16v") TLI_DEFINE_VECFUNC("__rd_asin_1", "__rd_asin_2", FIXED(2), "_ZGV_LLVM_N2v") TLI_DEFINE_VECFUNC("__rd_asin_1", "__rd_asin_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__rd_asin_1", "__rd_asin_8", FIXED(8), "_ZGV_LLVM_N8v") TLI_DEFINE_VECFUNC("__rs_asin_1", "__rs_asin_4", FIXED(4), "_ZGV_LLVM_N4v") TLI_DEFINE_VECFUNC("__rs_asin_1", "__rs_asin_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__rs_asin_1", "__rs_asin_16", FIXED(16), "_ZGV_LLVM_N16v") TLI_DEFINE_VECFUNC("__fd_acos_1", "__fd_acos_2", FIXED(2), "_ZGV_LLVM_N2v") TLI_DEFINE_VECFUNC("__fd_acos_1", "__fd_acos_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__fd_acos_1", "__fd_acos_8", FIXED(8), "_ZGV_LLVM_N8v") TLI_DEFINE_VECFUNC("__fs_acos_1", "__fs_acos_4", FIXED(4), "_ZGV_LLVM_N4v") TLI_DEFINE_VECFUNC("__fs_acos_1", "__fs_acos_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__fs_acos_1", "__fs_acos_16", FIXED(16), "_ZGV_LLVM_N16v") TLI_DEFINE_VECFUNC("__pd_acos_1", "__pd_acos_2", FIXED(2), "_ZGV_LLVM_N2v") TLI_DEFINE_VECFUNC("__pd_acos_1", "__pd_acos_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__pd_acos_1", "__pd_acos_8", FIXED(8), "_ZGV_LLVM_N8v") TLI_DEFINE_VECFUNC("__ps_acos_1", "__ps_acos_4", FIXED(4), "_ZGV_LLVM_N4v") TLI_DEFINE_VECFUNC("__ps_acos_1", "__ps_acos_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__ps_acos_1", "__ps_acos_16", FIXED(16), "_ZGV_LLVM_N16v") TLI_DEFINE_VECFUNC("__rd_acos_1", "__rd_acos_2", FIXED(2), "_ZGV_LLVM_N2v") TLI_DEFINE_VECFUNC("__rd_acos_1", "__rd_acos_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__rd_acos_1", "__rd_acos_8", FIXED(8), "_ZGV_LLVM_N8v") TLI_DEFINE_VECFUNC("__rs_acos_1", "__rs_acos_4", FIXED(4), "_ZGV_LLVM_N4v") TLI_DEFINE_VECFUNC("__rs_acos_1", "__rs_acos_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__rs_acos_1", "__rs_acos_16", FIXED(16), "_ZGV_LLVM_N16v") TLI_DEFINE_VECFUNC("__fd_atan_1", "__fd_atan_2", FIXED(2), "_ZGV_LLVM_N2v") TLI_DEFINE_VECFUNC("__fd_atan_1", "__fd_atan_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__fd_atan_1", "__fd_atan_8", FIXED(8), "_ZGV_LLVM_N8v") TLI_DEFINE_VECFUNC("__fs_atan_1", "__fs_atan_4", FIXED(4), "_ZGV_LLVM_N4v") TLI_DEFINE_VECFUNC("__fs_atan_1", "__fs_atan_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__fs_atan_1", "__fs_atan_16", FIXED(16), "_ZGV_LLVM_N16v") TLI_DEFINE_VECFUNC("__pd_atan_1", "__pd_atan_2", FIXED(2), "_ZGV_LLVM_N2v") TLI_DEFINE_VECFUNC("__pd_atan_1", "__pd_atan_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__pd_atan_1", "__pd_atan_8", FIXED(8), "_ZGV_LLVM_N8v") TLI_DEFINE_VECFUNC("__ps_atan_1", "__ps_atan_4", FIXED(4), "_ZGV_LLVM_N4v") TLI_DEFINE_VECFUNC("__ps_atan_1", "__ps_atan_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__ps_atan_1", "__ps_atan_16", FIXED(16), "_ZGV_LLVM_N16v") TLI_DEFINE_VECFUNC("__rd_atan_1", "__rd_atan_2", FIXED(2), "_ZGV_LLVM_N2v") TLI_DEFINE_VECFUNC("__rd_atan_1", "__rd_atan_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__rd_atan_1", "__rd_atan_8", FIXED(8), "_ZGV_LLVM_N8v") TLI_DEFINE_VECFUNC("__rs_atan_1", "__rs_atan_4", FIXED(4), "_ZGV_LLVM_N4v") TLI_DEFINE_VECFUNC("__rs_atan_1", "__rs_atan_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__rs_atan_1", "__rs_atan_16", FIXED(16), "_ZGV_LLVM_N16v") TLI_DEFINE_VECFUNC("__fd_atan2_1", "__fd_atan2_2", FIXED(2), "_ZGV_LLVM_N2vv") TLI_DEFINE_VECFUNC("__fd_atan2_1", "__fd_atan2_4", FIXED(4), "_ZGV_LLVM_N4vv") -TLI_DEFINE_VECFUNC("__fd_atan2_1", "__fd_atan2_8", FIXED(8), "_ZGV_LLVM_N8vv") TLI_DEFINE_VECFUNC("__fs_atan2_1", "__fs_atan2_4", FIXED(4), "_ZGV_LLVM_N4vv") TLI_DEFINE_VECFUNC("__fs_atan2_1", "__fs_atan2_8", FIXED(8), "_ZGV_LLVM_N8vv") -TLI_DEFINE_VECFUNC("__fs_atan2_1", "__fs_atan2_16", FIXED(16), "_ZGV_LLVM_N16vv") TLI_DEFINE_VECFUNC("__pd_atan2_1", "__pd_atan2_2", FIXED(2), "_ZGV_LLVM_N2vv") TLI_DEFINE_VECFUNC("__pd_atan2_1", "__pd_atan2_4", FIXED(4), "_ZGV_LLVM_N4vv") -TLI_DEFINE_VECFUNC("__pd_atan2_1", "__pd_atan2_8", FIXED(8), "_ZGV_LLVM_N8vv") TLI_DEFINE_VECFUNC("__ps_atan2_1", "__ps_atan2_4", FIXED(4), "_ZGV_LLVM_N4vv") TLI_DEFINE_VECFUNC("__ps_atan2_1", "__ps_atan2_8", FIXED(8), "_ZGV_LLVM_N8vv") -TLI_DEFINE_VECFUNC("__ps_atan2_1", "__ps_atan2_16", FIXED(16), "_ZGV_LLVM_N16vv") TLI_DEFINE_VECFUNC("__rd_atan2_1", "__rd_atan2_2", FIXED(2), "_ZGV_LLVM_N2vv") TLI_DEFINE_VECFUNC("__rd_atan2_1", "__rd_atan2_4", FIXED(4), "_ZGV_LLVM_N4vv") -TLI_DEFINE_VECFUNC("__rd_atan2_1", "__rd_atan2_8", FIXED(8), "_ZGV_LLVM_N8vv") TLI_DEFINE_VECFUNC("__rs_atan2_1", "__rs_atan2_4", FIXED(4), "_ZGV_LLVM_N4vv") TLI_DEFINE_VECFUNC("__rs_atan2_1", "__rs_atan2_8", FIXED(8), "_ZGV_LLVM_N8vv") -TLI_DEFINE_VECFUNC("__rs_atan2_1", "__rs_atan2_16", FIXED(16), "_ZGV_LLVM_N16vv") TLI_DEFINE_VECFUNC("__fd_pow_1", "__fd_pow_2", FIXED(2), "_ZGV_LLVM_N2vv") TLI_DEFINE_VECFUNC("__fd_pow_1", "__fd_pow_4", FIXED(4), "_ZGV_LLVM_N4vv") -TLI_DEFINE_VECFUNC("__fd_pow_1", "__fd_pow_8", FIXED(8), "_ZGV_LLVM_N8vv") TLI_DEFINE_VECFUNC("__fs_pow_1", "__fs_pow_4", FIXED(4), "_ZGV_LLVM_N4vv") TLI_DEFINE_VECFUNC("__fs_pow_1", "__fs_pow_8", FIXED(8), "_ZGV_LLVM_N8vv") -TLI_DEFINE_VECFUNC("__fs_pow_1", "__fs_pow_16", FIXED(16), "_ZGV_LLVM_N16vv") TLI_DEFINE_VECFUNC("__pd_pow_1", "__pd_pow_2", FIXED(2), "_ZGV_LLVM_N2vv") TLI_DEFINE_VECFUNC("__pd_pow_1", "__pd_pow_4", FIXED(4), "_ZGV_LLVM_N4vv") -TLI_DEFINE_VECFUNC("__pd_pow_1", "__pd_pow_8", FIXED(8), "_ZGV_LLVM_N8vv") TLI_DEFINE_VECFUNC("__ps_pow_1", "__ps_pow_4", FIXED(4), "_ZGV_LLVM_N4vv") TLI_DEFINE_VECFUNC("__ps_pow_1", "__ps_pow_8", FIXED(8), "_ZGV_LLVM_N8vv") -TLI_DEFINE_VECFUNC("__ps_pow_1", "__ps_pow_16", FIXED(16), "_ZGV_LLVM_N16vv") TLI_DEFINE_VECFUNC("__rd_pow_1", "__rd_pow_2", FIXED(2), "_ZGV_LLVM_N2vv") TLI_DEFINE_VECFUNC("__rd_pow_1", "__rd_pow_4", FIXED(4), "_ZGV_LLVM_N4vv") -TLI_DEFINE_VECFUNC("__rd_pow_1", "__rd_pow_8", FIXED(8), "_ZGV_LLVM_N8vv") TLI_DEFINE_VECFUNC("__rs_pow_1", "__rs_pow_4", FIXED(4), "_ZGV_LLVM_N4vv") TLI_DEFINE_VECFUNC("__rs_pow_1", "__rs_pow_8", FIXED(8), "_ZGV_LLVM_N8vv") -TLI_DEFINE_VECFUNC("__rs_pow_1", "__rs_pow_16", FIXED(16), "_ZGV_LLVM_N16vv") TLI_DEFINE_VECFUNC("__fs_powi_1", "__fs_powi_4", FIXED(4), "_ZGV_LLVM_N4vv") TLI_DEFINE_VECFUNC("__fs_powi_1", "__fs_powi_8", FIXED(8), "_ZGV_LLVM_N8vv") -TLI_DEFINE_VECFUNC("__fs_powi_1", "__fs_powi_16", FIXED(16), "_ZGV_LLVM_N16vv") TLI_DEFINE_VECFUNC("__ps_powi_1", "__ps_powi_4", FIXED(4), "_ZGV_LLVM_N4vv") TLI_DEFINE_VECFUNC("__ps_powi_1", "__ps_powi_8", FIXED(8), "_ZGV_LLVM_N8vv") -TLI_DEFINE_VECFUNC("__ps_powi_1", "__ps_powi_16", FIXED(16), "_ZGV_LLVM_N16vv") TLI_DEFINE_VECFUNC("__rs_powi_1", "__rs_powi_4", FIXED(4), "_ZGV_LLVM_N4vv") TLI_DEFINE_VECFUNC("__rs_powi_1", "__rs_powi_8", FIXED(8), "_ZGV_LLVM_N8vv") -TLI_DEFINE_VECFUNC("__rs_powi_1", "__rs_powi_16", FIXED(16), "_ZGV_LLVM_N16vv") TLI_DEFINE_VECFUNC("__fd_powi1_1", "__fd_powi1_2", FIXED(2), "_ZGV_LLVM_N2vv") TLI_DEFINE_VECFUNC("__fd_powi1_1", "__fd_powi1_4", FIXED(4), "_ZGV_LLVM_N4vv") -TLI_DEFINE_VECFUNC("__fd_powi1_1", "__fd_powi1_8", FIXED(8), "_ZGV_LLVM_N8vv") TLI_DEFINE_VECFUNC("__fs_powi1_1", "__fs_powi1_4", FIXED(4), "_ZGV_LLVM_N4vv") TLI_DEFINE_VECFUNC("__fs_powi1_1", "__fs_powi1_8", FIXED(8), "_ZGV_LLVM_N8vv") -TLI_DEFINE_VECFUNC("__fs_powi1_1", "__fs_powi1_16", FIXED(16), "_ZGV_LLVM_N16vv") TLI_DEFINE_VECFUNC("__pd_powi1_1", "__pd_powi1_2", FIXED(2), "_ZGV_LLVM_N2vv") TLI_DEFINE_VECFUNC("__pd_powi1_1", "__pd_powi1_4", FIXED(4), "_ZGV_LLVM_N4vv") -TLI_DEFINE_VECFUNC("__pd_powi1_1", "__pd_powi1_8", FIXED(8), "_ZGV_LLVM_N8vv") TLI_DEFINE_VECFUNC("__ps_powi1_1", "__ps_powi1_4", FIXED(4), "_ZGV_LLVM_N4vv") TLI_DEFINE_VECFUNC("__ps_powi1_1", "__ps_powi1_8", FIXED(8), "_ZGV_LLVM_N8vv") -TLI_DEFINE_VECFUNC("__ps_powi1_1", "__ps_powi1_16", FIXED(16), "_ZGV_LLVM_N16vv") TLI_DEFINE_VECFUNC("__rd_powi1_1", "__rd_powi1_2", FIXED(2), "_ZGV_LLVM_N2vv") TLI_DEFINE_VECFUNC("__rd_powi1_1", "__rd_powi1_4", FIXED(4), "_ZGV_LLVM_N4vv") -TLI_DEFINE_VECFUNC("__rd_powi1_1", "__rd_powi1_8", FIXED(8), "_ZGV_LLVM_N8vv") TLI_DEFINE_VECFUNC("__rs_powi1_1", "__rs_powi1_4", FIXED(4), "_ZGV_LLVM_N4vv") TLI_DEFINE_VECFUNC("__rs_powi1_1", "__rs_powi1_8", FIXED(8), "_ZGV_LLVM_N8vv") -TLI_DEFINE_VECFUNC("__rs_powi1_1", "__rs_powi1_16", FIXED(16), "_ZGV_LLVM_N16vv") TLI_DEFINE_VECFUNC("__fd_powk_1", "__fd_powk_2", FIXED(2), "_ZGV_LLVM_N2vv") TLI_DEFINE_VECFUNC("__fd_powk_1", "__fd_powk_4", FIXED(4), "_ZGV_LLVM_N4vv") -TLI_DEFINE_VECFUNC("__fd_powk_1", "__fd_powk_8", FIXED(8), "_ZGV_LLVM_N8vv") TLI_DEFINE_VECFUNC("__fs_powk_1", "__fs_powk_4", FIXED(4), "_ZGV_LLVM_N4vv") TLI_DEFINE_VECFUNC("__fs_powk_1", "__fs_powk_8", FIXED(8), "_ZGV_LLVM_N8vv") -TLI_DEFINE_VECFUNC("__fs_powk_1", "__fs_powk_16", FIXED(16), "_ZGV_LLVM_N16vv") TLI_DEFINE_VECFUNC("__pd_powk_1", "__pd_powk_2", FIXED(2), "_ZGV_LLVM_N2vv") TLI_DEFINE_VECFUNC("__pd_powk_1", "__pd_powk_4", FIXED(4), "_ZGV_LLVM_N4vv") -TLI_DEFINE_VECFUNC("__pd_powk_1", "__pd_powk_8", FIXED(8), "_ZGV_LLVM_N8vv") TLI_DEFINE_VECFUNC("__ps_powk_1", "__ps_powk_4", FIXED(4), "_ZGV_LLVM_N4vv") TLI_DEFINE_VECFUNC("__ps_powk_1", "__ps_powk_8", FIXED(8), "_ZGV_LLVM_N8vv") -TLI_DEFINE_VECFUNC("__ps_powk_1", "__ps_powk_16", FIXED(16), "_ZGV_LLVM_N16vv") TLI_DEFINE_VECFUNC("__rd_powk_1", "__rd_powk_2", FIXED(2), "_ZGV_LLVM_N2vv") TLI_DEFINE_VECFUNC("__rd_powk_1", "__rd_powk_4", FIXED(4), "_ZGV_LLVM_N4vv") -TLI_DEFINE_VECFUNC("__rd_powk_1", "__rd_powk_8", FIXED(8), "_ZGV_LLVM_N8vv") TLI_DEFINE_VECFUNC("__rs_powk_1", "__rs_powk_4", FIXED(4), "_ZGV_LLVM_N4vv") TLI_DEFINE_VECFUNC("__rs_powk_1", "__rs_powk_8", FIXED(8), "_ZGV_LLVM_N8vv") -TLI_DEFINE_VECFUNC("__rs_powk_1", "__rs_powk_16", FIXED(16), "_ZGV_LLVM_N16vv") TLI_DEFINE_VECFUNC("__fd_powk1_1", "__fd_powk1_2", FIXED(2), "_ZGV_LLVM_N2vv") TLI_DEFINE_VECFUNC("__fd_powk1_1", "__fd_powk1_4", FIXED(4), "_ZGV_LLVM_N4vv") -TLI_DEFINE_VECFUNC("__fd_powk1_1", "__fd_powk1_8", FIXED(8), "_ZGV_LLVM_N8vv") TLI_DEFINE_VECFUNC("__fs_powk1_1", "__fs_powk1_4", FIXED(4), "_ZGV_LLVM_N4vv") TLI_DEFINE_VECFUNC("__fs_powk1_1", "__fs_powk1_8", FIXED(8), "_ZGV_LLVM_N8vv") -TLI_DEFINE_VECFUNC("__fs_powk1_1", "__fs_powk1_16", FIXED(16), "_ZGV_LLVM_N16vv") TLI_DEFINE_VECFUNC("__pd_powk1_1", "__pd_powk1_2", FIXED(2), "_ZGV_LLVM_N2vv") TLI_DEFINE_VECFUNC("__pd_powk1_1", "__pd_powk1_4", FIXED(4), "_ZGV_LLVM_N4vv") -TLI_DEFINE_VECFUNC("__pd_powk1_1", "__pd_powk1_8", FIXED(8), "_ZGV_LLVM_N8vv") TLI_DEFINE_VECFUNC("__ps_powk1_1", "__ps_powk1_4", FIXED(4), "_ZGV_LLVM_N4vv") TLI_DEFINE_VECFUNC("__ps_powk1_1", "__ps_powk1_8", FIXED(8), "_ZGV_LLVM_N8vv") -TLI_DEFINE_VECFUNC("__ps_powk1_1", "__ps_powk1_16", FIXED(16), "_ZGV_LLVM_N16vv") TLI_DEFINE_VECFUNC("__rd_powk1_1", "__rd_powk1_2", FIXED(2), "_ZGV_LLVM_N2vv") TLI_DEFINE_VECFUNC("__rd_powk1_1", "__rd_powk1_4", FIXED(4), "_ZGV_LLVM_N4vv") -TLI_DEFINE_VECFUNC("__rd_powk1_1", "__rd_powk1_8", FIXED(8), "_ZGV_LLVM_N8vv") TLI_DEFINE_VECFUNC("__rs_powk1_1", "__rs_powk1_4", FIXED(4), "_ZGV_LLVM_N4vv") TLI_DEFINE_VECFUNC("__rs_powk1_1", "__rs_powk1_8", FIXED(8), "_ZGV_LLVM_N8vv") -TLI_DEFINE_VECFUNC("__rs_powk1_1", "__rs_powk1_16", FIXED(16), "_ZGV_LLVM_N16vv") TLI_DEFINE_VECFUNC("__fd_log10_1", "__fd_log10_2", FIXED(2), "_ZGV_LLVM_N2v") TLI_DEFINE_VECFUNC("__fd_log10_1", "__fd_log10_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__fd_log10_1", "__fd_log10_8", FIXED(8), "_ZGV_LLVM_N8v") TLI_DEFINE_VECFUNC("__fs_log10_1", "__fs_log10_4", FIXED(4), "_ZGV_LLVM_N4v") TLI_DEFINE_VECFUNC("__fs_log10_1", "__fs_log10_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__fs_log10_1", "__fs_log10_16", FIXED(16), "_ZGV_LLVM_N16v") TLI_DEFINE_VECFUNC("__pd_log10_1", "__pd_log10_2", FIXED(2), "_ZGV_LLVM_N2v") TLI_DEFINE_VECFUNC("__pd_log10_1", "__pd_log10_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__pd_log10_1", "__pd_log10_8", FIXED(8), "_ZGV_LLVM_N8v") TLI_DEFINE_VECFUNC("__ps_log10_1", "__ps_log10_4", FIXED(4), "_ZGV_LLVM_N4v") TLI_DEFINE_VECFUNC("__ps_log10_1", "__ps_log10_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__ps_log10_1", "__ps_log10_16", FIXED(16), "_ZGV_LLVM_N16v") TLI_DEFINE_VECFUNC("__rd_log10_1", "__rd_log10_2", FIXED(2), "_ZGV_LLVM_N2v") TLI_DEFINE_VECFUNC("__rd_log10_1", "__rd_log10_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__rd_log10_1", "__rd_log10_8", FIXED(8), "_ZGV_LLVM_N8v") TLI_DEFINE_VECFUNC("__rs_log10_1", "__rs_log10_4", FIXED(4), "_ZGV_LLVM_N4v") TLI_DEFINE_VECFUNC("__rs_log10_1", "__rs_log10_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__rs_log10_1", "__rs_log10_16", FIXED(16), "_ZGV_LLVM_N16v") TLI_DEFINE_VECFUNC("__fd_log_1", "__fd_log_2", FIXED(2), "_ZGV_LLVM_N2v") TLI_DEFINE_VECFUNC("__fd_log_1", "__fd_log_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__fd_log_1", "__fd_log_8", FIXED(8), "_ZGV_LLVM_N8v") TLI_DEFINE_VECFUNC("__fs_log_1", "__fs_log_4", FIXED(4), "_ZGV_LLVM_N4v") TLI_DEFINE_VECFUNC("__fs_log_1", "__fs_log_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__fs_log_1", "__fs_log_16", FIXED(16), "_ZGV_LLVM_N16v") TLI_DEFINE_VECFUNC("__pd_log_1", "__pd_log_2", FIXED(2), "_ZGV_LLVM_N2v") TLI_DEFINE_VECFUNC("__pd_log_1", "__pd_log_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__pd_log_1", "__pd_log_8", FIXED(8), "_ZGV_LLVM_N8v") TLI_DEFINE_VECFUNC("__ps_log_1", "__ps_log_4", FIXED(4), "_ZGV_LLVM_N4v") TLI_DEFINE_VECFUNC("__ps_log_1", "__ps_log_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__ps_log_1", "__ps_log_16", FIXED(16), "_ZGV_LLVM_N16v") TLI_DEFINE_VECFUNC("__rd_log_1", "__rd_log_2", FIXED(2), "_ZGV_LLVM_N2v") TLI_DEFINE_VECFUNC("__rd_log_1", "__rd_log_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__rd_log_1", "__rd_log_8", FIXED(8), "_ZGV_LLVM_N8v") TLI_DEFINE_VECFUNC("__rs_log_1", "__rs_log_4", FIXED(4), "_ZGV_LLVM_N4v") TLI_DEFINE_VECFUNC("__rs_log_1", "__rs_log_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__rs_log_1", "__rs_log_16", FIXED(16), "_ZGV_LLVM_N16v") TLI_DEFINE_VECFUNC("__fs_exp_1", "__fs_exp_4", FIXED(4), "_ZGV_LLVM_N4v") TLI_DEFINE_VECFUNC("__fs_exp_1", "__fs_exp_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__fs_exp_1", "__fs_exp_16", FIXED(16), "_ZGV_LLVM_N16v") TLI_DEFINE_VECFUNC("__pd_exp_1", "__pd_exp_2", FIXED(2), "_ZGV_LLVM_N2v") TLI_DEFINE_VECFUNC("__pd_exp_1", "__pd_exp_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__pd_exp_1", "__pd_exp_8", FIXED(8), "_ZGV_LLVM_N8v") TLI_DEFINE_VECFUNC("__ps_exp_1", "__ps_exp_4", FIXED(4), "_ZGV_LLVM_N4v") TLI_DEFINE_VECFUNC("__ps_exp_1", "__ps_exp_8", FIXED(8), "_ZGV_LLVM_N8v") -TLI_DEFINE_VECFUNC("__ps_exp_1", "__ps_exp_16", FIXED(16), "_ZGV_LLVM_N16v") TLI_DEFINE_VECFUNC("__rd_exp_1", "__rd_exp_2", FIXED(2), "_ZGV_LLVM_N2v") TLI_DEFINE_VECFUNC("__rd_exp_1", "__rd_exp_4", FIXED(4), "_ZGV_LLVM_N4v") -TLI_DEFINE_VECFUNC("__rd_exp_1", "__rd_exp_8", FIXED(8), "_ZGV_LLVM_N8v") TLI_DEFINE_VECFUNC("__rs_exp_1", "__rs_exp_4", FIXED(4), "_ZGV_LLVM_N4v") TLI_DEFINE_VECFUNC("__rs_exp_1", "__rs_exp_8", FIXED(8), "_ZGV_LLVM_N8v") + +#elif defined(TLI_DEFINE_PGMATH_X86_AVX512_VECFUNCS) +TLI_DEFINE_VECFUNC("__fd_sin_1", "__fd_sin_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__fs_sin_1", "__fs_sin_16", FIXED(16), "_ZGV_LLVM_N16v") +TLI_DEFINE_VECFUNC("__pd_sin_1", "__pd_sin_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__ps_sin_1", "__ps_sin_16", FIXED(16), "_ZGV_LLVM_N16v") +TLI_DEFINE_VECFUNC("__rd_sin_1", "__rd_sin_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__rs_sin_1", "__rs_sin_16", FIXED(16), "_ZGV_LLVM_N16v") + +TLI_DEFINE_VECFUNC("__fd_cos_1", "__fd_cos_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__fs_cos_1", "__fs_cos_16", FIXED(16), "_ZGV_LLVM_N16v") +TLI_DEFINE_VECFUNC("__pd_cos_1", "__pd_cos_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__ps_cos_1", "__ps_cos_16", FIXED(16), "_ZGV_LLVM_N16v") +TLI_DEFINE_VECFUNC("__rd_cos_1", "__rd_cos_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__rs_cos_1", "__rs_cos_16", FIXED(16), "_ZGV_LLVM_N16v") + +TLI_DEFINE_VECFUNC("__fd_tan_1", "__fd_tan_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__fs_tan_1", "__fs_tan_16", FIXED(16), "_ZGV_LLVM_N16v") +TLI_DEFINE_VECFUNC("__pd_tan_1", "__pd_tan_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__ps_tan_1", "__ps_tan_16", FIXED(16), "_ZGV_LLVM_N16v") +TLI_DEFINE_VECFUNC("__rd_tan_1", "__rd_tan_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__rs_tan_1", "__rs_tan_16", FIXED(16), "_ZGV_LLVM_N16v") + +TLI_DEFINE_VECFUNC("__fd_sinh_1", "__fd_sinh_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__fs_sinh_1", "__fs_sinh_16", FIXED(16), "_ZGV_LLVM_N16v") +TLI_DEFINE_VECFUNC("__pd_sinh_1", "__pd_sinh_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__ps_sinh_1", "__ps_sinh_16", FIXED(16), "_ZGV_LLVM_N16v") +TLI_DEFINE_VECFUNC("__rd_sinh_1", "__rd_sinh_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__rs_sinh_1", "__rs_sinh_16", FIXED(16), "_ZGV_LLVM_N16v") + +TLI_DEFINE_VECFUNC("__fd_cosh_1", "__fd_cosh_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__fs_cosh_1", "__fs_cosh_16", FIXED(16), "_ZGV_LLVM_N16v") +TLI_DEFINE_VECFUNC("__pd_cosh_1", "__pd_cosh_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__ps_cosh_1", "__ps_cosh_16", FIXED(16), "_ZGV_LLVM_N16v") +TLI_DEFINE_VECFUNC("__rd_cosh_1", "__rd_cosh_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__rs_cosh_1", "__rs_cosh_16", FIXED(16), "_ZGV_LLVM_N16v") + +TLI_DEFINE_VECFUNC("__fd_tanh_1", "__fd_tanh_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__fs_tanh_1", "__fs_tanh_16", FIXED(16), "_ZGV_LLVM_N16v") +TLI_DEFINE_VECFUNC("__pd_tanh_1", "__pd_tanh_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__ps_tanh_1", "__ps_tanh_16", FIXED(16), "_ZGV_LLVM_N16v") +TLI_DEFINE_VECFUNC("__rd_tanh_1", "__rd_tanh_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__rs_tanh_1", "__rs_tanh_16", FIXED(16), "_ZGV_LLVM_N16v") + +TLI_DEFINE_VECFUNC("__fd_asin_1", "__fd_asin_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__fs_asin_1", "__fs_asin_16", FIXED(16), "_ZGV_LLVM_N16v") +TLI_DEFINE_VECFUNC("__pd_asin_1", "__pd_asin_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__ps_asin_1", "__ps_asin_16", FIXED(16), "_ZGV_LLVM_N16v") +TLI_DEFINE_VECFUNC("__rd_asin_1", "__rd_asin_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__rs_asin_1", "__rs_asin_16", FIXED(16), "_ZGV_LLVM_N16v") + +TLI_DEFINE_VECFUNC("__fd_acos_1", "__fd_acos_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__fs_acos_1", "__fs_acos_16", FIXED(16), "_ZGV_LLVM_N16v") +TLI_DEFINE_VECFUNC("__pd_acos_1", "__pd_acos_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__ps_acos_1", "__ps_acos_16", FIXED(16), "_ZGV_LLVM_N16v") +TLI_DEFINE_VECFUNC("__rd_acos_1", "__rd_acos_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__rs_acos_1", "__rs_acos_16", FIXED(16), "_ZGV_LLVM_N16v") + +TLI_DEFINE_VECFUNC("__fd_atan_1", "__fd_atan_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__fs_atan_1", "__fs_atan_16", FIXED(16), "_ZGV_LLVM_N16v") +TLI_DEFINE_VECFUNC("__pd_atan_1", "__pd_atan_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__ps_atan_1", "__ps_atan_16", FIXED(16), "_ZGV_LLVM_N16v") +TLI_DEFINE_VECFUNC("__rd_atan_1", "__rd_atan_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__rs_atan_1", "__rs_atan_16", FIXED(16), "_ZGV_LLVM_N16v") + +TLI_DEFINE_VECFUNC("__fd_atan2_1", "__fd_atan2_8", FIXED(8), "_ZGV_LLVM_N8vv") +TLI_DEFINE_VECFUNC("__fs_atan2_1", "__fs_atan2_16", FIXED(16), "_ZGV_LLVM_N16vv") +TLI_DEFINE_VECFUNC("__pd_atan2_1", "__pd_atan2_8", FIXED(8), "_ZGV_LLVM_N8vv") +TLI_DEFINE_VECFUNC("__ps_atan2_1", "__ps_atan2_16", FIXED(16), "_ZGV_LLVM_N16vv") +TLI_DEFINE_VECFUNC("__rd_atan2_1", "__rd_atan2_8", FIXED(8), "_ZGV_LLVM_N8vv") +TLI_DEFINE_VECFUNC("__rs_atan2_1", "__rs_atan2_16", FIXED(16), "_ZGV_LLVM_N16vv") + +TLI_DEFINE_VECFUNC("__fd_pow_1", "__fd_pow_8", FIXED(8), "_ZGV_LLVM_N8vv") +TLI_DEFINE_VECFUNC("__fs_pow_1", "__fs_pow_16", FIXED(16), "_ZGV_LLVM_N16vv") +TLI_DEFINE_VECFUNC("__pd_pow_1", "__pd_pow_8", FIXED(8), "_ZGV_LLVM_N8vv") +TLI_DEFINE_VECFUNC("__ps_pow_1", "__ps_pow_16", FIXED(16), "_ZGV_LLVM_N16vv") +TLI_DEFINE_VECFUNC("__rd_pow_1", "__rd_pow_8", FIXED(8), "_ZGV_LLVM_N8vv") +TLI_DEFINE_VECFUNC("__rs_pow_1", "__rs_pow_16", FIXED(16), "_ZGV_LLVM_N16vv") + +TLI_DEFINE_VECFUNC("__fs_powi_1", "__fs_powi_16", FIXED(16), "_ZGV_LLVM_N16vv") +TLI_DEFINE_VECFUNC("__ps_powi_1", "__ps_powi_16", FIXED(16), "_ZGV_LLVM_N16vv") +TLI_DEFINE_VECFUNC("__rs_powi_1", "__rs_powi_16", FIXED(16), "_ZGV_LLVM_N16vv") + +TLI_DEFINE_VECFUNC("__fd_powi1_1", "__fd_powi1_8", FIXED(8), "_ZGV_LLVM_N8vv") +TLI_DEFINE_VECFUNC("__fs_powi1_1", "__fs_powi1_16", FIXED(16), "_ZGV_LLVM_N16vv") +TLI_DEFINE_VECFUNC("__pd_powi1_1", "__pd_powi1_8", FIXED(8), "_ZGV_LLVM_N8vv") +TLI_DEFINE_VECFUNC("__ps_powi1_1", "__ps_powi1_16", FIXED(16), "_ZGV_LLVM_N16vv") +TLI_DEFINE_VECFUNC("__rd_powi1_1", "__rd_powi1_8", FIXED(8), "_ZGV_LLVM_N8vv") +TLI_DEFINE_VECFUNC("__rs_powi1_1", "__rs_powi1_16", FIXED(16), "_ZGV_LLVM_N16vv") + +TLI_DEFINE_VECFUNC("__fd_powk_1", "__fd_powk_8", FIXED(8), "_ZGV_LLVM_N8vv") +TLI_DEFINE_VECFUNC("__fs_powk_1", "__fs_powk_16", FIXED(16), "_ZGV_LLVM_N16vv") +TLI_DEFINE_VECFUNC("__pd_powk_1", "__pd_powk_8", FIXED(8), "_ZGV_LLVM_N8vv") +TLI_DEFINE_VECFUNC("__ps_powk_1", "__ps_powk_16", FIXED(16), "_ZGV_LLVM_N16vv") +TLI_DEFINE_VECFUNC("__rd_powk_1", "__rd_powk_8", FIXED(8), "_ZGV_LLVM_N8vv") +TLI_DEFINE_VECFUNC("__rs_powk_1", "__rs_powk_16", FIXED(16), "_ZGV_LLVM_N16vv") + +TLI_DEFINE_VECFUNC("__fd_powk1_1", "__fd_powk1_8", FIXED(8), "_ZGV_LLVM_N8vv") +TLI_DEFINE_VECFUNC("__fs_powk1_1", "__fs_powk1_16", FIXED(16), "_ZGV_LLVM_N16vv") +TLI_DEFINE_VECFUNC("__pd_powk1_1", "__pd_powk1_8", FIXED(8), "_ZGV_LLVM_N8vv") +TLI_DEFINE_VECFUNC("__ps_powk1_1", "__ps_powk1_16", FIXED(16), "_ZGV_LLVM_N16vv") +TLI_DEFINE_VECFUNC("__rd_powk1_1", "__rd_powk1_8", FIXED(8), "_ZGV_LLVM_N8vv") +TLI_DEFINE_VECFUNC("__rs_powk1_1", "__rs_powk1_16", FIXED(16), "_ZGV_LLVM_N16vv") + +TLI_DEFINE_VECFUNC("__fd_log10_1", "__fd_log10_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__fs_log10_1", "__fs_log10_16", FIXED(16), "_ZGV_LLVM_N16v") +TLI_DEFINE_VECFUNC("__pd_log10_1", "__pd_log10_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__ps_log10_1", "__ps_log10_16", FIXED(16), "_ZGV_LLVM_N16v") +TLI_DEFINE_VECFUNC("__rd_log10_1", "__rd_log10_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__rs_log10_1", "__rs_log10_16", FIXED(16), "_ZGV_LLVM_N16v") + +TLI_DEFINE_VECFUNC("__fd_log_1", "__fd_log_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__fs_log_1", "__fs_log_16", FIXED(16), "_ZGV_LLVM_N16v") +TLI_DEFINE_VECFUNC("__pd_log_1", "__pd_log_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__ps_log_1", "__ps_log_16", FIXED(16), "_ZGV_LLVM_N16v") +TLI_DEFINE_VECFUNC("__rd_log_1", "__rd_log_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__rs_log_1", "__rs_log_16", FIXED(16), "_ZGV_LLVM_N16v") + +TLI_DEFINE_VECFUNC("__fs_exp_1", "__fs_exp_16", FIXED(16), "_ZGV_LLVM_N16v") +TLI_DEFINE_VECFUNC("__pd_exp_1", "__pd_exp_8", FIXED(8), "_ZGV_LLVM_N8v") +TLI_DEFINE_VECFUNC("__ps_exp_1", "__ps_exp_16", FIXED(16), "_ZGV_LLVM_N16v") +TLI_DEFINE_VECFUNC("__rd_exp_1", "__rd_exp_8", FIXED(8), "_ZGV_LLVM_N8v") TLI_DEFINE_VECFUNC("__rs_exp_1", "__rs_exp_16", FIXED(16), "_ZGV_LLVM_N16v") #else diff --git a/llvm/include/llvm/Frontend/Driver/CodeGenOptions.h b/llvm/include/llvm/Frontend/Driver/CodeGenOptions.h index 3aaf04b656dc..637e766f0cbd 100644 --- a/llvm/include/llvm/Frontend/Driver/CodeGenOptions.h +++ b/llvm/include/llvm/Frontend/Driver/CodeGenOptions.h @@ -37,7 +37,8 @@ enum class VectorLibrary { }; TargetLibraryInfoImpl *createTLII(llvm::Triple &TargetTriple, - VectorLibrary Veclib); + VectorLibrary Veclib, + bool targetAVX512); } // end namespace llvm::driver diff --git a/llvm/lib/Analysis/TargetLibraryInfo.cpp b/llvm/lib/Analysis/TargetLibraryInfo.cpp index 6a983e2a7064..33b1b8ca64dc 100644 --- a/llvm/lib/Analysis/TargetLibraryInfo.cpp +++ b/llvm/lib/Analysis/TargetLibraryInfo.cpp @@ -36,6 +36,8 @@ static cl::opt ClVectorLibrary( #ifdef ENABLE_CLASSIC_FLANG clEnumValN(TargetLibraryInfoImpl::PGMATH, "PGMATH", "PGI math library"), + clEnumValN(TargetLibraryInfoImpl::PGMATH_AVX512, "PGMATH_AVX512", + "PGI math library (AVX512)"), #endif clEnumValN(TargetLibraryInfoImpl::SVML, "SVML", "Intel SVML library"), @@ -1431,6 +1433,15 @@ void TargetLibraryInfoImpl::addVectorizableFunctionsFromVecLib( } break; } + case PGMATH_AVX512: { + const VecDesc VecFuncs[] = { + #define TLI_DEFINE_PGMATH_X86_AVX512_VECFUNCS + #include "llvm/Analysis/VecFuncs.def" + #undef TLI_DEFINE_PGMATH_X86_AVX512_VECFUNCS + }; + addVectorizableFunctions(VecFuncs); + break; + } #endif case NoLibrary: diff --git a/llvm/lib/Frontend/Driver/CodeGenOptions.cpp b/llvm/lib/Frontend/Driver/CodeGenOptions.cpp index b42803db4011..b0f7989c353c 100644 --- a/llvm/lib/Frontend/Driver/CodeGenOptions.cpp +++ b/llvm/lib/Frontend/Driver/CodeGenOptions.cpp @@ -13,7 +13,8 @@ namespace llvm::driver { TargetLibraryInfoImpl *createTLII(llvm::Triple &TargetTriple, - driver::VectorLibrary Veclib) { + driver::VectorLibrary Veclib, + bool TargetHasAVX512) { TargetLibraryInfoImpl *TLII = new TargetLibraryInfoImpl(TargetTriple); using VectorLibrary = llvm::driver::VectorLibrary; @@ -34,6 +35,9 @@ TargetLibraryInfoImpl *createTLII(llvm::Triple &TargetTriple, case VectorLibrary::PGMATH: TLII->addVectorizableFunctionsFromVecLib(TargetLibraryInfoImpl::PGMATH, TargetTriple); + if (TargetHasAVX512) + TLII->addVectorizableFunctionsFromVecLib( + TargetLibraryInfoImpl::PGMATH_AVX512, TargetTriple); break; #endif case VectorLibrary::SVML: From 8328b7ef0da168fedba6160b5fe4f92aafdb40f4 Mon Sep 17 00:00:00 2001 From: Bryan Chan Date: Thu, 26 Sep 2024 19:06:57 -0400 Subject: [PATCH 55/60] [Driver] Update FileCheck patterns for AArch64 target features LLVM 19 had changed how target feature flags are generated. In particular, the prerequisite flags "+sha2" and "+sha3" to "+sve2-sha3" are now explicit. --- clang/test/Driver/flang/classic-flang-vscale-mbits.f95 | 4 ++-- clang/test/Driver/flang/classic-flang-vscale.f95 | 6 +++--- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/clang/test/Driver/flang/classic-flang-vscale-mbits.f95 b/clang/test/Driver/flang/classic-flang-vscale-mbits.f95 index 40a20baa1c1b..5515deb0925d 100644 --- a/clang/test/Driver/flang/classic-flang-vscale-mbits.f95 +++ b/clang/test/Driver/flang/classic-flang-vscale-mbits.f95 @@ -20,9 +20,9 @@ // CHECK-SVE2-512-DAG: "-vscale_range_min" "4" "-vscale_range_max" "4" // CHECK-SVE2-512PLUS: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sve,+sve2" // CHECK-SVE2-512PLUS-DAG: "-vscale_range_min" "4" "-vscale_range_max" "0" -// CHECK-SVE2SHA3-2048: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sve,+sve2-sha3,+sve2" +// CHECK-SVE2SHA3-2048: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sha2,+sha3,+sve,+sve2,+sve2-sha3" // CHECK-SVE2SHA3-2048-DAG: "-vscale_range_min" "16" "-vscale_range_max" "16" -// CHECK-SVE2SHA3-2048PLUS: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sve,+sve2-sha3,+sve2" +// CHECK-SVE2SHA3-2048PLUS: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sha2,+sha3,+sve,+sve2,+sve2-sha3" // CHECK-SVE2SHA3-2048PLUS-DAG: "-vscale_range_min" "16" "-vscale_range_max" "0" // CHECK-SVE2-SCALABLE: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sve,+sve2" // CHECK-SVE2-SCALABLE-DAG: "-vscale_range_min" "1" "-vscale_range_max" "16" diff --git a/clang/test/Driver/flang/classic-flang-vscale.f95 b/clang/test/Driver/flang/classic-flang-vscale.f95 index a59dbf9c3327..455bfc35c5cf 100644 --- a/clang/test/Driver/flang/classic-flang-vscale.f95 +++ b/clang/test/Driver/flang/classic-flang-vscale.f95 @@ -14,15 +14,15 @@ // CHECK-SVE-DAG: "-vscale_range_min" "1" "-vscale_range_max" "16" // CHECK-SVE2: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sve,+sve2" // CHECK-SVE2-DAG: "-vscale_range_min" "1" "-vscale_range_max" "16" -// CHECK-SVE2SHA3: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sve,+sve2-sha3,+sve2" +// CHECK-SVE2SHA3: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sha2,+sha3,+sve,+sve2,+sve2-sha3" // CHECK-SVE2SHA3-DAG: "-vscale_range_min" "1" "-vscale_range_max" "16" // CHECK-SVE-NOSVE: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,-sve" // CHECK-SVE-NOSVE-NOT: "-vscale_range_min" // CHECK-SVE-NOSVE-NOT: "-vscale_range_max" // CHECK-SVE2-NOSVE2SHA3: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sve,+sve2" // CHECK-SVE2-NOSVE2SHA3-DAG: "-vscale_range_min" "1" "-vscale_range_max" "16" -// CHECK-SVE2SHA3-NOSVE2: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sve,-sve2-sha3,-sve2" +// CHECK-SVE2SHA3-NOSVE2: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sha2,+sha3,+sve,-sve2,-sve2-sha3" // CHECK-SVE2SHA3-NOSVE2-DAG: "-vscale_range_min" "1" "-vscale_range_max" "16" -// CHECK-SVE2SHA3-NOSVE: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,-sve,-sve2-sha3,-sve2" +// CHECK-SVE2SHA3-NOSVE: "-target_features" "+v8a,+fp-armv8,+fullfp16,+neon,+sha2,+sha3,-sve,-sve2,-sve2-sha3" // CHECK-SVE2SHA3-NOSVE-NOT: "-vscale_range_min" // CHECK-SVE2SHA3-NOSVE-NOT: "-vscale_range_max" From c1386f3a1ab77186ed999ec4de5f13e229b91043 Mon Sep 17 00:00:00 2001 From: Bryan Chan Date: Wed, 16 Oct 2024 11:10:20 -0400 Subject: [PATCH 56/60] Partially revert "[flang][OpenMP] Compile proper `omp_lib.mod` from the `openmp/src/include` sources (#80874)" This partially reverts commit fb5fd2d82f9befba9cf5152d1a0c5e6f91ee48f0, in order to remove the use of preprocessor directives in omp_lib.h, which causes the Classic Flang frontend to fail when the including source file is not preprocessed. --- openmp/runtime/src/CMakeLists.txt | 6 ++--- .../{omp_lib.F90.var => omp_lib.f90.var} | 20 ----------------- openmp/runtime/src/include/omp_lib.h.var | 22 ------------------- 3 files changed, 3 insertions(+), 45 deletions(-) rename openmp/runtime/src/include/{omp_lib.F90.var => omp_lib.f90.var} (99%) diff --git a/openmp/runtime/src/CMakeLists.txt b/openmp/runtime/src/CMakeLists.txt index 698e185d9c4d..c0e7b927d79a 100644 --- a/openmp/runtime/src/CMakeLists.txt +++ b/openmp/runtime/src/CMakeLists.txt @@ -366,14 +366,14 @@ endif() # Building the Fortran module files # One compilation step creates both omp_lib.mod and omp_lib_kinds.mod configure_file(${LIBOMP_INC_DIR}/omp_lib.h.var omp_lib.h @ONLY) -configure_file(${LIBOMP_INC_DIR}/omp_lib.F90.var omp_lib.F90 @ONLY) +configure_file(${LIBOMP_INC_DIR}/omp_lib.f90.var omp_lib.f90 @ONLY) set(BUILD_FORTRAN_MODULES False) if (NOT ${LIBOMP_FORTRAN_MODULES_COMPILER} STREQUAL "") # If libomp is built as an LLVM runtime and the flang compiler is available, # compile the Fortran module files. message(STATUS "configuring openmp to build Fortran module files using ${LIBOMP_FORTRAN_MODULES_COMPILER}") - set(LIBOMP_FORTRAN_SOURCE_FILE omp_lib.F90) + set(LIBOMP_FORTRAN_SOURCE_FILE omp_lib.f90) add_custom_target(libomp-mod ALL DEPENDS omp_lib.mod omp_lib_kinds.mod) add_custom_command( OUTPUT omp_lib.mod omp_lib_kinds.mod @@ -393,7 +393,7 @@ elseif(${LIBOMP_FORTRAN_MODULES}) set_target_properties(libomp-mod PROPERTIES FOLDER "OpenMP/Misc") libomp_get_fflags(LIBOMP_CONFIGURED_FFLAGS) if(CMAKE_Fortran_COMPILER_SUPPORTS_F90) - set(LIBOMP_FORTRAN_SOURCE_FILE omp_lib.F90) + set(LIBOMP_FORTRAN_SOURCE_FILE omp_lib.f90) else() message(FATAL_ERROR "Fortran module build requires Fortran 90 compiler") endif() diff --git a/openmp/runtime/src/include/omp_lib.F90.var b/openmp/runtime/src/include/omp_lib.f90.var similarity index 99% rename from openmp/runtime/src/include/omp_lib.F90.var rename to openmp/runtime/src/include/omp_lib.f90.var index 5133915c7d8c..e450360c50b7 100644 --- a/openmp/runtime/src/include/omp_lib.F90.var +++ b/openmp/runtime/src/include/omp_lib.f90.var @@ -430,102 +430,82 @@ end subroutine omp_fulfill_event subroutine omp_init_lock(svar) bind(c) -#ifdef __INTEL_COMPILER !DIR$ IF(__INTEL_COMPILER.GE.1400) !DIR$ attributes known_intrinsic :: omp_init_lock !DIR$ ENDIF -#endif use omp_lib_kinds integer (kind=omp_lock_kind) svar end subroutine omp_init_lock subroutine omp_destroy_lock(svar) bind(c) -#ifdef __INTEL_COMPILER !DIR$ IF(__INTEL_COMPILER.GE.1400) !DIR$ attributes known_intrinsic :: omp_destroy_lock !DIR$ ENDIF -#endif use omp_lib_kinds integer (kind=omp_lock_kind) svar end subroutine omp_destroy_lock subroutine omp_set_lock(svar) bind(c) -#ifdef __INTEL_COMPILER !DIR$ IF(__INTEL_COMPILER.GE.1400) !DIR$ attributes known_intrinsic :: omp_set_lock !DIR$ ENDIF -#endif use omp_lib_kinds integer (kind=omp_lock_kind) svar end subroutine omp_set_lock subroutine omp_unset_lock(svar) bind(c) -#ifdef __INTEL_COMPILER !DIR$ IF(__INTEL_COMPILER.GE.1400) !DIR$ attributes known_intrinsic :: omp_unset_lock !DIR$ ENDIF -#endif use omp_lib_kinds integer (kind=omp_lock_kind) svar end subroutine omp_unset_lock function omp_test_lock(svar) bind(c) -#ifdef __INTEL_COMPILER !DIR$ IF(__INTEL_COMPILER.GE.1400) !DIR$ attributes known_intrinsic :: omp_test_lock !DIR$ ENDIF -#endif use omp_lib_kinds logical (kind=omp_logical_kind) omp_test_lock integer (kind=omp_lock_kind) svar end function omp_test_lock subroutine omp_init_nest_lock(nvar) bind(c) -#ifdef __INTEL_COMPILER !DIR$ IF(__INTEL_COMPILER.GE.1400) !DIR$ attributes known_intrinsic :: omp_init_nest_lock !DIR$ ENDIF -#endif use omp_lib_kinds integer (kind=omp_nest_lock_kind) nvar end subroutine omp_init_nest_lock subroutine omp_destroy_nest_lock(nvar) bind(c) -#ifdef __INTEL_COMPILER !DIR$ IF(__INTEL_COMPILER.GE.1400) !DIR$ attributes known_intrinsic :: omp_destroy_nest_lock !DIR$ ENDIF -#endif use omp_lib_kinds integer (kind=omp_nest_lock_kind) nvar end subroutine omp_destroy_nest_lock subroutine omp_set_nest_lock(nvar) bind(c) -#ifdef __INTEL_COMPILER !DIR$ IF(__INTEL_COMPILER.GE.1400) !DIR$ attributes known_intrinsic :: omp_set_nest_lock !DIR$ ENDIF -#endif use omp_lib_kinds integer (kind=omp_nest_lock_kind) nvar end subroutine omp_set_nest_lock subroutine omp_unset_nest_lock(nvar) bind(c) -#ifdef __INTEL_COMPILER !DIR$ IF(__INTEL_COMPILER.GE.1400) !DIR$ attributes known_intrinsic :: omp_unset_nest_lock !DIR$ ENDIF -#endif use omp_lib_kinds integer (kind=omp_nest_lock_kind) nvar end subroutine omp_unset_nest_lock function omp_test_nest_lock(nvar) bind(c) -#ifdef __INTEL_COMPILER !DIR$ IF(__INTEL_COMPILER.GE.1400) !DIR$ attributes known_intrinsic :: omp_test_nest_lock !DIR$ ENDIF -#endif use omp_lib_kinds integer (kind=omp_integer_kind) omp_test_nest_lock integer (kind=omp_nest_lock_kind) nvar diff --git a/openmp/runtime/src/include/omp_lib.h.var b/openmp/runtime/src/include/omp_lib.h.var index db1dc889d129..74f4c2c6aa43 100644 --- a/openmp/runtime/src/include/omp_lib.h.var +++ b/openmp/runtime/src/include/omp_lib.h.var @@ -488,102 +488,82 @@ end subroutine omp_fulfill_event subroutine omp_init_lock(svar) bind(c) -#ifdef __INTEL_COMPILER !DIR$ IF(__INTEL_COMPILER.GE.1400) !DIR$ attributes known_intrinsic :: omp_init_lock !DIR$ ENDIF -#endif import integer (kind=omp_lock_kind) svar end subroutine omp_init_lock subroutine omp_destroy_lock(svar) bind(c) -#ifdef __INTEL_COMPILER !DIR$ IF(__INTEL_COMPILER.GE.1400) !DIR$ attributes known_intrinsic :: omp_destroy_lock !DIR$ ENDIF -#endif import integer (kind=omp_lock_kind) svar end subroutine omp_destroy_lock subroutine omp_set_lock(svar) bind(c) -#ifdef __INTEL_COMPILER !DIR$ IF(__INTEL_COMPILER.GE.1400) !DIR$ attributes known_intrinsic :: omp_set_lock !DIR$ ENDIF -#endif import integer (kind=omp_lock_kind) svar end subroutine omp_set_lock subroutine omp_unset_lock(svar) bind(c) -#ifdef __INTEL_COMPILER !DIR$ IF(__INTEL_COMPILER.GE.1400) !DIR$ attributes known_intrinsic :: omp_unset_lock !DIR$ ENDIF -#endif import integer (kind=omp_lock_kind) svar end subroutine omp_unset_lock function omp_test_lock(svar) bind(c) -#ifdef __INTEL_COMPILER !DIR$ IF(__INTEL_COMPILER.GE.1400) !DIR$ attributes known_intrinsic :: omp_test_lock !DIR$ ENDIF -#endif import logical (kind=omp_logical_kind) omp_test_lock integer (kind=omp_lock_kind) svar end function omp_test_lock subroutine omp_init_nest_lock(nvar) bind(c) -#ifdef __INTEL_COMPILER !DIR$ IF(__INTEL_COMPILER.GE.1400) !DIR$ attributes known_intrinsic :: omp_init_nest_lock !DIR$ ENDIF -#endif import integer (kind=omp_nest_lock_kind) nvar end subroutine omp_init_nest_lock subroutine omp_destroy_nest_lock(nvar) bind(c) -#ifdef __INTEL_COMPILER !DIR$ IF(__INTEL_COMPILER.GE.1400) !DIR$ attributes known_intrinsic :: omp_destroy_nest_lock !DIR$ ENDIF -#endif import integer (kind=omp_nest_lock_kind) nvar end subroutine omp_destroy_nest_lock subroutine omp_set_nest_lock(nvar) bind(c) -#ifdef __INTEL_COMPILER !DIR$ IF(__INTEL_COMPILER.GE.1400) !DIR$ attributes known_intrinsic :: omp_set_nest_lock !DIR$ ENDIF -#endif import integer (kind=omp_nest_lock_kind) nvar end subroutine omp_set_nest_lock subroutine omp_unset_nest_lock(nvar) bind(c) -#ifdef __INTEL_COMPILER !DIR$ IF(__INTEL_COMPILER.GE.1400) !DIR$ attributes known_intrinsic :: omp_unset_nest_lock !DIR$ ENDIF -#endif import integer (kind=omp_nest_lock_kind) nvar end subroutine omp_unset_nest_lock function omp_test_nest_lock(nvar) bind(c) -#ifdef __INTEL_COMPILER !DIR$ IF(__INTEL_COMPILER.GE.1400) !DIR$ attributes known_intrinsic :: omp_test_nest_lock !DIR$ ENDIF -#endif import integer (kind=omp_integer_kind) omp_test_nest_lock integer (kind=omp_nest_lock_kind) nvar @@ -1012,7 +992,6 @@ end subroutine kmp_set_warnings_off end interface -#ifdef __INTEL_COMPILER !DIR$ IF DEFINED (__INTEL_OFFLOAD) !DIR$ IF(__INTEL_COMPILER.LT.1900) @@ -1181,4 +1160,3 @@ !$omp declare target(omp_init_nest_lock_with_hint ) !DIR$ ENDIF !DIR$ ENDIF -#endif From 72c7d135d28217e7c91ae5fa5ed19b416ad709f9 Mon Sep 17 00:00:00 2001 From: Bryan Chan Date: Mon, 21 Oct 2024 13:17:12 -0400 Subject: [PATCH 57/60] [Driver] Enable Classic Flang cross-compilation, e.g. from X86 to AArch64 Co-authored-by: Prabhdeep Singh Soni --- clang/lib/Driver/ToolChains/ClassicFlang.cpp | 13 ++++++++++--- clang/lib/Driver/ToolChains/Linux.cpp | 6 +++++- .../Driver/flang/classic-flang-cross-compile.F95 | 15 +++++++++++++++ clang/test/lit.cfg.py | 2 ++ 4 files changed, 32 insertions(+), 4 deletions(-) create mode 100644 clang/test/Driver/flang/classic-flang-cross-compile.F95 diff --git a/clang/lib/Driver/ToolChains/ClassicFlang.cpp b/clang/lib/Driver/ToolChains/ClassicFlang.cpp index 7c99ac70fcf2..6354b32a18ca 100644 --- a/clang/lib/Driver/ToolChains/ClassicFlang.cpp +++ b/clang/lib/Driver/ToolChains/ClassicFlang.cpp @@ -668,7 +668,11 @@ void ClassicFlang::ConstructJob(Compilation &C, const JobAction &JA, /***** Upper part of the Fortran frontend *****/ // TODO do we need to invoke this under GDB sometimes? - const char *UpperExec = Args.MakeArgString(getToolChain().GetProgramPath("flang1")); + std::string flang1 = "flang1"; + if (getToolChain().isCrossCompiling()) + flang1 = getToolChain().getEffectiveTriple().getTriple() + "-" + flang1; + const char *UpperExec = + Args.MakeArgString(getToolChain().GetProgramPath(flang1.c_str())); UpperCmdArgs.push_back("-opt"); UpperCmdArgs.push_back(Args.MakeArgString(OptOStr)); UpperCmdArgs.push_back("-terse"); UpperCmdArgs.push_back("1"); @@ -998,8 +1002,11 @@ void ClassicFlang::ConstructJob(Compilation &C, const JobAction &JA, Args.hasArg(options::OPT_E)) return; /***** Lower part of Fortran frontend *****/ - - const char *LowerExec = Args.MakeArgString(getToolChain().GetProgramPath("flang2")); + std::string flang2 = "flang2"; + if (getToolChain().isCrossCompiling()) + flang2 = getToolChain().getEffectiveTriple().getTriple() + "-" + flang2; + const char *LowerExec = + Args.MakeArgString(getToolChain().GetProgramPath(flang2.c_str())); // TODO FLANG arg handling LowerCmdArgs.push_back("-fn"); LowerCmdArgs.push_back(Input.getBaseInput()); diff --git a/clang/lib/Driver/ToolChains/Linux.cpp b/clang/lib/Driver/ToolChains/Linux.cpp index b320b8249edb..562ff80a2dd1 100644 --- a/clang/lib/Driver/ToolChains/Linux.cpp +++ b/clang/lib/Driver/ToolChains/Linux.cpp @@ -666,7 +666,11 @@ void Linux::AddFlangSystemIncludeArgs(const ArgList &DriverArgs, { SmallString<128> P(D.Dir); - llvm::sys::path::append(P, "../include"); + if (isCrossCompiling()) + llvm::sys::path::append(P, "../include", + getEffectiveTriple().getTriple()); + else + llvm::sys::path::append(P, "../include"); IncludePathList.push_back(P.c_str()); } diff --git a/clang/test/Driver/flang/classic-flang-cross-compile.F95 b/clang/test/Driver/flang/classic-flang-cross-compile.F95 new file mode 100644 index 000000000000..8ab407d175d2 --- /dev/null +++ b/clang/test/Driver/flang/classic-flang-cross-compile.F95 @@ -0,0 +1,15 @@ +! REQUIRES: classic_flang +! REQUIRES: host-x86_64 + +! Check if the cross-compiling flang1/flang2 binaries and include paths +! are used by Clang when cross-compiling. + +! RUN: %clang --driver-mode=flang -target aarch64-unknown-linux-gnu %s -### 2>&1 \ +! RUN: | FileCheck %s + +! RUN: %clang --driver-mode=flang -target aarch64-linux-gnu %s -### 2>&1 \ +! RUN: | FileCheck %s + +! CHECK: aarch64-unknown-linux-gnu-flang1 +! CHECK-SAME: include/aarch64-unknown-linux-gnu +! CHECK: aarch64-unknown-linux-gnu-flang2 diff --git a/clang/test/lit.cfg.py b/clang/test/lit.cfg.py index 24355e3787d5..4a2b447fd59e 100644 --- a/clang/test/lit.cfg.py +++ b/clang/test/lit.cfg.py @@ -370,3 +370,5 @@ def calculate_arch_features(arch_string): if config.use_classic_flang: config.available_features.add("classic_flang") + +config.available_features.add("host-" + config.host_arch) From d037c2d8203aa20bbff0b7837d15435d7d9d81a7 Mon Sep 17 00:00:00 2001 From: Bryan Chan Date: Sat, 2 Nov 2024 18:21:03 -0400 Subject: [PATCH 58/60] [build] Modify build script to support a cross-compiling toolchain Also modified cmake/Modules/GetClangResourceDir.cmake to work around a missing definition for PACKAGE_VERSION when cross-compiling OpenMP libraries. --- build-llvm-project.sh | 81 ++++++++++++++++++------- cmake/Modules/GetClangResourceDir.cmake | 6 +- 2 files changed, 65 insertions(+), 22 deletions(-) diff --git a/build-llvm-project.sh b/build-llvm-project.sh index e36a50625dea..3f57dcb0d9b3 100755 --- a/build-llvm-project.sh +++ b/build-llvm-project.sh @@ -4,13 +4,14 @@ TARGET="X86" BUILD_TYPE="Release" INSTALL_PREFIX="/usr/local" +CROSS_TARGETS="" NPROC=1 USE_CCACHE="0" DO_INSTALL="0" USE_SUDO="0" C_COMPILER_PATH="/usr/bin/gcc" CXX_COMPILER_PATH="/usr/bin/g++" -LLVM_ENABLE_PROJECTS="clang;openmp" +LLVM_EXTRA_PROJECTS="" EXTRA_CMAKE_OPTS="" VERBOSE="" @@ -19,41 +20,42 @@ set -e # Exit script on first error. function print_usage { echo "Usage: ./build-llvm-project.sh [options]"; echo ""; - echo "Build and install classic-flang-llvm-project."; + echo "Build and install classic-flang-llvm-project (including clang, lld, and openmp)."; echo "Run this script in a directory with project sources."; echo "Example:"; echo " $ git clone https://github.com/flang-compiler/classic-flang-llvm-project"; echo " $ cd classic-flang-llvm-project"; - echo " $ .github/workflows/build-llvm-project.sh -t X86 -p /install/prefix/ \\"; - echo " $ -a /usr/bin/gcc-10 -b /usr/bin/g++-10 -i -s"; + echo " $ ./build-llvm-project.sh -t X86 -p /opt/classic-flang/ -i -s"; echo ""; echo "Options:"; echo " -t Target to build for (X86, AArch64, PowerPC). Default: X86"; echo " -d Set the CMake build type. Default: Release"; echo " -p Install prefix. Default: /usr/local"; + echo " -X Cross-compile OpenMP for given list of target triples. Default: none"; echo " -n Number of parallel jobs. Default: 1"; echo " -c Use ccache. Default: 0 - do not use ccache"; echo " -i Install the build. Default 0 - just build, do not install"; echo " -s Use sudo to install. Default: 0 - do not use sudo"; echo " -a C compiler path. Default: /usr/bin/gcc"; echo " -b C++ compiler path. Default: /usr/bin/g++"; - echo " -e List of the LLVM sub-projects to build. Default: clang;openmp"; + echo " -e List of additional LLVM sub-projects to build. Default: none"; echo " -x Extra CMake options. Default: ''"; echo " -v Enable verbose output"; } -while getopts "t:d:p:n:cisa:b:e:x:v?" opt; do +while getopts "t:d:p:X:n:cisa:b:e:x:v?" opt; do case "$opt" in t) TARGET=$OPTARG;; d) BUILD_TYPE=$OPTARG;; p) INSTALL_PREFIX=$OPTARG;; + X) CROSS_TARGETS=$OPTARG;; n) NPROC=$OPTARG;; c) USE_CCACHE="1";; i) DO_INSTALL="1";; s) USE_SUDO="1";; a) C_COMPILER_PATH=$OPTARG;; b) CXX_COMPILER_PATH=$OPTARG;; - e) LLVM_ENABLE_PROJECTS=$OPTARG;; + e) LLVM_EXTRA_PROJECTS=$OPTARG;; x) EXTRA_CMAKE_OPTS="$OPTARG";; v) VERBOSE="1";; ?) print_usage; exit 0;; @@ -61,14 +63,7 @@ while getopts "t:d:p:n:cisa:b:e:x:v?" opt; do done CMAKE_OPTIONS="-DCMAKE_INSTALL_PREFIX=$INSTALL_PREFIX \ - -DCMAKE_BUILD_TYPE=$BUILD_TYPE \ - -DCMAKE_C_COMPILER=$C_COMPILER_PATH \ - -DCMAKE_CXX_COMPILER=$CXX_COMPILER_PATH \ - -DLLVM_TARGETS_TO_BUILD=$TARGET \ - -DLLVM_ENABLE_CLASSIC_FLANG=ON \ - -DFLANG_BUILD_NEW_DRIVER=OFF" -# Warning: the -DLLVM_ENABLE_PROJECTS option is specified with cmake -# to avoid issues with nested quotation marks + -DCMAKE_BUILD_TYPE=$BUILD_TYPE" if [ $USE_CCACHE == "1" ]; then echo "Build using ccache" @@ -77,16 +72,19 @@ if [ $USE_CCACHE == "1" ]; then -DCMAKE_CXX_COMPILER_LAUNCHER=ccache" fi -if [ -n "$EXTRA_CMAKE_OPTS" ]; then - CMAKE_OPTIONS="$CMAKE_OPTIONS $EXTRA_CMAKE_OPTS" -fi - -# Build and install +# Build and install. mkdir -p build && cd build if [ -n "$VERBOSE" ]; then set -x fi -cmake $CMAKE_OPTIONS -DLLVM_ENABLE_PROJECTS=$LLVM_ENABLE_PROJECTS ../llvm +cmake $CMAKE_OPTIONS \ + -DCMAKE_C_COMPILER=$C_COMPILER_PATH \ + -DCMAKE_CXX_COMPILER=$CXX_COMPILER_PATH \ + -DLLVM_ENABLE_CLASSIC_FLANG=ON \ + -DLLVM_ENABLE_PROJECTS="clang;lld;openmp;$LLVM_EXTRA_PROJECTS" \ + -DLLVM_TARGETS_TO_BUILD="$TARGET" \ + $EXTRA_CMAKE_OPTS \ + ../llvm set +x make -j$NPROC VERBOSE=$VERBOSE if [ $DO_INSTALL == "1" ]; then @@ -100,3 +98,44 @@ if [ $DO_INSTALL == "1" ]; then fi cd .. +# Cross-compile OpenMP libraries if requested. +IFS=';' read -ra CROSS_TARGET_LIST <<< "$CROSS_TARGETS" +for T in ${CROSS_TARGET_LIST[@]}; do + mkdir -p "build/openmp-$T" + pushd "build/openmp-$T" + CMAKE_OPTIONS="$CMAKE_OPTIONS \ + -DCMAKE_AR=$INSTALL_PREFIX/bin/llvm-ar \ + -DCMAKE_ASM_COMPILER=$INSTALL_PREFIX/bin/clang \ + -DCMAKE_ASM_COMPILER_TARGET=$T \ + -DCMAKE_C_COMPILER=$INSTALL_PREFIX/bin/clang \ + -DCMAKE_C_COMPILER_TARGET=$T \ + -DCMAKE_CXX_COMPILER=$INSTALL_PREFIX/bin/clang++ \ + -DCMAKE_CXX_COMPILER_TARGET=$T \ + -DCMAKE_RANLIB=$INSTALL_PREFIX/bin/llvm-ranlib \ + -DCMAKE_SHARED_LINKER_FLAGS=-fuse-ld=lld" + if [ -n "$VERBOSE" ]; then + set -x + fi + cmake $CMAKE_OPTIONS \ + -DLLVM_DEFAULT_TARGET_TRIPLE=$T \ + -DLLVM_ENABLE_PER_TARGET_RUNTIME_DIR=ON \ + -DLLVM_ENABLE_RUNTIMES="openmp" \ + -DLIBOMP_OMPT_SUPPORT=OFF \ + -DOPENMP_ENABLE_LIBOMPTARGET=OFF \ + -DOPENMP_ENABLE_OMPT_TOOLS=OFF \ + -DOPENMP_LLVM_TOOLS_DIR=$PWD/../bin \ + $EXTRA_CMAKE_OPTS \ + ../../runtimes + set +x + make -j$NPROC VERBOSE=$VERBOSE + if [ $DO_INSTALL -eq 1 ]; then + if [ $USE_SUDO -eq 1 ]; then + echo "Install with sudo" + sudo make install + else + echo "Install without sudo" + make install + fi + fi + popd +done diff --git a/cmake/Modules/GetClangResourceDir.cmake b/cmake/Modules/GetClangResourceDir.cmake index def5bd60424e..026f3e9a1e2c 100644 --- a/cmake/Modules/GetClangResourceDir.cmake +++ b/cmake/Modules/GetClangResourceDir.cmake @@ -13,7 +13,11 @@ function(get_clang_resource_dir out_var) set(ret_dir bin/${CLANG_RESOURCE_DIR}) else() if (NOT CLANG_VERSION_MAJOR) - string(REGEX MATCH "^[0-9]+" CLANG_VERSION_MAJOR ${PACKAGE_VERSION}) + if (NOT PACKAGE_VERSION) + string(REGEX MATCH "^[0-9]+" CLANG_VERSION_MAJOR ${LLVM_VERSION_MAJOR}) + else() + string(REGEX MATCH "^[0-9]+" CLANG_VERSION_MAJOR ${PACKAGE_VERSION}) + endif() endif() set(ret_dir lib${LLVM_LIBDIR_SUFFIX}/clang/${CLANG_VERSION_MAJOR}) endif() From 9f13cf8931e59feb9bffc4854073e7dd1b2cc431 Mon Sep 17 00:00:00 2001 From: Bryan Chan Date: Wed, 19 Feb 2025 12:39:00 -0500 Subject: [PATCH 59/60] Revert "[flang][Driver] Support -print-supported-cpus and associated aliases (#117199)" This reverts commit 23d7a6cedb5198535086a67586487f19effbd411, which added support for PrecompileJobAction to LLVM Flang, in order to support the -print-supported-cpus option in fc1. Currently, Classic Flang does not support this option or the PrecompileJobAction. --- clang/include/clang/Driver/Options.td | 20 ++------ clang/lib/Driver/Driver.cpp | 6 +-- clang/lib/Driver/ToolChains/Flang.cpp | 18 ++------ .../include/flang/Frontend/FrontendOptions.h | 6 +-- flang/lib/Frontend/CompilerInvocation.cpp | 2 - flang/test/Driver/print-supported-cpus.f90 | 46 ------------------- flang/tools/flang-driver/fc1_main.cpp | 24 ---------- 7 files changed, 11 insertions(+), 111 deletions(-) delete mode 100644 flang/test/Driver/print-supported-cpus.f90 diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td index 1462b4cc4f5d..7af3a7e204d7 100644 --- a/clang/include/clang/Driver/Options.td +++ b/clang/include/clang/Driver/Options.td @@ -6028,24 +6028,12 @@ def target : Joined<["--"], "target=">, Flags<[NoXarchOption]>, def darwin_target_variant : Separate<["-"], "darwin-target-variant">, Flags<[NoXarchOption]>, Visibility<[ClangOption, CLOption]>, HelpText<"Generate code for an additional runtime variant of the deployment target">; - -//===----------------------------------------------------------------------===// -// Print CPU info options (clang, clang-cl, flang) -//===----------------------------------------------------------------------===// - -let Visibility = [ClangOption, CC1Option, CLOption, FlangOption, FC1Option] in { - def print_supported_cpus : Flag<["-", "--"], "print-supported-cpus">, Group, - HelpText<"Print supported cpu models for the given target (if target is not " - "specified,it will print the supported cpus for the default target)">, + Visibility<[ClangOption, CC1Option, CLOption]>, + HelpText<"Print supported cpu models for the given target (if target is not specified," + " it will print the supported cpus for the default target)">, MarshallingInfoFlag>; - -def : Flag<["-"], "mcpu=help">, Alias; -def : Flag<["-"], "mtune=help">, Alias; - -} // let Visibility = [ClangOption, CC1Option, CLOption, FlangOption, FC1Option] - def print_supported_extensions : Flag<["-", "--"], "print-supported-extensions">, Visibility<[ClangOption, CC1Option, CLOption]>, HelpText<"Print supported -march extensions (RISC-V, AArch64 and ARM only)">, @@ -6055,6 +6043,8 @@ def print_enabled_extensions : Flag<["-", "--"], "print-enabled-extensions">, HelpText<"Print the extensions enabled by the given target and -march/-mcpu options." " (AArch64 and RISC-V only)">, MarshallingInfoFlag>; +def : Flag<["-"], "mcpu=help">, Alias; +def : Flag<["-"], "mtune=help">, Alias; def time : Flag<["-"], "time">, HelpText<"Time individual commands">; def traditional_cpp : Flag<["-", "--"], "traditional-cpp">, diff --git a/clang/lib/Driver/Driver.cpp b/clang/lib/Driver/Driver.cpp index 20e9bb6b8cde..8b9765d26832 100644 --- a/clang/lib/Driver/Driver.cpp +++ b/clang/lib/Driver/Driver.cpp @@ -4634,8 +4634,7 @@ void Driver::BuildActions(Compilation &C, DerivedArgList &Args, // Use the -mcpu=? flag as the dummy input to cc1. Actions.clear(); - Action *InputAc = C.MakeAction( - *A, IsFlangMode() ? types::TY_Fortran : types::TY_C); + Action *InputAc = C.MakeAction(*A, types::TY_C); Actions.push_back( C.MakeAction(InputAc, types::TY_Nothing)); for (auto &I : Inputs) @@ -6904,8 +6903,7 @@ bool Driver::ShouldUseFlangCompiler(const JobAction &JA) const { return false; // And say "no" if this is not a kind of action flang understands. - if (!isa(JA) && !isa(JA) && - !isa(JA) + if (!isa(JA) && !isa(JA) #ifndef ENABLE_CLASSIC_FLANG && !isa(JA) #endif diff --git a/clang/lib/Driver/ToolChains/Flang.cpp b/clang/lib/Driver/ToolChains/Flang.cpp index 1ae865f37911..bdaca25503f3 100644 --- a/clang/lib/Driver/ToolChains/Flang.cpp +++ b/clang/lib/Driver/ToolChains/Flang.cpp @@ -777,9 +777,6 @@ void Flang::ConstructJob(Compilation &C, const JobAction &JA, } } else if (isa(JA)) { CmdArgs.push_back("-emit-obj"); - } else if (isa(JA)) { - // The precompile job action is only needed for options such as -mcpu=help. - // Those will already have been handled by the fc1 driver. } else { assert(false && "Unexpected action class for Flang tool."); } @@ -952,6 +949,8 @@ void Flang::ConstructJob(Compilation &C, const JobAction &JA, CmdArgs.push_back(Output.getFilename()); } + assert(Input.isFilename() && "Invalid input."); + if (Args.getLastArg(options::OPT_save_temps_EQ)) Args.AddLastArg(CmdArgs, options::OPT_save_temps_EQ); @@ -971,18 +970,7 @@ void Flang::ConstructJob(Compilation &C, const JobAction &JA, } } - // The input could be Ty_Nothing when "querying" options such as -mcpu=help - // are used. - ArrayRef FrontendInputs = Input; - if (Input.isNothing()) - FrontendInputs = {}; - - for (const InputInfo &Input : FrontendInputs) { - if (Input.isFilename()) - CmdArgs.push_back(Input.getFilename()); - else - Input.getInputArg().renderAsInput(Args, CmdArgs); - } + CmdArgs.push_back(Input.getFilename()); const char *Exec = Args.MakeArgString(D.GetProgramPath("flang", TC)); C.addCommand(std::make_unique(JA, *this, diff --git a/flang/include/flang/Frontend/FrontendOptions.h b/flang/include/flang/Frontend/FrontendOptions.h index a4cb021e309d..82ca99672ec6 100644 --- a/flang/include/flang/Frontend/FrontendOptions.h +++ b/flang/include/flang/Frontend/FrontendOptions.h @@ -236,8 +236,7 @@ class FrontendInputFile { struct FrontendOptions { FrontendOptions() : showHelp(false), showVersion(false), instrumentedParse(false), - showColors(false), printSupportedCPUs(false), - needProvenanceRangeToCharBlockMappings(false) {} + showColors(false), needProvenanceRangeToCharBlockMappings(false) {} /// Show the -help text. unsigned showHelp : 1; @@ -251,9 +250,6 @@ struct FrontendOptions { /// Enable color diagnostics. unsigned showColors : 1; - /// Print the supported cpus for the current target - unsigned printSupportedCPUs : 1; - /// Enable Provenance to character-stream mapping. Allows e.g. IDEs to find /// symbols based on source-code location. This is not needed in regular /// compilation. diff --git a/flang/lib/Frontend/CompilerInvocation.cpp b/flang/lib/Frontend/CompilerInvocation.cpp index 68b5950d3a51..7d03ad676e61 100644 --- a/flang/lib/Frontend/CompilerInvocation.cpp +++ b/flang/lib/Frontend/CompilerInvocation.cpp @@ -638,8 +638,6 @@ static bool parseFrontendArgs(FrontendOptions &opts, llvm::opt::ArgList &args, 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.printSupportedCPUs = - args.hasArg(clang::driver::options::OPT_print_supported_cpus); // Get the input kind (from the value passed via `-x`) InputKind dashX(Language::Unknown); diff --git a/flang/test/Driver/print-supported-cpus.f90 b/flang/test/Driver/print-supported-cpus.f90 deleted file mode 100644 index 60b725d4e1dc..000000000000 --- a/flang/test/Driver/print-supported-cpus.f90 +++ /dev/null @@ -1,46 +0,0 @@ -! Test --print-supported-cpus and associated aliases, -mcpu=help and -! -mtune=help - -! RUN: %if x86-registered-target %{ \ -! RUN: %flang --target=x86_64-unknown-linux-gnu --print-supported-cpus 2>&1 \ -! RUN: | FileCheck %s --check-prefixes=X86,CHECK \ -! RUN: %} -! RUN: %if x86-registered-target %{ \ -! RUN: %flang --target=x86_64-unknown-linux-gnu -mcpu=help 2>&1 \ -! RUN: | FileCheck %s --check-prefixes=X86,CHECK \ -! RUN: %} -! RUN: %if x86-registered-target %{ \ -! RUN: %flang --target=x86_64-unknown-linux-gnu -mtune=help 2>&1 \ -! RUN: | FileCheck %s --check-prefixes=X86,CHECK \ -! RUN: %} - -! RUN: %if aarch64-registered-target %{ \ -! RUN: %flang --target=aarch64-unknown-linux-gnu --print-supported-cpus 2>&1 \ -! RUN: | FileCheck %s --check-prefixes=AARCH64,CHECK \ -! RUN: %} -! RUN: %if aarch64-registered-target %{ \ -! RUN: %flang --target=aarch64-unknown-linux-gnu -mcpu=help 2>&1 \ -! RUN: | FileCheck %s --check-prefixes=AARCH64,CHECK \ -! RUN: %} -! RUN: %if aarch64-registered-target %{ \ -! RUN: %flang --target=aarch64-unknown-linux-gnu -mtune=help 2>&1 \ -! RUN: | FileCheck %s --check-prefixes=AARCH64,CHECK \ -! RUN: %} - -! CHECK-NOT: warning: argument unused during compilation - -! X86: Target: x86_64-unknown-linux-gnu -! X86: corei7 - -! AARCH64: Target: aarch64-unknown-linux-gnu -! AARCH64: cortex-a73 -! AARCH64: cortex-a75 - -! The footer displayed contains a reference to clang. This should be changed to -! flang, but that requires a change in llvm/MCSubtargetInfo. When that happens, -! this test will need to be updated and this comment can be removed. - -! CHECK: Use -mcpu or -mtune to specify the target's processor. -! CHECK: For example, clang --target=aarch64-unknown-linux-gnu - - end program diff --git a/flang/tools/flang-driver/fc1_main.cpp b/flang/tools/flang-driver/fc1_main.cpp index 561a0dd5524e..b5b062aaac26 100644 --- a/flang/tools/flang-driver/fc1_main.cpp +++ b/flang/tools/flang-driver/fc1_main.cpp @@ -21,35 +21,15 @@ #include "flang/Frontend/TextDiagnosticBuffer.h" #include "flang/FrontendTool/Utils.h" #include "clang/Driver/DriverDiagnostic.h" -#include "llvm/MC/TargetRegistry.h" #include "llvm/Option/Arg.h" #include "llvm/Option/ArgList.h" #include "llvm/Option/OptTable.h" #include "llvm/Support/TargetSelect.h" -#include "llvm/Support/raw_ostream.h" #include using namespace Fortran::frontend; -/// Print supported cpus of the given target. -static int printSupportedCPUs(llvm::StringRef triple) { - std::string error; - const llvm::Target *target = - llvm::TargetRegistry::lookupTarget(triple, error); - if (!target) { - llvm::errs() << error; - return 1; - } - - // the target machine will handle the mcpu printing - llvm::TargetOptions targetOpts; - std::unique_ptr targetMachine( - target->createTargetMachine(triple, "", "+cpuhelp", targetOpts, - std::nullopt)); - return 0; -} - int fc1_main(llvm::ArrayRef argv, const char *argv0) { // Create CompilerInstance std::unique_ptr flang(new CompilerInstance()); @@ -78,10 +58,6 @@ int fc1_main(llvm::ArrayRef argv, const char *argv0) { llvm::InitializeAllTargetMCs(); llvm::InitializeAllAsmPrinters(); - // --print-supported-cpus takes priority over the actual compilation. - if (flang->getFrontendOpts().printSupportedCPUs) - return printSupportedCPUs(flang->getInvocation().getTargetOpts().triple); - diagsBuffer->flushDiagnostics(flang->getDiagnostics()); if (!success) From f45eb31a155efa9979a7918189632989bcde634b Mon Sep 17 00:00:00 2001 From: Bryan Chan Date: Tue, 8 Apr 2025 18:18:17 -0400 Subject: [PATCH 60/60] [Driver] Make linker command generation compatible with LLVM Flang Upstream commit 1c0958bd95076 had changed how the -nostdlib option affects the linker command generated by the Classic Flang driver. This patch updates the Classic Flang test case to ensure that the behaviour is consistent with the LLVM Flang driver. --- clang/test/Driver/flang/classic-flang.f95 | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/clang/test/Driver/flang/classic-flang.f95 b/clang/test/Driver/flang/classic-flang.f95 index f19e1e7ae1fe..75edb96db745 100644 --- a/clang/test/Driver/flang/classic-flang.f95 +++ b/clang/test/Driver/flang/classic-flang.f95 @@ -129,10 +129,11 @@ ! CHECK-NOSTDLIB: "{{.*}}ld{{(.exe)?}}" ! CHECK-NOSTDLIB-SAME: "{{[^"]*}}classic-flang-{{[^ ]*}}.o" ! CHECK-NOSTDLIB-NOT: "-lflangmain" -! CHECK-NOSTDLIB-SAME: "-lfoo" "-L{{[^ ]*[/\\]+}}basic_linux_tree{{[/\\]+}}usr{{[/\\]+}}lib" +! CHECK-NOSTDLIB-SAME: "-lfoo" +! CHECK-NOSTDLIB-NOT: "-L{{[^ ]*[/\\]+}}basic_linux_tree{{[/\\]+}}usr{{[/\\]+}}lib" ! CHECK-NOSTDLIB-NOT: "-lflang" "-lflangrti" "-lpgmath" ! CHECK-NOSTDLIB-NOT: "-lpthread" "-lrt" -! CHECK-NOSTDLIB: "-lm" +! CHECK-NOSTDLIB-NOT: "-lm" ! CHECK-NOSTDLIB-NOT: "-lgcc" ! CHECK-NOSTDLIB-NOT: "-lgcc_s" ! CHECK-NOSTDLIB-NOT: "-lc"