Ml intrinsics

flang/CMakeLists.txt

@@ -23,7 +23,13 @@ endif()
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules")
 include(AddFlang)
 
-option(FLANG_ENABLE_WERROR "Fail and stop building flang if a warning is triggered." OFF)
+if (MSVC)
+  set(_FLANG_ENABLE_WERROR_DEFAULT OFF)
+else ()
+  set(_FLANG_ENABLE_WERROR_DEFAULT "${LLVM_ENABLE_WERROR}")
+endif()
+option(FLANG_ENABLE_WERROR "Fail and stop building flang if a warning is triggered."
+       "${_FLANG_ENABLE_WERROR_DEFAULT}")
 
 # Check for a standalone build and configure as appropriate from
 # there.
@@ -40,7 +46,7 @@ if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
     mark_as_advanced(LLVM_ENABLE_ASSERTIONS)
   endif()
 
-  # We need a pre-built/installed version of LLVM.
+  # We need a pre-built/installed version of LLVM and MLIR.
   find_package(LLVM REQUIRED HINTS "${LLVM_CMAKE_PATH}")
   # If the user specifies a relative path to LLVM_DIR, the calls to include
   # LLVM modules fail. Append the absolute path to LLVM_DIR instead.
@@ -53,14 +59,18 @@ if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
     find_package(Clang REQUIRED HINTS "${CLANG_DIR}")
   endif()
 
+  find_package(MLIR REQUIRED HINTS "${MLIR_CMAKE_PATH}")
+  list(APPEND CMAKE_MODULE_PATH ${MLIR_DIR})
+
   # If LLVM links to zlib we need the imported targets so we can too.
   if(LLVM_ENABLE_ZLIB)
     find_package(ZLIB REQUIRED)
   endif()
   option(LLVM_ENABLE_PEDANTIC "Compile with pedantic enabled." ON)
-  if(CMAKE_COMPILER_IS_GNUCXX)
-    set(USE_NO_MAYBE_UNINITIALIZED 1)
-  endif()
+
+  # They are used as destination of target generators.
+  set(LLVM_RUNTIME_OUTPUT_INTDIR ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/bin)
+  set(LLVM_LIBRARY_OUTPUT_INTDIR ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/lib${LLVM_LIBDIR_SUFFIX})
 
   include(CMakeParseArguments)
   include(AddLLVM)
@@ -98,6 +108,8 @@ if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
   # should not be suppressed).
   include_directories(SYSTEM ${LLVM_INCLUDE_DIRS})
   add_definitions(${LLVM_DEFINITIONS})
+  include_directories(SYSTEM ${MLIR_INCLUDE_DIRS})
+  add_definitions(${MLIR_DEFINITIONS})
 
   # LLVM's cmake configuration files currently sneak in a c++11 flag.
   # We look for it here and remove it from Flang's compile flags to
@@ -115,6 +127,10 @@ if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
 
   link_directories("${LLVM_LIBRARY_DIR}")
 
+  set(LLVM_TOOLS_BINARY_DIR ${TOOLS_BINARY_DIR} CACHE PATH "Path to llvm/bin")
+  find_program(MLIR_TABLEGEN_EXE "mlir-tblgen" ${LLVM_TOOLS_BINARY_DIR}
+    NO_DEFAULT_PATH)
+
   set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
   set(CMAKE_LIBRARY_OUTPUT_DIRECTORY
     ${CMAKE_BINARY_DIR}/lib${LLVM_LIBDIR_SUFFIX})
@@ -176,12 +192,7 @@ else()
          ${LLVM_INCLUDE_TESTS})
   set(FLANG_GTEST_AVAIL 1)
 
-  if(FLANG_STANDALONE_BUILD)
-    set(FLANG_BINARY_DIR ${CMAKE_BINARY_DIR}/tools/flang)
-  else()
-    set(FLANG_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
-  endif()
-
+  set(FLANG_BINARY_DIR ${CMAKE_BINARY_DIR}/tools/flang)
   set(BACKEND_PACKAGE_STRING "${PACKAGE_STRING}")
   set(MLIR_MAIN_SRC_DIR ${LLVM_MAIN_SRC_DIR}/../mlir/include ) # --src-root
   set(MLIR_INCLUDE_DIR ${LLVM_MAIN_SRC_DIR}/../mlir/include ) # --includedir
@@ -206,19 +217,33 @@ if(FLANG_BUILD_NEW_DRIVER)
     include_directories(SYSTEM ${CLANG_INCLUDE_DIR})
 endif()
 
-# tco tool and FIR lib output directories
-if(FLANG_STANDALONE_BUILD)
-  set(LLVM_RUNTIME_OUTPUT_INTDIR ${CMAKE_BINARY_DIR}/bin)
-  set(LLVM_LIBRARY_OUTPUT_INTDIR ${CMAKE_BINARY_DIR}/lib)
-endif()
-# Always build tco tool
-set(LLVM_BUILD_TOOLS ON)
-
 # Add Flang-centric modules to cmake path.
 include_directories(BEFORE
   ${FLANG_BINARY_DIR}/include
   ${FLANG_SOURCE_DIR}/include)
 
+if(MLIR_SOURCE_DIR)
+  include_directories(BEFORE
+    ${FLANG_BINARY_DIR}/include
+    ${FLANG_SOURCE_DIR}/include
+    ${MLIR_BINARY_DIR}/include
+    ${MLIR_SOURCE_DIR}/include
+    )
+  set(MLIR_MAIN_SRC_DIR ${MLIR_SOURCE_DIR})
+  set(MLIR_INCLUDE_DIR ${MLIR_SOURCE_DIR}/include)
+else()
+  include_directories(BEFORE
+    ${FLANG_BINARY_DIR}/include
+    ${FLANG_SOURCE_DIR}/include
+    ${MLIR_BINARY_DIR}/include
+    )
+  set(MLIR_MAIN_SRC_DIR ${MLIR_BINARY_DIR})
+  set(MLIR_INCLUDE_DIR ${MLIR_BINARY_DIR}/include)
+endif()
+
+set(MLIR_TABLEGEN_EXE mlir-tblgen)
+
+# Add Flang-centric modules to cmake path.
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules")
 
 if (NOT DEFAULT_SYSROOT)
@@ -306,6 +331,9 @@ if (FLANG_ENABLE_WERROR)
     append("-Werror" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
     append("-Wno-error" CMAKE_REQUIRED_FLAGS)
   endif( LLVM_COMPILER_IS_GCC_COMPATIBLE )
+  if (NOT LLVM_ENABLE_WERROR)
+      message(WARNING "FLANG_ENABLE_WERROR setting is different from LLVM_ENABLE_WERROR.")
+  endif()
 endif()
 
 # Builtin check_cxx_compiler_flag doesn't seem to work correctly
@@ -342,6 +370,10 @@ if (LLVM_COMPILER_IS_GCC_COMPATIBLE)
   set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DDEBUGF18")
   set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} -DCHECK=\"(void)\"")
 
+  if (GCC)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --gcc-toolchain=${GCC}")
+  endif()
+
   # Building shared libraries is bad for performance with GCC by default
   # due to the need to preserve the right to override external entry points
   if (BUILD_SHARED_LIBS AND NOT (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
@@ -387,12 +419,18 @@ endif()
 add_subdirectory(runtime)
 
 if (FLANG_INCLUDE_TESTS)
+  enable_testing()
   add_subdirectory(test)
   if (FLANG_GTEST_AVAIL)
     add_subdirectory(unittests)
   endif ()
 endif()
 
+option(FLANG_INCLUDE_TESTS
+       "Generate build targets for the Flang unit tests."
+       ON)
+enable_testing()
+
 option(FLANG_INCLUDE_DOCS "Generate build targets for the Flang docs."
        ${LLVM_INCLUDE_DOCS})
 if (FLANG_INCLUDE_DOCS)
@@ -431,5 +469,6 @@ if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
     PATTERN "*.td"
     PATTERN "config.h" EXCLUDE
     PATTERN ".git"     EXCLUDE
-    PATTERN "CMakeFiles" EXCLUDE)
+    PATTERN "CMakeFiles" EXCLUDE
+    PATTERN "*")
 endif()

flang/README.md

@@ -1,26 +1,13 @@
-# Flang
 
-Flang is a ground-up implementation of a Fortran front end written in modern
-C++. It started off as the f18 project (https://github.com/flang-compiler/f18)
-with an aim to replace the previous flang project
-(https://github.com/flang-compiler/flang) and address its various deficiencies.
-F18 was subsequently accepted into the LLVM project and rechristened as Flang.
+# FIR
 
-## Getting Started
+This file should not be upstreamed to llvm-project.
 
-Read more about flang in the [docs directory](docs).
-Start with the [compiler overview](docs/Overview.md).
+## Monorepo now contains Flang!
 
-To better understand Fortran as a language
-and the specific grammar accepted by flang,
-read [Fortran For C Programmers](docs/FortranForCProgrammers.md)
-and
-flang's specifications of the [Fortran grammar](docs/f2018-grammar.md)
-and
-the [OpenMP grammar](docs/OpenMP-4.5-grammar.md).
+### In-tree build
 
-Treatment of language extensions is covered
-in [this document](docs/Extensions.md).
+1. Get the stuff.
 
 To understand the compilers handling of intrinsics,
 see the [discussion of intrinsics](docs/Intrinsics.md).
@@ -36,112 +23,90 @@ also review [how flang uses modern C++ features](docs/C++17.md).
 If you are interested in writing new documentation, follow 
 [markdown style guide from LLVM](https://github.com/llvm/llvm-project/blob/main/llvm/docs/MarkdownQuickstartTemplate.md).
 
-## Supported C++ compilers
+2. Get "on" the right branches.
 
-Flang is written in C++17.
+```
+  (cd f18-llvm-project ; git checkout fir-dev)
+```
 
-The code has been compiled and tested with
-GCC versions from 7.2.0 to 9.3.0.
+3. (not needed!)
+
+4. Create a build space for cmake and make (or ninja)
 
-The code has been compiled and tested with
-clang version 7.0, 8.0, 9.0 and 10.0
-using either GNU's libstdc++ or LLVM's libc++.
+```
+  mkdir build
+  cd build
+  cmake ../f18-llvm-project/llvm -DCMAKE_BUILD_TYPE=RelWithDebInfo -DLLVM_TARGETS_TO_BUILD=X86 -DLLVM_ENABLE_PROJECTS="flang;mlir" -DCMAKE_CXX_STANDARD=17 -DLLVM_BUILD_TOOLS=On -DLLVM_INSTALL_UTILS=On <other-arguments>
+```
 
-The code has been compiled on
-AArch64, x86\_64 and ppc64le servers
-with CentOS7, Ubuntu18.04, Rhel, MacOs, Mojave, XCode and
-Apple Clang version 10.0.1.
+5. Build everything
 
-The code does not compile with Windows and a compiler that does not have
-support for C++17.
+```
+  make
+  make check-flang
+  make install
+```
 
-## Building Flang out of tree
-These instructions are for building Flang separately from LLVM; if you are
-building Flang alongside LLVM then follow the standard LLVM build instructions
-and add flang to `LLVM_ENABLE_PROJECTS` instead, as detailed there.
+### Out-of-tree build
 
-### LLVM dependency
+Assuming someone was nice enough to build MLIR and LLVM libraries and
+install them in a convenient place for you, then you may want to do a
+standalone build.
 
-The instructions to build LLVM can be found at
-https://llvm.org/docs/GettingStarted.html. If you are building flang as part
-of LLVM, follow those instructions and add flang to `LLVM_ENABLE_PROJECTS`.
+1. Get the stuff is the same as above. Get the code from the same repos.
 
-We highly recommend using the same compiler to compile both llvm and flang.
+2. Get on the right branches. Again, same as above.
 
-The flang CMakeList.txt file uses
-the variable `LLVM_DIR` to find the installed LLVM components
-and
-the variable `MLIR_DIR` to find the installed MLIR components.
+3. Create a build space for cmake and make (or ninja)
 
-To get the correct LLVM and MLIR libraries included in your flang build,
-define LLVM_DIR and MLIR_DIR on the cmake command line.
 ```
-LLVM=<LLVM_BUILD_DIR>/lib/cmake/llvm \
-MLIR=<LLVM_BUILD_DIR>/lib/cmake/mlir \
-cmake -DLLVM_DIR=$LLVM -DMLIR_DIR=$MLIR ...
+  mkdir build
+  cd build
+  export CC=<my-favorite-C-compiler>
+  export CXX=<my-favorite-C++-compiler>
+  cmake -GNinja ../f18-llvm-project/llvm -DCMAKE_BUILD_TYPE=Release -DLLVM_TARGETS_TO_BUILD=X86 -DLLVM_ENABLE_PROJECTS=mlir -DCMAKE_CXX_STANDARD=17 -DLLVM_BUILD_TOOLS=On -DLLVM_INSTALL_UTILS=On -DCMAKE_INSTALL_PREFIX=<install-llvm-here> <other-arguments>
 ```
-where `LLVM_BUILD_DIR` is
-the top-level directory where LLVM was built.
-
-### Building flang with GCC
 
-By default,
-cmake will search for g++ on your PATH.
-The g++ version must be one of the supported versions
-in order to build flang.
-
-Or, cmake will use the variable CXX to find the C++ compiler. CXX should include
-the full path to the compiler or a name that will be found on your PATH, e.g.
-g++-8.3, assuming g++-8.3 is on your PATH.
+5. Build and install
 
 ```
-export CXX=g++-8.3
+  ninja
+  ninja install
 ```
-or
+
+6. Add the new installation to your PATH
+
 ```
-CXX=/opt/gcc-8.3/bin/g++-8.3 cmake ...
+  PATH=<install-llvm-here>/bin:$PATH
 ```
 
-### Building flang with clang
+7. Create a build space for another round of cmake and make (or ninja)
 
-To build flang with clang,
-cmake needs to know how to find clang++
-and the GCC library and tools that were used to build clang++.
-
-CXX should include the full path to clang++
-or clang++ should be found on your PATH.
 ```
-export CXX=clang++
+  mkdir build-flang
+  cd build-flang
+  cmake -GNinja ../f18 -DLLVM_DIR=<install-llvm-here> -DCMAKE_BUILD_TYPE=RelWithDebInfo -DLLVM_TARGETS_TO_BUILD=X86 -DCMAKE_CXX_STANDARD=17 -DLLVM_BUILD_TOOLS=On -DCMAKE_INSTALL_PREFIX=<install-flang-here> <other-arguments>
 ```
+Note: if you plan on running lit regression tests, you should either:
+- Use `-DLLVM_DIR=<build-llvm-here>` instead of `-DLLVM_DIR=<install-llvm-here>`
+- Or, keep `-DLLVM_DIR=<install-llvm-here>` but add `-DLLVM_EXTERNAL_LIT=<path to llvm-lit>`.
+A valid `llvm-lit` path is `<build-llvm-here>/bin/llvm-lit`.
+Note that LLVM must also have been built with `-DLLVM_INSTALL_UTILS=On` so that tools required by tests like `FileCheck` are available in `<install-llvm-here>`.
 
-### Installation Directory
-
-To specify a custom install location,
-add
-`-DCMAKE_INSTALL_PREFIX=<INSTALL_PREFIX>`
-to the cmake command
-where `<INSTALL_PREFIX>`
-is the path where flang should be installed.
+8. Build and install
 
-### Build Types
+```
+  ninja
+  ninja check-flang
+  ninja install
+```
 
-To create a debug build,
-add
-`-DCMAKE_BUILD_TYPE=Debug`
-to the cmake command.
-Debug builds execute slowly.
+### Running regression tests
 
-To create a release build,
-add
-`-DCMAKE_BUILD_TYPE=Release`
-to the cmake command.
-Release builds execute quickly.
+Inside `build` for in-tree builds or inside `build-flang` for out-of-tree builds:
 
-### Build Flang out of tree
 ```
-cd ~/flang/build
-cmake -DLLVM_DIR=$LLVM -DMLIR_DIR=$MLIR ~/flang/src
-make
+  ninja check-flang
 ```
 
 ### Build The New Flang Driver
@@ -217,7 +182,7 @@ make check-flang
 # How to Generate Documentation
 
 ## Generate FIR Documentation
-If flang was built with `-DLINK_WITH_FIR=On` (`On` by default), it is possible to
+It is possible to
 generate FIR language documentation by running `make flang-doc`. This will
 create `docs/Dialect/FIRLangRef.md` in flang build directory.