diff --git a/.travis.yml b/.travis.yml index 3b9bd094a90..cad1a2faa78 100644 --- a/.travis.yml +++ b/.travis.yml @@ -7,30 +7,21 @@ git: matrix: include: - os: linux - d: ldc + d: ldc-beta env: LLVM_VERSION=9.0.0 OPTS="-DBUILD_SHARED_LIBS=ON -DRT_SUPPORT_SANITIZERS=ON" - os: linux - d: ldc-beta + d: ldc-0.17.6 env: LLVM_VERSION=8.0.0 OPTS="-DBUILD_SHARED_LIBS=OFF" # FIXME: strange crashes, possibly due to C++ compiler mismatch #- os: linux # d: ldc # env: LLVM_VERSION=7.0.1 OPTS="-DBUILD_SHARED_LIBS=ON" - os: linux - d: ldc-beta - env: LLVM_VERSION=6.0.1 OPTS="-DBUILD_SHARED_LIBS=OFF -DLIB_SUFFIX=64 -DRT_SUPPORT_SANITIZERS=ON" - - os: linux - d: ldc - env: LLVM_VERSION=5.0.2 OPTS="-DBUILD_SHARED_LIBS=ON -DLIB_SUFFIX=64" - - os: linux - d: ldc-0.17.6 - env: LLVM_VERSION=4.0.0 OPTS="-DLIB_SUFFIX=64" - - os: linux - d: dmd - env: LLVM_VERSION=3.9.1 + d: dmd-beta + env: LLVM_VERSION=6.0.1 OPTS="-DLIB_SUFFIX=64" - os: osx osx_image: xcode10.3 - d: dmd + d: dmd-beta env: LLVM_VERSION=10.0.0 OPTS="-DBUILD_SHARED_LIBS=ON -DRT_SUPPORT_SANITIZERS=ON" - os: osx osx_image: xcode10.3 @@ -45,9 +36,6 @@ cache: - llvm-7.0.1 - llvm-7.0.0 - llvm-6.0.1 - - llvm-5.0.2 - - llvm-4.0.0 - - llvm-3.9.1 addons: apt: @@ -134,11 +122,6 @@ script: # dmd-testsuite-debug only to reduce time-outs DMD_TESTSUITE_MAKE_ARGS=-j3 ctest -V -R "build-run-dmd-testsuite|dmd-testsuite-debug" else - if [ "$LLVM_VERSION" = "3.9.1" ]; then - # FIXME: assertion failure for runnable/mars1.d with DMD/LLVM 3.9.1 - # job (debug only, release passes) - rm tests/d2/dmd-testsuite/runnable/mars1.d - fi DMD_TESTSUITE_MAKE_ARGS=-j3 ctest -V -R "dmd-testsuite" fi # Run defaultlib unittests & druntime stand-alone tests diff --git a/CMakeLists.txt b/CMakeLists.txt index 592a70bca5c..b527cbf565e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -31,7 +31,7 @@ endfunction() # Locate LLVM. # -find_package(LLVM 3.9 REQUIRED +find_package(LLVM 6.0 REQUIRED all-targets analysis asmparser asmprinter bitreader bitwriter codegen core debuginfodwarf debuginfomsf debuginfopdb demangle instcombine ipo instrumentation irreader libdriver linker lto mc @@ -304,14 +304,11 @@ if (UNIX AND NOT "${LLVM_LDFLAGS}" STREQUAL "") endif() if(MSVC) separate_arguments(LLVM_LDFLAGS WINDOWS_COMMAND "${LLVM_LDFLAGS}") - # LLVM 5.0+ requires diaguids.lib from MS Debug Interface Access SDK - if(NOT (LDC_LLVM_VER LESS 500)) - if(NOT MSVC_IDE) # apparently not needed for VS (and spaces in path are problematic) - if(CMAKE_SIZEOF_VOID_P EQUAL 8) - list(APPEND LLVM_LDFLAGS "$ENV{VSINSTALLDIR}DIA SDK\\lib\\amd64\\diaguids.lib") - else() - list(APPEND LLVM_LDFLAGS "$ENV{VSINSTALLDIR}DIA SDK\\lib\\diaguids.lib") - endif() + if(NOT MSVC_IDE) # apparently not needed for VS (and spaces in path are problematic) + if(CMAKE_SIZEOF_VOID_P EQUAL 8) + list(APPEND LLVM_LDFLAGS "$ENV{VSINSTALLDIR}DIA SDK\\lib\\amd64\\diaguids.lib") + else() + list(APPEND LLVM_LDFLAGS "$ENV{VSINSTALLDIR}DIA SDK\\lib\\diaguids.lib") endif() endif() else() @@ -453,10 +450,7 @@ include(HandleLTOPGOBuildOptions) set(LDC_DYNAMIC_COMPILE "AUTO" CACHE STRING "Support dynamic compilation (ON|OFF). Enabled by default.") option(LDC_DYNAMIC_COMPILE_USE_CUSTOM_PASSES "Use custom LDC passes in jit" ON) if(LDC_DYNAMIC_COMPILE STREQUAL "AUTO") - set(LDC_DYNAMIC_COMPILE OFF) - if (NOT (LDC_LLVM_VER LESS 500)) - set(LDC_DYNAMIC_COMPILE ON) - endif() + set(LDC_DYNAMIC_COMPILE ON) endif() message(STATUS "Building LDC with dynamic compilation support: ${LDC_DYNAMIC_COMPILE} (LDC_DYNAMIC_COMPILE=${LDC_DYNAMIC_COMPILE})") if(LDC_DYNAMIC_COMPILE) @@ -489,8 +483,7 @@ append("-DLDC_HOST_FE_VER=${D_COMPILER_FE_VERSION}" LDC_CXXFLAGS) # LLD integration (requires headers & libs) # if(NOT DEFINED LDC_WITH_LLD) - if(((LDC_LLVM_VER LESS 600) AND (EXISTS "${LLVM_INCLUDE_DIRS}/lld/Driver/Driver.h")) OR - ((NOT LDC_LLVM_VER LESS 600) AND (EXISTS "${LLVM_INCLUDE_DIRS}/lld/Common/Driver.h"))) + if(EXISTS "${LLVM_INCLUDE_DIRS}/lld/Common/Driver.h") set(LDC_WITH_LLD ON) else() set(LDC_WITH_LLD OFF) @@ -600,22 +593,13 @@ if(LDC_WITH_LLD) set(LDC_LINKERFLAG_LIST -lLLVMSymbolize ${LDC_LINKERFLAG_LIST}) endif() endif() - # ELF, Mach-O, MinGW and WebAssembly formats supported since LLD 6.0.0, otherwise just Windows COFF - if(NOT (LDC_LLVM_VER LESS 600)) - if(MSVC) - list(APPEND LDC_LINKERFLAG_LIST lldDriver.lib lldMinGW.lib lldCOFF.lib lldELF.lib lldMachO.lib lldWasm.lib lldYAML.lib lldReaderWriter.lib lldCommon.lib lldCore.lib) - else() - set(LDC_LINKERFLAG_LIST -llldDriver -llldMinGW -llldCOFF -llldELF -llldMachO -llldWasm -llldYAML -llldReaderWriter -llldCommon -llldCore ${LDC_LINKERFLAG_LIST}) - endif() - if(APPLE) # bug, should be fixed in LLVM 6.0.1 - list(APPEND LDC_LINKERFLAG_LIST -lxml2) - endif() + if(MSVC) + list(APPEND LDC_LINKERFLAG_LIST lldDriver.lib lldMinGW.lib lldCOFF.lib lldELF.lib lldMachO.lib lldWasm.lib lldYAML.lib lldReaderWriter.lib lldCommon.lib lldCore.lib) else() - if(MSVC) - list(APPEND LDC_LINKERFLAG_LIST lldCOFF.lib lldCore.lib lldDriver.lib) - else() - set(LDC_LINKERFLAG_LIST -llldCOFF -llldCore -llldDriver ${LDC_LINKERFLAG_LIST}) - endif() + set(LDC_LINKERFLAG_LIST -llldDriver -llldMinGW -llldCOFF -llldELF -llldMachO -llldWasm -llldYAML -llldReaderWriter -llldCommon -llldCore ${LDC_LINKERFLAG_LIST}) + endif() + if(APPLE) # bug, should be fixed in LLVM 6.0.1 + list(APPEND LDC_LINKERFLAG_LIST -lxml2) endif() endif() @@ -723,14 +707,14 @@ function(copy_and_rename_file source_path target_path) endfunction() # -# Locate LLVM's LTO binary and use it (LLVM >= 3.9) +# Locate LLVM's LTO binary and use it # if(APPLE) set(LDC_INSTALL_LTOPLUGIN_DEFAULT ON) else() set(LDC_INSTALL_LTOPLUGIN_DEFAULT OFF) endif() -set(LDC_INSTALL_LTOPLUGIN ${LDC_INSTALL_LTOPLUGIN_DEFAULT} CACHE BOOL "Copy/install the LTO plugin from the LLVM package when available (LLVM >= 3.9).") +set(LDC_INSTALL_LTOPLUGIN ${LDC_INSTALL_LTOPLUGIN_DEFAULT} CACHE BOOL "Copy/install the LTO plugin from the LLVM package when available.") if (LDC_INSTALL_LTOPLUGIN) if(APPLE) set(LLVM_LTO_BINARY ${LLVM_LIBRARY_DIRS}/libLTO.dylib) @@ -776,16 +760,13 @@ include(CheckTypeSize) check_type_size(void* ptr_size) if (LDC_INSTALL_LLVM_RUNTIME_LIBS) # Locate LLVM sanitizer runtime libraries, and copy them to our lib folder - # Note: libFuzzer is part of compiler-rt version >= 6.0, but was part of LLVM =< 5.0 if(APPLE) copy_compilerrt_lib("darwin/libclang_rt.asan_osx_dynamic.dylib" "libldc_rt.asan.dylib" TRUE) copy_compilerrt_lib("darwin/libclang_rt.osx.a" "libldc_rt.builtins.a" FALSE) copy_compilerrt_lib("darwin/libclang_rt.profile_osx.a" "libldc_rt.profile.a" FALSE) - if(NOT (LDC_LLVM_VER LESS 600)) - copy_compilerrt_lib("darwin/libclang_rt.fuzzer_osx.a" "libldc_rt.fuzzer.a" FALSE) - copy_compilerrt_lib("darwin/libclang_rt.xray_osx.a" "libldc_rt.xray.a" FALSE) - endif() + copy_compilerrt_lib("darwin/libclang_rt.fuzzer_osx.a" "libldc_rt.fuzzer.a" FALSE) + copy_compilerrt_lib("darwin/libclang_rt.xray_osx.a" "libldc_rt.xray.a" FALSE) if(NOT (LDC_LLVM_VER LESS 700)) copy_compilerrt_lib("darwin/libclang_rt.xray-basic_osx.a" "libldc_rt.xray-basic.a" FALSE) copy_compilerrt_lib("darwin/libclang_rt.xray-fdr_osx.a" "libldc_rt.xray-fdr.a" FALSE) @@ -798,12 +779,8 @@ if (LDC_INSTALL_LLVM_RUNTIME_LIBS) copy_compilerrt_lib("${LDC_INSTALL_LLVM_RUNTIME_LIBS_OS}/libclang_rt.asan-${LDC_INSTALL_LLVM_RUNTIME_LIBS_ARCH}.a" "libldc_rt.asan.a" FALSE) copy_compilerrt_lib("${LDC_INSTALL_LLVM_RUNTIME_LIBS_OS}/libclang_rt.builtins-${LDC_INSTALL_LLVM_RUNTIME_LIBS_ARCH}.a" "libldc_rt.builtins.a" FALSE) copy_compilerrt_lib("${LDC_INSTALL_LLVM_RUNTIME_LIBS_OS}/libclang_rt.profile-${LDC_INSTALL_LLVM_RUNTIME_LIBS_ARCH}.a" "libldc_rt.profile.a" FALSE) - if(NOT (LDC_LLVM_VER LESS 500)) - copy_compilerrt_lib("${LDC_INSTALL_LLVM_RUNTIME_LIBS_OS}/libclang_rt.xray-${LDC_INSTALL_LLVM_RUNTIME_LIBS_ARCH}.a" "libldc_rt.xray.a" FALSE) - endif() - if(NOT (LDC_LLVM_VER LESS 600)) - copy_compilerrt_lib("${LDC_INSTALL_LLVM_RUNTIME_LIBS_OS}/libclang_rt.fuzzer-${LDC_INSTALL_LLVM_RUNTIME_LIBS_ARCH}.a" "libldc_rt.fuzzer.a" FALSE) - endif() + copy_compilerrt_lib("${LDC_INSTALL_LLVM_RUNTIME_LIBS_OS}/libclang_rt.xray-${LDC_INSTALL_LLVM_RUNTIME_LIBS_ARCH}.a" "libldc_rt.xray.a" FALSE) + copy_compilerrt_lib("${LDC_INSTALL_LLVM_RUNTIME_LIBS_OS}/libclang_rt.fuzzer-${LDC_INSTALL_LLVM_RUNTIME_LIBS_ARCH}.a" "libldc_rt.fuzzer.a" FALSE) if(NOT (LDC_LLVM_VER LESS 700)) copy_compilerrt_lib("${LDC_INSTALL_LLVM_RUNTIME_LIBS_OS}/libclang_rt.xray-basic-${LDC_INSTALL_LLVM_RUNTIME_LIBS_ARCH}.a" "libldc_rt.xray-basic.a" FALSE) copy_compilerrt_lib("${LDC_INSTALL_LLVM_RUNTIME_LIBS_OS}/libclang_rt.xray-fdr-${LDC_INSTALL_LLVM_RUNTIME_LIBS_ARCH}.a" "libldc_rt.xray-fdr.a" FALSE) @@ -817,28 +794,14 @@ if (LDC_INSTALL_LLVM_RUNTIME_LIBS) copy_compilerrt_lib("windows/clang_rt.asan-${compilerrt_arch_suffix}.lib" "ldc_rt.asan.lib" FALSE) copy_compilerrt_lib("windows/clang_rt.builtins-${compilerrt_arch_suffix}.lib" "ldc_rt.builtins.lib" FALSE) copy_compilerrt_lib("windows/clang_rt.profile-${compilerrt_arch_suffix}.lib" "ldc_rt.profile.lib" FALSE) - if(NOT (LDC_LLVM_VER LESS 600)) - copy_compilerrt_lib("windows/clang_rt.fuzzer-${compilerrt_arch_suffix}.lib" "ldc_rt.fuzzer.lib" FALSE) - copy_compilerrt_lib("windows/clang_rt.xray-${compilerrt_arch_suffix}.lib" "ldc_rt.xray.lib" FALSE) - endif() + copy_compilerrt_lib("windows/clang_rt.fuzzer-${compilerrt_arch_suffix}.lib" "ldc_rt.fuzzer.lib" FALSE) + copy_compilerrt_lib("windows/clang_rt.xray-${compilerrt_arch_suffix}.lib" "ldc_rt.xray.lib" FALSE) if(NOT (LDC_LLVM_VER LESS 700)) copy_compilerrt_lib("windows/clang_rt.xray-basic-${compilerrt_arch_suffix}.lib" "ldc_rt.xray-basic.lib" FALSE) copy_compilerrt_lib("windows/clang_rt.xray-fdr-${compilerrt_arch_suffix}.lib" "ldc_rt.xray-fdr.lib" FALSE) copy_compilerrt_lib("windows/clang_rt.xray-profiling-${compilerrt_arch_suffix}.lib" "ldc_rt.xray-profiling.lib" FALSE) endif() endif() - - if(LDC_LLVM_VER LESS 600) - set(LLVM_LIBFUZZER_PATH ${LLVM_LIBRARY_DIRS}/libFuzzer.a) - if(EXISTS ${LLVM_LIBFUZZER_PATH}) - message(STATUS "Copying libFuzzer library: ${LLVM_LIBFUZZER_PATH} --> libFuzzer.a") - file(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/lib${LIB_SUFFIX}) - file(COPY ${LLVM_LIBFUZZER_PATH} DESTINATION ${PROJECT_BINARY_DIR}/lib${LIB_SUFFIX}) - install(FILES ${PROJECT_BINARY_DIR}/lib${LIB_SUFFIX}/libFuzzer.a DESTINATION ${CMAKE_INSTALL_PREFIX}/lib${LIB_SUFFIX}) - else() - message(STATUS "Not found: ${LLVM_LIBFUZZER_PATH}") - endif() - endif() endif() # diff --git a/cmake/Modules/FindLLVM.cmake b/cmake/Modules/FindLLVM.cmake index f46cc2a7f4b..992956d1d2a 100644 --- a/cmake/Modules/FindLLVM.cmake +++ b/cmake/Modules/FindLLVM.cmake @@ -35,9 +35,6 @@ set(llvm_config_names llvm-config-10.0 llvm-config100 llvm-config-10 llvm-config-8.0 llvm-config80 llvm-config-8 llvm-config-7.0 llvm-config70 llvm-config-7 llvm-config-6.0 llvm-config60 - llvm-config-5.0 llvm-config50 - llvm-config-4.0 llvm-config40 - llvm-config-3.9 llvm-config39 llvm-config) find_program(LLVM_CONFIG NAMES ${llvm_config_names} @@ -113,19 +110,7 @@ else() # The LLVM version string _may_ contain a git/svn suffix, so match only the x.y.z part string(REGEX MATCH "^[0-9]+[.][0-9]+[.][0-9]+" LLVM_VERSION_BASE_STRING "${LLVM_VERSION_STRING}") - # Versions below 4.0 do not support components debuginfomsf and demangle - if(${LLVM_VERSION_STRING} MATCHES "^3\\..*") - list(REMOVE_ITEM LLVM_FIND_COMPONENTS "debuginfomsf" index) - list(REMOVE_ITEM LLVM_FIND_COMPONENTS "demangle" index) - endif() - # Versions below 6.0 do not support component windowsmanifest - if(${LLVM_VERSION_STRING} MATCHES "^[3-5]\\..*") - list(REMOVE_ITEM LLVM_FIND_COMPONENTS "windowsmanifest" index) - endif() - llvm_set(LDFLAGS ldflags) - # In LLVM 3.5+, the system library dependencies (e.g. "-lz") are accessed - # using the separate "--system-libs" flag. llvm_set(SYSTEM_LIBS system-libs) string(REPLACE "\n" " " LLVM_LDFLAGS "${LLVM_LDFLAGS} ${LLVM_SYSTEM_LIBS}") llvm_set(LIBRARY_DIRS libdir true) @@ -138,13 +123,7 @@ else() endif() endif() - # Versions below 4.0 do not support llvm-config --cmakedir - if(${LLVM_VERSION_STRING} MATCHES "^3\\..*") - set(LLVM_CMAKEDIR ${LLVM_LIBRARY_DIRS}/cmake/llvm) - else() - llvm_set(CMAKEDIR cmakedir) - endif() - + llvm_set(CMAKEDIR cmakedir) llvm_set(TARGETS_TO_BUILD targets-built) string(REGEX MATCHALL "${pattern}[^ ]+" LLVM_TARGETS_TO_BUILD ${LLVM_TARGETS_TO_BUILD}) diff --git a/driver/archiver.cpp b/driver/archiver.cpp index 0e5feee7075..c2c907b92cc 100644 --- a/driver/archiver.cpp +++ b/driver/archiver.cpp @@ -20,13 +20,8 @@ #include "llvm/Support/Errc.h" #include "llvm/Support/Path.h" #include "llvm/Support/raw_ostream.h" -#include - -#if LDC_LLVM_VER >= 500 #include "llvm/ToolDrivers/llvm-lib/LibDriver.h" -#else -#include "llvm/LibDriver/LibDriver.h" -#endif +#include using namespace llvm; @@ -70,10 +65,8 @@ int addMember(std::vector &Members, StringRef FileName, NewArchiveMember::getFile(FileName, Deterministic); failIfError(NMOrErr.takeError(), FileName); -#if LDC_LLVM_VER >= 500 // Use the basename of the object path for the member name. NMOrErr->MemberName = sys::path::filename(NMOrErr->MemberName); -#endif if (Pos == -1) Members.push_back(std::move(*NMOrErr)); @@ -106,11 +99,7 @@ int computeNewArchiveMembers(object::Archive *OldArchive, Error Err = Error::success(); for (auto &Child : OldArchive->children(Err)) { auto NameOrErr = Child.getName(); -#if LDC_LLVM_VER < 400 - failIfError(NameOrErr.getError(), ""); -#else failIfError(NameOrErr.takeError(), ""); -#endif StringRef Name = NameOrErr.get(); auto MemberI = find_if(Members, [Name](StringRef Path) { @@ -146,11 +135,7 @@ int computeNewArchiveMembers(object::Archive *OldArchive, object::Archive::Kind getDefaultForHost() { return Triple(sys::getProcessTriple()).isOSDarwin() -#if LDC_LLVM_VER >= 500 ? object::Archive::K_DARWIN -#else - ? object::Archive::K_BSD -#endif : object::Archive::K_GNU; } @@ -160,11 +145,7 @@ object::Archive::Kind getKindFromMember(const NewArchiveMember &Member) { if (OptionalObject) { return isa(**OptionalObject) -#if LDC_LLVM_VER >= 500 ? object::Archive::K_DARWIN -#else - ? object::Archive::K_BSD -#endif : object::Archive::K_GNU; } @@ -191,11 +172,7 @@ int performWriteOperation(object::Archive *OldArchive, writeArchive(ArchiveName, NewMembers, Symtab, Kind, Deterministic, Thin, std::move(OldArchiveBuf)); -#if LDC_LLVM_VER >= 600 failIfError(std::move(Result), ("error writing '" + ArchiveName + "'").str()); -#else - failIfError(Result.second, ("error writing '" + ArchiveName + "'").str()); -#endif return 0; } diff --git a/driver/args.cpp b/driver/args.cpp index 46362df1f13..5fa135e7b1c 100644 --- a/driver/args.cpp +++ b/driver/args.cpp @@ -1,6 +1,6 @@ //===-- args.cpp ----------------------------------------------------------===// // -// LDC – the LLVM D compiler +// LDC – the LLVM D compiler // // This file is distributed under the BSD-style LDC license. See the LICENSE // file for details. @@ -108,9 +108,7 @@ bool has(const wchar_t *wname) { return _wgetenv(wname) != nullptr; } std::string get(const char *name) { #ifdef _WIN32 -#if LDC_LLVM_VER >= 400 using llvm::UTF16; -#endif const wchar_t *wvalue = wget(name); std::string value; if (wvalue) { diff --git a/driver/cache.cpp b/driver/cache.cpp index 2d337684f7e..77ddd3ffdde 100644 --- a/driver/cache.cpp +++ b/driver/cache.cpp @@ -37,13 +37,8 @@ #include "gen/logger.h" #include "gen/optimizer.h" -#if LDC_LLVM_VER >= 400 #include "llvm/Bitcode/BitcodeWriter.h" #include "llvm/Support/Chrono.h" -#else -#include "llvm/Bitcode/ReaderWriter.h" -#include "llvm/Support/TimeValue.h" -#endif #include "llvm/Support/FileSystem.h" #include "llvm/Support/MD5.h" #include "llvm/Support/Path.h" @@ -144,7 +139,7 @@ llvm::cl::opt cacheRecoveryMode( "cache-retrieval", llvm::cl::ZeroOrMore, llvm::cl::desc("Set the cache retrieval mechanism (default: copy)."), llvm::cl::init(RetrievalMode::Copy), - clEnumValues( + llvm::cl::values( clEnumValN(RetrievalMode::Copy, "copy", "Make a copy of the cache file"), clEnumValN(RetrievalMode::HardLink, "hardlink", @@ -169,14 +164,10 @@ bool isPruningEnabled() { return false; } -#if LDC_LLVM_VER >= 400 llvm::sys::TimePoint getTimeNow() { using namespace std::chrono; return time_point_cast(system_clock::now()); } -#else -llvm::sys::TimeValue getTimeNow() { return llvm::sys::TimeValue::now(); } -#endif /// A raw_ostream that creates a hash of what is written to it. /// This class does not encounter output errors. @@ -309,13 +300,9 @@ void outputIR2ObjRelevantCmdlineArgs(llvm::raw_ostream &hash_os) { const auto relocModel = opts::getRelocModel(); if (relocModel.hasValue()) hash_os << relocModel.getValue(); -#if LDC_LLVM_VER >= 600 const auto codeModel = opts::getCodeModel(); if (codeModel.hasValue()) hash_os << codeModel.getValue(); -#else - hash_os << opts::getCodeModel(); -#endif #if LDC_LLVM_VER >= 800 const auto framePointerUsage = opts::framePointerUsage(); if (framePointerUsage.hasValue()) diff --git a/driver/cl_options-llvm.cpp b/driver/cl_options-llvm.cpp index 984b7c58aa0..4071074e094 100644 --- a/driver/cl_options-llvm.cpp +++ b/driver/cl_options-llvm.cpp @@ -13,10 +13,8 @@ // shared by multiple LLVM tools. #if LDC_LLVM_VER >= 700 #include "llvm/CodeGen/CommandFlags.inc" -#elif LDC_LLVM_VER >= 600 -#include "llvm/CodeGen/CommandFlags.def" #else -#include "llvm/CodeGen/CommandFlags.h" +#include "llvm/CodeGen/CommandFlags.def" #endif static cl::opt @@ -38,11 +36,7 @@ std::string getArchStr() { return ::MArch; } Optional getRelocModel() { return ::getRelocModel(); } -#if LDC_LLVM_VER >= 600 Optional getCodeModel() { return ::getCodeModel(); } -#else -CodeModel::Model getCodeModel() { return ::CMModel; } -#endif #if LDC_LLVM_VER >= 800 llvm::Optional framePointerUsage() { @@ -77,8 +71,8 @@ std::string getCPUStr() { return ::getCPUStr(); } std::string getFeaturesStr() { return ::getFeaturesStr(); } } // namespace opts -#if LDC_WITH_LLD && LDC_LLVM_VER >= 500 -// LLD 5.0 uses the shared header too (for LTO) and exposes some wrappers in +#if LDC_WITH_LLD +// LLD uses the shared header too (for LTO) and exposes some wrappers in // the lld namespace. Define them here to prevent the LLD object from being // linked in with its conflicting command-line options. namespace lld { @@ -98,12 +92,10 @@ Optional getRelocModelFromCMModel() { return ::getRelocModel(); } Optional getCodeModelFromCMModel() { return ::getCodeModel(); } -#elif LDC_LLVM_VER >= 600 +#else Optional GetCodeModelFromCMModel() { return ::getCodeModel(); } -#else -CodeModel::Model GetCodeModelFromCMModel() { return ::CMModel; } #endif #if LDC_LLVM_VER >= 900 @@ -118,4 +110,4 @@ std::vector getMAttrs() { return ::MAttrs; } std::vector GetMAttrs() { return ::MAttrs; } #endif } // namespace lld -#endif // LDC_WITH_LLD && LDC_LLVM_VER >= 500 +#endif // LDC_WITH_LLD diff --git a/driver/cl_options-llvm.h b/driver/cl_options-llvm.h index 21833d3c8f1..dda90542e25 100644 --- a/driver/cl_options-llvm.h +++ b/driver/cl_options-llvm.h @@ -1,6 +1,6 @@ //===-- driver/cl_options-llvm.h - LLVM command line options ----*- C++ -*-===// // -// LDC – the LLVM D compiler +// LDC – the LLVM D compiler // // This file is distributed under the BSD-style LDC license. See the LICENSE // file for details. @@ -18,11 +18,7 @@ namespace opts { std::string getArchStr(); llvm::Optional getRelocModel(); -#if LDC_LLVM_VER >= 600 llvm::Optional getCodeModel(); -#else -llvm::CodeModel::Model getCodeModel(); -#endif #if LDC_LLVM_VER >= 800 llvm::Optional framePointerUsage(); #else diff --git a/driver/cl_options.cpp b/driver/cl_options.cpp index 9cb7e8eec77..df172d353cc 100644 --- a/driver/cl_options.cpp +++ b/driver/cl_options.cpp @@ -65,7 +65,7 @@ cl::opt invokedByLDMD("ldmd", cl::desc("Invoked by LDMD?"), static cl::opt useDeprecated( cl::desc("Allow deprecated language features and symbols:"), cl::ZeroOrMore, cl::location(global.params.useDeprecated), cl::init(DIAGNOSTICinform), - clEnumValues( + cl::values( clEnumValN(DIAGNOSTICoff, "d", "Silently allow deprecated features and symbols"), clEnumValN(DIAGNOSTICinform, "dw", @@ -90,9 +90,9 @@ static cl::opt cl::opt defaultToHiddenVisibility( "fvisibility", cl::ZeroOrMore, cl::desc("Default visibility of symbols (not relevant for Windows)"), - clEnumValues(clEnumValN(0, "default", "Export all symbols"), - clEnumValN(1, "hidden", - "Only export symbols marked with 'export'"))); + cl::values(clEnumValN(0, "default", "Export all symbols"), + clEnumValN(1, "hidden", + "Only export symbols marked with 'export'"))); static cl::opt verbose("v", cl::desc("Verbose"), cl::ZeroOrMore, cl::location(global.params.verbose)); @@ -139,7 +139,7 @@ static cl::opt verrorStyle( "verror-style", cl::ZeroOrMore, cl::location(global.params.messageStyle), cl::desc( "Set the style for file/line number annotations on compiler messages"), - clEnumValues( + cl::values( clEnumValN(MESSAGESTYLEdigitalmars, "digitalmars", "'file(line[,column]): message' (default)"), clEnumValN(MESSAGESTYLEgnu, "gnu", @@ -149,7 +149,7 @@ static cl::opt verrorStyle( static cl::opt warnings( cl::desc("Warnings:"), cl::ZeroOrMore, cl::location(global.params.warnings), - clEnumValues( + cl::values( clEnumValN(DIAGNOSTICerror, "w", "Enable warnings as errors (compilation will halt)"), clEnumValN(DIAGNOSTICinform, "wi", @@ -164,7 +164,7 @@ static cl::opt cplusplus( "extern-std", cl::ZeroOrMore, cl::desc("C++ standard for name mangling compatibility"), cl::location(global.params.cplusplus), - clEnumValues( + cl::values( clEnumValN(CppStdRevisionCpp98, "c++98", "Sets `__traits(getTargetInfo, \"cppStd\")` to `199711`"), clEnumValN(CppStdRevisionCpp11, "c++11", @@ -176,7 +176,7 @@ static cl::opt cplusplus( static cl::opt debugInfo( cl::desc("Generating debug information:"), cl::ZeroOrMore, - clEnumValues( + cl::values( clEnumValN(1, "g", "Add symbolic debug info"), clEnumValN(2, "gc", "Add symbolic debug info, optimize for non D debuggers"), @@ -393,10 +393,10 @@ static cl::opt> static cl::opt boundsCheck( "boundscheck", cl::ZeroOrMore, cl::desc("Array bounds check"), cl::location(global.params.useArrayBounds), cl::init(CHECKENABLEdefault), - clEnumValues(clEnumValN(CHECKENABLEoff, "off", "Disabled"), - clEnumValN(CHECKENABLEsafeonly, "safeonly", - "Enabled for @safe functions only"), - clEnumValN(CHECKENABLEon, "on", "Enabled for all functions"))); + cl::values(clEnumValN(CHECKENABLEoff, "off", "Disabled"), + clEnumValN(CHECKENABLEsafeonly, "safeonly", + "Enabled for @safe functions only"), + clEnumValN(CHECKENABLEon, "on", "Enabled for all functions"))); static cl::opt> switchErrors( "switch-errors", cl::ZeroOrMore, @@ -430,7 +430,7 @@ static cl::opt checkAction( "checkaction", cl::ZeroOrMore, cl::location(global.params.checkAction), cl::desc("Action to take when an assert/boundscheck/final-switch fails"), cl::init(CHECKACTION_D), - clEnumValues( + cl::values( clEnumValN(CHECKACTION_D, "D", "Usual D behavior of throwing an AssertError"), clEnumValN(CHECKACTION_C, "C", @@ -474,11 +474,7 @@ bool fFastMath; // Storage for the dynamically created ffast-math option. llvm::FastMathFlags defaultFMF; void setDefaultMathOptions(llvm::TargetOptions &targetOptions) { if (fFastMath) { -#if LDC_LLVM_VER >= 600 defaultFMF.setFast(); -#else - defaultFMF.setUnsafeAlgebra(); -#endif targetOptions.UnsafeFPMath = true; } } @@ -518,19 +514,17 @@ cl::opt coverageAnalysis( cl::opt ltoMode( "flto", cl::ZeroOrMore, cl::desc("Set LTO mode, requires linker support"), cl::init(LTO_None), - clEnumValues( + cl::values( clEnumValN(LTO_Full, "full", "Merges all input into a single module"), clEnumValN(LTO_Thin, "thin", "Parallel importing and codegen (faster than 'full')"))); -#if LDC_LLVM_VER >= 400 cl::opt saveOptimizationRecord("fsave-optimization-record", cl::value_desc("filename"), cl::desc("Generate a YAML optimization record file " "of optimizations performed by LLVM"), cl::ValueOptional); -#endif #if LDC_LLVM_SUPPORTED_TARGET_SPIRV || LDC_LLVM_SUPPORTED_TARGET_NVPTX cl::list @@ -604,7 +598,7 @@ void createClashingOptions() { new cl::opt( "float-abi", cl::desc("ABI/operations to use for floating-point types:"), cl::ZeroOrMore, cl::location(floatABI), cl::init(FloatABI::Default), - clEnumValues( + cl::values( clEnumValN(FloatABI::Default, "default", "Target default floating-point ABI"), clEnumValN(FloatABI::Soft, "soft", diff --git a/driver/cl_options.h b/driver/cl_options.h index 54c07955175..07f212bb80a 100644 --- a/driver/cl_options.h +++ b/driver/cl_options.h @@ -107,9 +107,7 @@ extern cl::opt ltoMode; inline bool isUsingLTO() { return ltoMode != LTO_None; } inline bool isUsingThinLTO() { return ltoMode == LTO_Thin; } -#if LDC_LLVM_VER >= 400 extern cl::opt saveOptimizationRecord; -#endif #if LDC_LLVM_SUPPORTED_TARGET_SPIRV || LDC_LLVM_SUPPORTED_TARGET_NVPTX extern cl::list dcomputeTargets; extern cl::opt dcomputeFilePrefix; diff --git a/driver/cl_options_instrumentation.cpp b/driver/cl_options_instrumentation.cpp index 68e26f1bf5a..00fe6031d4c 100644 --- a/driver/cl_options_instrumentation.cpp +++ b/driver/cl_options_instrumentation.cpp @@ -51,14 +51,10 @@ cl::opt ASTPGOInstrUseFile( cl::desc("Use instrumentation data for profile-guided optimization"), cl::ValueRequired); -#if LDC_LLVM_VER >= 500 cl::opt fXRayInstructionThreshold( "fxray-instruction-threshold", cl::value_desc("value"), cl::desc("Sets the minimum function size to instrument with XRay"), cl::init(200), cl::ZeroOrMore, cl::ValueRequired); -#else -constexpr int fXRayInstructionThreshold = 200; -#endif } // anonymous namespace @@ -76,11 +72,9 @@ static cl::opt dmdFunctionTrace( "fdmd-trace-functions", cl::ZeroOrMore, cl::desc("DMD-style runtime performance profiling of generated code")); -#if LDC_LLVM_VER >= 500 cl::opt fXRayInstrument( "fxray-instrument", cl::ZeroOrMore, cl::desc("Generate XRay instrumentation sleds on function entry and exit")); -#endif llvm::StringRef getXRayInstructionThresholdString() { // The instruction threshold is constant during one compiler invoke, so we diff --git a/driver/cl_options_instrumentation.h b/driver/cl_options_instrumentation.h index 84b82efe9f6..7fd34fb3f01 100644 --- a/driver/cl_options_instrumentation.h +++ b/driver/cl_options_instrumentation.h @@ -26,11 +26,7 @@ namespace cl = llvm::cl; extern cl::opt instrumentFunctions; -#if LDC_LLVM_VER >= 500 extern cl::opt fXRayInstrument; -#else -constexpr bool fXRayInstrument = false; -#endif llvm::StringRef getXRayInstructionThresholdString(); /// This initializes the instrumentation options, and checks the validity of the diff --git a/driver/cl_options_sanitizers.cpp b/driver/cl_options_sanitizers.cpp index c11394ec7ed..557319e62fe 100644 --- a/driver/cl_options_sanitizers.cpp +++ b/driver/cl_options_sanitizers.cpp @@ -39,14 +39,12 @@ cl::list fSanitizeBlacklist( std::unique_ptr sanitizerBlacklist; -#ifdef ENABLE_COVERAGE_SANITIZER cl::list fSanitizeCoverage( "fsanitize-coverage", cl::CommaSeparated, cl::desc("Specify the type of coverage instrumentation for -fsanitize"), cl::value_desc("type")); llvm::SanitizerCoverageOptions sanitizerCoverageOptions; -#endif // Parse sanitizer name passed on commandline and return the corresponding // sanitizer bits. @@ -75,7 +73,6 @@ SanitizerBits parseFSanitizeCmdlineParameter() { return retval; } -#ifdef ENABLE_COVERAGE_SANITIZER void parseFSanitizeCoverageParameter(llvm::StringRef name, llvm::SanitizerCoverageOptions &opts) { if (name == "func") { @@ -110,19 +107,15 @@ void parseFSanitizeCoverageParameter(llvm::StringRef name, else if (name == "trace-pc-guard") { opts.TracePCGuard = true; } -#if LDC_LLVM_VER >= 500 else if (name == "inline-8bit-counters") { opts.Inline8bitCounters = true; } else if (name == "no-prune") { opts.NoPrune = true; } -#endif -#if LDC_LLVM_VER >= 600 else if (name == "pc-table") { opts.PCTable = true; } -#endif else { error(Loc(), "Unrecognized -fsanitize-coverage option '%s'.", name.str().c_str()); } @@ -136,7 +129,6 @@ void parseFSanitizeCoverageCmdlineParameter(llvm::SanitizerCoverageOptions &opts parseFSanitizeCoverageParameter(name, opts); } } -#endif } // anonymous namespace @@ -148,19 +140,13 @@ void initializeSanitizerOptionsFromCmdline() { enabledSanitizers |= parseFSanitizeCmdlineParameter(); -#ifdef ENABLE_COVERAGE_SANITIZER auto &sancovOpts = sanitizerCoverageOptions; - // LLVM < 6.0: The Fuzz sanitizer implies -fsanitize-coverage=trace-pc-guard,indirect-calls,trace-cmp - // LLVM >= 6.0: The Fuzz sanitizer implies -fsanitize-coverage=inline-8bit-counters,indirect-calls,trace-cmp,pc-table + // The Fuzz sanitizer implies -fsanitize-coverage=inline-8bit-counters,indirect-calls,trace-cmp,pc-table if (isSanitizerEnabled(FuzzSanitizer)) { enabledSanitizers |= CoverageSanitizer; -#if LDC_LLVM_VER < 600 - sancovOpts.TracePCGuard = true; -#else sancovOpts.Inline8bitCounters = true; sancovOpts.PCTable = true; -#endif sancovOpts.IndirectCalls = true; sancovOpts.TraceCmp = true; } @@ -170,14 +156,10 @@ void initializeSanitizerOptionsFromCmdline() // trace-pc/trace-pc-guard/inline-8bit-counters without specifying the // insertion type implies edge if ((sancovOpts.CoverageType == llvm::SanitizerCoverageOptions::SCK_None) && - (sancovOpts.TracePC || sancovOpts.TracePCGuard -#if LDC_LLVM_VER >= 500 - || sancovOpts.Inline8bitCounters -#endif - )) { + (sancovOpts.TracePC || sancovOpts.TracePCGuard || + sancovOpts.Inline8bitCounters)) { sancovOpts.CoverageType = llvm::SanitizerCoverageOptions::SCK_Edge; } -#endif if (isAnySanitizerEnabled() && !fSanitizeBlacklist.empty()) { std::string loadError; @@ -192,11 +174,9 @@ void initializeSanitizerOptionsFromCmdline() } } -#ifdef ENABLE_COVERAGE_SANITIZER llvm::SanitizerCoverageOptions getSanitizerCoverageOptions() { return sanitizerCoverageOptions; } -#endif // Output to `hash_os` all optimization settings that influence object code // output and that are not observable in the IR before running LLVM passes. This @@ -205,10 +185,8 @@ llvm::SanitizerCoverageOptions getSanitizerCoverageOptions() { void outputSanitizerSettings(llvm::raw_ostream &hash_os) { hash_os << SanitizerBits(enabledSanitizers); -#ifdef ENABLE_COVERAGE_SANITIZER hash_os.write(reinterpret_cast(&sanitizerCoverageOptions), sizeof(sanitizerCoverageOptions)); -#endif } bool functionIsInSanitizerBlacklist(FuncDeclaration *funcDecl) { @@ -218,16 +196,11 @@ bool functionIsInSanitizerBlacklist(FuncDeclaration *funcDecl) { auto funcName = mangleExact(funcDecl); auto fileName = funcDecl->loc.filename; -#if LDC_LLVM_VER >= 600 - // TODO: LLVM 6.0 supports sections (e.g. "[address]") in the blacklist file - // to only blacklist a function for a particular sanitizer. We could make use - // of that too. + // TODO: LLVM supports sections (e.g. "[address]") in the blacklist file to + // only blacklist a function for a particular sanitizer. We could make use of + // that too. return sanitizerBlacklist->inSection(/*Section=*/"", "fun", funcName) || sanitizerBlacklist->inSection(/*Section=*/"", "src", fileName); -#else - return sanitizerBlacklist->inSection("fun", funcName) || - sanitizerBlacklist->inSection("src", fileName); -#endif } } // namespace opts diff --git a/driver/cl_options_sanitizers.h b/driver/cl_options_sanitizers.h index f79f8f8d592..b94d326791c 100644 --- a/driver/cl_options_sanitizers.h +++ b/driver/cl_options_sanitizers.h @@ -16,12 +16,6 @@ #include "gen/cl_helpers.h" #include "llvm/Transforms/Instrumentation.h" -#if LDC_LLVM_VER >= 400 -// Enable coverage sanitizer options from LLVM 4.0 to simplify our code: earlier -// versions do not have all options available. -#define ENABLE_COVERAGE_SANITIZER -#endif - class FuncDeclaration; namespace llvm { class raw_ostream; @@ -48,9 +42,7 @@ inline bool isSanitizerEnabled(SanitizerCheck san) { void initializeSanitizerOptionsFromCmdline(); -#ifdef ENABLE_COVERAGE_SANITIZER llvm::SanitizerCoverageOptions getSanitizerCoverageOptions(); -#endif void outputSanitizerSettings(llvm::raw_ostream &hash_os); diff --git a/driver/codegenerator.cpp b/driver/codegenerator.cpp index ec00cba4580..0833df4614d 100644 --- a/driver/codegenerator.cpp +++ b/driver/codegenerator.cpp @@ -31,12 +31,6 @@ #include "llvm/Support/ToolOutputFile.h" #include "llvm/Support/YAMLTraits.h" -#if LDC_LLVM_VER < 600 -namespace llvm { -using ToolOutputFile = tool_output_file; -} -#endif - namespace { std::unique_ptr @@ -44,7 +38,6 @@ createAndSetDiagnosticsOutputFile(IRState &irs, llvm::LLVMContext &ctx, llvm::StringRef filename) { std::unique_ptr diagnosticsOutputFile; -#if LDC_LLVM_VER >= 400 // Set LLVM Diagnostics outputfile if requested if (opts::saveOptimizationRecord.getNumOccurrences() > 0) { llvm::SmallString<128> diagnosticsFilename; @@ -82,63 +75,14 @@ createAndSetDiagnosticsOutputFile(IRState &irs, llvm::LLVMContext &ctx, llvm::make_unique(diagnosticsOutputFile->os())); if (withHotness) { -#if LDC_LLVM_VER >= 500 ctx.setDiagnosticsHotnessRequested(true); -#else - ctx.setDiagnosticHotnessRequested(true); -#endif } #endif // LDC_LLVM_VER < 900 } -#endif return diagnosticsOutputFile; } -#if LDC_LLVM_VER < 500 -/// Add the Linker Options module flag. -/// If the flag is already present, merge it with the new data. -void emitLinkerOptions(IRState &irs) { - llvm::Module &M = irs.module; - llvm::LLVMContext &ctx = irs.context(); - if (!M.getModuleFlag("Linker Options")) { - M.addModuleFlag(llvm::Module::AppendUnique, "Linker Options", - llvm::MDNode::get(ctx, irs.linkerOptions)); - } else { - // Merge the Linker Options with the pre-existing one - // (this can happen when passing a .bc file on the commandline) - - auto *moduleFlags = M.getModuleFlagsMetadata(); - for (unsigned i = 0, e = moduleFlags->getNumOperands(); i < e; ++i) { - auto *flag = moduleFlags->getOperand(i); - if (flag->getNumOperands() < 3) - continue; - auto optionsMDString = - llvm::dyn_cast_or_null(flag->getOperand(1)); - if (!optionsMDString || optionsMDString->getString() != "Linker Options") - continue; - - // If we reach here, we found the Linker Options flag. - - // Add the old Linker Options to our linkerOptions list. - auto *oldLinkerOptions = llvm::cast(flag->getOperand(2)); - for (const auto &Option : oldLinkerOptions->operands()) { - irs.linkerOptions.push_back(Option); - } - - // Replace Linker Options with a newly created list. - llvm::Metadata *Ops[3] = { - llvm::ConstantAsMetadata::get(llvm::ConstantInt::get( - llvm::Type::getInt32Ty(ctx), llvm::Module::AppendUnique)), - llvm::MDString::get(ctx, "Linker Options"), - llvm::MDNode::get(ctx, irs.linkerOptions)}; - moduleFlags->setOperand(i, llvm::MDNode::get(ctx, Ops)); - - break; - } - } -} -#else void addLinkerMetadata(llvm::Module &M, const char *name, llvm::ArrayRef newOperands) { if (newOperands.empty()) @@ -172,7 +116,6 @@ void emitLinkerOptions(IRState &irs) { addLinkerMetadata(M, "llvm.linker.options", irs.linkerOptions); addLinkerMetadata(M, "llvm.dependent-libraries", irs.linkerDependentLibs); } -#endif void emitLLVMUsedArray(IRState &irs) { if (irs.usedArray.empty()) { diff --git a/driver/configfile.cpp b/driver/configfile.cpp index e2c3f67a6dc..cac8c7854fc 100644 --- a/driver/configfile.cpp +++ b/driver/configfile.cpp @@ -32,7 +32,7 @@ namespace sys = llvm::sys; -#if defined(_WIN32) && LDC_LLVM_VER >= 400 +#if defined(_WIN32) using llvm::UTF16; #endif diff --git a/driver/ldmd.cpp b/driver/ldmd.cpp index 5fffecc30f8..319ba688c8a 100644 --- a/driver/ldmd.cpp +++ b/driver/ldmd.cpp @@ -122,13 +122,7 @@ int execute(const std::string &exePath, const char **args) { #endif std::string errorMsg; - int rc = ls::ExecuteAndWait(exePath, argv, envVars, -#if LDC_LLVM_VER >= 600 - {}, -#else - nullptr, -#endif - 0, 0, &errorMsg); + int rc = ls::ExecuteAndWait(exePath, argv, envVars, {}, 0, 0, &errorMsg); if (!errorMsg.empty()) { error("Error executing %s: %s", exePath.c_str(), errorMsg.c_str()); } diff --git a/driver/linker-gcc.cpp b/driver/linker-gcc.cpp index 81630e015f5..79a20a8cff1 100644 --- a/driver/linker-gcc.cpp +++ b/driver/linker-gcc.cpp @@ -25,7 +25,7 @@ #include "llvm/Target/TargetMachine.h" #include "llvm/Target/TargetOptions.h" -#if LDC_WITH_LLD && LDC_LLVM_VER >= 600 +#if LDC_WITH_LLD #include "lld/Common/Driver.h" #endif @@ -139,13 +139,11 @@ void ArgsBuilder::addLTOGoldPluginFlags(bool requirePlugin) { optChars[13] = '0' + std::min(optLevel(), 3); addLdFlag(optChars); -#if LDC_LLVM_VER >= 400 const llvm::TargetOptions &TO = gTargetMachine->Options; if (TO.FunctionSections) addLdFlag("-plugin-opt=-function-sections"); if (TO.DataSections) addLdFlag("-plugin-opt=-data-sections"); -#endif } // Returns an empty string when libLTO.dylib was not specified nor found. @@ -327,13 +325,7 @@ void ArgsBuilder::addASanLinkFlags(const llvm::Triple &triple) { // Adds all required link flags for -fsanitize=fuzzer when libFuzzer library is // found. void ArgsBuilder::addFuzzLinkFlags(const llvm::Triple &triple) { -#if LDC_LLVM_VER >= 600 const auto searchPaths = getFullCompilerRTLibPathCandidates("fuzzer", triple); -#else - std::vector searchPaths; - appendFullLibPathCandidates(searchPaths, "libFuzzer.a"); - appendFullLibPathCandidates(searchPaths, "libLLVMFuzzer.a"); -#endif for (const auto &filepath : searchPaths) { IF_LOG Logger::println("Searching libFuzzer: %s", filepath.c_str()); @@ -722,7 +714,7 @@ class LdArgsBuilder : public ArgsBuilder { int linkObjToBinaryGcc(llvm::StringRef outputPath, const std::vector &defaultLibNames) { -#if LDC_WITH_LLD && LDC_LLVM_VER >= 600 +#if LDC_WITH_LLD if (useInternalLLDForLinking()) { LdArgsBuilder argsBuilder; argsBuilder.build(outputPath, defaultLibNames); @@ -787,17 +779,13 @@ int linkObjToBinaryGcc(llvm::StringRef outputPath, // exception: invoke (ld-compatible) linker directly for WebAssembly targets std::string tool; std::unique_ptr argsBuilder; -#if LDC_LLVM_VER >= 500 if (global.params.targetTriple->isOSBinFormatWasm()) { tool = getProgram("wasm-ld", &opts::linker); argsBuilder = llvm::make_unique(); } else { -#endif tool = getGcc(); argsBuilder = llvm::make_unique(); -#if LDC_LLVM_VER >= 500 } -#endif // build arguments argsBuilder->build(outputPath, defaultLibNames); diff --git a/driver/linker-msvc.cpp b/driver/linker-msvc.cpp index c5cc6ca7222..0b5441d9435 100644 --- a/driver/linker-msvc.cpp +++ b/driver/linker-msvc.cpp @@ -21,11 +21,7 @@ #include "llvm/Support/Path.h" #if LDC_WITH_LLD -#if LDC_LLVM_VER >= 600 #include "lld/Common/Driver.h" -#else -#include "lld/Driver/Driver.h" -#endif #endif ////////////////////////////////////////////////////////////////////////////// @@ -41,17 +37,11 @@ void addMscrtLibs(bool useInternalToolchain, std::vector &args) { // Pick one of the 4 variants matching the selected main UCRT lib. if (useInternalToolchain) { -#if LDC_LLVM_VER >= 400 assert(mscrtlibName.contains_lower("vcruntime")); -#endif return; } -#if LDC_LLVM_VER >= 400 const bool isStatic = mscrtlibName.contains_lower("libcmt"); -#else // LLVM 3.9: no llvm::StringRef::{contains,find}_lower - const bool isStatic = mscrtlibName.startswith_lower("libcmt"); -#endif const bool isDebug = mscrtlibName.endswith_lower("d") || mscrtlibName.endswith_lower("d.lib"); @@ -248,14 +238,11 @@ int linkObjToBinaryMSVC(llvm::StringRef outputPath, (useInternalToolchain && opts::linker.empty() && !opts::isUsingLTO())) { const auto fullArgs = getFullArgs("lld-link", args, global.params.verbose); - const bool success = lld::coff::link(fullArgs -#if LDC_LLVM_VER >= 600 - , + const bool success = lld::coff::link(fullArgs, /*CanExitEarly=*/false #if LDC_LLVM_VER >= 1000 , llvm::outs(), llvm::errs() -#endif #endif ); diff --git a/driver/main.cpp b/driver/main.cpp index aa83efe1014..5654561c50f 100644 --- a/driver/main.cpp +++ b/driver/main.cpp @@ -50,6 +50,7 @@ #include "gen/passes/Passes.h" #include "gen/runtime.h" #include "gen/uda.h" +#include "llvm/CodeGen/TargetSubtargetInfo.h" #include "llvm/InitializePasses.h" #include "llvm/IR/LLVMContext.h" #include "llvm/LinkAllIR.h" @@ -67,12 +68,6 @@ #include #include -#if LDC_LLVM_VER >= 600 -#include "llvm/CodeGen/TargetSubtargetInfo.h" -#else -#include "llvm/Target/TargetSubtargetInfo.h" -#endif - #if _WIN32 #include "llvm/Support/ConvertUTF.h" #include @@ -98,6 +93,8 @@ static cl::opt enableGC( cl::desc("Enable the garbage collector for the LDC front-end. This reduces " "the compiler memory requirements but increases compile times.")); +namespace { + // This function exits the program. void printVersion(llvm::raw_ostream &OS) { OS << "LDC - the LLVM D compiler (" << ldc::ldc_version << "):\n"; @@ -125,23 +122,11 @@ void printVersion(llvm::raw_ostream &OS) { // redirecting stdout to a file. OS.flush(); - llvm::TargetRegistry::printRegisteredTargetsForVersion( -#if LDC_LLVM_VER >= 600 - OS -#endif - ); + llvm::TargetRegistry::printRegisteredTargetsForVersion(OS); exit(EXIT_SUCCESS); } -// This function exits the program. -void printVersionStdout() { - printVersion(llvm::outs()); - assert(false); -} - -namespace { - // Helper function to handle -d-debug=* and -d-version=* void processVersions(std::vector &list, const char *type, unsigned &globalLevel, Strings *&globalIDs) { @@ -284,11 +269,7 @@ void parseCommandLine(Strings &sourceFiles) { // finalize by expanding response files specified in config file args::expandResponseFiles(allArguments); -#if LDC_LLVM_VER >= 600 cl::SetVersionPrinter(&printVersion); -#else - cl::SetVersionPrinter(&printVersionStdout); -#endif opts::hideLLVMOptions(); opts::createClashingOptions(); @@ -410,11 +391,9 @@ void parseCommandLine(Strings &sourceFiles) { if (includeImports) global.params.oneobj = true; -#if LDC_LLVM_VER >= 400 if (saveOptimizationRecord.getNumOccurrences() > 0) { global.params.outputSourceLocations = true; } -#endif opts::initializeSanitizerOptionsFromCmdline(); @@ -551,11 +530,7 @@ void initializePasses() { initializeTarget(Registry); // Initialize passes not included above -#if LDC_LLVM_VER >= 400 initializeRewriteSymbolsLegacyPassPass(Registry); -#else - initializeRewriteSymbolsPass(Registry); -#endif initializeSjLjEHPreparePass(Registry); } @@ -684,14 +659,12 @@ void registerPredefinedTargetVersions() { case llvm::Triple::msp430: VersionCondition::addPredefinedGlobalIdent("MSP430"); break; -#if LDC_LLVM_VER >= 400 case llvm::Triple::riscv32: VersionCondition::addPredefinedGlobalIdent("RISCV32"); break; case llvm::Triple::riscv64: VersionCondition::addPredefinedGlobalIdent("RISCV64"); break; -#endif case llvm::Triple::sparc: // FIXME: Detect SPARC v8+ (SPARC_V8Plus). VersionCondition::addPredefinedGlobalIdent("SPARC"); diff --git a/driver/targetmachine.cpp b/driver/targetmachine.cpp index d43bad9de8d..6b0590134dc 100644 --- a/driver/targetmachine.cpp +++ b/driver/targetmachine.cpp @@ -183,7 +183,6 @@ static std::string getAArch64TargetCPU(const llvm::Triple &triple) { return "generic"; } -#if LDC_LLVM_VER >= 400 static std::string getRiscv32TargetCPU(const llvm::Triple &triple) { return "generic-rv32"; } @@ -191,7 +190,6 @@ static std::string getRiscv32TargetCPU(const llvm::Triple &triple) { static std::string getRiscv64TargetCPU(const llvm::Triple &triple) { return "generic-rv64"; } -#endif /// Returns the LLVM name of the default CPU for the provided target triple. static std::string getTargetCPU(const llvm::Triple &triple) { @@ -210,12 +208,10 @@ static std::string getTargetCPU(const llvm::Triple &triple) { case llvm::Triple::aarch64: case llvm::Triple::aarch64_be: return getAArch64TargetCPU(triple); -#if LDC_LLVM_VER >= 400 case llvm::Triple::riscv32: return getRiscv32TargetCPU(triple); case llvm::Triple::riscv64: return getRiscv64TargetCPU(triple); -#endif } } @@ -342,11 +338,7 @@ createTargetMachine(const std::string targetTriple, const std::string arch, const ExplicitBitness::Type bitness, FloatABI::Type &floatABI, llvm::Optional relocModel, -#if LDC_LLVM_VER >= 600 llvm::Optional codeModel, -#else - llvm::CodeModel::Model codeModel, -#endif const llvm::CodeGenOpt::Level codeGenOptLevel, const bool noLinkerStripDead) { // Determine target triple. If the user didn't explicitly specify one, use diff --git a/driver/targetmachine.h b/driver/targetmachine.h index 05d3290e535..a53d7960ad3 100644 --- a/driver/targetmachine.h +++ b/driver/targetmachine.h @@ -56,11 +56,7 @@ createTargetMachine(std::string targetTriple, std::string arch, std::string cpu, std::string featuresString, ExplicitBitness::Type bitness, FloatABI::Type &floatABI, llvm::Optional relocModel, -#if LDC_LLVM_VER >= 600 llvm::Optional codeModel, -#else - llvm::CodeModel::Model codeModel, -#endif llvm::CodeGenOpt::Level codeGenOptLevel, bool noLinkerStripDead); diff --git a/driver/toobj.cpp b/driver/toobj.cpp index d7d49d9c57c..8f3773ea66a 100644 --- a/driver/toobj.cpp +++ b/driver/toobj.cpp @@ -20,12 +20,8 @@ #include "llvm/IR/AssemblyAnnotationWriter.h" #include "llvm/IR/Verifier.h" #include "llvm/Analysis/ModuleSummaryAnalysis.h" -#if LDC_LLVM_VER >= 400 #include "llvm/Analysis/ProfileSummaryInfo.h" #include "llvm/Bitcode/BitcodeWriter.h" -#else -#include "llvm/Bitcode/ReaderWriter.h" -#endif #include "llvm/IR/LegacyPassManager.h" #include "llvm/Support/CommandLine.h" #include "llvm/Support/FileSystem.h" @@ -34,11 +30,7 @@ #include "llvm/Support/Path.h" #include "llvm/Target/TargetMachine.h" #include "llvm/Analysis/TargetTransformInfo.h" -#if LDC_LLVM_VER >= 600 #include "llvm/CodeGen/TargetSubtargetInfo.h" -#else -#include "llvm/Target/TargetSubtargetInfo.h" -#endif #include "llvm/Transforms/Utils/Cloning.h" #include "llvm/IR/Module.h" #ifdef LDC_LLVM_SUPPORTED_TARGET_SPIRV @@ -171,13 +163,8 @@ class AssemblyAnnotator : public AssemblyAnnotationWriter { static llvm::StringRef GetDisplayName(const Function *F) { llvm::DebugInfoFinder Finder; Finder.processModule(*F->getParent()); - if (DISubprogram *N = FindSubprogram(F, Finder)) - { -#if LDC_LLVM_VER >= 500 + if (DISubprogram *N = FindSubprogram(F, Finder)) { return N->getName(); -#else - return N->getDisplayName(); -#endif } return ""; } @@ -298,13 +285,6 @@ bool shouldOutputObjectFile() { } bool shouldDoLTO(llvm::Module *m) { -#if LDC_LLVM_VER == 309 - // LLVM 3.9 bug: can't do ThinLTO with modules that have module-scope inline - // assembly blocks (duplicate definitions upon importing from such a module). - // https://llvm.org/bugs/show_bug.cgi?id=30610 - if (opts::isUsingThinLTO() && !m->getModuleInlineAsm().empty()) - return false; -#endif return opts::isUsingLTO(); } } // end of anonymous namespace @@ -390,20 +370,13 @@ void writeModule(llvm::Module *m, const char *filename) { if (opts::isUsingThinLTO()) { Logger::println("Creating module summary for ThinLTO"); -#if LDC_LLVM_VER == 309 - // When the function freq info callback is set to nullptr, LLVM will - // calculate it automatically for us. - llvm::ModuleSummaryIndexBuilder indexBuilder( - m, /* function freq callback */ nullptr); - auto &moduleSummaryIndex = indexBuilder.getIndex(); -#else + llvm::ProfileSummaryInfo PSI(*m); // When the function freq info callback is set to nullptr, LLVM will // calculate it automatically for us. auto moduleSummaryIndex = buildModuleSummaryIndex( *m, /* function freq callback */ nullptr, &PSI); -#endif llvm::WriteBitcodeToFile(M, bos, true, &moduleSummaryIndex, /* generate ThinLTO hash */ true); diff --git a/driver/tool.cpp b/driver/tool.cpp index b66200f317d..71a0da5e47b 100644 --- a/driver/tool.cpp +++ b/driver/tool.cpp @@ -195,13 +195,8 @@ int executeToolAndWait(const std::string &tool_, // Execute tool. std::string errstr; - if (int status = llvm::sys::ExecuteAndWait(tool, argv, envVars, -#if LDC_LLVM_VER >= 600 - {}, -#else - nullptr, -#endif - 0, 0, &errstr)) { + if (int status = + llvm::sys::ExecuteAndWait(tool, argv, envVars, {}, 0, 0, &errstr)) { error(Loc(), "%s failed with status: %d", tool.c_str(), status); if (!errstr.empty()) { error(Loc(), "message: %s", errstr.c_str()); diff --git a/gen/asm-gcc.cpp b/gen/asm-gcc.cpp index c8392a5d937..f00ab924b4d 100644 --- a/gen/asm-gcc.cpp +++ b/gen/asm-gcc.cpp @@ -1,6 +1,6 @@ //===-- asm-gcc.cpp -------------------------------------------------------===// // -// LDC – the LLVM D compiler +// LDC – the LLVM D compiler // // Converts a GDC/GCC-style inline assembly statement to an LLVM inline // assembler expression. @@ -130,11 +130,7 @@ class ConstraintsBuilder { auto N = gccName.size(); if (N == 1 || (N == 3 && gccName[0] == '^')) return false; -#if LDC_LLVM_VER >= 400 return !gccName.contains('{'); -#else - return gccName.find('{') == llvm::StringRef::npos; -#endif } public: diff --git a/gen/attributes.cpp b/gen/attributes.cpp index d3d5e61078e..41f26c4186b 100644 --- a/gen/attributes.cpp +++ b/gen/attributes.cpp @@ -16,37 +16,19 @@ AttrSet::AttrSet(const AttrSet &base, unsigned index, LLAttribute attribute) AttrSet AttrSet::extractFunctionAndReturnAttributes(const llvm::Function *function) { auto old = function->getAttributes(); -#if LDC_LLVM_VER >= 500 - return {LLAttributeSet::get(gIR->context(), old.getFnAttributes(), - old.getRetAttributes(), {})}; -#else - llvm::AttributeSet existingAttrs[] = {old.getFnAttributes(), - old.getRetAttributes()}; - return {LLAttributeSet::get(gIR->context(), existingAttrs)}; -#endif + return {LLAttributeList::get(gIR->context(), old.getFnAttributes(), + old.getRetAttributes(), {})}; } AttrSet &AttrSet::add(unsigned index, const llvm::AttrBuilder &builder) { if (builder.hasAttributes()) { -#if LDC_LLVM_VER >= 500 set = set.addAttributes(gIR->context(), index, builder); -#else - auto as = LLAttributeSet::get(gIR->context(), index, builder); - set = set.addAttributes(gIR->context(), index, as); -#endif } return *this; } AttrSet &AttrSet::merge(const AttrSet &other) { auto &os = other.set; -#if LDC_LLVM_VER >= 500 - set = LLAttributeSet::get(gIR->context(), {set,os}); -#else - for (unsigned i = 0; i < os.getNumSlots(); ++i) { - unsigned index = os.getSlotIndex(i); - set = set.addAttributes(gIR->context(), index, os.getSlotAttributes(i)); - } -#endif + set = LLAttributeList::get(gIR->context(), {set, os}); return *this; } diff --git a/gen/attributes.h b/gen/attributes.h index a2eb871787a..620db241dc8 100644 --- a/gen/attributes.h +++ b/gen/attributes.h @@ -12,42 +12,32 @@ #include "gen/llvm.h" using LLAttribute = llvm::Attribute::AttrKind; -#if LDC_LLVM_VER >= 500 - using LLAttributeSet = llvm::AttributeList; -#else - using LLAttributeSet = llvm::AttributeSet; -#endif +using LLAttributeList = llvm::AttributeList; class AttrSet { - LLAttributeSet set; + LLAttributeList set; AttrSet &add(unsigned index, const llvm::AttrBuilder &builder); public: AttrSet() = default; - AttrSet(const LLAttributeSet &nativeSet) : set(nativeSet) {} + AttrSet(const LLAttributeList &nativeSet) : set(nativeSet) {} AttrSet(const AttrSet &base, unsigned index, LLAttribute attribute); -#if LDC_LLVM_VER >= 500 - static const unsigned FirstArgIndex = LLAttributeSet::FirstArgIndex; -#else - static const unsigned FirstArgIndex = 1; -#endif - static AttrSet extractFunctionAndReturnAttributes(const llvm::Function *function); AttrSet &addToParam(unsigned paramIndex, const llvm::AttrBuilder &builder) { - return add(paramIndex + FirstArgIndex, builder); + return add(LLAttributeList::FirstArgIndex + paramIndex, builder); } AttrSet &addToFunction(const llvm::AttrBuilder &builder) { - return add(LLAttributeSet::FunctionIndex, builder); + return add(LLAttributeList::FunctionIndex, builder); } AttrSet &addToReturn(const llvm::AttrBuilder &builder) { - return add(LLAttributeSet::ReturnIndex, builder); + return add(LLAttributeList::ReturnIndex, builder); } AttrSet &merge(const AttrSet &other); - operator LLAttributeSet &() { return set; } - operator const LLAttributeSet &() const { return set; } + operator LLAttributeList &() { return set; } + operator const LLAttributeList &() const { return set; } }; diff --git a/gen/cl_helpers.h b/gen/cl_helpers.h index 7cd338da2e8..7354ab855e5 100644 --- a/gen/cl_helpers.h +++ b/gen/cl_helpers.h @@ -18,10 +18,6 @@ #include "llvm/Support/CommandLine.h" #include "llvm/Support/Compiler.h" -#if LDC_LLVM_VER >= 500 -#define LLVM_END_WITH_NULL -#endif - template struct Array; typedef Array Strings; @@ -87,22 +83,12 @@ template class FlagParser : public cl::generic_parser_base { // Implement virtual functions needed by generic_parser_base unsigned getNumOptions() const override { return 0; } -#if LDC_LLVM_VER >= 400 - llvm::StringRef -#else - const char * -#endif - getOption(unsigned N) const override { + llvm::StringRef getOption(unsigned N) const override { llvm_unreachable("Unexpected call"); return ""; } -#if LDC_LLVM_VER >= 400 - llvm::StringRef -#else - const char * -#endif - getDescription(unsigned N) const override { + llvm::StringRef getDescription(unsigned N) const override { llvm_unreachable("Unexpected call"); return ""; } @@ -169,7 +155,8 @@ class MultiSetter { bool invert; explicit MultiSetter(bool); // not implemented, disable auto-conversion public: - MultiSetter(bool invert, CHECKENABLE *p, ...) LLVM_END_WITH_NULL; + // end with a nullptr + MultiSetter(bool invert, CHECKENABLE *p, ...); void operator=(bool val); }; @@ -193,15 +180,3 @@ class StringsAdapter { void push_back(const std::string &str) { push_back(str.c_str()); } }; } - - -#if LDC_LLVM_VER >= 400 -#define clEnumValues llvm::cl::values -#else -template -llvm::cl::ValuesClass clEnumValues(const char *Arg, DataType Val, - const char *Desc, - OptsTy... Options) { - return llvm::cl::values(Arg, Val, Desc, Options..., clEnumValEnd); -} -#endif diff --git a/gen/ctfloat.cpp b/gen/ctfloat.cpp index 7f40098b551..19016054345 100644 --- a/gen/ctfloat.cpp +++ b/gen/ctfloat.cpp @@ -1,6 +1,6 @@ //===-- ctfloat.cpp -------------------------------------------------------===// // -// LDC – the LLVM D compiler +// LDC – the LLVM D compiler // // This file is distributed under the BSD-style LDC license. See the LICENSE // file for details. @@ -13,12 +13,6 @@ using llvm::APFloat; -#if LDC_LLVM_VER >= 400 -#define AP_SEMANTICS_PARENS () -#else -#define AP_SEMANTICS_PARENS -#endif - namespace { const llvm::fltSemantics *apSemantics = nullptr; @@ -53,19 +47,19 @@ void CTFloat::initialize() { #ifdef _MSC_VER // MSVC hosts use dmd.root.longdouble (80-bit x87) - apSemantics = &(APFloat::x87DoubleExtended AP_SEMANTICS_PARENS); + apSemantics = &APFloat::x87DoubleExtended(); #else static_assert(std::numeric_limits::is_specialized, "real_t is not an arithmetic type"); constexpr int digits = std::numeric_limits::digits; if (digits == 53) { - apSemantics = &(APFloat::IEEEdouble AP_SEMANTICS_PARENS); + apSemantics = &APFloat::IEEEdouble(); } else if (digits == 64) { - apSemantics = &(APFloat::x87DoubleExtended AP_SEMANTICS_PARENS); + apSemantics = &APFloat::x87DoubleExtended(); } else if (digits == 113) { - apSemantics = &(APFloat::IEEEquad AP_SEMANTICS_PARENS); + apSemantics = &APFloat::IEEEquad(); } else if (digits == 106) { - apSemantics = &(APFloat::PPCDoubleDouble AP_SEMANTICS_PARENS); + apSemantics = &APFloat::PPCDoubleDouble(); } else { llvm_unreachable("Unknown host real_t type for compile-time reals"); } @@ -122,13 +116,13 @@ real_t CTFloat::parse(const char *literal, bool *isOutOfRange) { bool CTFloat::isFloat32LiteralOutOfRange(const char *literal) { bool isOutOfRange; - parseLiteral(APFloat::IEEEsingle AP_SEMANTICS_PARENS, literal, &isOutOfRange); + parseLiteral(APFloat::IEEEsingle(), literal, &isOutOfRange); return isOutOfRange; } bool CTFloat::isFloat64LiteralOutOfRange(const char *literal) { bool isOutOfRange; - parseLiteral(APFloat::IEEEdouble AP_SEMANTICS_PARENS, literal, &isOutOfRange); + parseLiteral(APFloat::IEEEdouble(), literal, &isOutOfRange); return isOutOfRange; } diff --git a/gen/dibuilder.cpp b/gen/dibuilder.cpp index d0ea3155f10..1d2dbe83505 100644 --- a/gen/dibuilder.cpp +++ b/gen/dibuilder.cpp @@ -53,12 +53,6 @@ namespace ldc { const char *convertDIdentifierToCPlusPlus(const char *name, size_t nameLength); namespace { -#if LDC_LLVM_VER >= 400 -const auto DIFlagZero = DIFlags::FlagZero; -#else -const unsigned DIFlagZero = 0; -#endif - DIType getNullDIType() { return nullptr; } llvm::StringRef uniqueIdent(Type *t) { @@ -210,11 +204,8 @@ void DIBuilder::SetValue(const Loc &loc, llvm::Value *value, DILocalVariable divar, DIExpression diexpr) { auto debugLoc = llvm::DebugLoc::get(loc.linnum, getColumn(loc), GetCurrentScope()); - DBuilder.insertDbgValueIntrinsic(value, -#if LDC_LLVM_VER < 600 - 0, -#endif - divar, diexpr, debugLoc, IR->scopebb()); + DBuilder.insertDbgValueIntrinsic(value, divar, diexpr, debugLoc, + IR->scopebb()); } DIFile DIBuilder::CreateFile(Loc &loc) { @@ -322,9 +313,6 @@ DIType DIBuilder::CreateBasicType(Type *type) { return DBuilder.createBasicType(type->toChars(), // name getTypeAllocSize(T) * 8, // size (bits) -#if LDC_LLVM_VER < 400 - getABITypeAlign(T) * 8, // align (bits) -#endif Encoding); } @@ -375,21 +363,16 @@ DIType DIBuilder::CreatePointerType(Type *type) { if (nt->toBasetype()->ty == Tvoid) nt = Type::tuns8; -#if LDC_LLVM_VER >= 500 // TODO: The addressspace is important for dcompute targets. See e.g. // https://www.mail-archive.com/dwarf-discuss@lists.dwarfstd.org/msg00326.html const llvm::Optional DWARFAddressSpace = llvm::None; -#endif const auto name = processDIName(type->toPrettyChars(true)); return DBuilder.createPointerType(CreateTypeDescription(nt), getTypeAllocSize(T) * 8, // size (bits) getABITypeAlign(T) * 8, // align (bits) -#if LDC_LLVM_VER >= 500 - DWARFAddressSpace, -#endif - name); + DWARFAddressSpace, name); } DIType DIBuilder::CreateVectorType(Type *type) { @@ -446,7 +429,7 @@ DIType DIBuilder::CreateComplexType(Type *type) { 0, // LineNo getTypeAllocSize(T) * 8, // size in bits getABITypeAlign(T) * 8, // alignment - DIFlagZero, // What here? + DIFlags::FlagZero, // What here? getNullDIType(), // derived from DBuilder.getOrCreateArray(elems), 0, // RunTimeLang @@ -483,7 +466,7 @@ DIType DIBuilder::CreateMemberType(unsigned linnum, Type *type, DIFile file, // find base type DIType basetype = CreateTypeDescription(t); - auto Flags = DIFlagZero; + auto Flags = DIFlags::FlagZero; switch (prot) { case Prot::private_: Flags = DIFlags::FlagPrivate; @@ -647,13 +630,14 @@ DIType DIBuilder::CreateCompositeType(Type *type) { if (t->ty == Tclass) { ret = DBuilder.createClassType( scope, name, file, lineNum, sizeInBits, alignmentInBits, - classOffsetInBits, DIFlagZero, derivedFrom, elemsArray, vtableHolder, - templateParams, uniqueIdentifier); + classOffsetInBits, DIFlags::FlagZero, derivedFrom, elemsArray, + vtableHolder, templateParams, uniqueIdentifier); } else { const auto runtimeLang = 0; - ret = DBuilder.createStructType( - scope, name, file, lineNum, sizeInBits, alignmentInBits, DIFlagZero, - derivedFrom, elemsArray, runtimeLang, vtableHolder, uniqueIdentifier); + ret = DBuilder.createStructType(scope, name, file, lineNum, sizeInBits, + alignmentInBits, DIFlags::FlagZero, + derivedFrom, elemsArray, runtimeLang, + vtableHolder, uniqueIdentifier); } irAggr->diCompositeType = @@ -681,7 +665,7 @@ DIType DIBuilder::CreateArrayType(Type *type) { 0, // LineNo getTypeAllocSize(T) * 8, // size in bits getABITypeAlign(T) * 8, // alignment in bits - DIFlagZero, // What here? + DIFlags::FlagZero, // What here? getNullDIType(), // derived from DBuilder.getOrCreateArray(elems), 0, // RunTimeLang @@ -742,7 +726,7 @@ DIType DIBuilder::CreateAArrayType(Type *type) { 0, // LineNo getTypeAllocSize(T) * 8, // size in bits getABITypeAlign(T) * 8, // alignment in bits - DIFlagZero, // What here? + DIFlags::FlagZero, // What here? getNullDIType(), // derived from DBuilder.getOrCreateArray(elems), 0, // RunTimeLang @@ -771,7 +755,7 @@ DISubroutineType DIBuilder::CreateFunctionType(Type *type) { assert(t->ctype); unsigned CC = t->ctype->getIrFuncTy().reverseParams ? DW_CC_D_dmd : 0; - return DBuilder.createSubroutineType(paramsArray, DIFlagZero, CC); + return DBuilder.createSubroutineType(paramsArray, DIFlags::FlagZero, CC); } DISubroutineType DIBuilder::CreateEmptyFunctionType() { @@ -799,7 +783,7 @@ DIType DIBuilder::CreateDelegateType(Type *type) { 0, // line number where defined getTypeAllocSize(T) * 8, // size in bits getABITypeAlign(T) * 8, // alignment in bits - DIFlagZero, // flags + DIFlags::FlagZero, // flags getNullDIType(), // derived from DBuilder.getOrCreateArray(elems), 0, // RunTimeLang @@ -827,13 +811,12 @@ DIType DIBuilder::CreateTypeDescription(Type *type) { if (t->ty == Tvoid) return nullptr; - if (t->ty == Tnull) // display null as void* + if (t->ty == Tnull) { + // display null as void* return DBuilder.createPointerType(CreateTypeDescription(Type::tvoid), 8, 8, -#if LDC_LLVM_VER >= 500 /* DWARFAddressSpace */ llvm::None, -#endif - "typeof(null)"); + } if (t->ty == Tvector) return CreateVectorType(type); if (t->isintegral() || t->isfloating()) { @@ -856,11 +839,7 @@ DIType DIBuilder::CreateTypeDescription(Type *type) { const auto aggregateDIType = CreateCompositeType(type); const auto name = (aggregateDIType->getName() + "*").str(); return DBuilder.createPointerType(aggregateDIType, getTypeAllocSize(T) * 8, - getABITypeAlign(T) * 8, -#if LDC_LLVM_VER >= 500 - llvm::None, -#endif - name); + getABITypeAlign(T) * 8, llvm::None, name); } if (t->ty == Tfunction) return CreateFunctionType(type); @@ -923,12 +902,8 @@ void DIBuilder::EmitCompileUnit(Module *m) { CUNode = DBuilder.createCompileUnit( global.params.symdebug == 2 ? llvm::dwarf::DW_LANG_C_plus_plus : llvm::dwarf::DW_LANG_D, -#if LDC_LLVM_VER >= 400 DBuilder.createFile(llvm::sys::path::filename(srcpath), llvm::sys::path::parent_path(srcpath)), -#else - llvm::sys::path::filename(srcpath), llvm::sys::path::parent_path(srcpath), -#endif producerName, isOptimizationEnabled(), // isOptimized llvm::StringRef(), // Flags TODO @@ -964,16 +939,7 @@ DIModule DIBuilder::EmitModule(Module *m) { DINamespace DIBuilder::EmitNamespace(Dsymbol *sym, llvm::StringRef name) { name = processDIName(name); const bool exportSymbols = true; - return DBuilder.createNameSpace(GetSymbolScope(sym), name -#if LDC_LLVM_VER < 500 - , - CreateFile(sym), sym->loc.linnum -#endif -#if LDC_LLVM_VER >= 400 - , - exportSymbols -#endif - ); + return DBuilder.createNameSpace(GetSymbolScope(sym), name, exportSymbols); } void DIBuilder::EmitImport(Import *im) { @@ -984,11 +950,9 @@ void DIBuilder::EmitImport(Import *im) { auto diModule = EmitModule(im->mod); DBuilder.createImportedModule(GetCurrentScope(), - diModule, // imported module -#if LDC_LLVM_VER >= 500 + diModule, // imported module CreateFile(im), // file -#endif - im->loc.linnum // line num + im->loc.linnum // line num ); } @@ -1075,7 +1039,7 @@ DISubprogram DIBuilder::CreateFunction(DIScope scope, llvm::StringRef name, unsigned lineNo, DISubroutineType ty, bool isLocalToUnit, bool isDefinition, bool isOptimized, unsigned scopeLine, - DIFlagsType flags) { + DIFlags flags) { #if LDC_LLVM_VER >= 800 const auto dispFlags = llvm::DISubprogram::toSPFlags(isLocalToUnit, isDefinition, isOptimized); @@ -1244,11 +1208,7 @@ void DIBuilder::EmitValue(llvm::Value *val, VarDeclaration *vd) { return; llvm::Instruction *instr = DBuilder.insertDbgValueIntrinsic( - val, -#if LDC_LLVM_VER < 600 - 0, -#endif - debugVariable, DBuilder.createExpression(), + val, debugVariable, DBuilder.createExpression(), IR->ir->getCurrentDebugLocation(), IR->scopebb()); instr->setDebugLoc(IR->ir->getCurrentDebugLocation()); } @@ -1323,7 +1283,7 @@ void DIBuilder::EmitLocalVariable(llvm::Value *ll, VarDeclaration *vd, const auto lineNum = vd->loc.linnum; const auto preserve = true; auto flags = !isThisPtr - ? DIFlagZero + ? DIFlags::FlagZero : DIFlags::FlagArtificial | DIFlags::FlagObjectPointer; DILocalVariable debugVariable; @@ -1382,11 +1342,7 @@ void DIBuilder::EmitGlobalVariable(llvm::GlobalVariable *llVar, OutBuffer mangleBuf; mangleToBuffer(vd, &mangleBuf); -#if LDC_LLVM_VER >= 400 auto DIVar = DBuilder.createGlobalVariableExpression( -#else - DBuilder.createGlobalVariable( -#endif scope, // context vd->toChars(), // name mangleBuf.peekChars(), // linkage name @@ -1397,17 +1353,11 @@ void DIBuilder::EmitGlobalVariable(llvm::GlobalVariable *llVar, #if LDC_LLVM_VER >= 1000 !(vd->storage_class & STCextern), // bool isDefined #endif -#if LDC_LLVM_VER >= 400 nullptr, // DIExpression *Expr -#else - llVar, // llvm::Constant *Val -#endif - Decl // declaration + Decl // declaration ); -#if LDC_LLVM_VER >= 400 llVar->addDebugInfo(DIVar); -#endif } void DIBuilder::Finalize() { diff --git a/gen/dibuilder.h b/gen/dibuilder.h index e5fed1e1bbc..22b76de9c60 100644 --- a/gen/dibuilder.h +++ b/gen/dibuilder.h @@ -55,13 +55,7 @@ using DISubroutineType = llvm::DISubroutineType *; using DISubprogram = llvm::DISubprogram *; using DIModule = llvm::DIModule *; using DICompileUnit = llvm::DICompileUnit *; -#if LDC_LLVM_VER >= 400 -using DIFlagsType = llvm::DINode::DIFlags; using DIFlags = llvm::DINode::DIFlags; -#else -using DIFlagsType = unsigned; -using DIFlags = llvm::DINode; -#endif class DIBuilder { IRState *const IR; @@ -196,7 +190,7 @@ class DIBuilder { unsigned lineNo, DISubroutineType ty, bool isLocalToUnit, bool isDefinition, bool isOptimized, unsigned scopeLine, - DIFlagsType flags); + DIFlags flags); DIType CreateCompositeType(Type *type); DIType CreateArrayType(Type *type); DIType CreateSArrayType(Type *type); @@ -221,11 +215,7 @@ class DIBuilder { uint64_t offset = gDataLayout->getStructLayout(type)->getElementOffset(index); -#if LDC_LLVM_VER >= 500 addr.push_back(llvm::dwarf::DW_OP_plus_uconst); -#else - addr.push_back(llvm::dwarf::DW_OP_plus); -#endif addr.push_back(offset); } diff --git a/gen/functions.cpp b/gen/functions.cpp index 2bd230cd997..c8c0ec3d654 100644 --- a/gen/functions.cpp +++ b/gen/functions.cpp @@ -469,15 +469,10 @@ void applyTargetMachineAttributes(llvm::Function &func, } // Floating point settings func.addFnAttr("unsafe-fp-math", TO.UnsafeFPMath ? "true" : "false"); - const bool lessPreciseFPMADOption = -#if LDC_LLVM_VER >= 500 - // This option was removed from llvm::TargetOptions in LLVM 5.0. - // Clang sets this to true when `-cl-mad-enable` is passed (OpenCL only). - // TODO: implement interface for this option. - false; -#else - TO.LessPreciseFPMADOption; -#endif + // This option was removed from llvm::TargetOptions in LLVM 5.0. + // Clang sets this to true when `-cl-mad-enable` is passed (OpenCL only). + // TODO: implement interface for this option. + const bool lessPreciseFPMADOption = false; func.addFnAttr("less-precise-fpmad", lessPreciseFPMADOption ? "true" : "false"); func.addFnAttr("no-infs-fp-math", TO.NoInfsFPMath ? "true" : "false"); @@ -1195,9 +1190,7 @@ void DtoDefineFunction(FuncDeclaration *fd, bool linkageAvailableExternally) { // matter at all llvm::Instruction *allocaPoint = new llvm::AllocaInst(LLType::getInt32Ty(gIR->context()), -#if LDC_LLVM_VER >= 500 0, // Address space -#endif "alloca_point", beginbb); funcGen.allocapoint = allocaPoint; @@ -1219,7 +1212,7 @@ void DtoDefineFunction(FuncDeclaration *fd, bool linkageAvailableExternally) { llvm::Attribute::get(gIR->context(), "frame-pointer", "all")); #else func->addAttribute( - LLAttributeSet::FunctionIndex, + LLAttributeList::FunctionIndex, llvm::Attribute::get(gIR->context(), "no-frame-pointer-elim", "true")); #endif } diff --git a/gen/inlineir.cpp b/gen/inlineir.cpp index e42fa337f11..b0062204915 100644 --- a/gen/inlineir.cpp +++ b/gen/inlineir.cpp @@ -38,7 +38,7 @@ struct TempDisableDiscardValueNames { void copyFnAttributes(llvm::Function *wannabe, llvm::Function *idol) { auto attrSet = idol->getAttributes(); auto fnAttrSet = attrSet.getFnAttributes(); - wannabe->addAttributes(LLAttributeSet::FunctionIndex, fnAttrSet); + wannabe->addAttributes(LLAttributeList::FunctionIndex, fnAttrSet); } llvm::StringRef exprToString(StringExp *strexp) { diff --git a/gen/irstate.h b/gen/irstate.h index 0f81bfc0f40..a47c276c003 100644 --- a/gen/irstate.h +++ b/gen/irstate.h @@ -251,13 +251,8 @@ struct IRState { std::set dynamicCompiledVars; /// Vector of options passed to the linker as metadata in object file. -#if LDC_LLVM_VER >= 500 llvm::SmallVector linkerOptions; llvm::SmallVector linkerDependentLibs; -#else - llvm::SmallVector linkerOptions; - llvm::SmallVector linkerDependentLibs; -#endif void addLinkerOption(llvm::ArrayRef options); void addLinkerDependentLib(llvm::StringRef libraryName); diff --git a/gen/llvmhelpers.cpp b/gen/llvmhelpers.cpp index ffd2fa1f203..e6d9dd7e741 100644 --- a/gen/llvmhelpers.cpp +++ b/gen/llvmhelpers.cpp @@ -49,15 +49,15 @@ llvm::cl::opt clThreadModel( "fthread-model", llvm::cl::ZeroOrMore, llvm::cl::desc("Thread model"), llvm::cl::init(llvm::GlobalVariable::GeneralDynamicTLSModel), - clEnumValues(clEnumValN(llvm::GlobalVariable::GeneralDynamicTLSModel, - "global-dynamic", - "Global dynamic TLS model (default)"), - clEnumValN(llvm::GlobalVariable::LocalDynamicTLSModel, - "local-dynamic", "Local dynamic TLS model"), - clEnumValN(llvm::GlobalVariable::InitialExecTLSModel, - "initial-exec", "Initial exec TLS model"), - clEnumValN(llvm::GlobalVariable::LocalExecTLSModel, - "local-exec", "Local exec TLS model"))); + llvm::cl::values(clEnumValN(llvm::GlobalVariable::GeneralDynamicTLSModel, + "global-dynamic", + "Global dynamic TLS model (default)"), + clEnumValN(llvm::GlobalVariable::LocalDynamicTLSModel, + "local-dynamic", "Local dynamic TLS model"), + clEnumValN(llvm::GlobalVariable::InitialExecTLSModel, + "initial-exec", "Initial exec TLS model"), + clEnumValN(llvm::GlobalVariable::LocalExecTLSModel, + "local-exec", "Local exec TLS model"))); /****************************************************************************** * Simple Triple helpers for DFE @@ -178,10 +178,7 @@ llvm::AllocaInst *DtoArrayAlloca(Type *type, unsigned arraysize, const char *name) { LLType *lltype = DtoType(type); auto ai = new llvm::AllocaInst( - lltype, -#if LDC_LLVM_VER >= 500 - gIR->module.getDataLayout().getAllocaAddrSpace(), -#endif + lltype, gIR->module.getDataLayout().getAllocaAddrSpace(), DtoConstUint(arraysize), name, gIR->topallocapoint()); ai->setAlignment(LLMaybeAlign(DtoAlignment(type))); return ai; @@ -189,12 +186,9 @@ llvm::AllocaInst *DtoArrayAlloca(Type *type, unsigned arraysize, llvm::AllocaInst *DtoRawAlloca(LLType *lltype, size_t alignment, const char *name) { - auto ai = - new llvm::AllocaInst(lltype, -#if LDC_LLVM_VER >= 500 - gIR->module.getDataLayout().getAllocaAddrSpace(), -#endif - name, gIR->topallocapoint()); + auto ai = new llvm::AllocaInst( + lltype, gIR->module.getDataLayout().getAllocaAddrSpace(), name, + gIR->topallocapoint()); if (alignment) { ai->setAlignment(LLMaybeAlign(alignment)); } @@ -1443,11 +1437,7 @@ bool isLLVMUnsigned(Type *t) { return t->isunsigned() || t->ty == Tpointer; } void printLabelName(std::ostream &target, const char *func_mangle, const char *label_name) { - target << gTargetMachine->getMCAsmInfo() - ->getPrivateGlobalPrefix() -#if LDC_LLVM_VER >= 400 - .str() -#endif + target << gTargetMachine->getMCAsmInfo()->getPrivateGlobalPrefix().str() << func_mangle << "_" << label_name; } diff --git a/gen/modules.cpp b/gen/modules.cpp index cfc13e41bfa..bf9d715cb6f 100644 --- a/gen/modules.cpp +++ b/gen/modules.cpp @@ -121,11 +121,7 @@ RegistryStyle getModuleRegistryStyle() { const auto &t = *global.params.targetTriple; if (t.isWindowsMSVCEnvironment() || - t.getEnvironment() == llvm::Triple::Android -#if LDC_LLVM_VER >= 500 - || t.isOSBinFormatWasm() -#endif - ) { + t.getEnvironment() == llvm::Triple::Android || t.isOSBinFormatWasm()) { return RegistryStyle::sectionSimple; } diff --git a/gen/nested.cpp b/gen/nested.cpp index 45bbd3152b1..ce2b250c328 100644 --- a/gen/nested.cpp +++ b/gen/nested.cpp @@ -171,9 +171,6 @@ DValue *DtoNestedVariable(Loc &loc, Type *astype, VarDeclaration *vd, } if (!skipDIDeclaration && global.params.symdebug) { -#if LDC_LLVM_VER < 500 - gIR->DBuilder.OpDeref(dwarfAddrOps); -#endif gIR->DBuilder.EmitLocalVariable(ctx, vd, nullptr, false, /*forceAsLocal=*/true, false, dwarfAddrOps); } @@ -524,11 +521,6 @@ void DtoCreateNestedContext(FuncGenState &funcGen) { if (global.params.symdebug) { LLSmallVector dwarfAddrOps; -#if LDC_LLVM_VER < 500 - // Because we are passing a GEP instead of an alloca to - // llvm.dbg.declare, we have to make the address dereference explicit. - gIR->DBuilder.OpDeref(dwarfAddrOps); -#endif gIR->DBuilder.EmitLocalVariable(gep, vd, nullptr, false, false, false, dwarfAddrOps); } diff --git a/gen/optimizer.cpp b/gen/optimizer.cpp index 31be36a8db5..5832251b0ae 100644 --- a/gen/optimizer.cpp +++ b/gen/optimizer.cpp @@ -18,6 +18,7 @@ #include "driver/cl_options_sanitizers.h" #include "driver/targetmachine.h" #include "llvm/ADT/Triple.h" +#include "llvm/Analysis/InlineCost.h" #include "llvm/Analysis/TargetLibraryInfo.h" #include "llvm/Analysis/TargetTransformInfo.h" #include "llvm/IR/DataLayout.h" @@ -31,9 +32,6 @@ #include "llvm/Transforms/Instrumentation.h" #include "llvm/Transforms/IPO.h" #include "llvm/Transforms/IPO/PassManagerBuilder.h" -#if LDC_LLVM_VER >= 400 -#include "llvm/Analysis/InlineCost.h" -#endif #if LDC_LLVM_VER >= 800 #include "llvm/Transforms/Instrumentation/MemorySanitizer.h" #include "llvm/Transforms/Instrumentation/ThreadSanitizer.h" @@ -50,7 +48,7 @@ using namespace llvm; static cl::opt optimizeLevel( cl::desc("Setting the optimization level:"), cl::ZeroOrMore, - clEnumValues( + cl::values( clEnumValN(3, "O", "Equivalent to -O3"), clEnumValN(0, "O0", "No optimizations (default)"), clEnumValN(1, "O1", "Simple optimizations"), @@ -233,7 +231,6 @@ static void addThreadSanitizerPass(const PassManagerBuilder &Builder, static void addSanitizerCoveragePass(const PassManagerBuilder &Builder, legacy::PassManagerBase &PM) { -#ifdef ENABLE_COVERAGE_SANITIZER #if LDC_LLVM_VER >= 1000 PM.add(createModuleSanitizerCoverageLegacyPassPass( opts::getSanitizerCoverageOptions())); @@ -241,7 +238,6 @@ static void addSanitizerCoveragePass(const PassManagerBuilder &Builder, PM.add( createSanitizerCoverageModulePass(opts::getSanitizerCoverageOptions())); #endif -#endif } // Adds PGO instrumentation generation and use passes. @@ -254,18 +250,13 @@ static void addPGOPasses(PassManagerBuilder &builder, options.InstrProfileOutput = global.params.datafileInstrProf; mpm.add(createInstrProfilingLegacyPass(options)); } else if (opts::isUsingASTBasedPGOProfile()) { -// We are generating code with PGO profile information available. -#if LDC_LLVM_VER >= 500 + // We are generating code with PGO profile information available. // Do indirect call promotion from -O1 if (optLevel > 0) { mpm.add(createPGOIndirectCallPromotionLegacyPass()); } -#endif - } - else if (opts::isInstrumentingForIRBasedPGO()) { -#if LDC_LLVM_VER >= 400 + } else if (opts::isInstrumentingForIRBasedPGO()) { builder.EnablePGOInstrGen = true; -#endif builder.PGOInstrGen = global.params.datafileInstrProf; } else if (opts::isUsingIRBasedPGOProfile()) { builder.PGOInstrUse = global.params.datafileInstrProf; @@ -293,18 +284,10 @@ static void addOptimizationPasses(legacy::PassManagerBase &mpm, builder.PrepareForThinLTO = opts::isUsingThinLTO(); if (willInline()) { -#if LDC_LLVM_VER >= 400 auto params = llvm::getInlineParams(optLevel, sizeLevel); builder.Inliner = createFunctionInliningPass(params); -#else - builder.Inliner = createFunctionInliningPass(optLevel, sizeLevel); -#endif } else { -#if LDC_LLVM_VER >= 400 builder.Inliner = createAlwaysInlinerLegacyPass(); -#else - builder.Inliner = createAlwaysInlinerPass(); -#endif } #if LDC_LLVM_VER < 900 builder.DisableUnitAtATime = !unitAtATime; diff --git a/gen/passes/GarbageCollect2Stack.cpp b/gen/passes/GarbageCollect2Stack.cpp index f58fc4e04bf..a726f844cb1 100644 --- a/gen/passes/GarbageCollect2Stack.cpp +++ b/gen/passes/GarbageCollect2Stack.cpp @@ -38,14 +38,11 @@ #include "llvm/Support/CommandLine.h" #include "llvm/Support/Compiler.h" #include "llvm/Support/Debug.h" +#include "llvm/Support/KnownBits.h" #include "llvm/Support/MathExtras.h" #include "llvm/Support/raw_ostream.h" #include -#if LDC_LLVM_VER >= 500 -#include "llvm/Support/KnownBits.h" -#endif - using namespace llvm; STATISTIC(NumGcToStack, "Number of calls promoted to constant-size allocas"); @@ -130,9 +127,7 @@ class FunctionInfo { // FIXME: set alignment on alloca? return new AllocaInst(Ty, -#if LDC_LLVM_VER >= 500 BB.getModule()->getDataLayout().getAllocaAddrSpace(), -#endif ".nongc_mem", Begin); } @@ -155,19 +150,11 @@ static bool isKnownLessThan(Value *Val, uint64_t Limit, const Analysis &A) { if (Bits > BitsLimit) { APInt Mask = APInt::getLowBitsSet(Bits, BitsLimit); Mask.flipAllBits(); -#if LDC_LLVM_VER >= 500 KnownBits Known(Bits); computeKnownBits(Val, Known, A.DL); if ((Known.Zero & Mask) != Mask) { return false; } -#else - APInt KnownZero(Bits, 0), KnownOne(Bits, 0); - computeKnownBits(Val, KnownZero, KnownOne, A.DL); - if ((KnownZero & Mask) != Mask) { - return false; - } -#endif } return true; @@ -850,13 +837,7 @@ bool isSafeToStackAllocate(BasicBlock::iterator Alloc, Value *V, CallSite::arg_iterator B = CS.arg_begin(), E = CS.arg_end(); for (CallSite::arg_iterator A = B; A != E; ++A) { if (A->get() == V) { -#if LDC_LLVM_VER < 500 - const unsigned paramHasAttr_firstArg = 1; -#else - const unsigned paramHasAttr_firstArg = 0; -#endif - if (!CS.paramHasAttr(A - B + paramHasAttr_firstArg, - llvm::Attribute::AttrKind::NoCapture)) { + if (!CS.paramHasAttr(A - B, llvm::Attribute::AttrKind::NoCapture)) { // The parameter is not marked 'nocapture' - captured. return false; } diff --git a/gen/pgo_ASTbased.cpp b/gen/pgo_ASTbased.cpp index 821bb074e36..a06a2e23256 100644 --- a/gen/pgo_ASTbased.cpp +++ b/gen/pgo_ASTbased.cpp @@ -37,7 +37,7 @@ namespace { llvm::cl::opt> enablePGOIndirectCalls( "pgo-indirect-calls", llvm::cl::ZeroOrMore, llvm::cl::Hidden, - llvm::cl::desc("(*) Enable PGO of indirect calls (LLVM >= 3.9)"), + llvm::cl::desc("(*) Enable PGO of indirect calls"), llvm::cl::init(true)); } @@ -141,12 +141,7 @@ class PGOHash { // Finalize the MD5 and return the hash. llvm::MD5::MD5Result Result; MD5.final(Result); -#if LDC_LLVM_VER >= 500 return Result.low(); -#else - using namespace llvm::support; - return endian::read(Result); -#endif } }; diff --git a/gen/pgo_ASTbased.h b/gen/pgo_ASTbased.h index 4ae62982865..a64548754be 100644 --- a/gen/pgo_ASTbased.h +++ b/gen/pgo_ASTbased.h @@ -118,7 +118,6 @@ class CodeGenPGO { /// Adds profiling instrumentation/annotation of indirect calls to `funcPtr` /// for callsite `callSite`. - /// Does nothing for LLVM < 3.9. void emitIndirectCallPGO(llvm::Instruction *callSite, llvm::Value *funcPtr); /// Adds profiling instrumentation/annotation of a certain value. @@ -128,7 +127,6 @@ class CodeGenPGO { /// code site `valueSite`, and the to be profiled value is given by /// `value`. `value` should be of LLVM i64 type, unless `ptrCastNeeded` is /// true, in which case a ptrtoint cast to i64 is added. - /// Does nothing for LLVM < 3.9. void valueProfile(uint32_t valueKind, llvm::Instruction *valueSite, llvm::Value *value, bool ptrCastNeeded); diff --git a/gen/runtime.cpp b/gen/runtime.cpp index f84f0f7b766..a2b1355f936 100644 --- a/gen/runtime.cpp +++ b/gen/runtime.cpp @@ -30,18 +30,13 @@ #include "ir/irfunction.h" #include "ir/irtype.h" #include "ir/irtypefunction.h" +#include "llvm/Bitcode/BitcodeWriter.h" #include "llvm/IR/Attributes.h" #include "llvm/IR/Module.h" #include "llvm/Support/CommandLine.h" #include "llvm/Support/MemoryBuffer.h" #include -#if LDC_LLVM_VER >= 400 -#include "llvm/Bitcode/BitcodeWriter.h" -#else -#include "llvm/Bitcode/ReaderWriter.h" -#endif - //////////////////////////////////////////////////////////////////////////////// static llvm::cl::opt nogc( @@ -502,38 +497,38 @@ static void buildRuntimeModule() { // Construct some attribute lists used below (possibly multiple times) AttrSet NoAttrs, - Attr_NoAlias(NoAttrs, LLAttributeSet::ReturnIndex, + Attr_NoAlias(NoAttrs, LLAttributeList::ReturnIndex, llvm::Attribute::NoAlias), - Attr_NoUnwind(NoAttrs, LLAttributeSet::FunctionIndex, + Attr_NoUnwind(NoAttrs, LLAttributeList::FunctionIndex, llvm::Attribute::NoUnwind), - Attr_ReadOnly(NoAttrs, LLAttributeSet::FunctionIndex, + Attr_ReadOnly(NoAttrs, LLAttributeList::FunctionIndex, llvm::Attribute::ReadOnly), - Attr_Cold(NoAttrs, LLAttributeSet::FunctionIndex, llvm::Attribute::Cold), - Attr_Cold_NoReturn(Attr_Cold, LLAttributeSet::FunctionIndex, + Attr_Cold(NoAttrs, LLAttributeList::FunctionIndex, llvm::Attribute::Cold), + Attr_Cold_NoReturn(Attr_Cold, LLAttributeList::FunctionIndex, llvm::Attribute::NoReturn), Attr_Cold_NoReturn_NoUnwind(Attr_Cold_NoReturn, - LLAttributeSet::FunctionIndex, + LLAttributeList::FunctionIndex, llvm::Attribute::NoUnwind), - Attr_ReadOnly_NoUnwind(Attr_ReadOnly, LLAttributeSet::FunctionIndex, + Attr_ReadOnly_NoUnwind(Attr_ReadOnly, LLAttributeList::FunctionIndex, llvm::Attribute::NoUnwind), - Attr_ReadOnly_1_NoCapture(Attr_ReadOnly, AttrSet::FirstArgIndex, + Attr_ReadOnly_1_NoCapture(Attr_ReadOnly, LLAttributeList::FirstArgIndex, llvm::Attribute::NoCapture), Attr_ReadOnly_1_3_NoCapture(Attr_ReadOnly_1_NoCapture, - AttrSet::FirstArgIndex + 2, + LLAttributeList::FirstArgIndex + 2, llvm::Attribute::NoCapture), Attr_ReadOnly_NoUnwind_1_NoCapture(Attr_ReadOnly_1_NoCapture, - LLAttributeSet::FunctionIndex, + LLAttributeList::FunctionIndex, llvm::Attribute::NoUnwind), Attr_ReadOnly_NoUnwind_1_2_NoCapture(Attr_ReadOnly_NoUnwind_1_NoCapture, - AttrSet::FirstArgIndex + 1, + LLAttributeList::FirstArgIndex + 1, llvm::Attribute::NoCapture), - Attr_1_NoCapture(NoAttrs, AttrSet::FirstArgIndex, + Attr_1_NoCapture(NoAttrs, LLAttributeList::FirstArgIndex, llvm::Attribute::NoCapture), - Attr_1_2_NoCapture(Attr_1_NoCapture, AttrSet::FirstArgIndex + 1, + Attr_1_2_NoCapture(Attr_1_NoCapture, LLAttributeList::FirstArgIndex + 1, llvm::Attribute::NoCapture), - Attr_1_3_NoCapture(Attr_1_NoCapture, AttrSet::FirstArgIndex + 2, + Attr_1_3_NoCapture(Attr_1_NoCapture, LLAttributeList::FirstArgIndex + 2, llvm::Attribute::NoCapture), - Attr_1_4_NoCapture(Attr_1_NoCapture, AttrSet::FirstArgIndex + 3, + Attr_1_4_NoCapture(Attr_1_NoCapture, LLAttributeList::FirstArgIndex + 3, llvm::Attribute::NoCapture); ////////////////////////////////////////////////////////////////////////////// diff --git a/gen/target.cpp b/gen/target.cpp index 172c21d182d..af8ef1baf47 100644 --- a/gen/target.cpp +++ b/gen/target.cpp @@ -106,15 +106,9 @@ void Target::_init(const Param ¶ms) { // Finalize RealProperties for the target's `real` type. const auto targetRealSemantics = &real->getFltSemantics(); -#if LDC_LLVM_VER >= 400 const auto IEEEdouble = &APFloat::IEEEdouble(); const auto x87DoubleExtended = &APFloat::x87DoubleExtended(); const auto IEEEquad = &APFloat::IEEEquad(); -#else - const auto IEEEdouble = &APFloat::IEEEdouble; - const auto x87DoubleExtended = &APFloat::x87DoubleExtended; - const auto IEEEquad = &APFloat::IEEEquad; -#endif RealProperties.nan = CTFloat::nan; RealProperties.infinity = CTFloat::infinity; @@ -233,10 +227,8 @@ Expression *Target::getTargetInfo(const char *name_, const Loc &loc) { objectFormat = "macho"; } else if (triple.isOSBinFormatELF()) { objectFormat = "elf"; -#if LDC_LLVM_VER >= 500 } else if (triple.isOSBinFormatWasm()) { objectFormat = "wasm"; -#endif } return createStringExp(objectFormat); } diff --git a/gen/tocall.cpp b/gen/tocall.cpp index bca3032a3e9..fb497446a8c 100644 --- a/gen/tocall.cpp +++ b/gen/tocall.cpp @@ -367,18 +367,10 @@ bool DtoLowerMagicIntrinsic(IRState *p, FuncDeclaration *fndecl, CallExp *e, } auto atomicOrdering = static_cast((*e->arguments)[0]->toInteger()); -#if LDC_LLVM_VER >= 500 llvm::SyncScope::ID scope = llvm::SyncScope::System; if (e->arguments->length == 2) { scope = static_cast((*e->arguments)[1]->toInteger()); } -#else - auto scope = llvm::SynchronizationScope::CrossThread; - if (e->arguments->length == 2) { - scope = static_cast( - (*e->arguments)[1]->toInteger()); - } -#endif p->ir->CreateFence(atomicOrdering, scope); return true; } @@ -1001,7 +993,7 @@ DValue *DtoCallFunction(Loc &loc, Type *resulttype, DValue *fnval, } // set calling convention and parameter attributes - LLAttributeSet &attrlist = attrs; + LLAttributeList &attrlist = attrs; if (dfnval && dfnval->func) { LLFunction *llfunc = llvm::dyn_cast(DtoRVal(dfnval)); if (llfunc && llfunc->isIntrinsic()) // override intrinsic attrs @@ -1016,14 +1008,9 @@ DValue *DtoCallFunction(Loc &loc, Type *resulttype, DValue *fnval, call.setCallingConv(callconv); } // merge in function attributes set in callOrInvoke -#if LDC_LLVM_VER >= 500 - attrlist = attrlist.addAttributes( - gIR->context(), LLAttributeSet::FunctionIndex, - llvm::AttrBuilder(call.getAttributes(), LLAttributeSet::FunctionIndex)); -#else attrlist = attrlist.addAttributes( - gIR->context(), LLAttributeSet::FunctionIndex, call.getAttributes()); -#endif + gIR->context(), LLAttributeList::FunctionIndex, + llvm::AttrBuilder(call.getAttributes(), LLAttributeList::FunctionIndex)); call.setAttributes(attrlist); // Special case for struct constructor calls: For temporaries, using the diff --git a/gen/trycatchfinally.cpp b/gen/trycatchfinally.cpp index dc08a80b6e5..b06c4ae3cdc 100644 --- a/gen/trycatchfinally.cpp +++ b/gen/trycatchfinally.cpp @@ -1,6 +1,6 @@ //===-- trycatchfinally.cpp -------------------------------------*- C++ -*-===// // -// LDC – the LLVM D compiler +// LDC – the LLVM D compiler // // This file is distributed under the BSD-style LDC license. See the LICENSE // file for details. @@ -366,13 +366,11 @@ llvm::BasicBlock *CleanupScope::run(IRState &irs, llvm::BasicBlock *sourceBlock, // We need a branch selector if we are here... if (!branchSelector) { // ... and have not created one yet, so do so now. - branchSelector = new llvm::AllocaInst(llvm::Type::getInt32Ty(irs.context()), -#if LDC_LLVM_VER >= 500 - irs.module.getDataLayout().getAllocaAddrSpace(), -#endif - llvm::Twine("branchsel.") + - beginBlock()->getName(), - irs.topallocapoint()); + branchSelector = new llvm::AllocaInst( + llvm::Type::getInt32Ty(irs.context()), + irs.module.getDataLayout().getAllocaAddrSpace(), + llvm::Twine("branchsel.") + beginBlock()->getName(), + irs.topallocapoint()); // Now we also need to store 0 to it to keep the paths that go to the // only existing branch target the same. @@ -674,17 +672,12 @@ TryCatchFinallyScopes::getLandingPadRef(CleanupCursor scope) { namespace { llvm::LandingPadInst *createLandingPadInst(IRState &irs) { - LLType *retType = - LLStructType::get(LLType::getInt8PtrTy(irs.context()), - LLType::getInt32Ty(irs.context()) -#if LDC_LLVM_VER < 500 - , nullptr -#endif - ); - if (!irs.func()->hasLLVMPersonalityFn()) { - irs.func()->setLLVMPersonalityFn( - getRuntimeFunction(Loc(), irs.module, "_d_eh_personality")); - } + LLType *retType = LLStructType::get(LLType::getInt8PtrTy(irs.context()), + LLType::getInt32Ty(irs.context())); + if (!irs.func()->hasLLVMPersonalityFn()) { + irs.func()->setLLVMPersonalityFn( + getRuntimeFunction(Loc(), irs.module, "_d_eh_personality")); + } return irs.ir->CreateLandingPad(retType, 0); } } diff --git a/gen/uda.cpp b/gen/uda.cpp index 21fbc87caa6..80fa194e567 100644 --- a/gen/uda.cpp +++ b/gen/uda.cpp @@ -20,7 +20,7 @@ namespace llvm { // Auto-generate: // Attribute::AttrKind getAttrKindFromName(StringRef AttrName) { ... } #define GET_ATTR_KIND_FROM_NAME -#if LDC_LLVM_VER >= 400 && LDC_LLVM_VER < 700 +#if LDC_LLVM_VER < 700 #include "llvm/IR/Attributes.gen" #else #include "llvm/IR/Attributes.inc" @@ -195,14 +195,7 @@ void applyAttrAllocSize(StructLiteralExp *sle, IrFunction *irFunc) { llvm::Function *func = irFunc->getLLVMFunc(); -#if LDC_LLVM_VER >= 500 - func->addAttributes(LLAttributeSet::FunctionIndex, builder); -#else - func->addAttributes(LLAttributeSet::FunctionIndex, - LLAttributeSet::get(func->getContext(), - LLAttributeSet::FunctionIndex, - builder)); -#endif + func->addAttributes(LLAttributeList::FunctionIndex, builder); } // @llvmAttr("key", "value") @@ -231,19 +224,9 @@ void applyAttrLLVMFastMathFlag(StructLiteralExp *sle, IrFunction *irFunc) { if (value == "clear") { irFunc->FMF.clear(); } else if (value == "fast") { -#if LDC_LLVM_VER >= 600 irFunc->FMF.setFast(); -#else - irFunc->FMF.setUnsafeAlgebra(); -#endif } else if (value == "contract") { -#if LDC_LLVM_VER >= 500 irFunc->FMF.setAllowContract(true); -#else - sle->warning("ignoring parameter `contract` for `@ldc.attributes.%s`: " - "LDC needs to be built against LLVM 5.0+ for support", - sle->sd->ident->toChars()); -#endif } else if (value == "nnan") { irFunc->FMF.setNoNaNs(); } else if (value == "ninf") { @@ -425,13 +408,7 @@ void applyFuncDeclUDAs(FuncDeclaration *decl, IrFunction *irFunc) { } else if (ident == Id::udaLLVMAttr) { llvm::AttrBuilder attrs; applyAttrLLVMAttr(sle, attrs); -#if LDC_LLVM_VER >= 500 - func->addAttributes(LLAttributeSet::FunctionIndex, attrs); -#else - AttrSet attrSet; - attrSet.addToFunction(attrs); - func->addAttributes(LLAttributeSet::FunctionIndex, attrSet); -#endif + func->addAttributes(LLAttributeList::FunctionIndex, attrs); } else if (ident == Id::udaLLVMFastMathFlag) { applyAttrLLVMFastMathFlag(sle, irFunc); } else if (ident == Id::udaOptStrategy) { diff --git a/ir/irfunction.cpp b/ir/irfunction.cpp index 017129eb1c0..af0adb742a7 100644 --- a/ir/irfunction.cpp +++ b/ir/irfunction.cpp @@ -28,14 +28,14 @@ IrFunction::IrFunction(FuncDeclaration *fd) } void IrFunction::setNeverInline() { - assert(!func->getAttributes().hasAttribute(LLAttributeSet::FunctionIndex, + assert(!func->getAttributes().hasAttribute(LLAttributeList::FunctionIndex, llvm::Attribute::AlwaysInline) && "function can't be never- and always-inline at the same time"); func->addFnAttr(llvm::Attribute::NoInline); } void IrFunction::setAlwaysInline() { - assert(!func->getAttributes().hasAttribute(LLAttributeSet::FunctionIndex, + assert(!func->getAttributes().hasAttribute(LLAttributeList::FunctionIndex, llvm::Attribute::NoInline) && "function can't be never- and always-inline at the same time"); func->addFnAttr(llvm::Attribute::AlwaysInline); diff --git a/runtime/druntime b/runtime/druntime index 3e4b769df61..19731a92a97 160000 --- a/runtime/druntime +++ b/runtime/druntime @@ -1 +1 @@ -Subproject commit 3e4b769df6124aa0044e11cc326f2761a56ac457 +Subproject commit 19731a92a97dbe4d7f7a4e15ceaff8444a1f879a diff --git a/runtime/jit-rt/cpp-so/disassembler.cpp b/runtime/jit-rt/cpp-so/disassembler.cpp index dc35205b530..79e477615a2 100644 --- a/runtime/jit-rt/cpp-so/disassembler.cpp +++ b/runtime/jit-rt/cpp-so/disassembler.cpp @@ -255,13 +255,8 @@ void disassemble(const llvm::TargetMachine &tm, llvm::MCObjectFileInfo mofi; llvm::MCContext ctx(mai, mri, &mofi); -#if LDC_LLVM_VER >= 600 mofi.InitMCObjectFileInfo(tm.getTargetTriple(), tm.isPositionIndependent(), ctx, tm.getCodeModel() == llvm::CodeModel::Large); -#else - mofi.InitMCObjectFileInfo(tm.getTargetTriple(), tm.isPositionIndependent(), - tm.getCodeModel(), ctx); -#endif auto disasm = unique(target.createMCDisassembler(*sti, ctx)); if (nullptr == disasm) { @@ -284,13 +279,7 @@ void disassemble(const llvm::TargetMachine &tm, } llvm::MCTargetOptions opts; - auto mab = unique(target.createMCAsmBackend( -#if LDC_LLVM_VER >= 600 - *sti, *mri, opts) -#else - *mri, tm.getTargetTriple().getTriple(), tm.getTargetCPU(), opts) -#endif - ); + auto mab = unique(target.createMCAsmBackend(*sti, *mri, opts)); if (nullptr == mab) { return; } diff --git a/runtime/jit-rt/cpp-so/jit_context.cpp b/runtime/jit-rt/cpp-so/jit_context.cpp index 0f191c09e14..2a783e18988 100644 --- a/runtime/jit-rt/cpp-so/jit_context.cpp +++ b/runtime/jit-rt/cpp-so/jit_context.cpp @@ -64,13 +64,8 @@ std::unique_ptr createTargetMachine() { std::unique_ptr ret(target->createTargetMachine( triple, llvm::sys::getHostCPUName(), llvm::join(getHostAttrs(), ","), {}, llvm::Optional{}, -#if LDC_LLVM_VER == 500 - llvm::CodeModel::JITDefault -#else llvm::Optional{}, llvm::CodeGenOpt::Default, - /*jit*/ true -#endif - )); + /*jit*/ true)); assert(ret != nullptr); return ret; } diff --git a/runtime/jit-rt/cpp-so/optimizer.cpp b/runtime/jit-rt/cpp-so/optimizer.cpp index b75cbd15a30..839911de26f 100644 --- a/runtime/jit-rt/cpp-so/optimizer.cpp +++ b/runtime/jit-rt/cpp-so/optimizer.cpp @@ -125,18 +125,10 @@ void addOptimizationPasses(llvm::legacy::PassManagerBase &mpm, // TODO: expose this option from jit if (/*willInline()*/ true) { -#if LDC_LLVM_VER >= 400 auto params = llvm::getInlineParams(optLevel, sizeLevel); builder.Inliner = llvm::createFunctionInliningPass(params); -#else - builder.Inliner = llvm::createFunctionInliningPass(optLevel, sizeLevel); -#endif } else { -#if LDC_LLVM_VER >= 400 builder.Inliner = llvm::createAlwaysInlinerLegacyPass(); -#else - builder.Inliner = llvm::createAlwaysInlinerPass(); -#endif } #if LDC_LLVM_VER < 900 builder.DisableUnitAtATime = false; diff --git a/runtime/jit-rt/cpp-so/options.cpp b/runtime/jit-rt/cpp-so/options.cpp index b1527a063bf..1fd31c92a14 100644 --- a/runtime/jit-rt/cpp-so/options.cpp +++ b/runtime/jit-rt/cpp-so/options.cpp @@ -36,20 +36,10 @@ bool parseOptions(Slice> args, CallbackOstream os(callback); // There is no Option::setDefault() before llvm 60 -#if LDC_LLVM_VER >= 600 llvm::cl::ResetAllOptionOccurrences(); for (auto &i : llvm::cl::getRegisteredOptions()) { i.second->setDefault(); } -#else - static bool changed = false; - if (changed) { - os << "Cannot set options more than once"; - os.flush(); - return false; - } - changed = true; -#endif auto res = llvm::cl::ParseCommandLineOptions( static_cast(tempOpts.size()), tempOpts.data(), "", &os); os.flush(); diff --git a/tests/PGO/irbased_indirect_calls.d b/tests/PGO/irbased_indirect_calls.d index 9649a430d2e..2b994de3e63 100644 --- a/tests/PGO/irbased_indirect_calls.d +++ b/tests/PGO/irbased_indirect_calls.d @@ -2,9 +2,6 @@ // REQUIRES: PGO_RT -// with LLVM 4.0, @optStrategy apparently doesn't suffice to prevent eliding the hot() call -// XFAIL: llvm400 - // RUN: %ldc -O3 -fprofile-generate=%t.profraw -run %s \ // RUN: && %profdata merge %t.profraw -o %t.profdata \ // RUN: && %ldc -O3 -c -output-ll -of=%t.use.ll -fprofile-use=%t.profdata %s \ diff --git a/tests/PGO/thinlto_pgo.d b/tests/PGO/thinlto_pgo.d index c58eecd5403..a797dfd51d6 100644 --- a/tests/PGO/thinlto_pgo.d +++ b/tests/PGO/thinlto_pgo.d @@ -1,7 +1,6 @@ // Test execution path for ThinLTO when PGO data is available. // I manually verified that PGO data is added to the ThinLTO module summary, but do not know how to automatically test this reliably. -// REQUIRES: atleast_llvm400 // REQUIRES: LTO // REQUIRES: PGO_RT diff --git a/tests/codegen/attr_allocsize_diag.d b/tests/codegen/attr_allocsize_diag.d index 10949662782..338fa02cd41 100644 --- a/tests/codegen/attr_allocsize_diag.d +++ b/tests/codegen/attr_allocsize_diag.d @@ -1,7 +1,5 @@ // Test ldc.attributes.allocSize diagnostics -// Although @allocSize is only effective for LLVM>=3.9, diagnostics should work for all LLVM versions - // RUN: not %ldc -d-version=NORMAL %s 2>&1 | FileCheck %s --check-prefix=NORMAL // RUN: not %ldc -d-version=THIS %s 2>&1 | FileCheck %s --check-prefix=THIS diff --git a/tests/codegen/attr_llvmFMF_contract.d b/tests/codegen/attr_llvmFMF_contract.d index 43dd6f77b5e..3a7bd80b1c8 100644 --- a/tests/codegen/attr_llvmFMF_contract.d +++ b/tests/codegen/attr_llvmFMF_contract.d @@ -1,7 +1,7 @@ // Tests the @ldc.attributes.llvmFastMathFlag("contract") UDA // Also tests that adding this attribute indeed leads to LLVM optimizing it to a fused multiply-add for a simple case. -// REQUIRES: atleast_llvm500, target_X86 +// REQUIRES: target_X86 // RUN: %ldc -c -output-ll -of=%t.ll %s && FileCheck %s --check-prefix LLVM < %t.ll // RUN: %ldc -betterC -mtriple=x86_64-linux-gnu -mattr=+fma -O3 -release -c -output-s -of=%t.s %s && FileCheck %s --check-prefix ASM < %t.s diff --git a/tests/codegen/avr.d b/tests/codegen/avr.d index 734deadecec..c473cc7dc12 100644 --- a/tests/codegen/avr.d +++ b/tests/codegen/avr.d @@ -1,4 +1,4 @@ -// REQUIRES: atleast_llvm400, target_AVR +// REQUIRES: target_AVR // RUN: %ldc -mtriple=avr -betterC -output-ll -of=%t.ll %s && FileCheck %s < %t.ll diff --git a/tests/codegen/fence_pragma.d b/tests/codegen/fence_pragma.d index 1bc879beaa5..f2715f91d35 100644 --- a/tests/codegen/fence_pragma.d +++ b/tests/codegen/fence_pragma.d @@ -1,12 +1,10 @@ // RUN: %ldc %s -c -output-ll -of=%t.ll && FileCheck %s < %t.ll -// REQUIRES: atmost_llvm400 - import ldc.intrinsics; void fun0 () { llvm_memory_fence(DefaultOrdering, SynchronizationScope.CrossThread); // CHECK: fence seq_cst llvm_memory_fence(DefaultOrdering, SynchronizationScope.SingleThread); - // CHECK: fence singlethread seq_cst + // CHECK: fence syncscope("singlethread") seq_cst } diff --git a/tests/codegen/fence_pragma2.d b/tests/codegen/fence_pragma2.d deleted file mode 100644 index 27a804318b1..00000000000 --- a/tests/codegen/fence_pragma2.d +++ /dev/null @@ -1,12 +0,0 @@ -// RUN: %ldc %s -c -output-ll -of=%t.ll && FileCheck %s < %t.ll - -// REQUIRES: atleast_llvm500 - -import ldc.intrinsics; - -void fun0 () { - llvm_memory_fence(DefaultOrdering, SynchronizationScope.CrossThread); - // CHECK: fence seq_cst - llvm_memory_fence(DefaultOrdering, SynchronizationScope.SingleThread); - // CHECK: fence syncscope("singlethread") seq_cst -} diff --git a/tests/codegen/linker_directives_linux.d b/tests/codegen/linker_directives_linux.d index 00cad7578eb..307a3deb052 100644 --- a/tests/codegen/linker_directives_linux.d +++ b/tests/codegen/linker_directives_linux.d @@ -1,6 +1,6 @@ // RUN: %ldc -mtriple=x86_64-linux-gnu -output-ll -of=%t.ll %s && FileCheck %s < %t.ll -// REQUIRES: atleast_llvm500, target_X86 +// REQUIRES: target_X86 // CHECK: !llvm.dependent-libraries = !{!0} // CHECK: !0 = !{!"mylib"} diff --git a/tests/codegen/linker_directives_mac.d b/tests/codegen/linker_directives_mac.d index 83c4e6d9370..f157857f562 100644 --- a/tests/codegen/linker_directives_mac.d +++ b/tests/codegen/linker_directives_mac.d @@ -1,6 +1,6 @@ // RUN: %ldc -mtriple=x86_64-apple-darwin -output-ll -of=%t.ll %s && FileCheck %s < %t.ll -// REQUIRES: atleast_llvm500, target_X86 +// REQUIRES: target_X86 // CHECK: !llvm.linker.options = !{!0, !1, !2} diff --git a/tests/codegen/linker_directives_win.d b/tests/codegen/linker_directives_win.d index 1c187e3c663..ac03ea88598 100644 --- a/tests/codegen/linker_directives_win.d +++ b/tests/codegen/linker_directives_win.d @@ -1,6 +1,6 @@ // RUN: %ldc -mtriple=x86_64-pc-windows-msvc -output-ll -of=%t.ll %s && FileCheck %s < %t.ll -// REQUIRES: atleast_llvm500, target_X86 +// REQUIRES: target_X86 // CHECK: !llvm.linker.options = !{!0, !1, !2} diff --git a/tests/codegen/vector_intrinsics_gh2962.d b/tests/codegen/vector_intrinsics_gh2962.d index 0aeb1a97e53..c0d274b75bf 100644 --- a/tests/codegen/vector_intrinsics_gh2962.d +++ b/tests/codegen/vector_intrinsics_gh2962.d @@ -1,4 +1,3 @@ -// REQUIRES: atleast_llvm500 // REQUIRES: host_X86 // RUN: %ldc -run %s diff --git a/tests/codegen/vector_ops.d b/tests/codegen/vector_ops.d index a469551ac45..3d71450d0f2 100644 --- a/tests/codegen/vector_ops.d +++ b/tests/codegen/vector_ops.d @@ -1,4 +1,3 @@ -// REQUIRES: atleast_llvm500 // RUN: %ldc -run %s import core.simd; diff --git a/tests/debuginfo/nested_cdb.d b/tests/debuginfo/nested_cdb.d index d4080200fcf..175897bb3c5 100644 --- a/tests/debuginfo/nested_cdb.d +++ b/tests/debuginfo/nested_cdb.d @@ -1,4 +1,3 @@ -// REQUIRES: atleast_llvm500 // REQUIRES: Windows // REQUIRES: cdb // RUN: %ldc -g -of=%t.exe %s diff --git a/tests/debuginfo/nested_gdb.d b/tests/debuginfo/nested_gdb.d index 76090049800..5d0aae7ec20 100644 --- a/tests/debuginfo/nested_gdb.d +++ b/tests/debuginfo/nested_gdb.d @@ -46,7 +46,7 @@ void encloser(int arg0, ref int arg1) // GDB: b 46 // GDB: c // GDB: p arg0 -// no-CHECK: $10 = 456 (`` for LLVM < 5.0) +// CHECK: $10 = 456 // GDB: p arg1 // CHECK: $11 = (int &) @{{0x[0-9a-f]*}}: 456 // GDB: p enc_n diff --git a/tests/driver/save_optimization_record.d b/tests/driver/save_optimization_record.d index 2fadd36b5d9..ab8764234ea 100644 --- a/tests/driver/save_optimization_record.d +++ b/tests/driver/save_optimization_record.d @@ -1,5 +1,3 @@ -// REQUIRES: atleast_llvm400 - // Automatic output filename generation from LL output file // RUN: %ldc -c -betterC -O3 -g -fsave-optimization-record -output-ll -of=%t.1.ll %s \ // RUN: && FileCheck %s --check-prefix=LLVM < %t.1.ll \ diff --git a/tests/dynamiccompile/options_multiple_changes.d b/tests/dynamiccompile/options_multiple_changes.d index 12124971240..ab5c0e72aaa 100644 --- a/tests/dynamiccompile/options_multiple_changes.d +++ b/tests/dynamiccompile/options_multiple_changes.d @@ -1,6 +1,5 @@ // RUN: %ldc -enable-dynamic-compile -run %s -// REQUIRES: atleast_llvm600 import std.stdio; import std.array; diff --git a/tests/instrument/xray_instrument.d b/tests/instrument/xray_instrument.d index 8b769f18b67..9b90261ecbf 100644 --- a/tests/instrument/xray_instrument.d +++ b/tests/instrument/xray_instrument.d @@ -1,5 +1,3 @@ -// REQUIRES: atleast_llvm500 - // RUN: %ldc -c -output-ll -fxray-instrument -of=%t.ll %s && FileCheck %s < %t.ll import ldc.attributes; diff --git a/tests/instrument/xray_instrument_threshold.d b/tests/instrument/xray_instrument_threshold.d index 07ad048050c..cb1d4a3c808 100644 --- a/tests/instrument/xray_instrument_threshold.d +++ b/tests/instrument/xray_instrument_threshold.d @@ -1,5 +1,3 @@ -// REQUIRES: atleast_llvm500 - // RUN: %ldc -c -output-ll -fxray-instrument -fxray-instruction-threshold=543 -of=%t.ll %s && FileCheck %s < %t.ll // CHECK-LABEL: define{{.*}} @{{.*}}10instrument diff --git a/tests/linking/ir2obj_caching_flags2.d b/tests/linking/ir2obj_caching_flags2.d index 782310130b4..d5828620ed2 100644 --- a/tests/linking/ir2obj_caching_flags2.d +++ b/tests/linking/ir2obj_caching_flags2.d @@ -1,8 +1,6 @@ // Test that certain cmdline flags result in different cache objects, even though the LLVM IR may be the same. // Test a few fsanitize-coverage options. -// REQUIRES: atleast_llvm500 - // Note that the NO_HIT tests should change the default setting of the tested flag. // Create and then empty the cache for correct testing when running the test multiple times. diff --git a/tests/linking/link_bitcode_libs.d b/tests/linking/link_bitcode_libs.d index 929eb2797b9..af5e18bc2f3 100644 --- a/tests/linking/link_bitcode_libs.d +++ b/tests/linking/link_bitcode_libs.d @@ -1,8 +1,5 @@ // Test passing of LLVM bitcode file with Linker Options set -// LLVM >= 5.0 uses llvm.linker.options instead. See link_bitcode_libs_500.d. -// REQUIRES: atmost_llvm400 - // Linker Options are currently only set on Windows platform, so we must (cross-)compile to Windows // REQUIRES: target_X86 @@ -13,8 +10,7 @@ pragma(lib, "library_one"); pragma(lib, "library_two"); -// CHECK: !"Linker Options", ![[ATTR_TUPLE:[0-9]+]] -// CHECK: ![[ATTR_TUPLE]] = !{![[ATTR_LIB1:[0-9]+]], ![[ATTR_LIB2:[0-9]+]], ![[ATTR_LIB3:[0-9]+]], ![[ATTR_LIB4:[0-9]+]]} +// CHECK: !llvm.linker.options = !{![[ATTR_LIB1:[0-9]+]], ![[ATTR_LIB2:[0-9]+]], ![[ATTR_LIB3:[0-9]+]], ![[ATTR_LIB4:[0-9]+]]} // CHECK: ![[ATTR_LIB1]]{{.*}}library_one // CHECK: ![[ATTR_LIB2]]{{.*}}library_two // CHECK: ![[ATTR_LIB3]]{{.*}}imported_one diff --git a/tests/linking/link_bitcode_libs_500.d b/tests/linking/link_bitcode_libs_500.d deleted file mode 100644 index d0be6f07259..00000000000 --- a/tests/linking/link_bitcode_libs_500.d +++ /dev/null @@ -1,19 +0,0 @@ -// Test passing of LLVM bitcode file with Linker Options set - -// REQUIRES: atleast_llvm500 - -// Linker Options are currently only set on Windows platform, so we must (cross-)compile to Windows -// REQUIRES: target_X86 - -// RUN: %ldc -mtriple=x86_64-windows -c -output-bc %S/inputs/link_bitcode_libs_input.d -of=%t.bc \ -// RUN: && %ldc -mtriple=x86_64-windows -c -singleobj -output-ll %t.bc %s -of=%t.ll \ -// RUN: && FileCheck %s < %t.ll - -pragma(lib, "library_one"); -pragma(lib, "library_two"); - -// CHECK: !llvm.linker.options = !{![[ATTR_LIB1:[0-9]+]], ![[ATTR_LIB2:[0-9]+]], ![[ATTR_LIB3:[0-9]+]], ![[ATTR_LIB4:[0-9]+]]} -// CHECK: ![[ATTR_LIB1]]{{.*}}library_one -// CHECK: ![[ATTR_LIB2]]{{.*}}library_two -// CHECK: ![[ATTR_LIB3]]{{.*}}imported_one -// CHECK: ![[ATTR_LIB4]]{{.*}}imported_two diff --git a/tests/linking/thinlto_modulecdtors.d b/tests/linking/thinlto_modulecdtors.d index 4ef8560f6bd..ca8765aea6d 100644 --- a/tests/linking/thinlto_modulecdtors.d +++ b/tests/linking/thinlto_modulecdtors.d @@ -1,6 +1,5 @@ // ThinLTO: Test that module ctors/dtors are called -// REQUIRES: atleast_llvm309 // REQUIRES: LTO // RUN: %ldc -flto=thin -O3 -run %s | FileCheck %s diff --git a/tests/lit.site.cfg.in b/tests/lit.site.cfg.in index 05ece97696f..9f051e1a981 100644 --- a/tests/lit.site.cfg.in +++ b/tests/lit.site.cfg.in @@ -82,9 +82,9 @@ config.available_features.add("llvm%d" % config.llvm_version) # config.llvm_version: 309, 400, 500, ... # plusoneable_llvmversion: 39, 40, 50, ... plusoneable_llvmversion = config.llvm_version // 10 + config.llvm_version%10 -for version in range(39, plusoneable_llvmversion+1): +for version in range(60, plusoneable_llvmversion+1): config.available_features.add("atleast_llvm%d0%d" % (version//10, version%10)) -for version in range(plusoneable_llvmversion, 91): +for version in range(plusoneable_llvmversion, 101): config.available_features.add("atmost_llvm%d0%d" % (version//10, version%10)) # Define OS as available feature (Windows, Darwin, Linux) diff --git a/tests/sanitizers/fsanitize_coverage.d b/tests/sanitizers/fsanitize_coverage.d index 0099b66f8ec..f25e9eda447 100644 --- a/tests/sanitizers/fsanitize_coverage.d +++ b/tests/sanitizers/fsanitize_coverage.d @@ -1,7 +1,5 @@ // Test basic coverage sanitizer functionality -// REQUIRES: atleast_llvm400 - // RUN: %ldc -c -output-ll -fsanitize-coverage=trace-pc-guard -of=%t.ll %s && FileCheck %s --check-prefix=PCGUARD < %t.ll // RUN: %ldc -c -output-ll -fsanitize-coverage=trace-pc-guard,trace-cmp -of=%t.cmp.ll %s && FileCheck %s --check-prefix=PCCMP < %t.cmp.ll // RUN: %ldc -c -output-ll -fsanitize-coverage=trace-pc-guard,func -of=%t.func.ll %s && FileCheck %s --check-prefix=PCFUNC < %t.func.ll diff --git a/tests/sanitizers/fsanitize_error_diagnostic.d b/tests/sanitizers/fsanitize_error_diagnostic.d index cdca8d25fd8..57717343e70 100644 --- a/tests/sanitizers/fsanitize_error_diagnostic.d +++ b/tests/sanitizers/fsanitize_error_diagnostic.d @@ -1,7 +1,5 @@ // Test sanitizer errors on unrecognized values -// REQUIRES: atleast_llvm400 - // RUN: not %ldc -c -fsanitize=poiuyt -fsanitize-coverage=aqswdefr %s 2>&1 | FileCheck %s // CHECK-DAG: Unrecognized -fsanitize value 'poiuyt' diff --git a/tests/sanitizers/fsanitize_fuzzer.d b/tests/sanitizers/fsanitize_fuzzer.d index 3da3cc953a0..969f11544c3 100644 --- a/tests/sanitizers/fsanitize_fuzzer.d +++ b/tests/sanitizers/fsanitize_fuzzer.d @@ -1,7 +1,5 @@ // Test basic Fuzz sanitizer functionality -// REQUIRES: atleast_llvm400 - // RUN: %ldc -c -output-ll -O3 -fsanitize=fuzzer -of=%t.ll %s && FileCheck %s < %t.ll // RUN: %ldc -c -output-ll -fsanitize=fuzzer,address -of=%t.asan.ll %s && FileCheck %s --check-prefix=CHECK --check-prefix=wASAN < %t.asan.ll diff --git a/tests/sanitizers/fuzz_asan.d b/tests/sanitizers/fuzz_asan.d index a44b350ff6c..3b79e181b52 100644 --- a/tests/sanitizers/fuzz_asan.d +++ b/tests/sanitizers/fuzz_asan.d @@ -1,6 +1,5 @@ // Test Fuzz+ASan functionality -// REQUIRES: atleast_llvm500 // REQUIRES: Fuzzer, ASan // See https://github.com/ldc-developers/ldc/issues/2222 for %disable_fp_elim diff --git a/tests/sanitizers/fuzz_basic.d b/tests/sanitizers/fuzz_basic.d index 6d4070242bf..77e4d7a4b82 100644 --- a/tests/sanitizers/fuzz_basic.d +++ b/tests/sanitizers/fuzz_basic.d @@ -1,6 +1,5 @@ // Test basic fuzz test crash -// REQUIRES: atleast_llvm500 // REQUIRES: Fuzzer // UNSUPPORTED: Windows diff --git a/tests/sanitizers/fuzz_mixin.d b/tests/sanitizers/fuzz_mixin.d index dc59203f1e5..912795347f7 100644 --- a/tests/sanitizers/fuzz_mixin.d +++ b/tests/sanitizers/fuzz_mixin.d @@ -1,6 +1,5 @@ // Test the basic fuzz target mixin for a D-signature fuzz target. -// REQUIRES: atleast_llvm500 // REQUIRES: Fuzzer // UNSUPPORTED: Windows diff --git a/tests/sanitizers/link_fuzzer.d b/tests/sanitizers/link_fuzzer.d index 09837bf7785..6f033334342 100644 --- a/tests/sanitizers/link_fuzzer.d +++ b/tests/sanitizers/link_fuzzer.d @@ -1,11 +1,10 @@ // Test linking C++ stdlib (or not) with -fsanitize=fuzzer -// REQUIRES: atleast_llvm500 // REQUIRES: Fuzzer // RUN: %ldc -v -fsanitize=fuzzer %s | FileCheck %s -// "libFuzzer.a" before LLVM 6.0, "lib(ldc|clang)_rt.fuzzer.*.a" since LLVM 6.0 -// CHECK: {{(libFuzzer\.a|_rt\.fuzzer.*\.a)}} +// "lib(ldc|clang)_rt.fuzzer.*.a" since LLVM 6.0 +// CHECK: {{_rt\.fuzzer.*\.a}} // CHECK-SAME: -l{{(std)?}}c++ // RUN: %ldc -v -fsanitize=fuzzer -link-no-cpp %s > %t_nocpp.log || true diff --git a/tools/ldc-profdata/llvm-profdata-3.9.cpp b/tools/ldc-profdata/llvm-profdata-3.9.cpp deleted file mode 100644 index 8e4b4c3d4ed..00000000000 --- a/tools/ldc-profdata/llvm-profdata-3.9.cpp +++ /dev/null @@ -1,560 +0,0 @@ -//===- llvm-profdata.cpp - LLVM profile data tool -------------------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// llvm-profdata merges .profdata files. -// -//===----------------------------------------------------------------------===// - -#include "llvm/ADT/SmallSet.h" -#include "llvm/ADT/SmallVector.h" -#include "llvm/ADT/StringRef.h" -#include "llvm/IR/LLVMContext.h" -#include "llvm/ProfileData/InstrProfReader.h" -#include "llvm/ProfileData/InstrProfWriter.h" -#include "llvm/ProfileData/ProfileCommon.h" -#include "llvm/ProfileData/SampleProfReader.h" -#include "llvm/ProfileData/SampleProfWriter.h" -#include "llvm/Support/CommandLine.h" -#include "llvm/Support/Errc.h" -#include "llvm/Support/FileSystem.h" -#include "llvm/Support/Format.h" -#include "llvm/Support/ManagedStatic.h" -#include "llvm/Support/MemoryBuffer.h" -#include "llvm/Support/Path.h" -#include "llvm/Support/PrettyStackTrace.h" -#include "llvm/Support/Signals.h" -#include "llvm/Support/raw_ostream.h" -#include - -using namespace llvm; - -enum ProfileFormat { PF_None = 0, PF_Text, PF_Binary, PF_GCC }; - -static void exitWithError(const Twine &Message, StringRef Whence = "", - StringRef Hint = "") { - errs() << "error: "; - if (!Whence.empty()) - errs() << Whence << ": "; - errs() << Message << "\n"; - if (!Hint.empty()) - errs() << Hint << "\n"; - ::exit(1); -} - -static void exitWithError(Error E, StringRef Whence = "") { - if (E.isA()) { - handleAllErrors(std::move(E), [&](const InstrProfError &IPE) { - instrprof_error instrError = IPE.get(); - StringRef Hint = ""; - if (instrError == instrprof_error::unrecognized_format) { - // Hint for common error of forgetting -sample for sample profiles. - Hint = "Perhaps you forgot to use the -sample option?"; - } - exitWithError(IPE.message(), Whence, Hint); - }); - } - - exitWithError(toString(std::move(E)), Whence); -} - -static void exitWithErrorCode(std::error_code EC, StringRef Whence = "") { - exitWithError(EC.message(), Whence); -} - -namespace { -enum ProfileKinds { instr, sample }; -} - -static void handleMergeWriterError(Error E, StringRef WhenceFile = "", - StringRef WhenceFunction = "", - bool ShowHint = true) { - if (!WhenceFile.empty()) - errs() << WhenceFile << ": "; - if (!WhenceFunction.empty()) - errs() << WhenceFunction << ": "; - - auto IPE = instrprof_error::success; - E = handleErrors(std::move(E), - [&IPE](std::unique_ptr E) -> Error { - IPE = E->get(); - return Error(std::move(E)); - }); - errs() << toString(std::move(E)) << "\n"; - - if (ShowHint) { - StringRef Hint = ""; - if (IPE != instrprof_error::success) { - switch (IPE) { - case instrprof_error::hash_mismatch: - case instrprof_error::count_mismatch: - case instrprof_error::value_site_count_mismatch: - Hint = "Make sure that all profile data to be merged is generated " - "from the same binary."; - break; - default: - break; - } - } - - if (!Hint.empty()) - errs() << Hint << "\n"; - } -} - -struct WeightedFile { - StringRef Filename; - uint64_t Weight; - - WeightedFile() {} - - WeightedFile(StringRef F, uint64_t W) : Filename{F}, Weight{W} {} -}; -typedef SmallVector WeightedFileVector; - -static void mergeInstrProfile(const WeightedFileVector &Inputs, - StringRef OutputFilename, - ProfileFormat OutputFormat, bool OutputSparse) { - if (OutputFilename.compare("-") == 0) - exitWithError("Cannot write indexed profdata format to stdout."); - - if (OutputFormat != PF_Binary && OutputFormat != PF_Text) - exitWithError("Unknown format is specified."); - - std::error_code EC; - raw_fd_ostream Output(OutputFilename.data(), EC, sys::fs::F_None); - if (EC) - exitWithErrorCode(EC, OutputFilename); - - InstrProfWriter Writer(OutputSparse); - SmallSet WriterErrorCodes; - for (const auto &Input : Inputs) { - auto ReaderOrErr = InstrProfReader::create(Input.Filename); - if (Error E = ReaderOrErr.takeError()) - exitWithError(std::move(E), Input.Filename); - - auto Reader = std::move(ReaderOrErr.get()); - bool IsIRProfile = Reader->isIRLevelProfile(); - if (Writer.setIsIRLevelProfile(IsIRProfile)) - exitWithError("Merge IR generated profile with Clang generated profile."); - - for (auto &I : *Reader) { - if (Error E = Writer.addRecord(std::move(I), Input.Weight)) { - // Only show hint the first time an error occurs. - instrprof_error IPE = InstrProfError::take(std::move(E)); - bool firstTime = WriterErrorCodes.insert(IPE).second; - handleMergeWriterError(make_error(IPE), Input.Filename, - I.Name, firstTime); - } - } - if (Reader->hasError()) - exitWithError(Reader->getError(), Input.Filename); - } - if (OutputFormat == PF_Text) - Writer.writeText(Output); - else - Writer.write(Output); -} - -static sampleprof::SampleProfileFormat FormatMap[] = { - sampleprof::SPF_None, sampleprof::SPF_Text, sampleprof::SPF_Binary, - sampleprof::SPF_GCC}; - -static void mergeSampleProfile(const WeightedFileVector &Inputs, - StringRef OutputFilename, - ProfileFormat OutputFormat) { - using namespace sampleprof; - auto WriterOrErr = - SampleProfileWriter::create(OutputFilename, FormatMap[OutputFormat]); - if (std::error_code EC = WriterOrErr.getError()) - exitWithErrorCode(EC, OutputFilename); - - auto Writer = std::move(WriterOrErr.get()); - StringMap ProfileMap; - SmallVector, 5> Readers; - LLVMContext Context; - for (const auto &Input : Inputs) { - auto ReaderOrErr = SampleProfileReader::create(Input.Filename, Context); - if (std::error_code EC = ReaderOrErr.getError()) - exitWithErrorCode(EC, Input.Filename); - - // We need to keep the readers around until after all the files are - // read so that we do not lose the function names stored in each - // reader's memory. The function names are needed to write out the - // merged profile map. - Readers.push_back(std::move(ReaderOrErr.get())); - const auto Reader = Readers.back().get(); - if (std::error_code EC = Reader->read()) - exitWithErrorCode(EC, Input.Filename); - - StringMap &Profiles = Reader->getProfiles(); - for (StringMap::iterator I = Profiles.begin(), - E = Profiles.end(); - I != E; ++I) { - StringRef FName = I->first(); - FunctionSamples &Samples = I->second; - sampleprof_error Result = ProfileMap[FName].merge(Samples, Input.Weight); - if (Result != sampleprof_error::success) { - std::error_code EC = make_error_code(Result); - handleMergeWriterError(errorCodeToError(EC), Input.Filename, FName); - } - } - } - Writer->write(ProfileMap); -} - -static WeightedFile parseWeightedFile(const StringRef &WeightedFilename) { - StringRef WeightStr, FileName; - std::tie(WeightStr, FileName) = WeightedFilename.split(','); - - uint64_t Weight; - if (WeightStr.getAsInteger(10, Weight) || Weight < 1) - exitWithError("Input weight must be a positive integer."); - - if (!sys::fs::exists(FileName)) - exitWithErrorCode(make_error_code(errc::no_such_file_or_directory), - FileName); - - return WeightedFile(FileName, Weight); -} - -static std::unique_ptr -getInputFilenamesFileBuf(const StringRef &InputFilenamesFile) { - if (InputFilenamesFile == "") - return {}; - - auto BufOrError = MemoryBuffer::getFileOrSTDIN(InputFilenamesFile); - if (!BufOrError) - exitWithErrorCode(BufOrError.getError(), InputFilenamesFile); - - return std::move(*BufOrError); -} - -static void parseInputFilenamesFile(MemoryBuffer *Buffer, - WeightedFileVector &WFV) { - if (!Buffer) - return; - - SmallVector Entries; - StringRef Data = Buffer->getBuffer(); - Data.split(Entries, '\n', /*MaxSplit=*/-1, /*KeepEmpty=*/false); - for (const StringRef &FileWeightEntry : Entries) { - StringRef SanitizedEntry = FileWeightEntry.trim(" \t\v\f\r"); - // Skip comments. - if (SanitizedEntry.startswith("#")) - continue; - // If there's no comma, it's an unweighted profile. - else if (SanitizedEntry.find(',') == StringRef::npos) - WFV.emplace_back(SanitizedEntry, 1); - else - WFV.emplace_back(parseWeightedFile(SanitizedEntry)); - } -} - -static int merge_main(int argc, const char *argv[]) { - cl::list InputFilenames(cl::Positional, - cl::desc("")); - cl::list WeightedInputFilenames("weighted-input", - cl::desc(",")); - cl::opt InputFilenamesFile( - "input-files", cl::init(""), - cl::desc("Path to file containing newline-separated " - "[,] entries")); - cl::alias InputFilenamesFileA("f", cl::desc("Alias for --input-files"), - cl::aliasopt(InputFilenamesFile)); - cl::opt DumpInputFileList( - "dump-input-file-list", cl::init(false), cl::Hidden, - cl::desc("Dump the list of input files and their weights, then exit")); - cl::opt OutputFilename("output", cl::value_desc("output"), - cl::init("-"), cl::Required, - cl::desc("Output file")); - cl::alias OutputFilenameA("o", cl::desc("Alias for --output"), - cl::aliasopt(OutputFilename)); - cl::opt ProfileKind( - cl::desc("Profile kind:"), cl::init(instr), - cl::values(clEnumVal(instr, "Instrumentation profile (default)"), - clEnumVal(sample, "Sample profile"), clEnumValEnd)); - cl::opt OutputFormat( - cl::desc("Format of output profile"), cl::init(PF_Binary), - cl::values(clEnumValN(PF_Binary, "binary", "Binary encoding (default)"), - clEnumValN(PF_Text, "text", "Text encoding"), - clEnumValN(PF_GCC, "gcc", - "GCC encoding (only meaningful for -sample)"), - clEnumValEnd)); - cl::opt OutputSparse("sparse", cl::init(false), - cl::desc("Generate a sparse profile (only meaningful for -instr)")); - - cl::ParseCommandLineOptions(argc, argv, "LLVM profile data merger\n"); - - WeightedFileVector WeightedInputs; - for (StringRef Filename : InputFilenames) - WeightedInputs.emplace_back(Filename, 1); - for (StringRef WeightedFilename : WeightedInputFilenames) - WeightedInputs.emplace_back(parseWeightedFile(WeightedFilename)); - - // Make sure that the file buffer stays alive for the duration of the - // weighted input vector's lifetime. - auto Buffer = getInputFilenamesFileBuf(InputFilenamesFile); - parseInputFilenamesFile(Buffer.get(), WeightedInputs); - - if (WeightedInputs.empty()) - exitWithError("No input files specified. See " + - sys::path::filename(argv[0]) + " -help"); - - if (DumpInputFileList) { - for (auto &WF : WeightedInputs) - outs() << WF.Weight << "," << WF.Filename << "\n"; - return 0; - } - - if (ProfileKind == instr) - mergeInstrProfile(WeightedInputs, OutputFilename, OutputFormat, - OutputSparse); - else - mergeSampleProfile(WeightedInputs, OutputFilename, OutputFormat); - - return 0; -} - -static int showInstrProfile(const std::string &Filename, bool ShowCounts, - bool ShowIndirectCallTargets, - bool ShowDetailedSummary, - std::vector DetailedSummaryCutoffs, - bool ShowAllFunctions, - const std::string &ShowFunction, bool TextFormat, - raw_fd_ostream &OS) { - auto ReaderOrErr = InstrProfReader::create(Filename); - std::vector Cutoffs = std::move(DetailedSummaryCutoffs); - if (ShowDetailedSummary && Cutoffs.empty()) { - Cutoffs = {800000, 900000, 950000, 990000, 999000, 999900, 999990}; - } - InstrProfSummaryBuilder Builder(std::move(Cutoffs)); - if (Error E = ReaderOrErr.takeError()) - exitWithError(std::move(E), Filename); - - auto Reader = std::move(ReaderOrErr.get()); - bool IsIRInstr = Reader->isIRLevelProfile(); - size_t ShownFunctions = 0; - uint64_t TotalNumValueSites = 0; - uint64_t TotalNumValueSitesWithValueProfile = 0; - uint64_t TotalNumValues = 0; - for (const auto &Func : *Reader) { - bool Show = - ShowAllFunctions || (!ShowFunction.empty() && - Func.Name.find(ShowFunction) != Func.Name.npos); - - bool doTextFormatDump = (Show && ShowCounts && TextFormat); - - if (doTextFormatDump) { - InstrProfSymtab &Symtab = Reader->getSymtab(); - InstrProfWriter::writeRecordInText(Func, Symtab, OS); - continue; - } - - assert(Func.Counts.size() > 0 && "function missing entry counter"); - Builder.addRecord(Func); - - if (Show) { - - if (!ShownFunctions) - OS << "Counters:\n"; - - ++ShownFunctions; - - OS << " " << Func.Name << ":\n" - << " Hash: " << format("0x%016" PRIx64, Func.Hash) << "\n" - << " Counters: " << Func.Counts.size() << "\n"; - if (!IsIRInstr) - OS << " Function count: " << Func.Counts[0] << "\n"; - - if (ShowIndirectCallTargets) - OS << " Indirect Call Site Count: " - << Func.getNumValueSites(IPVK_IndirectCallTarget) << "\n"; - - if (ShowCounts) { - OS << " Block counts: ["; - size_t Start = (IsIRInstr ? 0 : 1); - for (size_t I = Start, E = Func.Counts.size(); I < E; ++I) { - OS << (I == Start ? "" : ", ") << Func.Counts[I]; - } - OS << "]\n"; - } - - if (ShowIndirectCallTargets) { - InstrProfSymtab &Symtab = Reader->getSymtab(); - uint32_t NS = Func.getNumValueSites(IPVK_IndirectCallTarget); - OS << " Indirect Target Results: \n"; - TotalNumValueSites += NS; - for (size_t I = 0; I < NS; ++I) { - uint32_t NV = Func.getNumValueDataForSite(IPVK_IndirectCallTarget, I); - std::unique_ptr VD = - Func.getValueForSite(IPVK_IndirectCallTarget, I); - TotalNumValues += NV; - if (NV) - TotalNumValueSitesWithValueProfile++; - for (uint32_t V = 0; V < NV; V++) { - OS << "\t[ " << I << ", "; - OS << Symtab.getFuncName(VD[V].Value) << ", " << VD[V].Count - << " ]\n"; - } - } - } - } - } - if (Reader->hasError()) - exitWithError(Reader->getError(), Filename); - - if (ShowCounts && TextFormat) - return 0; - std::unique_ptr PS(Builder.getSummary()); - if (ShowAllFunctions || !ShowFunction.empty()) - OS << "Functions shown: " << ShownFunctions << "\n"; - OS << "Total functions: " << PS->getNumFunctions() << "\n"; - OS << "Maximum function count: " << PS->getMaxFunctionCount() << "\n"; - OS << "Maximum internal block count: " << PS->getMaxInternalCount() << "\n"; - if (ShownFunctions && ShowIndirectCallTargets) { - OS << "Total Number of Indirect Call Sites : " << TotalNumValueSites - << "\n"; - OS << "Total Number of Sites With Values : " - << TotalNumValueSitesWithValueProfile << "\n"; - OS << "Total Number of Profiled Values : " << TotalNumValues << "\n"; - } - - if (ShowDetailedSummary) { - OS << "Detailed summary:\n"; - OS << "Total number of blocks: " << PS->getNumCounts() << "\n"; - OS << "Total count: " << PS->getTotalCount() << "\n"; - for (auto Entry : PS->getDetailedSummary()) { - OS << Entry.NumCounts << " blocks with count >= " << Entry.MinCount - << " account for " - << format("%0.6g", (float)Entry.Cutoff / ProfileSummary::Scale * 100) - << " percentage of the total counts.\n"; - } - } - return 0; -} - -static int showSampleProfile(const std::string &Filename, bool ShowCounts, - bool ShowAllFunctions, - const std::string &ShowFunction, - raw_fd_ostream &OS) { - using namespace sampleprof; - LLVMContext Context; - auto ReaderOrErr = SampleProfileReader::create(Filename, Context); - if (std::error_code EC = ReaderOrErr.getError()) - exitWithErrorCode(EC, Filename); - - auto Reader = std::move(ReaderOrErr.get()); - if (std::error_code EC = Reader->read()) - exitWithErrorCode(EC, Filename); - - if (ShowAllFunctions || ShowFunction.empty()) - Reader->dump(OS); - else - Reader->dumpFunctionProfile(ShowFunction, OS); - - return 0; -} - -static int show_main(int argc, const char *argv[]) { - cl::opt Filename(cl::Positional, cl::Required, - cl::desc("")); - - cl::opt ShowCounts("counts", cl::init(false), - cl::desc("Show counter values for shown functions")); - cl::opt TextFormat( - "text", cl::init(false), - cl::desc("Show instr profile data in text dump format")); - cl::opt ShowIndirectCallTargets( - "ic-targets", cl::init(false), - cl::desc("Show indirect call site target values for shown functions")); - cl::opt ShowDetailedSummary("detailed-summary", cl::init(false), - cl::desc("Show detailed profile summary")); - cl::list DetailedSummaryCutoffs( - cl::CommaSeparated, "detailed-summary-cutoffs", - cl::desc( - "Cutoff percentages (times 10000) for generating detailed summary"), - cl::value_desc("800000,901000,999999")); - cl::opt ShowAllFunctions("all-functions", cl::init(false), - cl::desc("Details for every function")); - cl::opt ShowFunction("function", - cl::desc("Details for matching functions")); - - cl::opt OutputFilename("output", cl::value_desc("output"), - cl::init("-"), cl::desc("Output file")); - cl::alias OutputFilenameA("o", cl::desc("Alias for --output"), - cl::aliasopt(OutputFilename)); - cl::opt ProfileKind( - cl::desc("Profile kind:"), cl::init(instr), - cl::values(clEnumVal(instr, "Instrumentation profile (default)"), - clEnumVal(sample, "Sample profile"), clEnumValEnd)); - - cl::ParseCommandLineOptions(argc, argv, "LLVM profile data summary\n"); - - if (OutputFilename.empty()) - OutputFilename = "-"; - - std::error_code EC; - raw_fd_ostream OS(OutputFilename.data(), EC, sys::fs::F_Text); - if (EC) - exitWithErrorCode(EC, OutputFilename); - - if (ShowAllFunctions && !ShowFunction.empty()) - errs() << "warning: -function argument ignored: showing all functions\n"; - - std::vector Cutoffs(DetailedSummaryCutoffs.begin(), - DetailedSummaryCutoffs.end()); - if (ProfileKind == instr) - return showInstrProfile(Filename, ShowCounts, ShowIndirectCallTargets, - ShowDetailedSummary, DetailedSummaryCutoffs, - ShowAllFunctions, ShowFunction, TextFormat, OS); - else - return showSampleProfile(Filename, ShowCounts, ShowAllFunctions, - ShowFunction, OS); -} - -int main(int argc, const char *argv[]) { - // Print a stack trace if we signal out. - sys::PrintStackTraceOnErrorSignal(argv[0]); - PrettyStackTraceProgram X(argc, argv); - llvm_shutdown_obj Y; // Call llvm_shutdown() on exit. - - StringRef ProgName(sys::path::filename(argv[0])); - if (argc > 1) { - int (*func)(int, const char *[]) = nullptr; - - if (strcmp(argv[1], "merge") == 0) - func = merge_main; - else if (strcmp(argv[1], "show") == 0) - func = show_main; - - if (func) { - std::string Invocation(ProgName.str() + " " + argv[1]); - argv[1] = Invocation.c_str(); - return func(argc - 1, argv + 1); - } - - if (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "-help") == 0 || - strcmp(argv[1], "--help") == 0) { - - errs() << "OVERVIEW: LLVM profile data tools\n\n" - << "USAGE: " << ProgName << " [args...]\n" - << "USAGE: " << ProgName << " -help\n\n" - << "Available commands: merge, show\n"; - return 0; - } - } - - if (argc < 2) - errs() << ProgName << ": No command specified!\n"; - else - errs() << ProgName << ": Unknown command!\n"; - - errs() << "USAGE: " << ProgName << " [args...]\n"; - return 1; -} diff --git a/tools/ldc-profdata/llvm-profdata-4.0.cpp b/tools/ldc-profdata/llvm-profdata-4.0.cpp deleted file mode 100644 index 6715566a166..00000000000 --- a/tools/ldc-profdata/llvm-profdata-4.0.cpp +++ /dev/null @@ -1,696 +0,0 @@ -//===- llvm-profdata.cpp - LLVM profile data tool -------------------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// llvm-profdata merges .profdata files. -// -//===----------------------------------------------------------------------===// - -#include "llvm/ADT/SmallSet.h" -#include "llvm/ADT/SmallVector.h" -#include "llvm/ADT/StringRef.h" -#include "llvm/IR/LLVMContext.h" -#include "llvm/ProfileData/InstrProfReader.h" -#include "llvm/ProfileData/InstrProfWriter.h" -#include "llvm/ProfileData/ProfileCommon.h" -#include "llvm/ProfileData/SampleProfReader.h" -#include "llvm/ProfileData/SampleProfWriter.h" -#include "llvm/Support/CommandLine.h" -#include "llvm/Support/Errc.h" -#include "llvm/Support/FileSystem.h" -#include "llvm/Support/Format.h" -#include "llvm/Support/ManagedStatic.h" -#include "llvm/Support/MemoryBuffer.h" -#include "llvm/Support/Path.h" -#include "llvm/Support/PrettyStackTrace.h" -#include "llvm/Support/Signals.h" -#include "llvm/Support/ThreadPool.h" -#include "llvm/Support/raw_ostream.h" -#include - -using namespace llvm; - -enum ProfileFormat { PF_None = 0, PF_Text, PF_Binary, PF_GCC }; - -static void exitWithError(const Twine &Message, StringRef Whence = "", - StringRef Hint = "") { - errs() << "error: "; - if (!Whence.empty()) - errs() << Whence << ": "; - errs() << Message << "\n"; - if (!Hint.empty()) - errs() << Hint << "\n"; - ::exit(1); -} - -static void exitWithError(Error E, StringRef Whence = "") { - if (E.isA()) { - handleAllErrors(std::move(E), [&](const InstrProfError &IPE) { - instrprof_error instrError = IPE.get(); - StringRef Hint = ""; - if (instrError == instrprof_error::unrecognized_format) { - // Hint for common error of forgetting -sample for sample profiles. - Hint = "Perhaps you forgot to use the -sample option?"; - } - exitWithError(IPE.message(), Whence, Hint); - }); - } - - exitWithError(toString(std::move(E)), Whence); -} - -static void exitWithErrorCode(std::error_code EC, StringRef Whence = "") { - exitWithError(EC.message(), Whence); -} - -namespace { -enum ProfileKinds { instr, sample }; -} - -static void handleMergeWriterError(Error E, StringRef WhenceFile = "", - StringRef WhenceFunction = "", - bool ShowHint = true) { - if (!WhenceFile.empty()) - errs() << WhenceFile << ": "; - if (!WhenceFunction.empty()) - errs() << WhenceFunction << ": "; - - auto IPE = instrprof_error::success; - E = handleErrors(std::move(E), - [&IPE](std::unique_ptr E) -> Error { - IPE = E->get(); - return Error(std::move(E)); - }); - errs() << toString(std::move(E)) << "\n"; - - if (ShowHint) { - StringRef Hint = ""; - if (IPE != instrprof_error::success) { - switch (IPE) { - case instrprof_error::hash_mismatch: - case instrprof_error::count_mismatch: - case instrprof_error::value_site_count_mismatch: - Hint = "Make sure that all profile data to be merged is generated " - "from the same binary."; - break; - default: - break; - } - } - - if (!Hint.empty()) - errs() << Hint << "\n"; - } -} - -struct WeightedFile { - std::string Filename; - uint64_t Weight; -}; -typedef SmallVector WeightedFileVector; - -/// Keep track of merged data and reported errors. -struct WriterContext { - std::mutex Lock; - InstrProfWriter Writer; - Error Err; - StringRef ErrWhence; - std::mutex &ErrLock; - SmallSet &WriterErrorCodes; - - WriterContext(bool IsSparse, std::mutex &ErrLock, - SmallSet &WriterErrorCodes) - : Lock(), Writer(IsSparse), Err(Error::success()), ErrWhence(""), - ErrLock(ErrLock), WriterErrorCodes(WriterErrorCodes) {} -}; - -/// Load an input into a writer context. -static void loadInput(const WeightedFile &Input, WriterContext *WC) { - std::unique_lock CtxGuard{WC->Lock}; - - // If there's a pending hard error, don't do more work. - if (WC->Err) - return; - - WC->ErrWhence = Input.Filename; - - auto ReaderOrErr = InstrProfReader::create(Input.Filename); - if (Error E = ReaderOrErr.takeError()) { - // Skip the empty profiles by returning sliently. - instrprof_error IPE = InstrProfError::take(std::move(E)); - if (IPE != instrprof_error::empty_raw_profile) - WC->Err = make_error(IPE); - return; - } - - auto Reader = std::move(ReaderOrErr.get()); - bool IsIRProfile = Reader->isIRLevelProfile(); - if (WC->Writer.setIsIRLevelProfile(IsIRProfile)) { - WC->Err = make_error( - "Merge IR generated profile with Clang generated profile.", - std::error_code()); - return; - } - - for (auto &I : *Reader) { - const StringRef FuncName = I.Name; - if (Error E = WC->Writer.addRecord(std::move(I), Input.Weight)) { - // Only show hint the first time an error occurs. - instrprof_error IPE = InstrProfError::take(std::move(E)); - std::unique_lock ErrGuard{WC->ErrLock}; - bool firstTime = WC->WriterErrorCodes.insert(IPE).second; - handleMergeWriterError(make_error(IPE), Input.Filename, - FuncName, firstTime); - } - } - if (Reader->hasError()) - WC->Err = Reader->getError(); -} - -/// Merge the \p Src writer context into \p Dst. -static void mergeWriterContexts(WriterContext *Dst, WriterContext *Src) { - if (Error E = Dst->Writer.mergeRecordsFromWriter(std::move(Src->Writer))) - Dst->Err = std::move(E); -} - -static void mergeInstrProfile(const WeightedFileVector &Inputs, - StringRef OutputFilename, - ProfileFormat OutputFormat, bool OutputSparse, - unsigned NumThreads) { - if (OutputFilename.compare("-") == 0) - exitWithError("Cannot write indexed profdata format to stdout."); - - if (OutputFormat != PF_Binary && OutputFormat != PF_Text) - exitWithError("Unknown format is specified."); - - std::error_code EC; - raw_fd_ostream Output(OutputFilename.data(), EC, sys::fs::F_None); - if (EC) - exitWithErrorCode(EC, OutputFilename); - - std::mutex ErrorLock; - SmallSet WriterErrorCodes; - - // If NumThreads is not specified, auto-detect a good default. - if (NumThreads == 0) - NumThreads = std::max(1U, std::min(std::thread::hardware_concurrency(), - unsigned(Inputs.size() / 2))); - - // Initialize the writer contexts. - SmallVector, 4> Contexts; - for (unsigned I = 0; I < NumThreads; ++I) - Contexts.emplace_back(llvm::make_unique( - OutputSparse, ErrorLock, WriterErrorCodes)); - - if (NumThreads == 1) { - for (const auto &Input : Inputs) - loadInput(Input, Contexts[0].get()); - } else { - ThreadPool Pool(NumThreads); - - // Load the inputs in parallel (N/NumThreads serial steps). - unsigned Ctx = 0; - for (const auto &Input : Inputs) { - Pool.async(loadInput, Input, Contexts[Ctx].get()); - Ctx = (Ctx + 1) % NumThreads; - } - Pool.wait(); - - // Merge the writer contexts together (~ lg(NumThreads) serial steps). - unsigned Mid = Contexts.size() / 2; - unsigned End = Contexts.size(); - assert(Mid > 0 && "Expected more than one context"); - do { - for (unsigned I = 0; I < Mid; ++I) - Pool.async(mergeWriterContexts, Contexts[I].get(), - Contexts[I + Mid].get()); - Pool.wait(); - if (End & 1) { - Pool.async(mergeWriterContexts, Contexts[0].get(), - Contexts[End - 1].get()); - Pool.wait(); - } - End = Mid; - Mid /= 2; - } while (Mid > 0); - } - - // Handle deferred hard errors encountered during merging. - for (std::unique_ptr &WC : Contexts) - if (WC->Err) - exitWithError(std::move(WC->Err), WC->ErrWhence); - - InstrProfWriter &Writer = Contexts[0]->Writer; - if (OutputFormat == PF_Text) - Writer.writeText(Output); - else - Writer.write(Output); -} - -static sampleprof::SampleProfileFormat FormatMap[] = { - sampleprof::SPF_None, sampleprof::SPF_Text, sampleprof::SPF_Binary, - sampleprof::SPF_GCC}; - -static void mergeSampleProfile(const WeightedFileVector &Inputs, - StringRef OutputFilename, - ProfileFormat OutputFormat) { - using namespace sampleprof; - auto WriterOrErr = - SampleProfileWriter::create(OutputFilename, FormatMap[OutputFormat]); - if (std::error_code EC = WriterOrErr.getError()) - exitWithErrorCode(EC, OutputFilename); - - auto Writer = std::move(WriterOrErr.get()); - StringMap ProfileMap; - SmallVector, 5> Readers; - LLVMContext Context; - for (const auto &Input : Inputs) { - auto ReaderOrErr = SampleProfileReader::create(Input.Filename, Context); - if (std::error_code EC = ReaderOrErr.getError()) - exitWithErrorCode(EC, Input.Filename); - - // We need to keep the readers around until after all the files are - // read so that we do not lose the function names stored in each - // reader's memory. The function names are needed to write out the - // merged profile map. - Readers.push_back(std::move(ReaderOrErr.get())); - const auto Reader = Readers.back().get(); - if (std::error_code EC = Reader->read()) - exitWithErrorCode(EC, Input.Filename); - - StringMap &Profiles = Reader->getProfiles(); - for (StringMap::iterator I = Profiles.begin(), - E = Profiles.end(); - I != E; ++I) { - StringRef FName = I->first(); - FunctionSamples &Samples = I->second; - sampleprof_error Result = ProfileMap[FName].merge(Samples, Input.Weight); - if (Result != sampleprof_error::success) { - std::error_code EC = make_error_code(Result); - handleMergeWriterError(errorCodeToError(EC), Input.Filename, FName); - } - } - } - Writer->write(ProfileMap); -} - -static WeightedFile parseWeightedFile(const StringRef &WeightedFilename) { - StringRef WeightStr, FileName; - std::tie(WeightStr, FileName) = WeightedFilename.split(','); - - uint64_t Weight; - if (WeightStr.getAsInteger(10, Weight) || Weight < 1) - exitWithError("Input weight must be a positive integer."); - - return {FileName, Weight}; -} - -static std::unique_ptr -getInputFilenamesFileBuf(const StringRef &InputFilenamesFile) { - if (InputFilenamesFile == "") - return {}; - - auto BufOrError = MemoryBuffer::getFileOrSTDIN(InputFilenamesFile); - if (!BufOrError) - exitWithErrorCode(BufOrError.getError(), InputFilenamesFile); - - return std::move(*BufOrError); -} - -static void addWeightedInput(WeightedFileVector &WNI, const WeightedFile &WF) { - StringRef Filename = WF.Filename; - uint64_t Weight = WF.Weight; - - // If it's STDIN just pass it on. - if (Filename == "-") { - WNI.push_back({Filename, Weight}); - return; - } - - llvm::sys::fs::file_status Status; - llvm::sys::fs::status(Filename, Status); - if (!llvm::sys::fs::exists(Status)) - exitWithErrorCode(make_error_code(errc::no_such_file_or_directory), - Filename); - // If it's a source file, collect it. - if (llvm::sys::fs::is_regular_file(Status)) { - WNI.push_back({Filename, Weight}); - return; - } - - if (llvm::sys::fs::is_directory(Status)) { - std::error_code EC; - for (llvm::sys::fs::recursive_directory_iterator F(Filename, EC), E; - F != E && !EC; F.increment(EC)) { - if (llvm::sys::fs::is_regular_file(F->path())) { - addWeightedInput(WNI, {F->path(), Weight}); - } - } - if (EC) - exitWithErrorCode(EC, Filename); - } -} - -static void parseInputFilenamesFile(MemoryBuffer *Buffer, - WeightedFileVector &WFV) { - if (!Buffer) - return; - - SmallVector Entries; - StringRef Data = Buffer->getBuffer(); - Data.split(Entries, '\n', /*MaxSplit=*/-1, /*KeepEmpty=*/false); - for (const StringRef &FileWeightEntry : Entries) { - StringRef SanitizedEntry = FileWeightEntry.trim(" \t\v\f\r"); - // Skip comments. - if (SanitizedEntry.startswith("#")) - continue; - // If there's no comma, it's an unweighted profile. - else if (SanitizedEntry.find(',') == StringRef::npos) - addWeightedInput(WFV, {SanitizedEntry, 1}); - else - addWeightedInput(WFV, parseWeightedFile(SanitizedEntry)); - } -} - -static int merge_main(int argc, const char *argv[]) { - cl::list InputFilenames(cl::Positional, - cl::desc("")); - cl::list WeightedInputFilenames("weighted-input", - cl::desc(",")); - cl::opt InputFilenamesFile( - "input-files", cl::init(""), - cl::desc("Path to file containing newline-separated " - "[,] entries")); - cl::alias InputFilenamesFileA("f", cl::desc("Alias for --input-files"), - cl::aliasopt(InputFilenamesFile)); - cl::opt DumpInputFileList( - "dump-input-file-list", cl::init(false), cl::Hidden, - cl::desc("Dump the list of input files and their weights, then exit")); - cl::opt OutputFilename("output", cl::value_desc("output"), - cl::init("-"), cl::Required, - cl::desc("Output file")); - cl::alias OutputFilenameA("o", cl::desc("Alias for --output"), - cl::aliasopt(OutputFilename)); - cl::opt ProfileKind( - cl::desc("Profile kind:"), cl::init(instr), - cl::values(clEnumVal(instr, "Instrumentation profile (default)"), - clEnumVal(sample, "Sample profile"))); - cl::opt OutputFormat( - cl::desc("Format of output profile"), cl::init(PF_Binary), - cl::values(clEnumValN(PF_Binary, "binary", "Binary encoding (default)"), - clEnumValN(PF_Text, "text", "Text encoding"), - clEnumValN(PF_GCC, "gcc", - "GCC encoding (only meaningful for -sample)"))); - cl::opt OutputSparse("sparse", cl::init(false), - cl::desc("Generate a sparse profile (only meaningful for -instr)")); - cl::opt NumThreads( - "num-threads", cl::init(0), - cl::desc("Number of merge threads to use (default: autodetect)")); - cl::alias NumThreadsA("j", cl::desc("Alias for --num-threads"), - cl::aliasopt(NumThreads)); - - cl::ParseCommandLineOptions(argc, argv, "LLVM profile data merger\n"); - - WeightedFileVector WeightedInputs; - for (StringRef Filename : InputFilenames) - addWeightedInput(WeightedInputs, {Filename, 1}); - for (StringRef WeightedFilename : WeightedInputFilenames) - addWeightedInput(WeightedInputs, parseWeightedFile(WeightedFilename)); - - // Make sure that the file buffer stays alive for the duration of the - // weighted input vector's lifetime. - auto Buffer = getInputFilenamesFileBuf(InputFilenamesFile); - parseInputFilenamesFile(Buffer.get(), WeightedInputs); - - if (WeightedInputs.empty()) - exitWithError("No input files specified. See " + - sys::path::filename(argv[0]) + " -help"); - - if (DumpInputFileList) { - for (auto &WF : WeightedInputs) - outs() << WF.Weight << "," << WF.Filename << "\n"; - return 0; - } - - if (ProfileKind == instr) - mergeInstrProfile(WeightedInputs, OutputFilename, OutputFormat, - OutputSparse, NumThreads); - else - mergeSampleProfile(WeightedInputs, OutputFilename, OutputFormat); - - return 0; -} - -static int showInstrProfile(const std::string &Filename, bool ShowCounts, - bool ShowIndirectCallTargets, - bool ShowDetailedSummary, - std::vector DetailedSummaryCutoffs, - bool ShowAllFunctions, - const std::string &ShowFunction, bool TextFormat, - raw_fd_ostream &OS) { - auto ReaderOrErr = InstrProfReader::create(Filename); - std::vector Cutoffs = std::move(DetailedSummaryCutoffs); - if (ShowDetailedSummary && Cutoffs.empty()) { - Cutoffs = {800000, 900000, 950000, 990000, 999000, 999900, 999990}; - } - InstrProfSummaryBuilder Builder(std::move(Cutoffs)); - if (Error E = ReaderOrErr.takeError()) - exitWithError(std::move(E), Filename); - - auto Reader = std::move(ReaderOrErr.get()); - bool IsIRInstr = Reader->isIRLevelProfile(); - size_t ShownFunctions = 0; - uint64_t TotalNumValueSites = 0; - uint64_t TotalNumValueSitesWithValueProfile = 0; - uint64_t TotalNumValues = 0; - std::vector ICHistogram; - for (const auto &Func : *Reader) { - bool Show = - ShowAllFunctions || (!ShowFunction.empty() && - Func.Name.find(ShowFunction) != Func.Name.npos); - - bool doTextFormatDump = (Show && ShowCounts && TextFormat); - - if (doTextFormatDump) { - InstrProfSymtab &Symtab = Reader->getSymtab(); - InstrProfWriter::writeRecordInText(Func, Symtab, OS); - continue; - } - - assert(Func.Counts.size() > 0 && "function missing entry counter"); - Builder.addRecord(Func); - - if (Show) { - - if (!ShownFunctions) - OS << "Counters:\n"; - - ++ShownFunctions; - - OS << " " << Func.Name << ":\n" - << " Hash: " << format("0x%016" PRIx64, Func.Hash) << "\n" - << " Counters: " << Func.Counts.size() << "\n"; - if (!IsIRInstr) - OS << " Function count: " << Func.Counts[0] << "\n"; - - if (ShowIndirectCallTargets) - OS << " Indirect Call Site Count: " - << Func.getNumValueSites(IPVK_IndirectCallTarget) << "\n"; - - if (ShowCounts) { - OS << " Block counts: ["; - size_t Start = (IsIRInstr ? 0 : 1); - for (size_t I = Start, E = Func.Counts.size(); I < E; ++I) { - OS << (I == Start ? "" : ", ") << Func.Counts[I]; - } - OS << "]\n"; - } - - if (ShowIndirectCallTargets) { - InstrProfSymtab &Symtab = Reader->getSymtab(); - uint32_t NS = Func.getNumValueSites(IPVK_IndirectCallTarget); - OS << " Indirect Target Results: \n"; - TotalNumValueSites += NS; - for (size_t I = 0; I < NS; ++I) { - uint32_t NV = Func.getNumValueDataForSite(IPVK_IndirectCallTarget, I); - std::unique_ptr VD = - Func.getValueForSite(IPVK_IndirectCallTarget, I); - TotalNumValues += NV; - if (NV) { - TotalNumValueSitesWithValueProfile++; - if (NV > ICHistogram.size()) - ICHistogram.resize(NV, 0); - ICHistogram[NV - 1]++; - } - for (uint32_t V = 0; V < NV; V++) { - OS << "\t[ " << I << ", "; - OS << Symtab.getFuncName(VD[V].Value) << ", " << VD[V].Count - << " ]\n"; - } - } - } - } - } - if (Reader->hasError()) - exitWithError(Reader->getError(), Filename); - - if (ShowCounts && TextFormat) - return 0; - std::unique_ptr PS(Builder.getSummary()); - if (ShowAllFunctions || !ShowFunction.empty()) - OS << "Functions shown: " << ShownFunctions << "\n"; - OS << "Total functions: " << PS->getNumFunctions() << "\n"; - OS << "Maximum function count: " << PS->getMaxFunctionCount() << "\n"; - OS << "Maximum internal block count: " << PS->getMaxInternalCount() << "\n"; - if (ShownFunctions && ShowIndirectCallTargets) { - OS << "Total Number of Indirect Call Sites : " << TotalNumValueSites - << "\n"; - OS << "Total Number of Sites With Values : " - << TotalNumValueSitesWithValueProfile << "\n"; - OS << "Total Number of Profiled Values : " << TotalNumValues << "\n"; - - OS << "IC Value histogram : \n\tNumTargets, SiteCount\n"; - for (unsigned I = 0; I < ICHistogram.size(); I++) { - OS << "\t" << I + 1 << ", " << ICHistogram[I] << "\n"; - } - } - - if (ShowDetailedSummary) { - OS << "Detailed summary:\n"; - OS << "Total number of blocks: " << PS->getNumCounts() << "\n"; - OS << "Total count: " << PS->getTotalCount() << "\n"; - for (auto Entry : PS->getDetailedSummary()) { - OS << Entry.NumCounts << " blocks with count >= " << Entry.MinCount - << " account for " - << format("%0.6g", (float)Entry.Cutoff / ProfileSummary::Scale * 100) - << " percentage of the total counts.\n"; - } - } - return 0; -} - -static int showSampleProfile(const std::string &Filename, bool ShowCounts, - bool ShowAllFunctions, - const std::string &ShowFunction, - raw_fd_ostream &OS) { - using namespace sampleprof; - LLVMContext Context; - auto ReaderOrErr = SampleProfileReader::create(Filename, Context); - if (std::error_code EC = ReaderOrErr.getError()) - exitWithErrorCode(EC, Filename); - - auto Reader = std::move(ReaderOrErr.get()); - if (std::error_code EC = Reader->read()) - exitWithErrorCode(EC, Filename); - - if (ShowAllFunctions || ShowFunction.empty()) - Reader->dump(OS); - else - Reader->dumpFunctionProfile(ShowFunction, OS); - - return 0; -} - -static int show_main(int argc, const char *argv[]) { - cl::opt Filename(cl::Positional, cl::Required, - cl::desc("")); - - cl::opt ShowCounts("counts", cl::init(false), - cl::desc("Show counter values for shown functions")); - cl::opt TextFormat( - "text", cl::init(false), - cl::desc("Show instr profile data in text dump format")); - cl::opt ShowIndirectCallTargets( - "ic-targets", cl::init(false), - cl::desc("Show indirect call site target values for shown functions")); - cl::opt ShowDetailedSummary("detailed-summary", cl::init(false), - cl::desc("Show detailed profile summary")); - cl::list DetailedSummaryCutoffs( - cl::CommaSeparated, "detailed-summary-cutoffs", - cl::desc( - "Cutoff percentages (times 10000) for generating detailed summary"), - cl::value_desc("800000,901000,999999")); - cl::opt ShowAllFunctions("all-functions", cl::init(false), - cl::desc("Details for every function")); - cl::opt ShowFunction("function", - cl::desc("Details for matching functions")); - - cl::opt OutputFilename("output", cl::value_desc("output"), - cl::init("-"), cl::desc("Output file")); - cl::alias OutputFilenameA("o", cl::desc("Alias for --output"), - cl::aliasopt(OutputFilename)); - cl::opt ProfileKind( - cl::desc("Profile kind:"), cl::init(instr), - cl::values(clEnumVal(instr, "Instrumentation profile (default)"), - clEnumVal(sample, "Sample profile"))); - - cl::ParseCommandLineOptions(argc, argv, "LLVM profile data summary\n"); - - if (OutputFilename.empty()) - OutputFilename = "-"; - - std::error_code EC; - raw_fd_ostream OS(OutputFilename.data(), EC, sys::fs::F_Text); - if (EC) - exitWithErrorCode(EC, OutputFilename); - - if (ShowAllFunctions && !ShowFunction.empty()) - errs() << "warning: -function argument ignored: showing all functions\n"; - - std::vector Cutoffs(DetailedSummaryCutoffs.begin(), - DetailedSummaryCutoffs.end()); - if (ProfileKind == instr) - return showInstrProfile(Filename, ShowCounts, ShowIndirectCallTargets, - ShowDetailedSummary, DetailedSummaryCutoffs, - ShowAllFunctions, ShowFunction, TextFormat, OS); - else - return showSampleProfile(Filename, ShowCounts, ShowAllFunctions, - ShowFunction, OS); -} - -int main(int argc, const char *argv[]) { - // Print a stack trace if we signal out. - sys::PrintStackTraceOnErrorSignal(argv[0]); - PrettyStackTraceProgram X(argc, argv); - llvm_shutdown_obj Y; // Call llvm_shutdown() on exit. - - StringRef ProgName(sys::path::filename(argv[0])); - if (argc > 1) { - int (*func)(int, const char *[]) = nullptr; - - if (strcmp(argv[1], "merge") == 0) - func = merge_main; - else if (strcmp(argv[1], "show") == 0) - func = show_main; - - if (func) { - std::string Invocation(ProgName.str() + " " + argv[1]); - argv[1] = Invocation.c_str(); - return func(argc - 1, argv + 1); - } - - if (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "-help") == 0 || - strcmp(argv[1], "--help") == 0) { - - errs() << "OVERVIEW: LLVM profile data tools\n\n" - << "USAGE: " << ProgName << " [args...]\n" - << "USAGE: " << ProgName << " -help\n\n" - << "See each individual command --help for more details.\n" - << "Available commands: merge, show\n"; - return 0; - } - } - - if (argc < 2) - errs() << ProgName << ": No command specified!\n"; - else - errs() << ProgName << ": Unknown command!\n"; - - errs() << "USAGE: " << ProgName << " [args...]\n"; - return 1; -} diff --git a/tools/ldc-profdata/llvm-profdata-5.0.cpp b/tools/ldc-profdata/llvm-profdata-5.0.cpp deleted file mode 100644 index eee242107da..00000000000 --- a/tools/ldc-profdata/llvm-profdata-5.0.cpp +++ /dev/null @@ -1,798 +0,0 @@ -//===- llvm-profdata.cpp - LLVM profile data tool -------------------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// llvm-profdata merges .profdata files. -// -//===----------------------------------------------------------------------===// - -#include "llvm/ADT/SmallSet.h" -#include "llvm/ADT/SmallVector.h" -#include "llvm/ADT/StringRef.h" -#include "llvm/IR/LLVMContext.h" -#include "llvm/ProfileData/InstrProfReader.h" -#include "llvm/ProfileData/InstrProfWriter.h" -#include "llvm/ProfileData/ProfileCommon.h" -#include "llvm/ProfileData/SampleProfReader.h" -#include "llvm/ProfileData/SampleProfWriter.h" -#include "llvm/Support/CommandLine.h" -#include "llvm/Support/Errc.h" -#include "llvm/Support/FileSystem.h" -#include "llvm/Support/Format.h" -#include "llvm/Support/ManagedStatic.h" -#include "llvm/Support/MemoryBuffer.h" -#include "llvm/Support/Path.h" -#include "llvm/Support/PrettyStackTrace.h" -#include "llvm/Support/Signals.h" -#include "llvm/Support/ThreadPool.h" -#include "llvm/Support/raw_ostream.h" -#include - -using namespace llvm; - -enum ProfileFormat { PF_None = 0, PF_Text, PF_Binary, PF_GCC }; - -static void exitWithError(const Twine &Message, StringRef Whence = "", - StringRef Hint = "") { - errs() << "error: "; - if (!Whence.empty()) - errs() << Whence << ": "; - errs() << Message << "\n"; - if (!Hint.empty()) - errs() << Hint << "\n"; - ::exit(1); -} - -static void exitWithError(Error E, StringRef Whence = "") { - if (E.isA()) { - handleAllErrors(std::move(E), [&](const InstrProfError &IPE) { - instrprof_error instrError = IPE.get(); - StringRef Hint = ""; - if (instrError == instrprof_error::unrecognized_format) { - // Hint for common error of forgetting -sample for sample profiles. - Hint = "Perhaps you forgot to use the -sample option?"; - } - exitWithError(IPE.message(), Whence, Hint); - }); - } - - exitWithError(toString(std::move(E)), Whence); -} - -static void exitWithErrorCode(std::error_code EC, StringRef Whence = "") { - exitWithError(EC.message(), Whence); -} - -namespace { -enum ProfileKinds { instr, sample }; -} - -static void handleMergeWriterError(Error E, StringRef WhenceFile = "", - StringRef WhenceFunction = "", - bool ShowHint = true) { - if (!WhenceFile.empty()) - errs() << WhenceFile << ": "; - if (!WhenceFunction.empty()) - errs() << WhenceFunction << ": "; - - auto IPE = instrprof_error::success; - E = handleErrors(std::move(E), - [&IPE](std::unique_ptr E) -> Error { - IPE = E->get(); - return Error(std::move(E)); - }); - errs() << toString(std::move(E)) << "\n"; - - if (ShowHint) { - StringRef Hint = ""; - if (IPE != instrprof_error::success) { - switch (IPE) { - case instrprof_error::hash_mismatch: - case instrprof_error::count_mismatch: - case instrprof_error::value_site_count_mismatch: - Hint = "Make sure that all profile data to be merged is generated " - "from the same binary."; - break; - default: - break; - } - } - - if (!Hint.empty()) - errs() << Hint << "\n"; - } -} - -struct WeightedFile { - std::string Filename; - uint64_t Weight; -}; -typedef SmallVector WeightedFileVector; - -/// Keep track of merged data and reported errors. -struct WriterContext { - std::mutex Lock; - InstrProfWriter Writer; - Error Err; - StringRef ErrWhence; - std::mutex &ErrLock; - SmallSet &WriterErrorCodes; - - WriterContext(bool IsSparse, std::mutex &ErrLock, - SmallSet &WriterErrorCodes) - : Lock(), Writer(IsSparse), Err(Error::success()), ErrWhence(""), - ErrLock(ErrLock), WriterErrorCodes(WriterErrorCodes) {} -}; - -/// Load an input into a writer context. -static void loadInput(const WeightedFile &Input, WriterContext *WC) { - std::unique_lock CtxGuard{WC->Lock}; - - // If there's a pending hard error, don't do more work. - if (WC->Err) - return; - - WC->ErrWhence = Input.Filename; - - auto ReaderOrErr = InstrProfReader::create(Input.Filename); - if (Error E = ReaderOrErr.takeError()) { - // Skip the empty profiles by returning sliently. - instrprof_error IPE = InstrProfError::take(std::move(E)); - if (IPE != instrprof_error::empty_raw_profile) - WC->Err = make_error(IPE); - return; - } - - auto Reader = std::move(ReaderOrErr.get()); - bool IsIRProfile = Reader->isIRLevelProfile(); - if (WC->Writer.setIsIRLevelProfile(IsIRProfile)) { - WC->Err = make_error( - "Merge IR generated profile with Clang generated profile.", - std::error_code()); - return; - } - - for (auto &I : *Reader) { - const StringRef FuncName = I.Name; - bool Reported = false; - WC->Writer.addRecord(std::move(I), Input.Weight, [&](Error E) { - if (Reported) { - consumeError(std::move(E)); - return; - } - Reported = true; - // Only show hint the first time an error occurs. - instrprof_error IPE = InstrProfError::take(std::move(E)); - std::unique_lock ErrGuard{WC->ErrLock}; - bool firstTime = WC->WriterErrorCodes.insert(IPE).second; - handleMergeWriterError(make_error(IPE), Input.Filename, - FuncName, firstTime); - }); - } - if (Reader->hasError()) - WC->Err = Reader->getError(); -} - -/// Merge the \p Src writer context into \p Dst. -static void mergeWriterContexts(WriterContext *Dst, WriterContext *Src) { - bool Reported = false; - Dst->Writer.mergeRecordsFromWriter(std::move(Src->Writer), [&](Error E) { - if (Reported) { - consumeError(std::move(E)); - return; - } - Reported = true; - Dst->Err = std::move(E); - }); -} - -static void mergeInstrProfile(const WeightedFileVector &Inputs, - StringRef OutputFilename, - ProfileFormat OutputFormat, bool OutputSparse, - unsigned NumThreads) { - if (OutputFilename.compare("-") == 0) - exitWithError("Cannot write indexed profdata format to stdout."); - - if (OutputFormat != PF_Binary && OutputFormat != PF_Text) - exitWithError("Unknown format is specified."); - - std::error_code EC; - raw_fd_ostream Output(OutputFilename.data(), EC, sys::fs::F_None); - if (EC) - exitWithErrorCode(EC, OutputFilename); - - std::mutex ErrorLock; - SmallSet WriterErrorCodes; - - // If NumThreads is not specified, auto-detect a good default. - if (NumThreads == 0) - NumThreads = std::max(1U, std::min(std::thread::hardware_concurrency(), - unsigned(Inputs.size() / 2))); - - // Initialize the writer contexts. - SmallVector, 4> Contexts; - for (unsigned I = 0; I < NumThreads; ++I) - Contexts.emplace_back(llvm::make_unique( - OutputSparse, ErrorLock, WriterErrorCodes)); - - if (NumThreads == 1) { - for (const auto &Input : Inputs) - loadInput(Input, Contexts[0].get()); - } else { - ThreadPool Pool(NumThreads); - - // Load the inputs in parallel (N/NumThreads serial steps). - unsigned Ctx = 0; - for (const auto &Input : Inputs) { - Pool.async(loadInput, Input, Contexts[Ctx].get()); - Ctx = (Ctx + 1) % NumThreads; - } - Pool.wait(); - - // Merge the writer contexts together (~ lg(NumThreads) serial steps). - unsigned Mid = Contexts.size() / 2; - unsigned End = Contexts.size(); - assert(Mid > 0 && "Expected more than one context"); - do { - for (unsigned I = 0; I < Mid; ++I) - Pool.async(mergeWriterContexts, Contexts[I].get(), - Contexts[I + Mid].get()); - Pool.wait(); - if (End & 1) { - Pool.async(mergeWriterContexts, Contexts[0].get(), - Contexts[End - 1].get()); - Pool.wait(); - } - End = Mid; - Mid /= 2; - } while (Mid > 0); - } - - // Handle deferred hard errors encountered during merging. - for (std::unique_ptr &WC : Contexts) - if (WC->Err) - exitWithError(std::move(WC->Err), WC->ErrWhence); - - InstrProfWriter &Writer = Contexts[0]->Writer; - if (OutputFormat == PF_Text) { - if (Error E = Writer.writeText(Output)) - exitWithError(std::move(E)); - } else { - Writer.write(Output); - } -} - -static sampleprof::SampleProfileFormat FormatMap[] = { - sampleprof::SPF_None, sampleprof::SPF_Text, sampleprof::SPF_Binary, - sampleprof::SPF_GCC}; - -static void mergeSampleProfile(const WeightedFileVector &Inputs, - StringRef OutputFilename, - ProfileFormat OutputFormat) { - using namespace sampleprof; - auto WriterOrErr = - SampleProfileWriter::create(OutputFilename, FormatMap[OutputFormat]); - if (std::error_code EC = WriterOrErr.getError()) - exitWithErrorCode(EC, OutputFilename); - - auto Writer = std::move(WriterOrErr.get()); - StringMap ProfileMap; - SmallVector, 5> Readers; - LLVMContext Context; - for (const auto &Input : Inputs) { - auto ReaderOrErr = SampleProfileReader::create(Input.Filename, Context); - if (std::error_code EC = ReaderOrErr.getError()) - exitWithErrorCode(EC, Input.Filename); - - // We need to keep the readers around until after all the files are - // read so that we do not lose the function names stored in each - // reader's memory. The function names are needed to write out the - // merged profile map. - Readers.push_back(std::move(ReaderOrErr.get())); - const auto Reader = Readers.back().get(); - if (std::error_code EC = Reader->read()) - exitWithErrorCode(EC, Input.Filename); - - StringMap &Profiles = Reader->getProfiles(); - for (StringMap::iterator I = Profiles.begin(), - E = Profiles.end(); - I != E; ++I) { - StringRef FName = I->first(); - FunctionSamples &Samples = I->second; - sampleprof_error Result = ProfileMap[FName].merge(Samples, Input.Weight); - if (Result != sampleprof_error::success) { - std::error_code EC = make_error_code(Result); - handleMergeWriterError(errorCodeToError(EC), Input.Filename, FName); - } - } - } - Writer->write(ProfileMap); -} - -static WeightedFile parseWeightedFile(const StringRef &WeightedFilename) { - StringRef WeightStr, FileName; - std::tie(WeightStr, FileName) = WeightedFilename.split(','); - - uint64_t Weight; - if (WeightStr.getAsInteger(10, Weight) || Weight < 1) - exitWithError("Input weight must be a positive integer."); - - return {FileName, Weight}; -} - -static std::unique_ptr -getInputFilenamesFileBuf(const StringRef &InputFilenamesFile) { - if (InputFilenamesFile == "") - return {}; - - auto BufOrError = MemoryBuffer::getFileOrSTDIN(InputFilenamesFile); - if (!BufOrError) - exitWithErrorCode(BufOrError.getError(), InputFilenamesFile); - - return std::move(*BufOrError); -} - -static void addWeightedInput(WeightedFileVector &WNI, const WeightedFile &WF) { - StringRef Filename = WF.Filename; - uint64_t Weight = WF.Weight; - - // If it's STDIN just pass it on. - if (Filename == "-") { - WNI.push_back({Filename, Weight}); - return; - } - - llvm::sys::fs::file_status Status; - llvm::sys::fs::status(Filename, Status); - if (!llvm::sys::fs::exists(Status)) - exitWithErrorCode(make_error_code(errc::no_such_file_or_directory), - Filename); - // If it's a source file, collect it. - if (llvm::sys::fs::is_regular_file(Status)) { - WNI.push_back({Filename, Weight}); - return; - } - - if (llvm::sys::fs::is_directory(Status)) { - std::error_code EC; - for (llvm::sys::fs::recursive_directory_iterator F(Filename, EC), E; - F != E && !EC; F.increment(EC)) { - if (llvm::sys::fs::is_regular_file(F->path())) { - addWeightedInput(WNI, {F->path(), Weight}); - } - } - if (EC) - exitWithErrorCode(EC, Filename); - } -} - -static void parseInputFilenamesFile(MemoryBuffer *Buffer, - WeightedFileVector &WFV) { - if (!Buffer) - return; - - SmallVector Entries; - StringRef Data = Buffer->getBuffer(); - Data.split(Entries, '\n', /*MaxSplit=*/-1, /*KeepEmpty=*/false); - for (const StringRef &FileWeightEntry : Entries) { - StringRef SanitizedEntry = FileWeightEntry.trim(" \t\v\f\r"); - // Skip comments. - if (SanitizedEntry.startswith("#")) - continue; - // If there's no comma, it's an unweighted profile. - else if (SanitizedEntry.find(',') == StringRef::npos) - addWeightedInput(WFV, {SanitizedEntry, 1}); - else - addWeightedInput(WFV, parseWeightedFile(SanitizedEntry)); - } -} - -static int merge_main(int argc, const char *argv[]) { - cl::list InputFilenames(cl::Positional, - cl::desc("")); - cl::list WeightedInputFilenames("weighted-input", - cl::desc(",")); - cl::opt InputFilenamesFile( - "input-files", cl::init(""), - cl::desc("Path to file containing newline-separated " - "[,] entries")); - cl::alias InputFilenamesFileA("f", cl::desc("Alias for --input-files"), - cl::aliasopt(InputFilenamesFile)); - cl::opt DumpInputFileList( - "dump-input-file-list", cl::init(false), cl::Hidden, - cl::desc("Dump the list of input files and their weights, then exit")); - cl::opt OutputFilename("output", cl::value_desc("output"), - cl::init("-"), cl::Required, - cl::desc("Output file")); - cl::alias OutputFilenameA("o", cl::desc("Alias for --output"), - cl::aliasopt(OutputFilename)); - cl::opt ProfileKind( - cl::desc("Profile kind:"), cl::init(instr), - cl::values(clEnumVal(instr, "Instrumentation profile (default)"), - clEnumVal(sample, "Sample profile"))); - cl::opt OutputFormat( - cl::desc("Format of output profile"), cl::init(PF_Binary), - cl::values(clEnumValN(PF_Binary, "binary", "Binary encoding (default)"), - clEnumValN(PF_Text, "text", "Text encoding"), - clEnumValN(PF_GCC, "gcc", - "GCC encoding (only meaningful for -sample)"))); - cl::opt OutputSparse("sparse", cl::init(false), - cl::desc("Generate a sparse profile (only meaningful for -instr)")); - cl::opt NumThreads( - "num-threads", cl::init(0), - cl::desc("Number of merge threads to use (default: autodetect)")); - cl::alias NumThreadsA("j", cl::desc("Alias for --num-threads"), - cl::aliasopt(NumThreads)); - - cl::ParseCommandLineOptions(argc, argv, "LLVM profile data merger\n"); - - WeightedFileVector WeightedInputs; - for (StringRef Filename : InputFilenames) - addWeightedInput(WeightedInputs, {Filename, 1}); - for (StringRef WeightedFilename : WeightedInputFilenames) - addWeightedInput(WeightedInputs, parseWeightedFile(WeightedFilename)); - - // Make sure that the file buffer stays alive for the duration of the - // weighted input vector's lifetime. - auto Buffer = getInputFilenamesFileBuf(InputFilenamesFile); - parseInputFilenamesFile(Buffer.get(), WeightedInputs); - - if (WeightedInputs.empty()) - exitWithError("No input files specified. See " + - sys::path::filename(argv[0]) + " -help"); - - if (DumpInputFileList) { - for (auto &WF : WeightedInputs) - outs() << WF.Weight << "," << WF.Filename << "\n"; - return 0; - } - - if (ProfileKind == instr) - mergeInstrProfile(WeightedInputs, OutputFilename, OutputFormat, - OutputSparse, NumThreads); - else - mergeSampleProfile(WeightedInputs, OutputFilename, OutputFormat); - - return 0; -} - -typedef struct ValueSitesStats { - ValueSitesStats() - : TotalNumValueSites(0), TotalNumValueSitesWithValueProfile(0), - TotalNumValues(0) {} - uint64_t TotalNumValueSites; - uint64_t TotalNumValueSitesWithValueProfile; - uint64_t TotalNumValues; - std::vector ValueSitesHistogram; -} ValueSitesStats; - -static void traverseAllValueSites(const InstrProfRecord &Func, uint32_t VK, - ValueSitesStats &Stats, raw_fd_ostream &OS, - InstrProfSymtab *Symtab) { - uint32_t NS = Func.getNumValueSites(VK); - Stats.TotalNumValueSites += NS; - for (size_t I = 0; I < NS; ++I) { - uint32_t NV = Func.getNumValueDataForSite(VK, I); - std::unique_ptr VD = Func.getValueForSite(VK, I); - Stats.TotalNumValues += NV; - if (NV) { - Stats.TotalNumValueSitesWithValueProfile++; - if (NV > Stats.ValueSitesHistogram.size()) - Stats.ValueSitesHistogram.resize(NV, 0); - Stats.ValueSitesHistogram[NV - 1]++; - } - for (uint32_t V = 0; V < NV; V++) { - OS << "\t[ " << I << ", "; - if (Symtab == nullptr) - OS << VD[V].Value; - else - OS << Symtab->getFuncName(VD[V].Value); - OS << ", " << VD[V].Count << " ]\n"; - } - } -} - -static void showValueSitesStats(raw_fd_ostream &OS, uint32_t VK, - ValueSitesStats &Stats) { - OS << " Total number of sites: " << Stats.TotalNumValueSites << "\n"; - OS << " Total number of sites with values: " - << Stats.TotalNumValueSitesWithValueProfile << "\n"; - OS << " Total number of profiled values: " << Stats.TotalNumValues << "\n"; - - OS << " Value sites histogram:\n\tNumTargets, SiteCount\n"; - for (unsigned I = 0; I < Stats.ValueSitesHistogram.size(); I++) { - if (Stats.ValueSitesHistogram[I] > 0) - OS << "\t" << I + 1 << ", " << Stats.ValueSitesHistogram[I] << "\n"; - } -} - -static int showInstrProfile(const std::string &Filename, bool ShowCounts, - uint32_t TopN, bool ShowIndirectCallTargets, - bool ShowMemOPSizes, bool ShowDetailedSummary, - std::vector DetailedSummaryCutoffs, - bool ShowAllFunctions, - const std::string &ShowFunction, bool TextFormat, - raw_fd_ostream &OS) { - auto ReaderOrErr = InstrProfReader::create(Filename); - std::vector Cutoffs = std::move(DetailedSummaryCutoffs); - if (ShowDetailedSummary && Cutoffs.empty()) { - Cutoffs = {800000, 900000, 950000, 990000, 999000, 999900, 999990}; - } - InstrProfSummaryBuilder Builder(std::move(Cutoffs)); - if (Error E = ReaderOrErr.takeError()) - exitWithError(std::move(E), Filename); - - auto Reader = std::move(ReaderOrErr.get()); - bool IsIRInstr = Reader->isIRLevelProfile(); - size_t ShownFunctions = 0; - int NumVPKind = IPVK_Last - IPVK_First + 1; - std::vector VPStats(NumVPKind); - - auto MinCmp = [](const std::pair &v1, - const std::pair &v2) { - return v1.second > v2.second; - }; - - std::priority_queue, - std::vector>, - decltype(MinCmp)> - HottestFuncs(MinCmp); - - for (const auto &Func : *Reader) { - bool Show = - ShowAllFunctions || (!ShowFunction.empty() && - Func.Name.find(ShowFunction) != Func.Name.npos); - - bool doTextFormatDump = (Show && ShowCounts && TextFormat); - - if (doTextFormatDump) { - InstrProfSymtab &Symtab = Reader->getSymtab(); - InstrProfWriter::writeRecordInText(Func.Name, Func.Hash, Func, Symtab, - OS); - continue; - } - - assert(Func.Counts.size() > 0 && "function missing entry counter"); - Builder.addRecord(Func); - - if (TopN) { - uint64_t FuncMax = 0; - for (size_t I = 0, E = Func.Counts.size(); I < E; ++I) - FuncMax = std::max(FuncMax, Func.Counts[I]); - - if (HottestFuncs.size() == TopN) { - if (HottestFuncs.top().second < FuncMax) { - HottestFuncs.pop(); - HottestFuncs.emplace(std::make_pair(std::string(Func.Name), FuncMax)); - } - } else - HottestFuncs.emplace(std::make_pair(std::string(Func.Name), FuncMax)); - } - - if (Show) { - - if (!ShownFunctions) - OS << "Counters:\n"; - - ++ShownFunctions; - - OS << " " << Func.Name << ":\n" - << " Hash: " << format("0x%016" PRIx64, Func.Hash) << "\n" - << " Counters: " << Func.Counts.size() << "\n"; - if (!IsIRInstr) - OS << " Function count: " << Func.Counts[0] << "\n"; - - if (ShowIndirectCallTargets) - OS << " Indirect Call Site Count: " - << Func.getNumValueSites(IPVK_IndirectCallTarget) << "\n"; - - uint32_t NumMemOPCalls = Func.getNumValueSites(IPVK_MemOPSize); - if (ShowMemOPSizes && NumMemOPCalls > 0) - OS << " Number of Memory Intrinsics Calls: " << NumMemOPCalls - << "\n"; - - if (ShowCounts) { - OS << " Block counts: ["; - size_t Start = (IsIRInstr ? 0 : 1); - for (size_t I = Start, E = Func.Counts.size(); I < E; ++I) { - OS << (I == Start ? "" : ", ") << Func.Counts[I]; - } - OS << "]\n"; - } - - if (ShowIndirectCallTargets) { - OS << " Indirect Target Results:\n"; - traverseAllValueSites(Func, IPVK_IndirectCallTarget, - VPStats[IPVK_IndirectCallTarget], OS, - &(Reader->getSymtab())); - } - - if (ShowMemOPSizes && NumMemOPCalls > 0) { - OS << " Memory Intrinsic Size Results:\n"; - traverseAllValueSites(Func, IPVK_MemOPSize, VPStats[IPVK_MemOPSize], OS, - nullptr); - } - } - } - if (Reader->hasError()) - exitWithError(Reader->getError(), Filename); - - if (ShowCounts && TextFormat) - return 0; - std::unique_ptr PS(Builder.getSummary()); - if (ShowAllFunctions || !ShowFunction.empty()) - OS << "Functions shown: " << ShownFunctions << "\n"; - OS << "Total functions: " << PS->getNumFunctions() << "\n"; - OS << "Maximum function count: " << PS->getMaxFunctionCount() << "\n"; - OS << "Maximum internal block count: " << PS->getMaxInternalCount() << "\n"; - - if (TopN) { - std::vector> SortedHottestFuncs; - while (!HottestFuncs.empty()) { - SortedHottestFuncs.emplace_back(HottestFuncs.top()); - HottestFuncs.pop(); - } - OS << "Top " << TopN - << " functions with the largest internal block counts: \n"; - for (auto &hotfunc : llvm::reverse(SortedHottestFuncs)) - OS << " " << hotfunc.first << ", max count = " << hotfunc.second << "\n"; - } - - if (ShownFunctions && ShowIndirectCallTargets) { - OS << "Statistics for indirect call sites profile:\n"; - showValueSitesStats(OS, IPVK_IndirectCallTarget, - VPStats[IPVK_IndirectCallTarget]); - } - - if (ShownFunctions && ShowMemOPSizes) { - OS << "Statistics for memory intrinsic calls sizes profile:\n"; - showValueSitesStats(OS, IPVK_MemOPSize, VPStats[IPVK_MemOPSize]); - } - - if (ShowDetailedSummary) { - OS << "Detailed summary:\n"; - OS << "Total number of blocks: " << PS->getNumCounts() << "\n"; - OS << "Total count: " << PS->getTotalCount() << "\n"; - for (auto Entry : PS->getDetailedSummary()) { - OS << Entry.NumCounts << " blocks with count >= " << Entry.MinCount - << " account for " - << format("%0.6g", (float)Entry.Cutoff / ProfileSummary::Scale * 100) - << " percentage of the total counts.\n"; - } - } - return 0; -} - -static int showSampleProfile(const std::string &Filename, bool ShowCounts, - bool ShowAllFunctions, - const std::string &ShowFunction, - raw_fd_ostream &OS) { - using namespace sampleprof; - LLVMContext Context; - auto ReaderOrErr = SampleProfileReader::create(Filename, Context); - if (std::error_code EC = ReaderOrErr.getError()) - exitWithErrorCode(EC, Filename); - - auto Reader = std::move(ReaderOrErr.get()); - if (std::error_code EC = Reader->read()) - exitWithErrorCode(EC, Filename); - - if (ShowAllFunctions || ShowFunction.empty()) - Reader->dump(OS); - else - Reader->dumpFunctionProfile(ShowFunction, OS); - - return 0; -} - -static int show_main(int argc, const char *argv[]) { - cl::opt Filename(cl::Positional, cl::Required, - cl::desc("")); - - cl::opt ShowCounts("counts", cl::init(false), - cl::desc("Show counter values for shown functions")); - cl::opt TextFormat( - "text", cl::init(false), - cl::desc("Show instr profile data in text dump format")); - cl::opt ShowIndirectCallTargets( - "ic-targets", cl::init(false), - cl::desc("Show indirect call site target values for shown functions")); - cl::opt ShowMemOPSizes( - "memop-sizes", cl::init(false), - cl::desc("Show the profiled sizes of the memory intrinsic calls " - "for shown functions")); - cl::opt ShowDetailedSummary("detailed-summary", cl::init(false), - cl::desc("Show detailed profile summary")); - cl::list DetailedSummaryCutoffs( - cl::CommaSeparated, "detailed-summary-cutoffs", - cl::desc( - "Cutoff percentages (times 10000) for generating detailed summary"), - cl::value_desc("800000,901000,999999")); - cl::opt ShowAllFunctions("all-functions", cl::init(false), - cl::desc("Details for every function")); - cl::opt ShowFunction("function", - cl::desc("Details for matching functions")); - - cl::opt OutputFilename("output", cl::value_desc("output"), - cl::init("-"), cl::desc("Output file")); - cl::alias OutputFilenameA("o", cl::desc("Alias for --output"), - cl::aliasopt(OutputFilename)); - cl::opt ProfileKind( - cl::desc("Profile kind:"), cl::init(instr), - cl::values(clEnumVal(instr, "Instrumentation profile (default)"), - clEnumVal(sample, "Sample profile"))); - cl::opt TopNFunctions( - "topn", cl::init(0), - cl::desc("Show the list of functions with the largest internal counts")); - - cl::ParseCommandLineOptions(argc, argv, "LLVM profile data summary\n"); - - if (OutputFilename.empty()) - OutputFilename = "-"; - - std::error_code EC; - raw_fd_ostream OS(OutputFilename.data(), EC, sys::fs::F_Text); - if (EC) - exitWithErrorCode(EC, OutputFilename); - - if (ShowAllFunctions && !ShowFunction.empty()) - errs() << "warning: -function argument ignored: showing all functions\n"; - - std::vector Cutoffs(DetailedSummaryCutoffs.begin(), - DetailedSummaryCutoffs.end()); - if (ProfileKind == instr) - return showInstrProfile(Filename, ShowCounts, TopNFunctions, - ShowIndirectCallTargets, ShowMemOPSizes, - ShowDetailedSummary, DetailedSummaryCutoffs, - ShowAllFunctions, ShowFunction, TextFormat, OS); - else - return showSampleProfile(Filename, ShowCounts, ShowAllFunctions, - ShowFunction, OS); -} - -int main(int argc, const char *argv[]) { - // Print a stack trace if we signal out. - sys::PrintStackTraceOnErrorSignal(argv[0]); - PrettyStackTraceProgram X(argc, argv); - llvm_shutdown_obj Y; // Call llvm_shutdown() on exit. - - StringRef ProgName(sys::path::filename(argv[0])); - if (argc > 1) { - int (*func)(int, const char *[]) = nullptr; - - if (strcmp(argv[1], "merge") == 0) - func = merge_main; - else if (strcmp(argv[1], "show") == 0) - func = show_main; - - if (func) { - std::string Invocation(ProgName.str() + " " + argv[1]); - argv[1] = Invocation.c_str(); - return func(argc - 1, argv + 1); - } - - if (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "-help") == 0 || - strcmp(argv[1], "--help") == 0) { - - errs() << "OVERVIEW: LLVM profile data tools\n\n" - << "USAGE: " << ProgName << " [args...]\n" - << "USAGE: " << ProgName << " -help\n\n" - << "See each individual command --help for more details.\n" - << "Available commands: merge, show\n"; - return 0; - } - } - - if (argc < 2) - errs() << ProgName << ": No command specified!\n"; - else - errs() << ProgName << ": Unknown command!\n"; - - errs() << "USAGE: " << ProgName << " [args...]\n"; - return 1; -} diff --git a/utils/FileCheck-3.9.cpp b/utils/FileCheck-3.9.cpp deleted file mode 100644 index 6c9b62d5b24..00000000000 --- a/utils/FileCheck-3.9.cpp +++ /dev/null @@ -1,1416 +0,0 @@ -//===- FileCheck.cpp - Check that File's Contents match what is expected --===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// FileCheck does a line-by line check of a file that validates whether it -// contains the expected content. This is useful for regression tests etc. -// -// This program exits with an error status of 2 on error, exit status of 0 if -// the file matched the expected contents, and exit status of 1 if it did not -// contain the expected contents. -// -//===----------------------------------------------------------------------===// - -#include "llvm/ADT/SmallString.h" -#include "llvm/ADT/StringExtras.h" -#include "llvm/ADT/StringMap.h" -#include "llvm/ADT/StringSet.h" -#include "llvm/Support/CommandLine.h" -#include "llvm/Support/MemoryBuffer.h" -#include "llvm/Support/PrettyStackTrace.h" -#include "llvm/Support/Regex.h" -#include "llvm/Support/Signals.h" -#include "llvm/Support/SourceMgr.h" -#include "llvm/Support/raw_ostream.h" -#include -#include -#include -#include -#include -#include -using namespace llvm; - -static cl::opt -CheckFilename(cl::Positional, cl::desc(""), cl::Required); - -static cl::opt -InputFilename("input-file", cl::desc("File to check (defaults to stdin)"), - cl::init("-"), cl::value_desc("filename")); - -static cl::list -CheckPrefixes("check-prefix", - cl::desc("Prefix to use from check file (defaults to 'CHECK')")); -static cl::alias CheckPrefixesAlias( - "check-prefixes", cl::aliasopt(CheckPrefixes), cl::CommaSeparated, - cl::NotHidden, - cl::desc( - "Alias for -check-prefix permitting multiple comma separated values")); - -static cl::opt -NoCanonicalizeWhiteSpace("strict-whitespace", - cl::desc("Do not treat all horizontal whitespace as equivalent")); - -static cl::list ImplicitCheckNot( - "implicit-check-not", - cl::desc("Add an implicit negative check with this pattern to every\n" - "positive check. This can be used to ensure that no instances of\n" - "this pattern occur which are not matched by a positive pattern"), - cl::value_desc("pattern")); - -static cl::opt AllowEmptyInput( - "allow-empty", cl::init(false), - cl::desc("Allow the input file to be empty. This is useful when making\n" - "checks that some error message does not occur, for example.")); - -static cl::opt MatchFullLines( - "match-full-lines", cl::init(false), - cl::desc("Require all positive matches to cover an entire input line.\n" - "Allows leading and trailing whitespace if --strict-whitespace\n" - "is not also passed.")); - -typedef cl::list::const_iterator prefix_iterator; - -//===----------------------------------------------------------------------===// -// Pattern Handling Code. -//===----------------------------------------------------------------------===// - -namespace Check { - enum CheckType { - CheckNone = 0, - CheckPlain, - CheckNext, - CheckSame, - CheckNot, - CheckDAG, - CheckLabel, - - /// MatchEOF - When set, this pattern only matches the end of file. This is - /// used for trailing CHECK-NOTs. - CheckEOF, - /// CheckBadNot - Found -NOT combined with another CHECK suffix. - CheckBadNot - }; -} - -class Pattern { - SMLoc PatternLoc; - - Check::CheckType CheckTy; - - /// FixedStr - If non-empty, this pattern is a fixed string match with the - /// specified fixed string. - StringRef FixedStr; - - /// RegEx - If non-empty, this is a regex pattern. - std::string RegExStr; - - /// \brief Contains the number of line this pattern is in. - unsigned LineNumber; - - /// VariableUses - Entries in this vector map to uses of a variable in the - /// pattern, e.g. "foo[[bar]]baz". In this case, the RegExStr will contain - /// "foobaz" and we'll get an entry in this vector that tells us to insert the - /// value of bar at offset 3. - std::vector > VariableUses; - - /// VariableDefs - Maps definitions of variables to their parenthesized - /// capture numbers. - /// E.g. for the pattern "foo[[bar:.*]]baz", VariableDefs will map "bar" to 1. - std::map VariableDefs; - -public: - - Pattern(Check::CheckType Ty) - : CheckTy(Ty) { } - - /// getLoc - Return the location in source code. - SMLoc getLoc() const { return PatternLoc; } - - /// ParsePattern - Parse the given string into the Pattern. Prefix provides - /// which prefix is being matched, SM provides the SourceMgr used for error - /// reports, and LineNumber is the line number in the input file from which - /// the pattern string was read. Returns true in case of an error, false - /// otherwise. - bool ParsePattern(StringRef PatternStr, - StringRef Prefix, - SourceMgr &SM, - unsigned LineNumber); - - /// Match - Match the pattern string against the input buffer Buffer. This - /// returns the position that is matched or npos if there is no match. If - /// there is a match, the size of the matched string is returned in MatchLen. - /// - /// The VariableTable StringMap provides the current values of filecheck - /// variables and is updated if this match defines new values. - size_t Match(StringRef Buffer, size_t &MatchLen, - StringMap &VariableTable) const; - - /// PrintFailureInfo - Print additional information about a failure to match - /// involving this pattern. - void PrintFailureInfo(const SourceMgr &SM, StringRef Buffer, - const StringMap &VariableTable) const; - - bool hasVariable() const { return !(VariableUses.empty() && - VariableDefs.empty()); } - - Check::CheckType getCheckTy() const { return CheckTy; } - -private: - bool AddRegExToRegEx(StringRef RS, unsigned &CurParen, SourceMgr &SM); - void AddBackrefToRegEx(unsigned BackrefNum); - - /// ComputeMatchDistance - Compute an arbitrary estimate for the quality of - /// matching this pattern at the start of \arg Buffer; a distance of zero - /// should correspond to a perfect match. - unsigned ComputeMatchDistance(StringRef Buffer, - const StringMap &VariableTable) const; - - /// \brief Evaluates expression and stores the result to \p Value. - /// \return true on success. false when the expression has invalid syntax. - bool EvaluateExpression(StringRef Expr, std::string &Value) const; - - /// \brief Finds the closing sequence of a regex variable usage or - /// definition. Str has to point in the beginning of the definition - /// (right after the opening sequence). - /// \return offset of the closing sequence within Str, or npos if it was not - /// found. - size_t FindRegexVarEnd(StringRef Str, SourceMgr &SM); -}; - - -bool Pattern::ParsePattern(StringRef PatternStr, - StringRef Prefix, - SourceMgr &SM, - unsigned LineNumber) { - bool MatchFullLinesHere = MatchFullLines && CheckTy != Check::CheckNot; - - this->LineNumber = LineNumber; - PatternLoc = SMLoc::getFromPointer(PatternStr.data()); - - // Ignore trailing whitespace. - while (!PatternStr.empty() && - (PatternStr.back() == ' ' || PatternStr.back() == '\t')) - PatternStr = PatternStr.substr(0, PatternStr.size()-1); - - // Check that there is something on the line. - if (PatternStr.empty()) { - SM.PrintMessage(PatternLoc, SourceMgr::DK_Error, - "found empty check string with prefix '" + - Prefix + ":'"); - return true; - } - - // Check to see if this is a fixed string, or if it has regex pieces. - if (!MatchFullLinesHere && - (PatternStr.size() < 2 || (PatternStr.find("{{") == StringRef::npos && - PatternStr.find("[[") == StringRef::npos))) { - FixedStr = PatternStr; - return false; - } - - if (MatchFullLinesHere) { - RegExStr += '^'; - if (!NoCanonicalizeWhiteSpace) - RegExStr += " *"; - } - - // Paren value #0 is for the fully matched string. Any new parenthesized - // values add from there. - unsigned CurParen = 1; - - // Otherwise, there is at least one regex piece. Build up the regex pattern - // by escaping scary characters in fixed strings, building up one big regex. - while (!PatternStr.empty()) { - // RegEx matches. - if (PatternStr.startswith("{{")) { - // This is the start of a regex match. Scan for the }}. - size_t End = PatternStr.find("}}"); - if (End == StringRef::npos) { - SM.PrintMessage(SMLoc::getFromPointer(PatternStr.data()), - SourceMgr::DK_Error, - "found start of regex string with no end '}}'"); - return true; - } - - // Enclose {{}} patterns in parens just like [[]] even though we're not - // capturing the result for any purpose. This is required in case the - // expression contains an alternation like: CHECK: abc{{x|z}}def. We - // want this to turn into: "abc(x|z)def" not "abcx|zdef". - RegExStr += '('; - ++CurParen; - - if (AddRegExToRegEx(PatternStr.substr(2, End-2), CurParen, SM)) - return true; - RegExStr += ')'; - - PatternStr = PatternStr.substr(End+2); - continue; - } - - // Named RegEx matches. These are of two forms: [[foo:.*]] which matches .* - // (or some other regex) and assigns it to the FileCheck variable 'foo'. The - // second form is [[foo]] which is a reference to foo. The variable name - // itself must be of the form "[a-zA-Z_][0-9a-zA-Z_]*", otherwise we reject - // it. This is to catch some common errors. - if (PatternStr.startswith("[[")) { - // Find the closing bracket pair ending the match. End is going to be an - // offset relative to the beginning of the match string. - size_t End = FindRegexVarEnd(PatternStr.substr(2), SM); - - if (End == StringRef::npos) { - SM.PrintMessage(SMLoc::getFromPointer(PatternStr.data()), - SourceMgr::DK_Error, - "invalid named regex reference, no ]] found"); - return true; - } - - StringRef MatchStr = PatternStr.substr(2, End); - PatternStr = PatternStr.substr(End+4); - - // Get the regex name (e.g. "foo"). - size_t NameEnd = MatchStr.find(':'); - StringRef Name = MatchStr.substr(0, NameEnd); - - if (Name.empty()) { - SM.PrintMessage(SMLoc::getFromPointer(Name.data()), SourceMgr::DK_Error, - "invalid name in named regex: empty name"); - return true; - } - - // Verify that the name/expression is well formed. FileCheck currently - // supports @LINE, @LINE+number, @LINE-number expressions. The check here - // is relaxed, more strict check is performed in \c EvaluateExpression. - bool IsExpression = false; - for (unsigned i = 0, e = Name.size(); i != e; ++i) { - if (i == 0 && Name[i] == '@') { - if (NameEnd != StringRef::npos) { - SM.PrintMessage(SMLoc::getFromPointer(Name.data()), - SourceMgr::DK_Error, - "invalid name in named regex definition"); - return true; - } - IsExpression = true; - continue; - } - if (Name[i] != '_' && !isalnum(Name[i]) && - (!IsExpression || (Name[i] != '+' && Name[i] != '-'))) { - SM.PrintMessage(SMLoc::getFromPointer(Name.data()+i), - SourceMgr::DK_Error, "invalid name in named regex"); - return true; - } - } - - // Name can't start with a digit. - if (isdigit(static_cast(Name[0]))) { - SM.PrintMessage(SMLoc::getFromPointer(Name.data()), SourceMgr::DK_Error, - "invalid name in named regex"); - return true; - } - - // Handle [[foo]]. - if (NameEnd == StringRef::npos) { - // Handle variables that were defined earlier on the same line by - // emitting a backreference. - if (VariableDefs.find(Name) != VariableDefs.end()) { - unsigned VarParenNum = VariableDefs[Name]; - if (VarParenNum < 1 || VarParenNum > 9) { - SM.PrintMessage(SMLoc::getFromPointer(Name.data()), - SourceMgr::DK_Error, - "Can't back-reference more than 9 variables"); - return true; - } - AddBackrefToRegEx(VarParenNum); - } else { - VariableUses.push_back(std::make_pair(Name, RegExStr.size())); - } - continue; - } - - // Handle [[foo:.*]]. - VariableDefs[Name] = CurParen; - RegExStr += '('; - ++CurParen; - - if (AddRegExToRegEx(MatchStr.substr(NameEnd+1), CurParen, SM)) - return true; - - RegExStr += ')'; - } - - // Handle fixed string matches. - // Find the end, which is the start of the next regex. - size_t FixedMatchEnd = PatternStr.find("{{"); - FixedMatchEnd = std::min(FixedMatchEnd, PatternStr.find("[[")); - RegExStr += Regex::escape(PatternStr.substr(0, FixedMatchEnd)); - PatternStr = PatternStr.substr(FixedMatchEnd); - } - - if (MatchFullLinesHere) { - if (!NoCanonicalizeWhiteSpace) - RegExStr += " *"; - RegExStr += '$'; - } - - return false; -} - -bool Pattern::AddRegExToRegEx(StringRef RS, unsigned &CurParen, - SourceMgr &SM) { - Regex R(RS); - std::string Error; - if (!R.isValid(Error)) { - SM.PrintMessage(SMLoc::getFromPointer(RS.data()), SourceMgr::DK_Error, - "invalid regex: " + Error); - return true; - } - - RegExStr += RS.str(); - CurParen += R.getNumMatches(); - return false; -} - -void Pattern::AddBackrefToRegEx(unsigned BackrefNum) { - assert(BackrefNum >= 1 && BackrefNum <= 9 && "Invalid backref number"); - std::string Backref = std::string("\\") + - std::string(1, '0' + BackrefNum); - RegExStr += Backref; -} - -bool Pattern::EvaluateExpression(StringRef Expr, std::string &Value) const { - // The only supported expression is @LINE([\+-]\d+)? - if (!Expr.startswith("@LINE")) - return false; - Expr = Expr.substr(StringRef("@LINE").size()); - int Offset = 0; - if (!Expr.empty()) { - if (Expr[0] == '+') - Expr = Expr.substr(1); - else if (Expr[0] != '-') - return false; - if (Expr.getAsInteger(10, Offset)) - return false; - } - Value = llvm::itostr(LineNumber + Offset); - return true; -} - -/// Match - Match the pattern string against the input buffer Buffer. This -/// returns the position that is matched or npos if there is no match. If -/// there is a match, the size of the matched string is returned in MatchLen. -size_t Pattern::Match(StringRef Buffer, size_t &MatchLen, - StringMap &VariableTable) const { - // If this is the EOF pattern, match it immediately. - if (CheckTy == Check::CheckEOF) { - MatchLen = 0; - return Buffer.size(); - } - - // If this is a fixed string pattern, just match it now. - if (!FixedStr.empty()) { - MatchLen = FixedStr.size(); - return Buffer.find(FixedStr); - } - - // Regex match. - - // If there are variable uses, we need to create a temporary string with the - // actual value. - StringRef RegExToMatch = RegExStr; - std::string TmpStr; - if (!VariableUses.empty()) { - TmpStr = RegExStr; - - unsigned InsertOffset = 0; - for (const auto &VariableUse : VariableUses) { - std::string Value; - - if (VariableUse.first[0] == '@') { - if (!EvaluateExpression(VariableUse.first, Value)) - return StringRef::npos; - } else { - StringMap::iterator it = - VariableTable.find(VariableUse.first); - // If the variable is undefined, return an error. - if (it == VariableTable.end()) - return StringRef::npos; - - // Look up the value and escape it so that we can put it into the regex. - Value += Regex::escape(it->second); - } - - // Plop it into the regex at the adjusted offset. - TmpStr.insert(TmpStr.begin() + VariableUse.second + InsertOffset, - Value.begin(), Value.end()); - InsertOffset += Value.size(); - } - - // Match the newly constructed regex. - RegExToMatch = TmpStr; - } - - - SmallVector MatchInfo; - if (!Regex(RegExToMatch, Regex::Newline).match(Buffer, &MatchInfo)) - return StringRef::npos; - - // Successful regex match. - assert(!MatchInfo.empty() && "Didn't get any match"); - StringRef FullMatch = MatchInfo[0]; - - // If this defines any variables, remember their values. - for (const auto &VariableDef : VariableDefs) { - assert(VariableDef.second < MatchInfo.size() && "Internal paren error"); - VariableTable[VariableDef.first] = MatchInfo[VariableDef.second]; - } - - MatchLen = FullMatch.size(); - return FullMatch.data()-Buffer.data(); -} - -unsigned Pattern::ComputeMatchDistance(StringRef Buffer, - const StringMap &VariableTable) const { - // Just compute the number of matching characters. For regular expressions, we - // just compare against the regex itself and hope for the best. - // - // FIXME: One easy improvement here is have the regex lib generate a single - // example regular expression which matches, and use that as the example - // string. - StringRef ExampleString(FixedStr); - if (ExampleString.empty()) - ExampleString = RegExStr; - - // Only compare up to the first line in the buffer, or the string size. - StringRef BufferPrefix = Buffer.substr(0, ExampleString.size()); - BufferPrefix = BufferPrefix.split('\n').first; - return BufferPrefix.edit_distance(ExampleString); -} - -void Pattern::PrintFailureInfo(const SourceMgr &SM, StringRef Buffer, - const StringMap &VariableTable) const{ - // If this was a regular expression using variables, print the current - // variable values. - if (!VariableUses.empty()) { - for (const auto &VariableUse : VariableUses) { - SmallString<256> Msg; - raw_svector_ostream OS(Msg); - StringRef Var = VariableUse.first; - if (Var[0] == '@') { - std::string Value; - if (EvaluateExpression(Var, Value)) { - OS << "with expression \""; - OS.write_escaped(Var) << "\" equal to \""; - OS.write_escaped(Value) << "\""; - } else { - OS << "uses incorrect expression \""; - OS.write_escaped(Var) << "\""; - } - } else { - StringMap::const_iterator it = VariableTable.find(Var); - - // Check for undefined variable references. - if (it == VariableTable.end()) { - OS << "uses undefined variable \""; - OS.write_escaped(Var) << "\""; - } else { - OS << "with variable \""; - OS.write_escaped(Var) << "\" equal to \""; - OS.write_escaped(it->second) << "\""; - } - } - - SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()), SourceMgr::DK_Note, - OS.str()); - } - } - - // Attempt to find the closest/best fuzzy match. Usually an error happens - // because some string in the output didn't exactly match. In these cases, we - // would like to show the user a best guess at what "should have" matched, to - // save them having to actually check the input manually. - size_t NumLinesForward = 0; - size_t Best = StringRef::npos; - double BestQuality = 0; - - // Use an arbitrary 4k limit on how far we will search. - for (size_t i = 0, e = std::min(size_t(4096), Buffer.size()); i != e; ++i) { - if (Buffer[i] == '\n') - ++NumLinesForward; - - // Patterns have leading whitespace stripped, so skip whitespace when - // looking for something which looks like a pattern. - if (Buffer[i] == ' ' || Buffer[i] == '\t') - continue; - - // Compute the "quality" of this match as an arbitrary combination of the - // match distance and the number of lines skipped to get to this match. - unsigned Distance = ComputeMatchDistance(Buffer.substr(i), VariableTable); - double Quality = Distance + (NumLinesForward / 100.); - - if (Quality < BestQuality || Best == StringRef::npos) { - Best = i; - BestQuality = Quality; - } - } - - // Print the "possible intended match here" line if we found something - // reasonable and not equal to what we showed in the "scanning from here" - // line. - if (Best && Best != StringRef::npos && BestQuality < 50) { - SM.PrintMessage(SMLoc::getFromPointer(Buffer.data() + Best), - SourceMgr::DK_Note, "possible intended match here"); - - // FIXME: If we wanted to be really friendly we would show why the match - // failed, as it can be hard to spot simple one character differences. - } -} - -size_t Pattern::FindRegexVarEnd(StringRef Str, SourceMgr &SM) { - // Offset keeps track of the current offset within the input Str - size_t Offset = 0; - // [...] Nesting depth - size_t BracketDepth = 0; - - while (!Str.empty()) { - if (Str.startswith("]]") && BracketDepth == 0) - return Offset; - if (Str[0] == '\\') { - // Backslash escapes the next char within regexes, so skip them both. - Str = Str.substr(2); - Offset += 2; - } else { - switch (Str[0]) { - default: - break; - case '[': - BracketDepth++; - break; - case ']': - if (BracketDepth == 0) { - SM.PrintMessage(SMLoc::getFromPointer(Str.data()), - SourceMgr::DK_Error, - "missing closing \"]\" for regex variable"); - exit(1); - } - BracketDepth--; - break; - } - Str = Str.substr(1); - Offset++; - } - } - - return StringRef::npos; -} - - -//===----------------------------------------------------------------------===// -// Check Strings. -//===----------------------------------------------------------------------===// - -/// CheckString - This is a check that we found in the input file. -struct CheckString { - /// Pat - The pattern to match. - Pattern Pat; - - /// Prefix - Which prefix name this check matched. - StringRef Prefix; - - /// Loc - The location in the match file that the check string was specified. - SMLoc Loc; - - /// CheckTy - Specify what kind of check this is. e.g. CHECK-NEXT: directive, - /// as opposed to a CHECK: directive. - // Check::CheckType CheckTy; - - /// DagNotStrings - These are all of the strings that are disallowed from - /// occurring between this match string and the previous one (or start of - /// file). - std::vector DagNotStrings; - - CheckString(const Pattern &P, StringRef S, SMLoc L) - : Pat(P), Prefix(S), Loc(L) {} - - /// Check - Match check string and its "not strings" and/or "dag strings". - size_t Check(const SourceMgr &SM, StringRef Buffer, bool IsLabelScanMode, - size_t &MatchLen, StringMap &VariableTable) const; - - /// CheckNext - Verify there is a single line in the given buffer. - bool CheckNext(const SourceMgr &SM, StringRef Buffer) const; - - /// CheckSame - Verify there is no newline in the given buffer. - bool CheckSame(const SourceMgr &SM, StringRef Buffer) const; - - /// CheckNot - Verify there's no "not strings" in the given buffer. - bool CheckNot(const SourceMgr &SM, StringRef Buffer, - const std::vector &NotStrings, - StringMap &VariableTable) const; - - /// CheckDag - Match "dag strings" and their mixed "not strings". - size_t CheckDag(const SourceMgr &SM, StringRef Buffer, - std::vector &NotStrings, - StringMap &VariableTable) const; -}; - -/// Canonicalize whitespaces in the input file. Line endings are replaced -/// with UNIX-style '\n'. -/// -/// \param PreserveHorizontal Don't squash consecutive horizontal whitespace -/// characters to a single space. -static std::unique_ptr -CanonicalizeInputFile(std::unique_ptr MB, - bool PreserveHorizontal) { - SmallString<128> NewFile; - NewFile.reserve(MB->getBufferSize()); - - for (const char *Ptr = MB->getBufferStart(), *End = MB->getBufferEnd(); - Ptr != End; ++Ptr) { - // Eliminate trailing dosish \r. - if (Ptr <= End - 2 && Ptr[0] == '\r' && Ptr[1] == '\n') { - continue; - } - - // If current char is not a horizontal whitespace or if horizontal - // whitespace canonicalization is disabled, dump it to output as is. - if (PreserveHorizontal || (*Ptr != ' ' && *Ptr != '\t')) { - NewFile.push_back(*Ptr); - continue; - } - - // Otherwise, add one space and advance over neighboring space. - NewFile.push_back(' '); - while (Ptr+1 != End && - (Ptr[1] == ' ' || Ptr[1] == '\t')) - ++Ptr; - } - - return std::unique_ptr( - MemoryBuffer::getMemBufferCopy(NewFile.str(), MB->getBufferIdentifier())); -} - -static bool IsPartOfWord(char c) { - return (isalnum(c) || c == '-' || c == '_'); -} - -// Get the size of the prefix extension. -static size_t CheckTypeSize(Check::CheckType Ty) { - switch (Ty) { - case Check::CheckNone: - case Check::CheckBadNot: - return 0; - - case Check::CheckPlain: - return sizeof(":") - 1; - - case Check::CheckNext: - return sizeof("-NEXT:") - 1; - - case Check::CheckSame: - return sizeof("-SAME:") - 1; - - case Check::CheckNot: - return sizeof("-NOT:") - 1; - - case Check::CheckDAG: - return sizeof("-DAG:") - 1; - - case Check::CheckLabel: - return sizeof("-LABEL:") - 1; - - case Check::CheckEOF: - llvm_unreachable("Should not be using EOF size"); - } - - llvm_unreachable("Bad check type"); -} - -static Check::CheckType FindCheckType(StringRef Buffer, StringRef Prefix) { - char NextChar = Buffer[Prefix.size()]; - - // Verify that the : is present after the prefix. - if (NextChar == ':') - return Check::CheckPlain; - - if (NextChar != '-') - return Check::CheckNone; - - StringRef Rest = Buffer.drop_front(Prefix.size() + 1); - if (Rest.startswith("NEXT:")) - return Check::CheckNext; - - if (Rest.startswith("SAME:")) - return Check::CheckSame; - - if (Rest.startswith("NOT:")) - return Check::CheckNot; - - if (Rest.startswith("DAG:")) - return Check::CheckDAG; - - if (Rest.startswith("LABEL:")) - return Check::CheckLabel; - - // You can't combine -NOT with another suffix. - if (Rest.startswith("DAG-NOT:") || Rest.startswith("NOT-DAG:") || - Rest.startswith("NEXT-NOT:") || Rest.startswith("NOT-NEXT:") || - Rest.startswith("SAME-NOT:") || Rest.startswith("NOT-SAME:")) - return Check::CheckBadNot; - - return Check::CheckNone; -} - -// From the given position, find the next character after the word. -static size_t SkipWord(StringRef Str, size_t Loc) { - while (Loc < Str.size() && IsPartOfWord(Str[Loc])) - ++Loc; - return Loc; -} - -// Try to find the first match in buffer for any prefix. If a valid match is -// found, return that prefix and set its type and location. If there are almost -// matches (e.g. the actual prefix string is found, but is not an actual check -// string), but no valid match, return an empty string and set the position to -// resume searching from. If no partial matches are found, return an empty -// string and the location will be StringRef::npos. If one prefix is a substring -// of another, the maximal match should be found. e.g. if "A" and "AA" are -// prefixes then AA-CHECK: should match the second one. -static StringRef FindFirstCandidateMatch(StringRef &Buffer, - Check::CheckType &CheckTy, - size_t &CheckLoc) { - StringRef FirstPrefix; - size_t FirstLoc = StringRef::npos; - size_t SearchLoc = StringRef::npos; - Check::CheckType FirstTy = Check::CheckNone; - - CheckTy = Check::CheckNone; - CheckLoc = StringRef::npos; - - for (StringRef Prefix : CheckPrefixes) { - size_t PrefixLoc = Buffer.find(Prefix); - - if (PrefixLoc == StringRef::npos) - continue; - - // Track where we are searching for invalid prefixes that look almost right. - // We need to only advance to the first partial match on the next attempt - // since a partial match could be a substring of a later, valid prefix. - // Need to skip to the end of the word, otherwise we could end up - // matching a prefix in a substring later. - if (PrefixLoc < SearchLoc) - SearchLoc = SkipWord(Buffer, PrefixLoc); - - // We only want to find the first match to avoid skipping some. - if (PrefixLoc > FirstLoc) - continue; - // If one matching check-prefix is a prefix of another, choose the - // longer one. - if (PrefixLoc == FirstLoc && Prefix.size() < FirstPrefix.size()) - continue; - - StringRef Rest = Buffer.drop_front(PrefixLoc); - // Make sure we have actually found the prefix, and not a word containing - // it. This should also prevent matching the wrong prefix when one is a - // substring of another. - if (PrefixLoc != 0 && IsPartOfWord(Buffer[PrefixLoc - 1])) - FirstTy = Check::CheckNone; - else - FirstTy = FindCheckType(Rest, Prefix); - - FirstLoc = PrefixLoc; - FirstPrefix = Prefix; - } - - // If the first prefix is invalid, we should continue the search after it. - if (FirstTy == Check::CheckNone) { - CheckLoc = SearchLoc; - return ""; - } - - CheckTy = FirstTy; - CheckLoc = FirstLoc; - return FirstPrefix; -} - -static StringRef FindFirstMatchingPrefix(StringRef &Buffer, - unsigned &LineNumber, - Check::CheckType &CheckTy, - size_t &CheckLoc) { - while (!Buffer.empty()) { - StringRef Prefix = FindFirstCandidateMatch(Buffer, CheckTy, CheckLoc); - // If we found a real match, we are done. - if (!Prefix.empty()) { - LineNumber += Buffer.substr(0, CheckLoc).count('\n'); - return Prefix; - } - - // We didn't find any almost matches either, we are also done. - if (CheckLoc == StringRef::npos) - return StringRef(); - - LineNumber += Buffer.substr(0, CheckLoc + 1).count('\n'); - - // Advance to the last possible match we found and try again. - Buffer = Buffer.drop_front(CheckLoc + 1); - } - - return StringRef(); -} - -/// ReadCheckFile - Read the check file, which specifies the sequence of -/// expected strings. The strings are added to the CheckStrings vector. -/// Returns true in case of an error, false otherwise. -static bool ReadCheckFile(SourceMgr &SM, - std::vector &CheckStrings) { - ErrorOr> FileOrErr = - MemoryBuffer::getFileOrSTDIN(CheckFilename); - if (std::error_code EC = FileOrErr.getError()) { - errs() << "Could not open check file '" << CheckFilename - << "': " << EC.message() << '\n'; - return true; - } - - // If we want to canonicalize whitespace, strip excess whitespace from the - // buffer containing the CHECK lines. Remove DOS style line endings. - std::unique_ptr F = CanonicalizeInputFile( - std::move(FileOrErr.get()), NoCanonicalizeWhiteSpace); - - // Find all instances of CheckPrefix followed by : in the file. - StringRef Buffer = F->getBuffer(); - - SM.AddNewSourceBuffer(std::move(F), SMLoc()); - - std::vector ImplicitNegativeChecks; - for (const auto &PatternString : ImplicitCheckNot) { - // Create a buffer with fake command line content in order to display the - // command line option responsible for the specific implicit CHECK-NOT. - std::string Prefix = (Twine("-") + ImplicitCheckNot.ArgStr + "='").str(); - std::string Suffix = "'"; - std::unique_ptr CmdLine = MemoryBuffer::getMemBufferCopy( - Prefix + PatternString + Suffix, "command line"); - - StringRef PatternInBuffer = - CmdLine->getBuffer().substr(Prefix.size(), PatternString.size()); - SM.AddNewSourceBuffer(std::move(CmdLine), SMLoc()); - - ImplicitNegativeChecks.push_back(Pattern(Check::CheckNot)); - ImplicitNegativeChecks.back().ParsePattern(PatternInBuffer, - "IMPLICIT-CHECK", SM, 0); - } - - - std::vector DagNotMatches = ImplicitNegativeChecks; - - // LineNumber keeps track of the line on which CheckPrefix instances are - // found. - unsigned LineNumber = 1; - - while (1) { - Check::CheckType CheckTy; - size_t PrefixLoc; - - // See if a prefix occurs in the memory buffer. - StringRef UsedPrefix = FindFirstMatchingPrefix(Buffer, - LineNumber, - CheckTy, - PrefixLoc); - if (UsedPrefix.empty()) - break; - - Buffer = Buffer.drop_front(PrefixLoc); - - // Location to use for error messages. - const char *UsedPrefixStart = Buffer.data() + (PrefixLoc == 0 ? 0 : 1); - - // PrefixLoc is to the start of the prefix. Skip to the end. - Buffer = Buffer.drop_front(UsedPrefix.size() + CheckTypeSize(CheckTy)); - - // Complain about useful-looking but unsupported suffixes. - if (CheckTy == Check::CheckBadNot) { - SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()), - SourceMgr::DK_Error, - "unsupported -NOT combo on prefix '" + UsedPrefix + "'"); - return true; - } - - // Okay, we found the prefix, yay. Remember the rest of the line, but ignore - // leading and trailing whitespace. - Buffer = Buffer.substr(Buffer.find_first_not_of(" \t")); - - // Scan ahead to the end of line. - size_t EOL = Buffer.find_first_of("\n\r"); - - // Remember the location of the start of the pattern, for diagnostics. - SMLoc PatternLoc = SMLoc::getFromPointer(Buffer.data()); - - // Parse the pattern. - Pattern P(CheckTy); - if (P.ParsePattern(Buffer.substr(0, EOL), UsedPrefix, SM, LineNumber)) - return true; - - // Verify that CHECK-LABEL lines do not define or use variables - if ((CheckTy == Check::CheckLabel) && P.hasVariable()) { - SM.PrintMessage(SMLoc::getFromPointer(UsedPrefixStart), - SourceMgr::DK_Error, - "found '" + UsedPrefix + "-LABEL:'" - " with variable definition or use"); - return true; - } - - Buffer = Buffer.substr(EOL); - - // Verify that CHECK-NEXT lines have at least one CHECK line before them. - if ((CheckTy == Check::CheckNext || CheckTy == Check::CheckSame) && - CheckStrings.empty()) { - StringRef Type = CheckTy == Check::CheckNext ? "NEXT" : "SAME"; - SM.PrintMessage(SMLoc::getFromPointer(UsedPrefixStart), - SourceMgr::DK_Error, - "found '" + UsedPrefix + "-" + Type + "' without previous '" - + UsedPrefix + ": line"); - return true; - } - - // Handle CHECK-DAG/-NOT. - if (CheckTy == Check::CheckDAG || CheckTy == Check::CheckNot) { - DagNotMatches.push_back(P); - continue; - } - - // Okay, add the string we captured to the output vector and move on. - CheckStrings.emplace_back(P, UsedPrefix, PatternLoc); - std::swap(DagNotMatches, CheckStrings.back().DagNotStrings); - DagNotMatches = ImplicitNegativeChecks; - } - - // Add an EOF pattern for any trailing CHECK-DAG/-NOTs, and use the first - // prefix as a filler for the error message. - if (!DagNotMatches.empty()) { - CheckStrings.emplace_back(Pattern(Check::CheckEOF), *CheckPrefixes.begin(), - SMLoc::getFromPointer(Buffer.data())); - std::swap(DagNotMatches, CheckStrings.back().DagNotStrings); - } - - if (CheckStrings.empty()) { - errs() << "error: no check strings found with prefix" - << (CheckPrefixes.size() > 1 ? "es " : " "); - prefix_iterator I = CheckPrefixes.begin(); - prefix_iterator E = CheckPrefixes.end(); - if (I != E) { - errs() << "\'" << *I << ":'"; - ++I; - } - for (; I != E; ++I) - errs() << ", \'" << *I << ":'"; - - errs() << '\n'; - return true; - } - - return false; -} - -static void PrintCheckFailed(const SourceMgr &SM, SMLoc Loc, - const Pattern &Pat, StringRef Buffer, - StringMap &VariableTable) { - // Otherwise, we have an error, emit an error message. - SM.PrintMessage(Loc, SourceMgr::DK_Error, - "expected string not found in input"); - - // Print the "scanning from here" line. If the current position is at the - // end of a line, advance to the start of the next line. - Buffer = Buffer.substr(Buffer.find_first_not_of(" \t\n\r")); - - SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()), SourceMgr::DK_Note, - "scanning from here"); - - // Allow the pattern to print additional information if desired. - Pat.PrintFailureInfo(SM, Buffer, VariableTable); -} - -static void PrintCheckFailed(const SourceMgr &SM, const CheckString &CheckStr, - StringRef Buffer, - StringMap &VariableTable) { - PrintCheckFailed(SM, CheckStr.Loc, CheckStr.Pat, Buffer, VariableTable); -} - -/// CountNumNewlinesBetween - Count the number of newlines in the specified -/// range. -static unsigned CountNumNewlinesBetween(StringRef Range, - const char *&FirstNewLine) { - unsigned NumNewLines = 0; - while (1) { - // Scan for newline. - Range = Range.substr(Range.find_first_of("\n\r")); - if (Range.empty()) return NumNewLines; - - ++NumNewLines; - - // Handle \n\r and \r\n as a single newline. - if (Range.size() > 1 && - (Range[1] == '\n' || Range[1] == '\r') && - (Range[0] != Range[1])) - Range = Range.substr(1); - Range = Range.substr(1); - - if (NumNewLines == 1) - FirstNewLine = Range.begin(); - } -} - -size_t CheckString::Check(const SourceMgr &SM, StringRef Buffer, - bool IsLabelScanMode, size_t &MatchLen, - StringMap &VariableTable) const { - size_t LastPos = 0; - std::vector NotStrings; - - // IsLabelScanMode is true when we are scanning forward to find CHECK-LABEL - // bounds; we have not processed variable definitions within the bounded block - // yet so cannot handle any final CHECK-DAG yet; this is handled when going - // over the block again (including the last CHECK-LABEL) in normal mode. - if (!IsLabelScanMode) { - // Match "dag strings" (with mixed "not strings" if any). - LastPos = CheckDag(SM, Buffer, NotStrings, VariableTable); - if (LastPos == StringRef::npos) - return StringRef::npos; - } - - // Match itself from the last position after matching CHECK-DAG. - StringRef MatchBuffer = Buffer.substr(LastPos); - size_t MatchPos = Pat.Match(MatchBuffer, MatchLen, VariableTable); - if (MatchPos == StringRef::npos) { - PrintCheckFailed(SM, *this, MatchBuffer, VariableTable); - return StringRef::npos; - } - - // Similar to the above, in "label-scan mode" we can't yet handle CHECK-NEXT - // or CHECK-NOT - if (!IsLabelScanMode) { - StringRef SkippedRegion = Buffer.substr(LastPos, MatchPos); - - // If this check is a "CHECK-NEXT", verify that the previous match was on - // the previous line (i.e. that there is one newline between them). - if (CheckNext(SM, SkippedRegion)) - return StringRef::npos; - - // If this check is a "CHECK-SAME", verify that the previous match was on - // the same line (i.e. that there is no newline between them). - if (CheckSame(SM, SkippedRegion)) - return StringRef::npos; - - // If this match had "not strings", verify that they don't exist in the - // skipped region. - if (CheckNot(SM, SkippedRegion, NotStrings, VariableTable)) - return StringRef::npos; - } - - return LastPos + MatchPos; -} - -bool CheckString::CheckNext(const SourceMgr &SM, StringRef Buffer) const { - if (Pat.getCheckTy() != Check::CheckNext) - return false; - - // Count the number of newlines between the previous match and this one. - assert(Buffer.data() != - SM.getMemoryBuffer( - SM.FindBufferContainingLoc( - SMLoc::getFromPointer(Buffer.data())))->getBufferStart() && - "CHECK-NEXT can't be the first check in a file"); - - const char *FirstNewLine = nullptr; - unsigned NumNewLines = CountNumNewlinesBetween(Buffer, FirstNewLine); - - if (NumNewLines == 0) { - SM.PrintMessage(Loc, SourceMgr::DK_Error, Prefix + - "-NEXT: is on the same line as previous match"); - SM.PrintMessage(SMLoc::getFromPointer(Buffer.end()), - SourceMgr::DK_Note, "'next' match was here"); - SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()), SourceMgr::DK_Note, - "previous match ended here"); - return true; - } - - if (NumNewLines != 1) { - SM.PrintMessage(Loc, SourceMgr::DK_Error, Prefix + - "-NEXT: is not on the line after the previous match"); - SM.PrintMessage(SMLoc::getFromPointer(Buffer.end()), - SourceMgr::DK_Note, "'next' match was here"); - SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()), SourceMgr::DK_Note, - "previous match ended here"); - SM.PrintMessage(SMLoc::getFromPointer(FirstNewLine), SourceMgr::DK_Note, - "non-matching line after previous match is here"); - return true; - } - - return false; -} - -bool CheckString::CheckSame(const SourceMgr &SM, StringRef Buffer) const { - if (Pat.getCheckTy() != Check::CheckSame) - return false; - - // Count the number of newlines between the previous match and this one. - assert(Buffer.data() != - SM.getMemoryBuffer(SM.FindBufferContainingLoc( - SMLoc::getFromPointer(Buffer.data()))) - ->getBufferStart() && - "CHECK-SAME can't be the first check in a file"); - - const char *FirstNewLine = nullptr; - unsigned NumNewLines = CountNumNewlinesBetween(Buffer, FirstNewLine); - - if (NumNewLines != 0) { - SM.PrintMessage(Loc, SourceMgr::DK_Error, - Prefix + - "-SAME: is not on the same line as the previous match"); - SM.PrintMessage(SMLoc::getFromPointer(Buffer.end()), SourceMgr::DK_Note, - "'next' match was here"); - SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()), SourceMgr::DK_Note, - "previous match ended here"); - return true; - } - - return false; -} - -bool CheckString::CheckNot(const SourceMgr &SM, StringRef Buffer, - const std::vector &NotStrings, - StringMap &VariableTable) const { - for (const Pattern *Pat : NotStrings) { - assert((Pat->getCheckTy() == Check::CheckNot) && "Expect CHECK-NOT!"); - - size_t MatchLen = 0; - size_t Pos = Pat->Match(Buffer, MatchLen, VariableTable); - - if (Pos == StringRef::npos) continue; - - SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()+Pos), - SourceMgr::DK_Error, - Prefix + "-NOT: string occurred!"); - SM.PrintMessage(Pat->getLoc(), SourceMgr::DK_Note, - Prefix + "-NOT: pattern specified here"); - return true; - } - - return false; -} - -size_t CheckString::CheckDag(const SourceMgr &SM, StringRef Buffer, - std::vector &NotStrings, - StringMap &VariableTable) const { - if (DagNotStrings.empty()) - return 0; - - size_t LastPos = 0; - size_t StartPos = LastPos; - - for (const Pattern &Pat : DagNotStrings) { - assert((Pat.getCheckTy() == Check::CheckDAG || - Pat.getCheckTy() == Check::CheckNot) && - "Invalid CHECK-DAG or CHECK-NOT!"); - - if (Pat.getCheckTy() == Check::CheckNot) { - NotStrings.push_back(&Pat); - continue; - } - - assert((Pat.getCheckTy() == Check::CheckDAG) && "Expect CHECK-DAG!"); - - size_t MatchLen = 0, MatchPos; - - // CHECK-DAG always matches from the start. - StringRef MatchBuffer = Buffer.substr(StartPos); - MatchPos = Pat.Match(MatchBuffer, MatchLen, VariableTable); - // With a group of CHECK-DAGs, a single mismatching means the match on - // that group of CHECK-DAGs fails immediately. - if (MatchPos == StringRef::npos) { - PrintCheckFailed(SM, Pat.getLoc(), Pat, MatchBuffer, VariableTable); - return StringRef::npos; - } - // Re-calc it as the offset relative to the start of the original string. - MatchPos += StartPos; - - if (!NotStrings.empty()) { - if (MatchPos < LastPos) { - // Reordered? - SM.PrintMessage(SMLoc::getFromPointer(Buffer.data() + MatchPos), - SourceMgr::DK_Error, - Prefix + "-DAG: found a match of CHECK-DAG" - " reordering across a CHECK-NOT"); - SM.PrintMessage(SMLoc::getFromPointer(Buffer.data() + LastPos), - SourceMgr::DK_Note, - Prefix + "-DAG: the farthest match of CHECK-DAG" - " is found here"); - SM.PrintMessage(NotStrings[0]->getLoc(), SourceMgr::DK_Note, - Prefix + "-NOT: the crossed pattern specified" - " here"); - SM.PrintMessage(Pat.getLoc(), SourceMgr::DK_Note, - Prefix + "-DAG: the reordered pattern specified" - " here"); - return StringRef::npos; - } - // All subsequent CHECK-DAGs should be matched from the farthest - // position of all precedent CHECK-DAGs (including this one.) - StartPos = LastPos; - // If there's CHECK-NOTs between two CHECK-DAGs or from CHECK to - // CHECK-DAG, verify that there's no 'not' strings occurred in that - // region. - StringRef SkippedRegion = Buffer.substr(LastPos, MatchPos); - if (CheckNot(SM, SkippedRegion, NotStrings, VariableTable)) - return StringRef::npos; - // Clear "not strings". - NotStrings.clear(); - } - - // Update the last position with CHECK-DAG matches. - LastPos = std::max(MatchPos + MatchLen, LastPos); - } - - return LastPos; -} - -// A check prefix must contain only alphanumeric, hyphens and underscores. -static bool ValidateCheckPrefix(StringRef CheckPrefix) { - Regex Validator("^[a-zA-Z0-9_-]*$"); - return Validator.match(CheckPrefix); -} - -static bool ValidateCheckPrefixes() { - StringSet<> PrefixSet; - - for (StringRef Prefix : CheckPrefixes) { - // Reject empty prefixes. - if (Prefix == "") - return false; - - if (!PrefixSet.insert(Prefix).second) - return false; - - if (!ValidateCheckPrefix(Prefix)) - return false; - } - - return true; -} - -// I don't think there's a way to specify an initial value for cl::list, -// so if nothing was specified, add the default -static void AddCheckPrefixIfNeeded() { - if (CheckPrefixes.empty()) - CheckPrefixes.push_back("CHECK"); -} - -static void DumpCommandLine(int argc, char **argv) { - errs() << "FileCheck command line: "; - for (int I = 0; I < argc; I++) - errs() << " " << argv[I]; - errs() << "\n"; -} - -int main(int argc, char **argv) { - sys::PrintStackTraceOnErrorSignal(argv[0]); - PrettyStackTraceProgram X(argc, argv); - cl::ParseCommandLineOptions(argc, argv); - - if (!ValidateCheckPrefixes()) { - errs() << "Supplied check-prefix is invalid! Prefixes must be unique and " - "start with a letter and contain only alphanumeric characters, " - "hyphens and underscores\n"; - return 2; - } - - AddCheckPrefixIfNeeded(); - - SourceMgr SM; - - // Read the expected strings from the check file. - std::vector CheckStrings; - if (ReadCheckFile(SM, CheckStrings)) - return 2; - - // Open the file to check and add it to SourceMgr. - ErrorOr> FileOrErr = - MemoryBuffer::getFileOrSTDIN(InputFilename); - if (std::error_code EC = FileOrErr.getError()) { - errs() << "Could not open input file '" << InputFilename - << "': " << EC.message() << '\n'; - return 2; - } - std::unique_ptr &File = FileOrErr.get(); - - if (File->getBufferSize() == 0 && !AllowEmptyInput) { - errs() << "FileCheck error: '" << InputFilename << "' is empty.\n"; - DumpCommandLine(argc, argv); - return 2; - } - - // Remove duplicate spaces in the input file if requested. - // Remove DOS style line endings. - std::unique_ptr F = - CanonicalizeInputFile(std::move(File), NoCanonicalizeWhiteSpace); - - // Check that we have all of the expected strings, in order, in the input - // file. - StringRef Buffer = F->getBuffer(); - - SM.AddNewSourceBuffer(std::move(F), SMLoc()); - - /// VariableTable - This holds all the current filecheck variables. - StringMap VariableTable; - - bool hasError = false; - - unsigned i = 0, j = 0, e = CheckStrings.size(); - - while (true) { - StringRef CheckRegion; - if (j == e) { - CheckRegion = Buffer; - } else { - const CheckString &CheckLabelStr = CheckStrings[j]; - if (CheckLabelStr.Pat.getCheckTy() != Check::CheckLabel) { - ++j; - continue; - } - - // Scan to next CHECK-LABEL match, ignoring CHECK-NOT and CHECK-DAG - size_t MatchLabelLen = 0; - size_t MatchLabelPos = CheckLabelStr.Check(SM, Buffer, true, - MatchLabelLen, VariableTable); - if (MatchLabelPos == StringRef::npos) { - hasError = true; - break; - } - - CheckRegion = Buffer.substr(0, MatchLabelPos + MatchLabelLen); - Buffer = Buffer.substr(MatchLabelPos + MatchLabelLen); - ++j; - } - - for ( ; i != j; ++i) { - const CheckString &CheckStr = CheckStrings[i]; - - // Check each string within the scanned region, including a second check - // of any final CHECK-LABEL (to verify CHECK-NOT and CHECK-DAG) - size_t MatchLen = 0; - size_t MatchPos = CheckStr.Check(SM, CheckRegion, false, MatchLen, - VariableTable); - - if (MatchPos == StringRef::npos) { - hasError = true; - i = j; - break; - } - - CheckRegion = CheckRegion.substr(MatchPos + MatchLen); - } - - if (j == e) - break; - } - - return hasError ? 1 : 0; -} diff --git a/utils/FileCheck-4.0.cpp b/utils/FileCheck-4.0.cpp deleted file mode 100644 index 6c9b62d5b24..00000000000 --- a/utils/FileCheck-4.0.cpp +++ /dev/null @@ -1,1416 +0,0 @@ -//===- FileCheck.cpp - Check that File's Contents match what is expected --===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// FileCheck does a line-by line check of a file that validates whether it -// contains the expected content. This is useful for regression tests etc. -// -// This program exits with an error status of 2 on error, exit status of 0 if -// the file matched the expected contents, and exit status of 1 if it did not -// contain the expected contents. -// -//===----------------------------------------------------------------------===// - -#include "llvm/ADT/SmallString.h" -#include "llvm/ADT/StringExtras.h" -#include "llvm/ADT/StringMap.h" -#include "llvm/ADT/StringSet.h" -#include "llvm/Support/CommandLine.h" -#include "llvm/Support/MemoryBuffer.h" -#include "llvm/Support/PrettyStackTrace.h" -#include "llvm/Support/Regex.h" -#include "llvm/Support/Signals.h" -#include "llvm/Support/SourceMgr.h" -#include "llvm/Support/raw_ostream.h" -#include -#include -#include -#include -#include -#include -using namespace llvm; - -static cl::opt -CheckFilename(cl::Positional, cl::desc(""), cl::Required); - -static cl::opt -InputFilename("input-file", cl::desc("File to check (defaults to stdin)"), - cl::init("-"), cl::value_desc("filename")); - -static cl::list -CheckPrefixes("check-prefix", - cl::desc("Prefix to use from check file (defaults to 'CHECK')")); -static cl::alias CheckPrefixesAlias( - "check-prefixes", cl::aliasopt(CheckPrefixes), cl::CommaSeparated, - cl::NotHidden, - cl::desc( - "Alias for -check-prefix permitting multiple comma separated values")); - -static cl::opt -NoCanonicalizeWhiteSpace("strict-whitespace", - cl::desc("Do not treat all horizontal whitespace as equivalent")); - -static cl::list ImplicitCheckNot( - "implicit-check-not", - cl::desc("Add an implicit negative check with this pattern to every\n" - "positive check. This can be used to ensure that no instances of\n" - "this pattern occur which are not matched by a positive pattern"), - cl::value_desc("pattern")); - -static cl::opt AllowEmptyInput( - "allow-empty", cl::init(false), - cl::desc("Allow the input file to be empty. This is useful when making\n" - "checks that some error message does not occur, for example.")); - -static cl::opt MatchFullLines( - "match-full-lines", cl::init(false), - cl::desc("Require all positive matches to cover an entire input line.\n" - "Allows leading and trailing whitespace if --strict-whitespace\n" - "is not also passed.")); - -typedef cl::list::const_iterator prefix_iterator; - -//===----------------------------------------------------------------------===// -// Pattern Handling Code. -//===----------------------------------------------------------------------===// - -namespace Check { - enum CheckType { - CheckNone = 0, - CheckPlain, - CheckNext, - CheckSame, - CheckNot, - CheckDAG, - CheckLabel, - - /// MatchEOF - When set, this pattern only matches the end of file. This is - /// used for trailing CHECK-NOTs. - CheckEOF, - /// CheckBadNot - Found -NOT combined with another CHECK suffix. - CheckBadNot - }; -} - -class Pattern { - SMLoc PatternLoc; - - Check::CheckType CheckTy; - - /// FixedStr - If non-empty, this pattern is a fixed string match with the - /// specified fixed string. - StringRef FixedStr; - - /// RegEx - If non-empty, this is a regex pattern. - std::string RegExStr; - - /// \brief Contains the number of line this pattern is in. - unsigned LineNumber; - - /// VariableUses - Entries in this vector map to uses of a variable in the - /// pattern, e.g. "foo[[bar]]baz". In this case, the RegExStr will contain - /// "foobaz" and we'll get an entry in this vector that tells us to insert the - /// value of bar at offset 3. - std::vector > VariableUses; - - /// VariableDefs - Maps definitions of variables to their parenthesized - /// capture numbers. - /// E.g. for the pattern "foo[[bar:.*]]baz", VariableDefs will map "bar" to 1. - std::map VariableDefs; - -public: - - Pattern(Check::CheckType Ty) - : CheckTy(Ty) { } - - /// getLoc - Return the location in source code. - SMLoc getLoc() const { return PatternLoc; } - - /// ParsePattern - Parse the given string into the Pattern. Prefix provides - /// which prefix is being matched, SM provides the SourceMgr used for error - /// reports, and LineNumber is the line number in the input file from which - /// the pattern string was read. Returns true in case of an error, false - /// otherwise. - bool ParsePattern(StringRef PatternStr, - StringRef Prefix, - SourceMgr &SM, - unsigned LineNumber); - - /// Match - Match the pattern string against the input buffer Buffer. This - /// returns the position that is matched or npos if there is no match. If - /// there is a match, the size of the matched string is returned in MatchLen. - /// - /// The VariableTable StringMap provides the current values of filecheck - /// variables and is updated if this match defines new values. - size_t Match(StringRef Buffer, size_t &MatchLen, - StringMap &VariableTable) const; - - /// PrintFailureInfo - Print additional information about a failure to match - /// involving this pattern. - void PrintFailureInfo(const SourceMgr &SM, StringRef Buffer, - const StringMap &VariableTable) const; - - bool hasVariable() const { return !(VariableUses.empty() && - VariableDefs.empty()); } - - Check::CheckType getCheckTy() const { return CheckTy; } - -private: - bool AddRegExToRegEx(StringRef RS, unsigned &CurParen, SourceMgr &SM); - void AddBackrefToRegEx(unsigned BackrefNum); - - /// ComputeMatchDistance - Compute an arbitrary estimate for the quality of - /// matching this pattern at the start of \arg Buffer; a distance of zero - /// should correspond to a perfect match. - unsigned ComputeMatchDistance(StringRef Buffer, - const StringMap &VariableTable) const; - - /// \brief Evaluates expression and stores the result to \p Value. - /// \return true on success. false when the expression has invalid syntax. - bool EvaluateExpression(StringRef Expr, std::string &Value) const; - - /// \brief Finds the closing sequence of a regex variable usage or - /// definition. Str has to point in the beginning of the definition - /// (right after the opening sequence). - /// \return offset of the closing sequence within Str, or npos if it was not - /// found. - size_t FindRegexVarEnd(StringRef Str, SourceMgr &SM); -}; - - -bool Pattern::ParsePattern(StringRef PatternStr, - StringRef Prefix, - SourceMgr &SM, - unsigned LineNumber) { - bool MatchFullLinesHere = MatchFullLines && CheckTy != Check::CheckNot; - - this->LineNumber = LineNumber; - PatternLoc = SMLoc::getFromPointer(PatternStr.data()); - - // Ignore trailing whitespace. - while (!PatternStr.empty() && - (PatternStr.back() == ' ' || PatternStr.back() == '\t')) - PatternStr = PatternStr.substr(0, PatternStr.size()-1); - - // Check that there is something on the line. - if (PatternStr.empty()) { - SM.PrintMessage(PatternLoc, SourceMgr::DK_Error, - "found empty check string with prefix '" + - Prefix + ":'"); - return true; - } - - // Check to see if this is a fixed string, or if it has regex pieces. - if (!MatchFullLinesHere && - (PatternStr.size() < 2 || (PatternStr.find("{{") == StringRef::npos && - PatternStr.find("[[") == StringRef::npos))) { - FixedStr = PatternStr; - return false; - } - - if (MatchFullLinesHere) { - RegExStr += '^'; - if (!NoCanonicalizeWhiteSpace) - RegExStr += " *"; - } - - // Paren value #0 is for the fully matched string. Any new parenthesized - // values add from there. - unsigned CurParen = 1; - - // Otherwise, there is at least one regex piece. Build up the regex pattern - // by escaping scary characters in fixed strings, building up one big regex. - while (!PatternStr.empty()) { - // RegEx matches. - if (PatternStr.startswith("{{")) { - // This is the start of a regex match. Scan for the }}. - size_t End = PatternStr.find("}}"); - if (End == StringRef::npos) { - SM.PrintMessage(SMLoc::getFromPointer(PatternStr.data()), - SourceMgr::DK_Error, - "found start of regex string with no end '}}'"); - return true; - } - - // Enclose {{}} patterns in parens just like [[]] even though we're not - // capturing the result for any purpose. This is required in case the - // expression contains an alternation like: CHECK: abc{{x|z}}def. We - // want this to turn into: "abc(x|z)def" not "abcx|zdef". - RegExStr += '('; - ++CurParen; - - if (AddRegExToRegEx(PatternStr.substr(2, End-2), CurParen, SM)) - return true; - RegExStr += ')'; - - PatternStr = PatternStr.substr(End+2); - continue; - } - - // Named RegEx matches. These are of two forms: [[foo:.*]] which matches .* - // (or some other regex) and assigns it to the FileCheck variable 'foo'. The - // second form is [[foo]] which is a reference to foo. The variable name - // itself must be of the form "[a-zA-Z_][0-9a-zA-Z_]*", otherwise we reject - // it. This is to catch some common errors. - if (PatternStr.startswith("[[")) { - // Find the closing bracket pair ending the match. End is going to be an - // offset relative to the beginning of the match string. - size_t End = FindRegexVarEnd(PatternStr.substr(2), SM); - - if (End == StringRef::npos) { - SM.PrintMessage(SMLoc::getFromPointer(PatternStr.data()), - SourceMgr::DK_Error, - "invalid named regex reference, no ]] found"); - return true; - } - - StringRef MatchStr = PatternStr.substr(2, End); - PatternStr = PatternStr.substr(End+4); - - // Get the regex name (e.g. "foo"). - size_t NameEnd = MatchStr.find(':'); - StringRef Name = MatchStr.substr(0, NameEnd); - - if (Name.empty()) { - SM.PrintMessage(SMLoc::getFromPointer(Name.data()), SourceMgr::DK_Error, - "invalid name in named regex: empty name"); - return true; - } - - // Verify that the name/expression is well formed. FileCheck currently - // supports @LINE, @LINE+number, @LINE-number expressions. The check here - // is relaxed, more strict check is performed in \c EvaluateExpression. - bool IsExpression = false; - for (unsigned i = 0, e = Name.size(); i != e; ++i) { - if (i == 0 && Name[i] == '@') { - if (NameEnd != StringRef::npos) { - SM.PrintMessage(SMLoc::getFromPointer(Name.data()), - SourceMgr::DK_Error, - "invalid name in named regex definition"); - return true; - } - IsExpression = true; - continue; - } - if (Name[i] != '_' && !isalnum(Name[i]) && - (!IsExpression || (Name[i] != '+' && Name[i] != '-'))) { - SM.PrintMessage(SMLoc::getFromPointer(Name.data()+i), - SourceMgr::DK_Error, "invalid name in named regex"); - return true; - } - } - - // Name can't start with a digit. - if (isdigit(static_cast(Name[0]))) { - SM.PrintMessage(SMLoc::getFromPointer(Name.data()), SourceMgr::DK_Error, - "invalid name in named regex"); - return true; - } - - // Handle [[foo]]. - if (NameEnd == StringRef::npos) { - // Handle variables that were defined earlier on the same line by - // emitting a backreference. - if (VariableDefs.find(Name) != VariableDefs.end()) { - unsigned VarParenNum = VariableDefs[Name]; - if (VarParenNum < 1 || VarParenNum > 9) { - SM.PrintMessage(SMLoc::getFromPointer(Name.data()), - SourceMgr::DK_Error, - "Can't back-reference more than 9 variables"); - return true; - } - AddBackrefToRegEx(VarParenNum); - } else { - VariableUses.push_back(std::make_pair(Name, RegExStr.size())); - } - continue; - } - - // Handle [[foo:.*]]. - VariableDefs[Name] = CurParen; - RegExStr += '('; - ++CurParen; - - if (AddRegExToRegEx(MatchStr.substr(NameEnd+1), CurParen, SM)) - return true; - - RegExStr += ')'; - } - - // Handle fixed string matches. - // Find the end, which is the start of the next regex. - size_t FixedMatchEnd = PatternStr.find("{{"); - FixedMatchEnd = std::min(FixedMatchEnd, PatternStr.find("[[")); - RegExStr += Regex::escape(PatternStr.substr(0, FixedMatchEnd)); - PatternStr = PatternStr.substr(FixedMatchEnd); - } - - if (MatchFullLinesHere) { - if (!NoCanonicalizeWhiteSpace) - RegExStr += " *"; - RegExStr += '$'; - } - - return false; -} - -bool Pattern::AddRegExToRegEx(StringRef RS, unsigned &CurParen, - SourceMgr &SM) { - Regex R(RS); - std::string Error; - if (!R.isValid(Error)) { - SM.PrintMessage(SMLoc::getFromPointer(RS.data()), SourceMgr::DK_Error, - "invalid regex: " + Error); - return true; - } - - RegExStr += RS.str(); - CurParen += R.getNumMatches(); - return false; -} - -void Pattern::AddBackrefToRegEx(unsigned BackrefNum) { - assert(BackrefNum >= 1 && BackrefNum <= 9 && "Invalid backref number"); - std::string Backref = std::string("\\") + - std::string(1, '0' + BackrefNum); - RegExStr += Backref; -} - -bool Pattern::EvaluateExpression(StringRef Expr, std::string &Value) const { - // The only supported expression is @LINE([\+-]\d+)? - if (!Expr.startswith("@LINE")) - return false; - Expr = Expr.substr(StringRef("@LINE").size()); - int Offset = 0; - if (!Expr.empty()) { - if (Expr[0] == '+') - Expr = Expr.substr(1); - else if (Expr[0] != '-') - return false; - if (Expr.getAsInteger(10, Offset)) - return false; - } - Value = llvm::itostr(LineNumber + Offset); - return true; -} - -/// Match - Match the pattern string against the input buffer Buffer. This -/// returns the position that is matched or npos if there is no match. If -/// there is a match, the size of the matched string is returned in MatchLen. -size_t Pattern::Match(StringRef Buffer, size_t &MatchLen, - StringMap &VariableTable) const { - // If this is the EOF pattern, match it immediately. - if (CheckTy == Check::CheckEOF) { - MatchLen = 0; - return Buffer.size(); - } - - // If this is a fixed string pattern, just match it now. - if (!FixedStr.empty()) { - MatchLen = FixedStr.size(); - return Buffer.find(FixedStr); - } - - // Regex match. - - // If there are variable uses, we need to create a temporary string with the - // actual value. - StringRef RegExToMatch = RegExStr; - std::string TmpStr; - if (!VariableUses.empty()) { - TmpStr = RegExStr; - - unsigned InsertOffset = 0; - for (const auto &VariableUse : VariableUses) { - std::string Value; - - if (VariableUse.first[0] == '@') { - if (!EvaluateExpression(VariableUse.first, Value)) - return StringRef::npos; - } else { - StringMap::iterator it = - VariableTable.find(VariableUse.first); - // If the variable is undefined, return an error. - if (it == VariableTable.end()) - return StringRef::npos; - - // Look up the value and escape it so that we can put it into the regex. - Value += Regex::escape(it->second); - } - - // Plop it into the regex at the adjusted offset. - TmpStr.insert(TmpStr.begin() + VariableUse.second + InsertOffset, - Value.begin(), Value.end()); - InsertOffset += Value.size(); - } - - // Match the newly constructed regex. - RegExToMatch = TmpStr; - } - - - SmallVector MatchInfo; - if (!Regex(RegExToMatch, Regex::Newline).match(Buffer, &MatchInfo)) - return StringRef::npos; - - // Successful regex match. - assert(!MatchInfo.empty() && "Didn't get any match"); - StringRef FullMatch = MatchInfo[0]; - - // If this defines any variables, remember their values. - for (const auto &VariableDef : VariableDefs) { - assert(VariableDef.second < MatchInfo.size() && "Internal paren error"); - VariableTable[VariableDef.first] = MatchInfo[VariableDef.second]; - } - - MatchLen = FullMatch.size(); - return FullMatch.data()-Buffer.data(); -} - -unsigned Pattern::ComputeMatchDistance(StringRef Buffer, - const StringMap &VariableTable) const { - // Just compute the number of matching characters. For regular expressions, we - // just compare against the regex itself and hope for the best. - // - // FIXME: One easy improvement here is have the regex lib generate a single - // example regular expression which matches, and use that as the example - // string. - StringRef ExampleString(FixedStr); - if (ExampleString.empty()) - ExampleString = RegExStr; - - // Only compare up to the first line in the buffer, or the string size. - StringRef BufferPrefix = Buffer.substr(0, ExampleString.size()); - BufferPrefix = BufferPrefix.split('\n').first; - return BufferPrefix.edit_distance(ExampleString); -} - -void Pattern::PrintFailureInfo(const SourceMgr &SM, StringRef Buffer, - const StringMap &VariableTable) const{ - // If this was a regular expression using variables, print the current - // variable values. - if (!VariableUses.empty()) { - for (const auto &VariableUse : VariableUses) { - SmallString<256> Msg; - raw_svector_ostream OS(Msg); - StringRef Var = VariableUse.first; - if (Var[0] == '@') { - std::string Value; - if (EvaluateExpression(Var, Value)) { - OS << "with expression \""; - OS.write_escaped(Var) << "\" equal to \""; - OS.write_escaped(Value) << "\""; - } else { - OS << "uses incorrect expression \""; - OS.write_escaped(Var) << "\""; - } - } else { - StringMap::const_iterator it = VariableTable.find(Var); - - // Check for undefined variable references. - if (it == VariableTable.end()) { - OS << "uses undefined variable \""; - OS.write_escaped(Var) << "\""; - } else { - OS << "with variable \""; - OS.write_escaped(Var) << "\" equal to \""; - OS.write_escaped(it->second) << "\""; - } - } - - SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()), SourceMgr::DK_Note, - OS.str()); - } - } - - // Attempt to find the closest/best fuzzy match. Usually an error happens - // because some string in the output didn't exactly match. In these cases, we - // would like to show the user a best guess at what "should have" matched, to - // save them having to actually check the input manually. - size_t NumLinesForward = 0; - size_t Best = StringRef::npos; - double BestQuality = 0; - - // Use an arbitrary 4k limit on how far we will search. - for (size_t i = 0, e = std::min(size_t(4096), Buffer.size()); i != e; ++i) { - if (Buffer[i] == '\n') - ++NumLinesForward; - - // Patterns have leading whitespace stripped, so skip whitespace when - // looking for something which looks like a pattern. - if (Buffer[i] == ' ' || Buffer[i] == '\t') - continue; - - // Compute the "quality" of this match as an arbitrary combination of the - // match distance and the number of lines skipped to get to this match. - unsigned Distance = ComputeMatchDistance(Buffer.substr(i), VariableTable); - double Quality = Distance + (NumLinesForward / 100.); - - if (Quality < BestQuality || Best == StringRef::npos) { - Best = i; - BestQuality = Quality; - } - } - - // Print the "possible intended match here" line if we found something - // reasonable and not equal to what we showed in the "scanning from here" - // line. - if (Best && Best != StringRef::npos && BestQuality < 50) { - SM.PrintMessage(SMLoc::getFromPointer(Buffer.data() + Best), - SourceMgr::DK_Note, "possible intended match here"); - - // FIXME: If we wanted to be really friendly we would show why the match - // failed, as it can be hard to spot simple one character differences. - } -} - -size_t Pattern::FindRegexVarEnd(StringRef Str, SourceMgr &SM) { - // Offset keeps track of the current offset within the input Str - size_t Offset = 0; - // [...] Nesting depth - size_t BracketDepth = 0; - - while (!Str.empty()) { - if (Str.startswith("]]") && BracketDepth == 0) - return Offset; - if (Str[0] == '\\') { - // Backslash escapes the next char within regexes, so skip them both. - Str = Str.substr(2); - Offset += 2; - } else { - switch (Str[0]) { - default: - break; - case '[': - BracketDepth++; - break; - case ']': - if (BracketDepth == 0) { - SM.PrintMessage(SMLoc::getFromPointer(Str.data()), - SourceMgr::DK_Error, - "missing closing \"]\" for regex variable"); - exit(1); - } - BracketDepth--; - break; - } - Str = Str.substr(1); - Offset++; - } - } - - return StringRef::npos; -} - - -//===----------------------------------------------------------------------===// -// Check Strings. -//===----------------------------------------------------------------------===// - -/// CheckString - This is a check that we found in the input file. -struct CheckString { - /// Pat - The pattern to match. - Pattern Pat; - - /// Prefix - Which prefix name this check matched. - StringRef Prefix; - - /// Loc - The location in the match file that the check string was specified. - SMLoc Loc; - - /// CheckTy - Specify what kind of check this is. e.g. CHECK-NEXT: directive, - /// as opposed to a CHECK: directive. - // Check::CheckType CheckTy; - - /// DagNotStrings - These are all of the strings that are disallowed from - /// occurring between this match string and the previous one (or start of - /// file). - std::vector DagNotStrings; - - CheckString(const Pattern &P, StringRef S, SMLoc L) - : Pat(P), Prefix(S), Loc(L) {} - - /// Check - Match check string and its "not strings" and/or "dag strings". - size_t Check(const SourceMgr &SM, StringRef Buffer, bool IsLabelScanMode, - size_t &MatchLen, StringMap &VariableTable) const; - - /// CheckNext - Verify there is a single line in the given buffer. - bool CheckNext(const SourceMgr &SM, StringRef Buffer) const; - - /// CheckSame - Verify there is no newline in the given buffer. - bool CheckSame(const SourceMgr &SM, StringRef Buffer) const; - - /// CheckNot - Verify there's no "not strings" in the given buffer. - bool CheckNot(const SourceMgr &SM, StringRef Buffer, - const std::vector &NotStrings, - StringMap &VariableTable) const; - - /// CheckDag - Match "dag strings" and their mixed "not strings". - size_t CheckDag(const SourceMgr &SM, StringRef Buffer, - std::vector &NotStrings, - StringMap &VariableTable) const; -}; - -/// Canonicalize whitespaces in the input file. Line endings are replaced -/// with UNIX-style '\n'. -/// -/// \param PreserveHorizontal Don't squash consecutive horizontal whitespace -/// characters to a single space. -static std::unique_ptr -CanonicalizeInputFile(std::unique_ptr MB, - bool PreserveHorizontal) { - SmallString<128> NewFile; - NewFile.reserve(MB->getBufferSize()); - - for (const char *Ptr = MB->getBufferStart(), *End = MB->getBufferEnd(); - Ptr != End; ++Ptr) { - // Eliminate trailing dosish \r. - if (Ptr <= End - 2 && Ptr[0] == '\r' && Ptr[1] == '\n') { - continue; - } - - // If current char is not a horizontal whitespace or if horizontal - // whitespace canonicalization is disabled, dump it to output as is. - if (PreserveHorizontal || (*Ptr != ' ' && *Ptr != '\t')) { - NewFile.push_back(*Ptr); - continue; - } - - // Otherwise, add one space and advance over neighboring space. - NewFile.push_back(' '); - while (Ptr+1 != End && - (Ptr[1] == ' ' || Ptr[1] == '\t')) - ++Ptr; - } - - return std::unique_ptr( - MemoryBuffer::getMemBufferCopy(NewFile.str(), MB->getBufferIdentifier())); -} - -static bool IsPartOfWord(char c) { - return (isalnum(c) || c == '-' || c == '_'); -} - -// Get the size of the prefix extension. -static size_t CheckTypeSize(Check::CheckType Ty) { - switch (Ty) { - case Check::CheckNone: - case Check::CheckBadNot: - return 0; - - case Check::CheckPlain: - return sizeof(":") - 1; - - case Check::CheckNext: - return sizeof("-NEXT:") - 1; - - case Check::CheckSame: - return sizeof("-SAME:") - 1; - - case Check::CheckNot: - return sizeof("-NOT:") - 1; - - case Check::CheckDAG: - return sizeof("-DAG:") - 1; - - case Check::CheckLabel: - return sizeof("-LABEL:") - 1; - - case Check::CheckEOF: - llvm_unreachable("Should not be using EOF size"); - } - - llvm_unreachable("Bad check type"); -} - -static Check::CheckType FindCheckType(StringRef Buffer, StringRef Prefix) { - char NextChar = Buffer[Prefix.size()]; - - // Verify that the : is present after the prefix. - if (NextChar == ':') - return Check::CheckPlain; - - if (NextChar != '-') - return Check::CheckNone; - - StringRef Rest = Buffer.drop_front(Prefix.size() + 1); - if (Rest.startswith("NEXT:")) - return Check::CheckNext; - - if (Rest.startswith("SAME:")) - return Check::CheckSame; - - if (Rest.startswith("NOT:")) - return Check::CheckNot; - - if (Rest.startswith("DAG:")) - return Check::CheckDAG; - - if (Rest.startswith("LABEL:")) - return Check::CheckLabel; - - // You can't combine -NOT with another suffix. - if (Rest.startswith("DAG-NOT:") || Rest.startswith("NOT-DAG:") || - Rest.startswith("NEXT-NOT:") || Rest.startswith("NOT-NEXT:") || - Rest.startswith("SAME-NOT:") || Rest.startswith("NOT-SAME:")) - return Check::CheckBadNot; - - return Check::CheckNone; -} - -// From the given position, find the next character after the word. -static size_t SkipWord(StringRef Str, size_t Loc) { - while (Loc < Str.size() && IsPartOfWord(Str[Loc])) - ++Loc; - return Loc; -} - -// Try to find the first match in buffer for any prefix. If a valid match is -// found, return that prefix and set its type and location. If there are almost -// matches (e.g. the actual prefix string is found, but is not an actual check -// string), but no valid match, return an empty string and set the position to -// resume searching from. If no partial matches are found, return an empty -// string and the location will be StringRef::npos. If one prefix is a substring -// of another, the maximal match should be found. e.g. if "A" and "AA" are -// prefixes then AA-CHECK: should match the second one. -static StringRef FindFirstCandidateMatch(StringRef &Buffer, - Check::CheckType &CheckTy, - size_t &CheckLoc) { - StringRef FirstPrefix; - size_t FirstLoc = StringRef::npos; - size_t SearchLoc = StringRef::npos; - Check::CheckType FirstTy = Check::CheckNone; - - CheckTy = Check::CheckNone; - CheckLoc = StringRef::npos; - - for (StringRef Prefix : CheckPrefixes) { - size_t PrefixLoc = Buffer.find(Prefix); - - if (PrefixLoc == StringRef::npos) - continue; - - // Track where we are searching for invalid prefixes that look almost right. - // We need to only advance to the first partial match on the next attempt - // since a partial match could be a substring of a later, valid prefix. - // Need to skip to the end of the word, otherwise we could end up - // matching a prefix in a substring later. - if (PrefixLoc < SearchLoc) - SearchLoc = SkipWord(Buffer, PrefixLoc); - - // We only want to find the first match to avoid skipping some. - if (PrefixLoc > FirstLoc) - continue; - // If one matching check-prefix is a prefix of another, choose the - // longer one. - if (PrefixLoc == FirstLoc && Prefix.size() < FirstPrefix.size()) - continue; - - StringRef Rest = Buffer.drop_front(PrefixLoc); - // Make sure we have actually found the prefix, and not a word containing - // it. This should also prevent matching the wrong prefix when one is a - // substring of another. - if (PrefixLoc != 0 && IsPartOfWord(Buffer[PrefixLoc - 1])) - FirstTy = Check::CheckNone; - else - FirstTy = FindCheckType(Rest, Prefix); - - FirstLoc = PrefixLoc; - FirstPrefix = Prefix; - } - - // If the first prefix is invalid, we should continue the search after it. - if (FirstTy == Check::CheckNone) { - CheckLoc = SearchLoc; - return ""; - } - - CheckTy = FirstTy; - CheckLoc = FirstLoc; - return FirstPrefix; -} - -static StringRef FindFirstMatchingPrefix(StringRef &Buffer, - unsigned &LineNumber, - Check::CheckType &CheckTy, - size_t &CheckLoc) { - while (!Buffer.empty()) { - StringRef Prefix = FindFirstCandidateMatch(Buffer, CheckTy, CheckLoc); - // If we found a real match, we are done. - if (!Prefix.empty()) { - LineNumber += Buffer.substr(0, CheckLoc).count('\n'); - return Prefix; - } - - // We didn't find any almost matches either, we are also done. - if (CheckLoc == StringRef::npos) - return StringRef(); - - LineNumber += Buffer.substr(0, CheckLoc + 1).count('\n'); - - // Advance to the last possible match we found and try again. - Buffer = Buffer.drop_front(CheckLoc + 1); - } - - return StringRef(); -} - -/// ReadCheckFile - Read the check file, which specifies the sequence of -/// expected strings. The strings are added to the CheckStrings vector. -/// Returns true in case of an error, false otherwise. -static bool ReadCheckFile(SourceMgr &SM, - std::vector &CheckStrings) { - ErrorOr> FileOrErr = - MemoryBuffer::getFileOrSTDIN(CheckFilename); - if (std::error_code EC = FileOrErr.getError()) { - errs() << "Could not open check file '" << CheckFilename - << "': " << EC.message() << '\n'; - return true; - } - - // If we want to canonicalize whitespace, strip excess whitespace from the - // buffer containing the CHECK lines. Remove DOS style line endings. - std::unique_ptr F = CanonicalizeInputFile( - std::move(FileOrErr.get()), NoCanonicalizeWhiteSpace); - - // Find all instances of CheckPrefix followed by : in the file. - StringRef Buffer = F->getBuffer(); - - SM.AddNewSourceBuffer(std::move(F), SMLoc()); - - std::vector ImplicitNegativeChecks; - for (const auto &PatternString : ImplicitCheckNot) { - // Create a buffer with fake command line content in order to display the - // command line option responsible for the specific implicit CHECK-NOT. - std::string Prefix = (Twine("-") + ImplicitCheckNot.ArgStr + "='").str(); - std::string Suffix = "'"; - std::unique_ptr CmdLine = MemoryBuffer::getMemBufferCopy( - Prefix + PatternString + Suffix, "command line"); - - StringRef PatternInBuffer = - CmdLine->getBuffer().substr(Prefix.size(), PatternString.size()); - SM.AddNewSourceBuffer(std::move(CmdLine), SMLoc()); - - ImplicitNegativeChecks.push_back(Pattern(Check::CheckNot)); - ImplicitNegativeChecks.back().ParsePattern(PatternInBuffer, - "IMPLICIT-CHECK", SM, 0); - } - - - std::vector DagNotMatches = ImplicitNegativeChecks; - - // LineNumber keeps track of the line on which CheckPrefix instances are - // found. - unsigned LineNumber = 1; - - while (1) { - Check::CheckType CheckTy; - size_t PrefixLoc; - - // See if a prefix occurs in the memory buffer. - StringRef UsedPrefix = FindFirstMatchingPrefix(Buffer, - LineNumber, - CheckTy, - PrefixLoc); - if (UsedPrefix.empty()) - break; - - Buffer = Buffer.drop_front(PrefixLoc); - - // Location to use for error messages. - const char *UsedPrefixStart = Buffer.data() + (PrefixLoc == 0 ? 0 : 1); - - // PrefixLoc is to the start of the prefix. Skip to the end. - Buffer = Buffer.drop_front(UsedPrefix.size() + CheckTypeSize(CheckTy)); - - // Complain about useful-looking but unsupported suffixes. - if (CheckTy == Check::CheckBadNot) { - SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()), - SourceMgr::DK_Error, - "unsupported -NOT combo on prefix '" + UsedPrefix + "'"); - return true; - } - - // Okay, we found the prefix, yay. Remember the rest of the line, but ignore - // leading and trailing whitespace. - Buffer = Buffer.substr(Buffer.find_first_not_of(" \t")); - - // Scan ahead to the end of line. - size_t EOL = Buffer.find_first_of("\n\r"); - - // Remember the location of the start of the pattern, for diagnostics. - SMLoc PatternLoc = SMLoc::getFromPointer(Buffer.data()); - - // Parse the pattern. - Pattern P(CheckTy); - if (P.ParsePattern(Buffer.substr(0, EOL), UsedPrefix, SM, LineNumber)) - return true; - - // Verify that CHECK-LABEL lines do not define or use variables - if ((CheckTy == Check::CheckLabel) && P.hasVariable()) { - SM.PrintMessage(SMLoc::getFromPointer(UsedPrefixStart), - SourceMgr::DK_Error, - "found '" + UsedPrefix + "-LABEL:'" - " with variable definition or use"); - return true; - } - - Buffer = Buffer.substr(EOL); - - // Verify that CHECK-NEXT lines have at least one CHECK line before them. - if ((CheckTy == Check::CheckNext || CheckTy == Check::CheckSame) && - CheckStrings.empty()) { - StringRef Type = CheckTy == Check::CheckNext ? "NEXT" : "SAME"; - SM.PrintMessage(SMLoc::getFromPointer(UsedPrefixStart), - SourceMgr::DK_Error, - "found '" + UsedPrefix + "-" + Type + "' without previous '" - + UsedPrefix + ": line"); - return true; - } - - // Handle CHECK-DAG/-NOT. - if (CheckTy == Check::CheckDAG || CheckTy == Check::CheckNot) { - DagNotMatches.push_back(P); - continue; - } - - // Okay, add the string we captured to the output vector and move on. - CheckStrings.emplace_back(P, UsedPrefix, PatternLoc); - std::swap(DagNotMatches, CheckStrings.back().DagNotStrings); - DagNotMatches = ImplicitNegativeChecks; - } - - // Add an EOF pattern for any trailing CHECK-DAG/-NOTs, and use the first - // prefix as a filler for the error message. - if (!DagNotMatches.empty()) { - CheckStrings.emplace_back(Pattern(Check::CheckEOF), *CheckPrefixes.begin(), - SMLoc::getFromPointer(Buffer.data())); - std::swap(DagNotMatches, CheckStrings.back().DagNotStrings); - } - - if (CheckStrings.empty()) { - errs() << "error: no check strings found with prefix" - << (CheckPrefixes.size() > 1 ? "es " : " "); - prefix_iterator I = CheckPrefixes.begin(); - prefix_iterator E = CheckPrefixes.end(); - if (I != E) { - errs() << "\'" << *I << ":'"; - ++I; - } - for (; I != E; ++I) - errs() << ", \'" << *I << ":'"; - - errs() << '\n'; - return true; - } - - return false; -} - -static void PrintCheckFailed(const SourceMgr &SM, SMLoc Loc, - const Pattern &Pat, StringRef Buffer, - StringMap &VariableTable) { - // Otherwise, we have an error, emit an error message. - SM.PrintMessage(Loc, SourceMgr::DK_Error, - "expected string not found in input"); - - // Print the "scanning from here" line. If the current position is at the - // end of a line, advance to the start of the next line. - Buffer = Buffer.substr(Buffer.find_first_not_of(" \t\n\r")); - - SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()), SourceMgr::DK_Note, - "scanning from here"); - - // Allow the pattern to print additional information if desired. - Pat.PrintFailureInfo(SM, Buffer, VariableTable); -} - -static void PrintCheckFailed(const SourceMgr &SM, const CheckString &CheckStr, - StringRef Buffer, - StringMap &VariableTable) { - PrintCheckFailed(SM, CheckStr.Loc, CheckStr.Pat, Buffer, VariableTable); -} - -/// CountNumNewlinesBetween - Count the number of newlines in the specified -/// range. -static unsigned CountNumNewlinesBetween(StringRef Range, - const char *&FirstNewLine) { - unsigned NumNewLines = 0; - while (1) { - // Scan for newline. - Range = Range.substr(Range.find_first_of("\n\r")); - if (Range.empty()) return NumNewLines; - - ++NumNewLines; - - // Handle \n\r and \r\n as a single newline. - if (Range.size() > 1 && - (Range[1] == '\n' || Range[1] == '\r') && - (Range[0] != Range[1])) - Range = Range.substr(1); - Range = Range.substr(1); - - if (NumNewLines == 1) - FirstNewLine = Range.begin(); - } -} - -size_t CheckString::Check(const SourceMgr &SM, StringRef Buffer, - bool IsLabelScanMode, size_t &MatchLen, - StringMap &VariableTable) const { - size_t LastPos = 0; - std::vector NotStrings; - - // IsLabelScanMode is true when we are scanning forward to find CHECK-LABEL - // bounds; we have not processed variable definitions within the bounded block - // yet so cannot handle any final CHECK-DAG yet; this is handled when going - // over the block again (including the last CHECK-LABEL) in normal mode. - if (!IsLabelScanMode) { - // Match "dag strings" (with mixed "not strings" if any). - LastPos = CheckDag(SM, Buffer, NotStrings, VariableTable); - if (LastPos == StringRef::npos) - return StringRef::npos; - } - - // Match itself from the last position after matching CHECK-DAG. - StringRef MatchBuffer = Buffer.substr(LastPos); - size_t MatchPos = Pat.Match(MatchBuffer, MatchLen, VariableTable); - if (MatchPos == StringRef::npos) { - PrintCheckFailed(SM, *this, MatchBuffer, VariableTable); - return StringRef::npos; - } - - // Similar to the above, in "label-scan mode" we can't yet handle CHECK-NEXT - // or CHECK-NOT - if (!IsLabelScanMode) { - StringRef SkippedRegion = Buffer.substr(LastPos, MatchPos); - - // If this check is a "CHECK-NEXT", verify that the previous match was on - // the previous line (i.e. that there is one newline between them). - if (CheckNext(SM, SkippedRegion)) - return StringRef::npos; - - // If this check is a "CHECK-SAME", verify that the previous match was on - // the same line (i.e. that there is no newline between them). - if (CheckSame(SM, SkippedRegion)) - return StringRef::npos; - - // If this match had "not strings", verify that they don't exist in the - // skipped region. - if (CheckNot(SM, SkippedRegion, NotStrings, VariableTable)) - return StringRef::npos; - } - - return LastPos + MatchPos; -} - -bool CheckString::CheckNext(const SourceMgr &SM, StringRef Buffer) const { - if (Pat.getCheckTy() != Check::CheckNext) - return false; - - // Count the number of newlines between the previous match and this one. - assert(Buffer.data() != - SM.getMemoryBuffer( - SM.FindBufferContainingLoc( - SMLoc::getFromPointer(Buffer.data())))->getBufferStart() && - "CHECK-NEXT can't be the first check in a file"); - - const char *FirstNewLine = nullptr; - unsigned NumNewLines = CountNumNewlinesBetween(Buffer, FirstNewLine); - - if (NumNewLines == 0) { - SM.PrintMessage(Loc, SourceMgr::DK_Error, Prefix + - "-NEXT: is on the same line as previous match"); - SM.PrintMessage(SMLoc::getFromPointer(Buffer.end()), - SourceMgr::DK_Note, "'next' match was here"); - SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()), SourceMgr::DK_Note, - "previous match ended here"); - return true; - } - - if (NumNewLines != 1) { - SM.PrintMessage(Loc, SourceMgr::DK_Error, Prefix + - "-NEXT: is not on the line after the previous match"); - SM.PrintMessage(SMLoc::getFromPointer(Buffer.end()), - SourceMgr::DK_Note, "'next' match was here"); - SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()), SourceMgr::DK_Note, - "previous match ended here"); - SM.PrintMessage(SMLoc::getFromPointer(FirstNewLine), SourceMgr::DK_Note, - "non-matching line after previous match is here"); - return true; - } - - return false; -} - -bool CheckString::CheckSame(const SourceMgr &SM, StringRef Buffer) const { - if (Pat.getCheckTy() != Check::CheckSame) - return false; - - // Count the number of newlines between the previous match and this one. - assert(Buffer.data() != - SM.getMemoryBuffer(SM.FindBufferContainingLoc( - SMLoc::getFromPointer(Buffer.data()))) - ->getBufferStart() && - "CHECK-SAME can't be the first check in a file"); - - const char *FirstNewLine = nullptr; - unsigned NumNewLines = CountNumNewlinesBetween(Buffer, FirstNewLine); - - if (NumNewLines != 0) { - SM.PrintMessage(Loc, SourceMgr::DK_Error, - Prefix + - "-SAME: is not on the same line as the previous match"); - SM.PrintMessage(SMLoc::getFromPointer(Buffer.end()), SourceMgr::DK_Note, - "'next' match was here"); - SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()), SourceMgr::DK_Note, - "previous match ended here"); - return true; - } - - return false; -} - -bool CheckString::CheckNot(const SourceMgr &SM, StringRef Buffer, - const std::vector &NotStrings, - StringMap &VariableTable) const { - for (const Pattern *Pat : NotStrings) { - assert((Pat->getCheckTy() == Check::CheckNot) && "Expect CHECK-NOT!"); - - size_t MatchLen = 0; - size_t Pos = Pat->Match(Buffer, MatchLen, VariableTable); - - if (Pos == StringRef::npos) continue; - - SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()+Pos), - SourceMgr::DK_Error, - Prefix + "-NOT: string occurred!"); - SM.PrintMessage(Pat->getLoc(), SourceMgr::DK_Note, - Prefix + "-NOT: pattern specified here"); - return true; - } - - return false; -} - -size_t CheckString::CheckDag(const SourceMgr &SM, StringRef Buffer, - std::vector &NotStrings, - StringMap &VariableTable) const { - if (DagNotStrings.empty()) - return 0; - - size_t LastPos = 0; - size_t StartPos = LastPos; - - for (const Pattern &Pat : DagNotStrings) { - assert((Pat.getCheckTy() == Check::CheckDAG || - Pat.getCheckTy() == Check::CheckNot) && - "Invalid CHECK-DAG or CHECK-NOT!"); - - if (Pat.getCheckTy() == Check::CheckNot) { - NotStrings.push_back(&Pat); - continue; - } - - assert((Pat.getCheckTy() == Check::CheckDAG) && "Expect CHECK-DAG!"); - - size_t MatchLen = 0, MatchPos; - - // CHECK-DAG always matches from the start. - StringRef MatchBuffer = Buffer.substr(StartPos); - MatchPos = Pat.Match(MatchBuffer, MatchLen, VariableTable); - // With a group of CHECK-DAGs, a single mismatching means the match on - // that group of CHECK-DAGs fails immediately. - if (MatchPos == StringRef::npos) { - PrintCheckFailed(SM, Pat.getLoc(), Pat, MatchBuffer, VariableTable); - return StringRef::npos; - } - // Re-calc it as the offset relative to the start of the original string. - MatchPos += StartPos; - - if (!NotStrings.empty()) { - if (MatchPos < LastPos) { - // Reordered? - SM.PrintMessage(SMLoc::getFromPointer(Buffer.data() + MatchPos), - SourceMgr::DK_Error, - Prefix + "-DAG: found a match of CHECK-DAG" - " reordering across a CHECK-NOT"); - SM.PrintMessage(SMLoc::getFromPointer(Buffer.data() + LastPos), - SourceMgr::DK_Note, - Prefix + "-DAG: the farthest match of CHECK-DAG" - " is found here"); - SM.PrintMessage(NotStrings[0]->getLoc(), SourceMgr::DK_Note, - Prefix + "-NOT: the crossed pattern specified" - " here"); - SM.PrintMessage(Pat.getLoc(), SourceMgr::DK_Note, - Prefix + "-DAG: the reordered pattern specified" - " here"); - return StringRef::npos; - } - // All subsequent CHECK-DAGs should be matched from the farthest - // position of all precedent CHECK-DAGs (including this one.) - StartPos = LastPos; - // If there's CHECK-NOTs between two CHECK-DAGs or from CHECK to - // CHECK-DAG, verify that there's no 'not' strings occurred in that - // region. - StringRef SkippedRegion = Buffer.substr(LastPos, MatchPos); - if (CheckNot(SM, SkippedRegion, NotStrings, VariableTable)) - return StringRef::npos; - // Clear "not strings". - NotStrings.clear(); - } - - // Update the last position with CHECK-DAG matches. - LastPos = std::max(MatchPos + MatchLen, LastPos); - } - - return LastPos; -} - -// A check prefix must contain only alphanumeric, hyphens and underscores. -static bool ValidateCheckPrefix(StringRef CheckPrefix) { - Regex Validator("^[a-zA-Z0-9_-]*$"); - return Validator.match(CheckPrefix); -} - -static bool ValidateCheckPrefixes() { - StringSet<> PrefixSet; - - for (StringRef Prefix : CheckPrefixes) { - // Reject empty prefixes. - if (Prefix == "") - return false; - - if (!PrefixSet.insert(Prefix).second) - return false; - - if (!ValidateCheckPrefix(Prefix)) - return false; - } - - return true; -} - -// I don't think there's a way to specify an initial value for cl::list, -// so if nothing was specified, add the default -static void AddCheckPrefixIfNeeded() { - if (CheckPrefixes.empty()) - CheckPrefixes.push_back("CHECK"); -} - -static void DumpCommandLine(int argc, char **argv) { - errs() << "FileCheck command line: "; - for (int I = 0; I < argc; I++) - errs() << " " << argv[I]; - errs() << "\n"; -} - -int main(int argc, char **argv) { - sys::PrintStackTraceOnErrorSignal(argv[0]); - PrettyStackTraceProgram X(argc, argv); - cl::ParseCommandLineOptions(argc, argv); - - if (!ValidateCheckPrefixes()) { - errs() << "Supplied check-prefix is invalid! Prefixes must be unique and " - "start with a letter and contain only alphanumeric characters, " - "hyphens and underscores\n"; - return 2; - } - - AddCheckPrefixIfNeeded(); - - SourceMgr SM; - - // Read the expected strings from the check file. - std::vector CheckStrings; - if (ReadCheckFile(SM, CheckStrings)) - return 2; - - // Open the file to check and add it to SourceMgr. - ErrorOr> FileOrErr = - MemoryBuffer::getFileOrSTDIN(InputFilename); - if (std::error_code EC = FileOrErr.getError()) { - errs() << "Could not open input file '" << InputFilename - << "': " << EC.message() << '\n'; - return 2; - } - std::unique_ptr &File = FileOrErr.get(); - - if (File->getBufferSize() == 0 && !AllowEmptyInput) { - errs() << "FileCheck error: '" << InputFilename << "' is empty.\n"; - DumpCommandLine(argc, argv); - return 2; - } - - // Remove duplicate spaces in the input file if requested. - // Remove DOS style line endings. - std::unique_ptr F = - CanonicalizeInputFile(std::move(File), NoCanonicalizeWhiteSpace); - - // Check that we have all of the expected strings, in order, in the input - // file. - StringRef Buffer = F->getBuffer(); - - SM.AddNewSourceBuffer(std::move(F), SMLoc()); - - /// VariableTable - This holds all the current filecheck variables. - StringMap VariableTable; - - bool hasError = false; - - unsigned i = 0, j = 0, e = CheckStrings.size(); - - while (true) { - StringRef CheckRegion; - if (j == e) { - CheckRegion = Buffer; - } else { - const CheckString &CheckLabelStr = CheckStrings[j]; - if (CheckLabelStr.Pat.getCheckTy() != Check::CheckLabel) { - ++j; - continue; - } - - // Scan to next CHECK-LABEL match, ignoring CHECK-NOT and CHECK-DAG - size_t MatchLabelLen = 0; - size_t MatchLabelPos = CheckLabelStr.Check(SM, Buffer, true, - MatchLabelLen, VariableTable); - if (MatchLabelPos == StringRef::npos) { - hasError = true; - break; - } - - CheckRegion = Buffer.substr(0, MatchLabelPos + MatchLabelLen); - Buffer = Buffer.substr(MatchLabelPos + MatchLabelLen); - ++j; - } - - for ( ; i != j; ++i) { - const CheckString &CheckStr = CheckStrings[i]; - - // Check each string within the scanned region, including a second check - // of any final CHECK-LABEL (to verify CHECK-NOT and CHECK-DAG) - size_t MatchLen = 0; - size_t MatchPos = CheckStr.Check(SM, CheckRegion, false, MatchLen, - VariableTable); - - if (MatchPos == StringRef::npos) { - hasError = true; - i = j; - break; - } - - CheckRegion = CheckRegion.substr(MatchPos + MatchLen); - } - - if (j == e) - break; - } - - return hasError ? 1 : 0; -} diff --git a/utils/FileCheck-5.0.cpp b/utils/FileCheck-5.0.cpp deleted file mode 100644 index 9d808cc875c..00000000000 --- a/utils/FileCheck-5.0.cpp +++ /dev/null @@ -1,1422 +0,0 @@ -//===- FileCheck.cpp - Check that File's Contents match what is expected --===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// FileCheck does a line-by line check of a file that validates whether it -// contains the expected content. This is useful for regression tests etc. -// -// This program exits with an exit status of 2 on error, exit status of 0 if -// the file matched the expected contents, and exit status of 1 if it did not -// contain the expected contents. -// -//===----------------------------------------------------------------------===// - -#include "llvm/ADT/SmallString.h" -#include "llvm/ADT/StringExtras.h" -#include "llvm/ADT/StringMap.h" -#include "llvm/ADT/StringSet.h" -#include "llvm/Support/CommandLine.h" -#include "llvm/Support/MemoryBuffer.h" -#include "llvm/Support/PrettyStackTrace.h" -#include "llvm/Support/Regex.h" -#include "llvm/Support/Signals.h" -#include "llvm/Support/SourceMgr.h" -#include "llvm/Support/raw_ostream.h" -#include -#include -#include -#include -#include -#include -using namespace llvm; - -static cl::opt - CheckFilename(cl::Positional, cl::desc(""), cl::Required); - -static cl::opt - InputFilename("input-file", cl::desc("File to check (defaults to stdin)"), - cl::init("-"), cl::value_desc("filename")); - -static cl::list CheckPrefixes( - "check-prefix", - cl::desc("Prefix to use from check file (defaults to 'CHECK')")); -static cl::alias CheckPrefixesAlias( - "check-prefixes", cl::aliasopt(CheckPrefixes), cl::CommaSeparated, - cl::NotHidden, - cl::desc( - "Alias for -check-prefix permitting multiple comma separated values")); - -static cl::opt NoCanonicalizeWhiteSpace( - "strict-whitespace", - cl::desc("Do not treat all horizontal whitespace as equivalent")); - -static cl::list ImplicitCheckNot( - "implicit-check-not", - cl::desc("Add an implicit negative check with this pattern to every\n" - "positive check. This can be used to ensure that no instances of\n" - "this pattern occur which are not matched by a positive pattern"), - cl::value_desc("pattern")); - -static cl::opt AllowEmptyInput( - "allow-empty", cl::init(false), - cl::desc("Allow the input file to be empty. This is useful when making\n" - "checks that some error message does not occur, for example.")); - -static cl::opt MatchFullLines( - "match-full-lines", cl::init(false), - cl::desc("Require all positive matches to cover an entire input line.\n" - "Allows leading and trailing whitespace if --strict-whitespace\n" - "is not also passed.")); - -static cl::opt EnableVarScope( - "enable-var-scope", cl::init(false), - cl::desc("Enables scope for regex variables. Variables with names that\n" - "do not start with '$' will be reset at the beginning of\n" - "each CHECK-LABEL block.")); - -typedef cl::list::const_iterator prefix_iterator; - -//===----------------------------------------------------------------------===// -// Pattern Handling Code. -//===----------------------------------------------------------------------===// - -namespace Check { -enum CheckType { - CheckNone = 0, - CheckPlain, - CheckNext, - CheckSame, - CheckNot, - CheckDAG, - CheckLabel, - - /// Indicates the pattern only matches the end of file. This is used for - /// trailing CHECK-NOTs. - CheckEOF, - - /// Marks when parsing found a -NOT check combined with another CHECK suffix. - CheckBadNot -}; -} - -class Pattern { - SMLoc PatternLoc; - - /// A fixed string to match as the pattern or empty if this pattern requires - /// a regex match. - StringRef FixedStr; - - /// A regex string to match as the pattern or empty if this pattern requires - /// a fixed string to match. - std::string RegExStr; - - /// Entries in this vector map to uses of a variable in the pattern, e.g. - /// "foo[[bar]]baz". In this case, the RegExStr will contain "foobaz" and - /// we'll get an entry in this vector that tells us to insert the value of - /// bar at offset 3. - std::vector> VariableUses; - - /// Maps definitions of variables to their parenthesized capture numbers. - /// - /// E.g. for the pattern "foo[[bar:.*]]baz", VariableDefs will map "bar" to - /// 1. - std::map VariableDefs; - - Check::CheckType CheckTy; - - /// Contains the number of line this pattern is in. - unsigned LineNumber; - -public: - explicit Pattern(Check::CheckType Ty) : CheckTy(Ty) {} - - /// Returns the location in source code. - SMLoc getLoc() const { return PatternLoc; } - - bool ParsePattern(StringRef PatternStr, StringRef Prefix, SourceMgr &SM, - unsigned LineNumber); - size_t Match(StringRef Buffer, size_t &MatchLen, - StringMap &VariableTable) const; - void PrintFailureInfo(const SourceMgr &SM, StringRef Buffer, - const StringMap &VariableTable) const; - - bool hasVariable() const { - return !(VariableUses.empty() && VariableDefs.empty()); - } - - Check::CheckType getCheckTy() const { return CheckTy; } - -private: - bool AddRegExToRegEx(StringRef RS, unsigned &CurParen, SourceMgr &SM); - void AddBackrefToRegEx(unsigned BackrefNum); - unsigned - ComputeMatchDistance(StringRef Buffer, - const StringMap &VariableTable) const; - bool EvaluateExpression(StringRef Expr, std::string &Value) const; - size_t FindRegexVarEnd(StringRef Str, SourceMgr &SM); -}; - -/// Parses the given string into the Pattern. -/// -/// \p Prefix provides which prefix is being matched, \p SM provides the -/// SourceMgr used for error reports, and \p LineNumber is the line number in -/// the input file from which the pattern string was read. Returns true in -/// case of an error, false otherwise. -bool Pattern::ParsePattern(StringRef PatternStr, StringRef Prefix, - SourceMgr &SM, unsigned LineNumber) { - bool MatchFullLinesHere = MatchFullLines && CheckTy != Check::CheckNot; - - this->LineNumber = LineNumber; - PatternLoc = SMLoc::getFromPointer(PatternStr.data()); - - if (!(NoCanonicalizeWhiteSpace && MatchFullLines)) - // Ignore trailing whitespace. - while (!PatternStr.empty() && - (PatternStr.back() == ' ' || PatternStr.back() == '\t')) - PatternStr = PatternStr.substr(0, PatternStr.size() - 1); - - // Check that there is something on the line. - if (PatternStr.empty()) { - SM.PrintMessage(PatternLoc, SourceMgr::DK_Error, - "found empty check string with prefix '" + Prefix + ":'"); - return true; - } - - // Check to see if this is a fixed string, or if it has regex pieces. - if (!MatchFullLinesHere && - (PatternStr.size() < 2 || (PatternStr.find("{{") == StringRef::npos && - PatternStr.find("[[") == StringRef::npos))) { - FixedStr = PatternStr; - return false; - } - - if (MatchFullLinesHere) { - RegExStr += '^'; - if (!NoCanonicalizeWhiteSpace) - RegExStr += " *"; - } - - // Paren value #0 is for the fully matched string. Any new parenthesized - // values add from there. - unsigned CurParen = 1; - - // Otherwise, there is at least one regex piece. Build up the regex pattern - // by escaping scary characters in fixed strings, building up one big regex. - while (!PatternStr.empty()) { - // RegEx matches. - if (PatternStr.startswith("{{")) { - // This is the start of a regex match. Scan for the }}. - size_t End = PatternStr.find("}}"); - if (End == StringRef::npos) { - SM.PrintMessage(SMLoc::getFromPointer(PatternStr.data()), - SourceMgr::DK_Error, - "found start of regex string with no end '}}'"); - return true; - } - - // Enclose {{}} patterns in parens just like [[]] even though we're not - // capturing the result for any purpose. This is required in case the - // expression contains an alternation like: CHECK: abc{{x|z}}def. We - // want this to turn into: "abc(x|z)def" not "abcx|zdef". - RegExStr += '('; - ++CurParen; - - if (AddRegExToRegEx(PatternStr.substr(2, End - 2), CurParen, SM)) - return true; - RegExStr += ')'; - - PatternStr = PatternStr.substr(End + 2); - continue; - } - - // Named RegEx matches. These are of two forms: [[foo:.*]] which matches .* - // (or some other regex) and assigns it to the FileCheck variable 'foo'. The - // second form is [[foo]] which is a reference to foo. The variable name - // itself must be of the form "[a-zA-Z_][0-9a-zA-Z_]*", otherwise we reject - // it. This is to catch some common errors. - if (PatternStr.startswith("[[")) { - // Find the closing bracket pair ending the match. End is going to be an - // offset relative to the beginning of the match string. - size_t End = FindRegexVarEnd(PatternStr.substr(2), SM); - - if (End == StringRef::npos) { - SM.PrintMessage(SMLoc::getFromPointer(PatternStr.data()), - SourceMgr::DK_Error, - "invalid named regex reference, no ]] found"); - return true; - } - - StringRef MatchStr = PatternStr.substr(2, End); - PatternStr = PatternStr.substr(End + 4); - - // Get the regex name (e.g. "foo"). - size_t NameEnd = MatchStr.find(':'); - StringRef Name = MatchStr.substr(0, NameEnd); - - if (Name.empty()) { - SM.PrintMessage(SMLoc::getFromPointer(Name.data()), SourceMgr::DK_Error, - "invalid name in named regex: empty name"); - return true; - } - - // Verify that the name/expression is well formed. FileCheck currently - // supports @LINE, @LINE+number, @LINE-number expressions. The check here - // is relaxed, more strict check is performed in \c EvaluateExpression. - bool IsExpression = false; - for (unsigned i = 0, e = Name.size(); i != e; ++i) { - if (i == 0) { - if (Name[i] == '$') // Global vars start with '$' - continue; - if (Name[i] == '@') { - if (NameEnd != StringRef::npos) { - SM.PrintMessage(SMLoc::getFromPointer(Name.data()), - SourceMgr::DK_Error, - "invalid name in named regex definition"); - return true; - } - IsExpression = true; - continue; - } - } - if (Name[i] != '_' && !isalnum(Name[i]) && - (!IsExpression || (Name[i] != '+' && Name[i] != '-'))) { - SM.PrintMessage(SMLoc::getFromPointer(Name.data() + i), - SourceMgr::DK_Error, "invalid name in named regex"); - return true; - } - } - - // Name can't start with a digit. - if (isdigit(static_cast(Name[0]))) { - SM.PrintMessage(SMLoc::getFromPointer(Name.data()), SourceMgr::DK_Error, - "invalid name in named regex"); - return true; - } - - // Handle [[foo]]. - if (NameEnd == StringRef::npos) { - // Handle variables that were defined earlier on the same line by - // emitting a backreference. - if (VariableDefs.find(Name) != VariableDefs.end()) { - unsigned VarParenNum = VariableDefs[Name]; - if (VarParenNum < 1 || VarParenNum > 9) { - SM.PrintMessage(SMLoc::getFromPointer(Name.data()), - SourceMgr::DK_Error, - "Can't back-reference more than 9 variables"); - return true; - } - AddBackrefToRegEx(VarParenNum); - } else { - VariableUses.push_back(std::make_pair(Name, RegExStr.size())); - } - continue; - } - - // Handle [[foo:.*]]. - VariableDefs[Name] = CurParen; - RegExStr += '('; - ++CurParen; - - if (AddRegExToRegEx(MatchStr.substr(NameEnd + 1), CurParen, SM)) - return true; - - RegExStr += ')'; - } - - // Handle fixed string matches. - // Find the end, which is the start of the next regex. - size_t FixedMatchEnd = PatternStr.find("{{"); - FixedMatchEnd = std::min(FixedMatchEnd, PatternStr.find("[[")); - RegExStr += Regex::escape(PatternStr.substr(0, FixedMatchEnd)); - PatternStr = PatternStr.substr(FixedMatchEnd); - } - - if (MatchFullLinesHere) { - if (!NoCanonicalizeWhiteSpace) - RegExStr += " *"; - RegExStr += '$'; - } - - return false; -} - -bool Pattern::AddRegExToRegEx(StringRef RS, unsigned &CurParen, SourceMgr &SM) { - Regex R(RS); - std::string Error; - if (!R.isValid(Error)) { - SM.PrintMessage(SMLoc::getFromPointer(RS.data()), SourceMgr::DK_Error, - "invalid regex: " + Error); - return true; - } - - RegExStr += RS.str(); - CurParen += R.getNumMatches(); - return false; -} - -void Pattern::AddBackrefToRegEx(unsigned BackrefNum) { - assert(BackrefNum >= 1 && BackrefNum <= 9 && "Invalid backref number"); - std::string Backref = std::string("\\") + std::string(1, '0' + BackrefNum); - RegExStr += Backref; -} - -/// Evaluates expression and stores the result to \p Value. -/// -/// Returns true on success and false when the expression has invalid syntax. -bool Pattern::EvaluateExpression(StringRef Expr, std::string &Value) const { - // The only supported expression is @LINE([\+-]\d+)? - if (!Expr.startswith("@LINE")) - return false; - Expr = Expr.substr(StringRef("@LINE").size()); - int Offset = 0; - if (!Expr.empty()) { - if (Expr[0] == '+') - Expr = Expr.substr(1); - else if (Expr[0] != '-') - return false; - if (Expr.getAsInteger(10, Offset)) - return false; - } - Value = llvm::itostr(LineNumber + Offset); - return true; -} - -/// Matches the pattern string against the input buffer \p Buffer -/// -/// This returns the position that is matched or npos if there is no match. If -/// there is a match, the size of the matched string is returned in \p -/// MatchLen. -/// -/// The \p VariableTable StringMap provides the current values of filecheck -/// variables and is updated if this match defines new values. -size_t Pattern::Match(StringRef Buffer, size_t &MatchLen, - StringMap &VariableTable) const { - // If this is the EOF pattern, match it immediately. - if (CheckTy == Check::CheckEOF) { - MatchLen = 0; - return Buffer.size(); - } - - // If this is a fixed string pattern, just match it now. - if (!FixedStr.empty()) { - MatchLen = FixedStr.size(); - return Buffer.find(FixedStr); - } - - // Regex match. - - // If there are variable uses, we need to create a temporary string with the - // actual value. - StringRef RegExToMatch = RegExStr; - std::string TmpStr; - if (!VariableUses.empty()) { - TmpStr = RegExStr; - - unsigned InsertOffset = 0; - for (const auto &VariableUse : VariableUses) { - std::string Value; - - if (VariableUse.first[0] == '@') { - if (!EvaluateExpression(VariableUse.first, Value)) - return StringRef::npos; - } else { - StringMap::iterator it = - VariableTable.find(VariableUse.first); - // If the variable is undefined, return an error. - if (it == VariableTable.end()) - return StringRef::npos; - - // Look up the value and escape it so that we can put it into the regex. - Value += Regex::escape(it->second); - } - - // Plop it into the regex at the adjusted offset. - TmpStr.insert(TmpStr.begin() + VariableUse.second + InsertOffset, - Value.begin(), Value.end()); - InsertOffset += Value.size(); - } - - // Match the newly constructed regex. - RegExToMatch = TmpStr; - } - - SmallVector MatchInfo; - if (!Regex(RegExToMatch, Regex::Newline).match(Buffer, &MatchInfo)) - return StringRef::npos; - - // Successful regex match. - assert(!MatchInfo.empty() && "Didn't get any match"); - StringRef FullMatch = MatchInfo[0]; - - // If this defines any variables, remember their values. - for (const auto &VariableDef : VariableDefs) { - assert(VariableDef.second < MatchInfo.size() && "Internal paren error"); - VariableTable[VariableDef.first] = MatchInfo[VariableDef.second]; - } - - MatchLen = FullMatch.size(); - return FullMatch.data() - Buffer.data(); -} - - -/// Computes an arbitrary estimate for the quality of matching this pattern at -/// the start of \p Buffer; a distance of zero should correspond to a perfect -/// match. -unsigned -Pattern::ComputeMatchDistance(StringRef Buffer, - const StringMap &VariableTable) const { - // Just compute the number of matching characters. For regular expressions, we - // just compare against the regex itself and hope for the best. - // - // FIXME: One easy improvement here is have the regex lib generate a single - // example regular expression which matches, and use that as the example - // string. - StringRef ExampleString(FixedStr); - if (ExampleString.empty()) - ExampleString = RegExStr; - - // Only compare up to the first line in the buffer, or the string size. - StringRef BufferPrefix = Buffer.substr(0, ExampleString.size()); - BufferPrefix = BufferPrefix.split('\n').first; - return BufferPrefix.edit_distance(ExampleString); -} - -/// Prints additional information about a failure to match involving this -/// pattern. -void Pattern::PrintFailureInfo( - const SourceMgr &SM, StringRef Buffer, - const StringMap &VariableTable) const { - // If this was a regular expression using variables, print the current - // variable values. - if (!VariableUses.empty()) { - for (const auto &VariableUse : VariableUses) { - SmallString<256> Msg; - raw_svector_ostream OS(Msg); - StringRef Var = VariableUse.first; - if (Var[0] == '@') { - std::string Value; - if (EvaluateExpression(Var, Value)) { - OS << "with expression \""; - OS.write_escaped(Var) << "\" equal to \""; - OS.write_escaped(Value) << "\""; - } else { - OS << "uses incorrect expression \""; - OS.write_escaped(Var) << "\""; - } - } else { - StringMap::const_iterator it = VariableTable.find(Var); - - // Check for undefined variable references. - if (it == VariableTable.end()) { - OS << "uses undefined variable \""; - OS.write_escaped(Var) << "\""; - } else { - OS << "with variable \""; - OS.write_escaped(Var) << "\" equal to \""; - OS.write_escaped(it->second) << "\""; - } - } - - SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()), SourceMgr::DK_Note, - OS.str()); - } - } - - // Attempt to find the closest/best fuzzy match. Usually an error happens - // because some string in the output didn't exactly match. In these cases, we - // would like to show the user a best guess at what "should have" matched, to - // save them having to actually check the input manually. - size_t NumLinesForward = 0; - size_t Best = StringRef::npos; - double BestQuality = 0; - - // Use an arbitrary 4k limit on how far we will search. - for (size_t i = 0, e = std::min(size_t(4096), Buffer.size()); i != e; ++i) { - if (Buffer[i] == '\n') - ++NumLinesForward; - - // Patterns have leading whitespace stripped, so skip whitespace when - // looking for something which looks like a pattern. - if (Buffer[i] == ' ' || Buffer[i] == '\t') - continue; - - // Compute the "quality" of this match as an arbitrary combination of the - // match distance and the number of lines skipped to get to this match. - unsigned Distance = ComputeMatchDistance(Buffer.substr(i), VariableTable); - double Quality = Distance + (NumLinesForward / 100.); - - if (Quality < BestQuality || Best == StringRef::npos) { - Best = i; - BestQuality = Quality; - } - } - - // Print the "possible intended match here" line if we found something - // reasonable and not equal to what we showed in the "scanning from here" - // line. - if (Best && Best != StringRef::npos && BestQuality < 50) { - SM.PrintMessage(SMLoc::getFromPointer(Buffer.data() + Best), - SourceMgr::DK_Note, "possible intended match here"); - - // FIXME: If we wanted to be really friendly we would show why the match - // failed, as it can be hard to spot simple one character differences. - } -} - -/// Finds the closing sequence of a regex variable usage or definition. -/// -/// \p Str has to point in the beginning of the definition (right after the -/// opening sequence). Returns the offset of the closing sequence within Str, -/// or npos if it was not found. -size_t Pattern::FindRegexVarEnd(StringRef Str, SourceMgr &SM) { - // Offset keeps track of the current offset within the input Str - size_t Offset = 0; - // [...] Nesting depth - size_t BracketDepth = 0; - - while (!Str.empty()) { - if (Str.startswith("]]") && BracketDepth == 0) - return Offset; - if (Str[0] == '\\') { - // Backslash escapes the next char within regexes, so skip them both. - Str = Str.substr(2); - Offset += 2; - } else { - switch (Str[0]) { - default: - break; - case '[': - BracketDepth++; - break; - case ']': - if (BracketDepth == 0) { - SM.PrintMessage(SMLoc::getFromPointer(Str.data()), - SourceMgr::DK_Error, - "missing closing \"]\" for regex variable"); - exit(1); - } - BracketDepth--; - break; - } - Str = Str.substr(1); - Offset++; - } - } - - return StringRef::npos; -} - -//===----------------------------------------------------------------------===// -// Check Strings. -//===----------------------------------------------------------------------===// - -/// A check that we found in the input file. -struct CheckString { - /// The pattern to match. - Pattern Pat; - - /// Which prefix name this check matched. - StringRef Prefix; - - /// The location in the match file that the check string was specified. - SMLoc Loc; - - /// All of the strings that are disallowed from occurring between this match - /// string and the previous one (or start of file). - std::vector DagNotStrings; - - CheckString(const Pattern &P, StringRef S, SMLoc L) - : Pat(P), Prefix(S), Loc(L) {} - - size_t Check(const SourceMgr &SM, StringRef Buffer, bool IsLabelScanMode, - size_t &MatchLen, StringMap &VariableTable) const; - - bool CheckNext(const SourceMgr &SM, StringRef Buffer) const; - bool CheckSame(const SourceMgr &SM, StringRef Buffer) const; - bool CheckNot(const SourceMgr &SM, StringRef Buffer, - const std::vector &NotStrings, - StringMap &VariableTable) const; - size_t CheckDag(const SourceMgr &SM, StringRef Buffer, - std::vector &NotStrings, - StringMap &VariableTable) const; -}; - -/// Canonicalize whitespaces in the file. Line endings are replaced with -/// UNIX-style '\n'. -static StringRef CanonicalizeFile(MemoryBuffer &MB, - SmallVectorImpl &OutputBuffer) { - OutputBuffer.reserve(MB.getBufferSize()); - - for (const char *Ptr = MB.getBufferStart(), *End = MB.getBufferEnd(); - Ptr != End; ++Ptr) { - // Eliminate trailing dosish \r. - if (Ptr <= End - 2 && Ptr[0] == '\r' && Ptr[1] == '\n') { - continue; - } - - // If current char is not a horizontal whitespace or if horizontal - // whitespace canonicalization is disabled, dump it to output as is. - if (NoCanonicalizeWhiteSpace || (*Ptr != ' ' && *Ptr != '\t')) { - OutputBuffer.push_back(*Ptr); - continue; - } - - // Otherwise, add one space and advance over neighboring space. - OutputBuffer.push_back(' '); - while (Ptr + 1 != End && (Ptr[1] == ' ' || Ptr[1] == '\t')) - ++Ptr; - } - - // Add a null byte and then return all but that byte. - OutputBuffer.push_back('\0'); - return StringRef(OutputBuffer.data(), OutputBuffer.size() - 1); -} - -static bool IsPartOfWord(char c) { - return (isalnum(c) || c == '-' || c == '_'); -} - -// Get the size of the prefix extension. -static size_t CheckTypeSize(Check::CheckType Ty) { - switch (Ty) { - case Check::CheckNone: - case Check::CheckBadNot: - return 0; - - case Check::CheckPlain: - return sizeof(":") - 1; - - case Check::CheckNext: - return sizeof("-NEXT:") - 1; - - case Check::CheckSame: - return sizeof("-SAME:") - 1; - - case Check::CheckNot: - return sizeof("-NOT:") - 1; - - case Check::CheckDAG: - return sizeof("-DAG:") - 1; - - case Check::CheckLabel: - return sizeof("-LABEL:") - 1; - - case Check::CheckEOF: - llvm_unreachable("Should not be using EOF size"); - } - - llvm_unreachable("Bad check type"); -} - -static Check::CheckType FindCheckType(StringRef Buffer, StringRef Prefix) { - char NextChar = Buffer[Prefix.size()]; - - // Verify that the : is present after the prefix. - if (NextChar == ':') - return Check::CheckPlain; - - if (NextChar != '-') - return Check::CheckNone; - - StringRef Rest = Buffer.drop_front(Prefix.size() + 1); - if (Rest.startswith("NEXT:")) - return Check::CheckNext; - - if (Rest.startswith("SAME:")) - return Check::CheckSame; - - if (Rest.startswith("NOT:")) - return Check::CheckNot; - - if (Rest.startswith("DAG:")) - return Check::CheckDAG; - - if (Rest.startswith("LABEL:")) - return Check::CheckLabel; - - // You can't combine -NOT with another suffix. - if (Rest.startswith("DAG-NOT:") || Rest.startswith("NOT-DAG:") || - Rest.startswith("NEXT-NOT:") || Rest.startswith("NOT-NEXT:") || - Rest.startswith("SAME-NOT:") || Rest.startswith("NOT-SAME:")) - return Check::CheckBadNot; - - return Check::CheckNone; -} - -// From the given position, find the next character after the word. -static size_t SkipWord(StringRef Str, size_t Loc) { - while (Loc < Str.size() && IsPartOfWord(Str[Loc])) - ++Loc; - return Loc; -} - -/// Search the buffer for the first prefix in the prefix regular expression. -/// -/// This searches the buffer using the provided regular expression, however it -/// enforces constraints beyond that: -/// 1) The found prefix must not be a suffix of something that looks like -/// a valid prefix. -/// 2) The found prefix must be followed by a valid check type suffix using \c -/// FindCheckType above. -/// -/// The first match of the regular expression to satisfy these two is returned, -/// otherwise an empty StringRef is returned to indicate failure. -/// -/// If this routine returns a valid prefix, it will also shrink \p Buffer to -/// start at the beginning of the returned prefix, increment \p LineNumber for -/// each new line consumed from \p Buffer, and set \p CheckTy to the type of -/// check found by examining the suffix. -/// -/// If no valid prefix is found, the state of Buffer, LineNumber, and CheckTy -/// is unspecified. -static StringRef FindFirstMatchingPrefix(Regex &PrefixRE, StringRef &Buffer, - unsigned &LineNumber, - Check::CheckType &CheckTy) { - SmallVector Matches; - - while (!Buffer.empty()) { - // Find the first (longest) match using the RE. - if (!PrefixRE.match(Buffer, &Matches)) - // No match at all, bail. - return StringRef(); - - StringRef Prefix = Matches[0]; - Matches.clear(); - - assert(Prefix.data() >= Buffer.data() && - Prefix.data() < Buffer.data() + Buffer.size() && - "Prefix doesn't start inside of buffer!"); - size_t Loc = Prefix.data() - Buffer.data(); - StringRef Skipped = Buffer.substr(0, Loc); - Buffer = Buffer.drop_front(Loc); - LineNumber += Skipped.count('\n'); - - // Check that the matched prefix isn't a suffix of some other check-like - // word. - // FIXME: This is a very ad-hoc check. it would be better handled in some - // other way. Among other things it seems hard to distinguish between - // intentional and unintentional uses of this feature. - if (Skipped.empty() || !IsPartOfWord(Skipped.back())) { - // Now extract the type. - CheckTy = FindCheckType(Buffer, Prefix); - - // If we've found a valid check type for this prefix, we're done. - if (CheckTy != Check::CheckNone) - return Prefix; - } - - // If we didn't successfully find a prefix, we need to skip this invalid - // prefix and continue scanning. We directly skip the prefix that was - // matched and any additional parts of that check-like word. - Buffer = Buffer.drop_front(SkipWord(Buffer, Prefix.size())); - } - - // We ran out of buffer while skipping partial matches so give up. - return StringRef(); -} - -/// Read the check file, which specifies the sequence of expected strings. -/// -/// The strings are added to the CheckStrings vector. Returns true in case of -/// an error, false otherwise. -static bool ReadCheckFile(SourceMgr &SM, StringRef Buffer, Regex &PrefixRE, - std::vector &CheckStrings) { - std::vector ImplicitNegativeChecks; - for (const auto &PatternString : ImplicitCheckNot) { - // Create a buffer with fake command line content in order to display the - // command line option responsible for the specific implicit CHECK-NOT. - std::string Prefix = (Twine("-") + ImplicitCheckNot.ArgStr + "='").str(); - std::string Suffix = "'"; - std::unique_ptr CmdLine = MemoryBuffer::getMemBufferCopy( - Prefix + PatternString + Suffix, "command line"); - - StringRef PatternInBuffer = - CmdLine->getBuffer().substr(Prefix.size(), PatternString.size()); - SM.AddNewSourceBuffer(std::move(CmdLine), SMLoc()); - - ImplicitNegativeChecks.push_back(Pattern(Check::CheckNot)); - ImplicitNegativeChecks.back().ParsePattern(PatternInBuffer, - "IMPLICIT-CHECK", SM, 0); - } - - std::vector DagNotMatches = ImplicitNegativeChecks; - - // LineNumber keeps track of the line on which CheckPrefix instances are - // found. - unsigned LineNumber = 1; - - while (1) { - Check::CheckType CheckTy; - - // See if a prefix occurs in the memory buffer. - StringRef UsedPrefix = FindFirstMatchingPrefix(PrefixRE, Buffer, LineNumber, - CheckTy); - if (UsedPrefix.empty()) - break; - assert(UsedPrefix.data() == Buffer.data() && - "Failed to move Buffer's start forward, or pointed prefix outside " - "of the buffer!"); - - // Location to use for error messages. - const char *UsedPrefixStart = UsedPrefix.data(); - - // Skip the buffer to the end. - Buffer = Buffer.drop_front(UsedPrefix.size() + CheckTypeSize(CheckTy)); - - // Complain about useful-looking but unsupported suffixes. - if (CheckTy == Check::CheckBadNot) { - SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()), SourceMgr::DK_Error, - "unsupported -NOT combo on prefix '" + UsedPrefix + "'"); - return true; - } - - // Okay, we found the prefix, yay. Remember the rest of the line, but ignore - // leading whitespace. - if (!(NoCanonicalizeWhiteSpace && MatchFullLines)) - Buffer = Buffer.substr(Buffer.find_first_not_of(" \t")); - - // Scan ahead to the end of line. - size_t EOL = Buffer.find_first_of("\n\r"); - - // Remember the location of the start of the pattern, for diagnostics. - SMLoc PatternLoc = SMLoc::getFromPointer(Buffer.data()); - - // Parse the pattern. - Pattern P(CheckTy); - if (P.ParsePattern(Buffer.substr(0, EOL), UsedPrefix, SM, LineNumber)) - return true; - - // Verify that CHECK-LABEL lines do not define or use variables - if ((CheckTy == Check::CheckLabel) && P.hasVariable()) { - SM.PrintMessage( - SMLoc::getFromPointer(UsedPrefixStart), SourceMgr::DK_Error, - "found '" + UsedPrefix + "-LABEL:'" - " with variable definition or use"); - return true; - } - - Buffer = Buffer.substr(EOL); - - // Verify that CHECK-NEXT lines have at least one CHECK line before them. - if ((CheckTy == Check::CheckNext || CheckTy == Check::CheckSame) && - CheckStrings.empty()) { - StringRef Type = CheckTy == Check::CheckNext ? "NEXT" : "SAME"; - SM.PrintMessage(SMLoc::getFromPointer(UsedPrefixStart), - SourceMgr::DK_Error, - "found '" + UsedPrefix + "-" + Type + - "' without previous '" + UsedPrefix + ": line"); - return true; - } - - // Handle CHECK-DAG/-NOT. - if (CheckTy == Check::CheckDAG || CheckTy == Check::CheckNot) { - DagNotMatches.push_back(P); - continue; - } - - // Okay, add the string we captured to the output vector and move on. - CheckStrings.emplace_back(P, UsedPrefix, PatternLoc); - std::swap(DagNotMatches, CheckStrings.back().DagNotStrings); - DagNotMatches = ImplicitNegativeChecks; - } - - // Add an EOF pattern for any trailing CHECK-DAG/-NOTs, and use the first - // prefix as a filler for the error message. - if (!DagNotMatches.empty()) { - CheckStrings.emplace_back(Pattern(Check::CheckEOF), *CheckPrefixes.begin(), - SMLoc::getFromPointer(Buffer.data())); - std::swap(DagNotMatches, CheckStrings.back().DagNotStrings); - } - - if (CheckStrings.empty()) { - errs() << "error: no check strings found with prefix" - << (CheckPrefixes.size() > 1 ? "es " : " "); - prefix_iterator I = CheckPrefixes.begin(); - prefix_iterator E = CheckPrefixes.end(); - if (I != E) { - errs() << "\'" << *I << ":'"; - ++I; - } - for (; I != E; ++I) - errs() << ", \'" << *I << ":'"; - - errs() << '\n'; - return true; - } - - return false; -} - -static void PrintCheckFailed(const SourceMgr &SM, SMLoc Loc, const Pattern &Pat, - StringRef Buffer, - StringMap &VariableTable) { - // Otherwise, we have an error, emit an error message. - SM.PrintMessage(Loc, SourceMgr::DK_Error, - "expected string not found in input"); - - // Print the "scanning from here" line. If the current position is at the - // end of a line, advance to the start of the next line. - Buffer = Buffer.substr(Buffer.find_first_not_of(" \t\n\r")); - - SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()), SourceMgr::DK_Note, - "scanning from here"); - - // Allow the pattern to print additional information if desired. - Pat.PrintFailureInfo(SM, Buffer, VariableTable); -} - -static void PrintCheckFailed(const SourceMgr &SM, const CheckString &CheckStr, - StringRef Buffer, - StringMap &VariableTable) { - PrintCheckFailed(SM, CheckStr.Loc, CheckStr.Pat, Buffer, VariableTable); -} - -/// Count the number of newlines in the specified range. -static unsigned CountNumNewlinesBetween(StringRef Range, - const char *&FirstNewLine) { - unsigned NumNewLines = 0; - while (1) { - // Scan for newline. - Range = Range.substr(Range.find_first_of("\n\r")); - if (Range.empty()) - return NumNewLines; - - ++NumNewLines; - - // Handle \n\r and \r\n as a single newline. - if (Range.size() > 1 && (Range[1] == '\n' || Range[1] == '\r') && - (Range[0] != Range[1])) - Range = Range.substr(1); - Range = Range.substr(1); - - if (NumNewLines == 1) - FirstNewLine = Range.begin(); - } -} - -/// Match check string and its "not strings" and/or "dag strings". -size_t CheckString::Check(const SourceMgr &SM, StringRef Buffer, - bool IsLabelScanMode, size_t &MatchLen, - StringMap &VariableTable) const { - size_t LastPos = 0; - std::vector NotStrings; - - // IsLabelScanMode is true when we are scanning forward to find CHECK-LABEL - // bounds; we have not processed variable definitions within the bounded block - // yet so cannot handle any final CHECK-DAG yet; this is handled when going - // over the block again (including the last CHECK-LABEL) in normal mode. - if (!IsLabelScanMode) { - // Match "dag strings" (with mixed "not strings" if any). - LastPos = CheckDag(SM, Buffer, NotStrings, VariableTable); - if (LastPos == StringRef::npos) - return StringRef::npos; - } - - // Match itself from the last position after matching CHECK-DAG. - StringRef MatchBuffer = Buffer.substr(LastPos); - size_t MatchPos = Pat.Match(MatchBuffer, MatchLen, VariableTable); - if (MatchPos == StringRef::npos) { - PrintCheckFailed(SM, *this, MatchBuffer, VariableTable); - return StringRef::npos; - } - - // Similar to the above, in "label-scan mode" we can't yet handle CHECK-NEXT - // or CHECK-NOT - if (!IsLabelScanMode) { - StringRef SkippedRegion = Buffer.substr(LastPos, MatchPos); - - // If this check is a "CHECK-NEXT", verify that the previous match was on - // the previous line (i.e. that there is one newline between them). - if (CheckNext(SM, SkippedRegion)) - return StringRef::npos; - - // If this check is a "CHECK-SAME", verify that the previous match was on - // the same line (i.e. that there is no newline between them). - if (CheckSame(SM, SkippedRegion)) - return StringRef::npos; - - // If this match had "not strings", verify that they don't exist in the - // skipped region. - if (CheckNot(SM, SkippedRegion, NotStrings, VariableTable)) - return StringRef::npos; - } - - return LastPos + MatchPos; -} - -/// Verify there is a single line in the given buffer. -bool CheckString::CheckNext(const SourceMgr &SM, StringRef Buffer) const { - if (Pat.getCheckTy() != Check::CheckNext) - return false; - - // Count the number of newlines between the previous match and this one. - assert(Buffer.data() != - SM.getMemoryBuffer(SM.FindBufferContainingLoc( - SMLoc::getFromPointer(Buffer.data()))) - ->getBufferStart() && - "CHECK-NEXT can't be the first check in a file"); - - const char *FirstNewLine = nullptr; - unsigned NumNewLines = CountNumNewlinesBetween(Buffer, FirstNewLine); - - if (NumNewLines == 0) { - SM.PrintMessage(Loc, SourceMgr::DK_Error, - Prefix + "-NEXT: is on the same line as previous match"); - SM.PrintMessage(SMLoc::getFromPointer(Buffer.end()), SourceMgr::DK_Note, - "'next' match was here"); - SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()), SourceMgr::DK_Note, - "previous match ended here"); - return true; - } - - if (NumNewLines != 1) { - SM.PrintMessage(Loc, SourceMgr::DK_Error, - Prefix + - "-NEXT: is not on the line after the previous match"); - SM.PrintMessage(SMLoc::getFromPointer(Buffer.end()), SourceMgr::DK_Note, - "'next' match was here"); - SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()), SourceMgr::DK_Note, - "previous match ended here"); - SM.PrintMessage(SMLoc::getFromPointer(FirstNewLine), SourceMgr::DK_Note, - "non-matching line after previous match is here"); - return true; - } - - return false; -} - -/// Verify there is no newline in the given buffer. -bool CheckString::CheckSame(const SourceMgr &SM, StringRef Buffer) const { - if (Pat.getCheckTy() != Check::CheckSame) - return false; - - // Count the number of newlines between the previous match and this one. - assert(Buffer.data() != - SM.getMemoryBuffer(SM.FindBufferContainingLoc( - SMLoc::getFromPointer(Buffer.data()))) - ->getBufferStart() && - "CHECK-SAME can't be the first check in a file"); - - const char *FirstNewLine = nullptr; - unsigned NumNewLines = CountNumNewlinesBetween(Buffer, FirstNewLine); - - if (NumNewLines != 0) { - SM.PrintMessage(Loc, SourceMgr::DK_Error, - Prefix + - "-SAME: is not on the same line as the previous match"); - SM.PrintMessage(SMLoc::getFromPointer(Buffer.end()), SourceMgr::DK_Note, - "'next' match was here"); - SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()), SourceMgr::DK_Note, - "previous match ended here"); - return true; - } - - return false; -} - -/// Verify there's no "not strings" in the given buffer. -bool CheckString::CheckNot(const SourceMgr &SM, StringRef Buffer, - const std::vector &NotStrings, - StringMap &VariableTable) const { - for (const Pattern *Pat : NotStrings) { - assert((Pat->getCheckTy() == Check::CheckNot) && "Expect CHECK-NOT!"); - - size_t MatchLen = 0; - size_t Pos = Pat->Match(Buffer, MatchLen, VariableTable); - - if (Pos == StringRef::npos) - continue; - - SM.PrintMessage(SMLoc::getFromPointer(Buffer.data() + Pos), - SourceMgr::DK_Error, Prefix + "-NOT: string occurred!"); - SM.PrintMessage(Pat->getLoc(), SourceMgr::DK_Note, - Prefix + "-NOT: pattern specified here"); - return true; - } - - return false; -} - -/// Match "dag strings" and their mixed "not strings". -size_t CheckString::CheckDag(const SourceMgr &SM, StringRef Buffer, - std::vector &NotStrings, - StringMap &VariableTable) const { - if (DagNotStrings.empty()) - return 0; - - size_t LastPos = 0; - size_t StartPos = LastPos; - - for (const Pattern &Pat : DagNotStrings) { - assert((Pat.getCheckTy() == Check::CheckDAG || - Pat.getCheckTy() == Check::CheckNot) && - "Invalid CHECK-DAG or CHECK-NOT!"); - - if (Pat.getCheckTy() == Check::CheckNot) { - NotStrings.push_back(&Pat); - continue; - } - - assert((Pat.getCheckTy() == Check::CheckDAG) && "Expect CHECK-DAG!"); - - size_t MatchLen = 0, MatchPos; - - // CHECK-DAG always matches from the start. - StringRef MatchBuffer = Buffer.substr(StartPos); - MatchPos = Pat.Match(MatchBuffer, MatchLen, VariableTable); - // With a group of CHECK-DAGs, a single mismatching means the match on - // that group of CHECK-DAGs fails immediately. - if (MatchPos == StringRef::npos) { - PrintCheckFailed(SM, Pat.getLoc(), Pat, MatchBuffer, VariableTable); - return StringRef::npos; - } - // Re-calc it as the offset relative to the start of the original string. - MatchPos += StartPos; - - if (!NotStrings.empty()) { - if (MatchPos < LastPos) { - // Reordered? - SM.PrintMessage(SMLoc::getFromPointer(Buffer.data() + MatchPos), - SourceMgr::DK_Error, - Prefix + "-DAG: found a match of CHECK-DAG" - " reordering across a CHECK-NOT"); - SM.PrintMessage(SMLoc::getFromPointer(Buffer.data() + LastPos), - SourceMgr::DK_Note, - Prefix + "-DAG: the farthest match of CHECK-DAG" - " is found here"); - SM.PrintMessage(NotStrings[0]->getLoc(), SourceMgr::DK_Note, - Prefix + "-NOT: the crossed pattern specified" - " here"); - SM.PrintMessage(Pat.getLoc(), SourceMgr::DK_Note, - Prefix + "-DAG: the reordered pattern specified" - " here"); - return StringRef::npos; - } - // All subsequent CHECK-DAGs should be matched from the farthest - // position of all precedent CHECK-DAGs (including this one.) - StartPos = LastPos; - // If there's CHECK-NOTs between two CHECK-DAGs or from CHECK to - // CHECK-DAG, verify that there's no 'not' strings occurred in that - // region. - StringRef SkippedRegion = Buffer.slice(LastPos, MatchPos); - if (CheckNot(SM, SkippedRegion, NotStrings, VariableTable)) - return StringRef::npos; - // Clear "not strings". - NotStrings.clear(); - } - - // Update the last position with CHECK-DAG matches. - LastPos = std::max(MatchPos + MatchLen, LastPos); - } - - return LastPos; -} - -// A check prefix must contain only alphanumeric, hyphens and underscores. -static bool ValidateCheckPrefix(StringRef CheckPrefix) { - Regex Validator("^[a-zA-Z0-9_-]*$"); - return Validator.match(CheckPrefix); -} - -static bool ValidateCheckPrefixes() { - StringSet<> PrefixSet; - - for (StringRef Prefix : CheckPrefixes) { - // Reject empty prefixes. - if (Prefix == "") - return false; - - if (!PrefixSet.insert(Prefix).second) - return false; - - if (!ValidateCheckPrefix(Prefix)) - return false; - } - - return true; -} - -// Combines the check prefixes into a single regex so that we can efficiently -// scan for any of the set. -// -// The semantics are that the longest-match wins which matches our regex -// library. -static Regex buildCheckPrefixRegex() { - // I don't think there's a way to specify an initial value for cl::list, - // so if nothing was specified, add the default - if (CheckPrefixes.empty()) - CheckPrefixes.push_back("CHECK"); - - // We already validated the contents of CheckPrefixes so just concatenate - // them as alternatives. - SmallString<32> PrefixRegexStr; - for (StringRef Prefix : CheckPrefixes) { - if (Prefix != CheckPrefixes.front()) - PrefixRegexStr.push_back('|'); - - PrefixRegexStr.append(Prefix); - } - - return Regex(PrefixRegexStr); -} - -static void DumpCommandLine(int argc, char **argv) { - errs() << "FileCheck command line: "; - for (int I = 0; I < argc; I++) - errs() << " " << argv[I]; - errs() << "\n"; -} - -// Remove local variables from \p VariableTable. Global variables -// (start with '$') are preserved. -static void ClearLocalVars(StringMap &VariableTable) { - SmallVector LocalVars; - for (const auto &Var : VariableTable) - if (Var.first()[0] != '$') - LocalVars.push_back(Var.first()); - - for (const auto &Var : LocalVars) - VariableTable.erase(Var); -} - -/// Check the input to FileCheck provided in the \p Buffer against the \p -/// CheckStrings read from the check file. -/// -/// Returns false if the input fails to satisfy the checks. -bool CheckInput(SourceMgr &SM, StringRef Buffer, - ArrayRef CheckStrings) { - bool ChecksFailed = false; - - /// VariableTable - This holds all the current filecheck variables. - StringMap VariableTable; - - unsigned i = 0, j = 0, e = CheckStrings.size(); - while (true) { - StringRef CheckRegion; - if (j == e) { - CheckRegion = Buffer; - } else { - const CheckString &CheckLabelStr = CheckStrings[j]; - if (CheckLabelStr.Pat.getCheckTy() != Check::CheckLabel) { - ++j; - continue; - } - - // Scan to next CHECK-LABEL match, ignoring CHECK-NOT and CHECK-DAG - size_t MatchLabelLen = 0; - size_t MatchLabelPos = - CheckLabelStr.Check(SM, Buffer, true, MatchLabelLen, VariableTable); - if (MatchLabelPos == StringRef::npos) - // Immediately bail of CHECK-LABEL fails, nothing else we can do. - return false; - - CheckRegion = Buffer.substr(0, MatchLabelPos + MatchLabelLen); - Buffer = Buffer.substr(MatchLabelPos + MatchLabelLen); - ++j; - } - - if (EnableVarScope) - ClearLocalVars(VariableTable); - - for (; i != j; ++i) { - const CheckString &CheckStr = CheckStrings[i]; - - // Check each string within the scanned region, including a second check - // of any final CHECK-LABEL (to verify CHECK-NOT and CHECK-DAG) - size_t MatchLen = 0; - size_t MatchPos = - CheckStr.Check(SM, CheckRegion, false, MatchLen, VariableTable); - - if (MatchPos == StringRef::npos) { - ChecksFailed = true; - i = j; - break; - } - - CheckRegion = CheckRegion.substr(MatchPos + MatchLen); - } - - if (j == e) - break; - } - - // Success if no checks failed. - return !ChecksFailed; -} - -int main(int argc, char **argv) { - sys::PrintStackTraceOnErrorSignal(argv[0]); - PrettyStackTraceProgram X(argc, argv); - cl::ParseCommandLineOptions(argc, argv); - - if (!ValidateCheckPrefixes()) { - errs() << "Supplied check-prefix is invalid! Prefixes must be unique and " - "start with a letter and contain only alphanumeric characters, " - "hyphens and underscores\n"; - return 2; - } - - Regex PrefixRE = buildCheckPrefixRegex(); - std::string REError; - if (!PrefixRE.isValid(REError)) { - errs() << "Unable to combine check-prefix strings into a prefix regular " - "expression! This is likely a bug in FileCheck's verification of " - "the check-prefix strings. Regular expression parsing failed " - "with the following error: " - << REError << "\n"; - return 2; - } - - SourceMgr SM; - - // Read the expected strings from the check file. - ErrorOr> CheckFileOrErr = - MemoryBuffer::getFileOrSTDIN(CheckFilename); - if (std::error_code EC = CheckFileOrErr.getError()) { - errs() << "Could not open check file '" << CheckFilename - << "': " << EC.message() << '\n'; - return 2; - } - MemoryBuffer &CheckFile = *CheckFileOrErr.get(); - - SmallString<4096> CheckFileBuffer; - StringRef CheckFileText = CanonicalizeFile(CheckFile, CheckFileBuffer); - - SM.AddNewSourceBuffer(MemoryBuffer::getMemBuffer( - CheckFileText, CheckFile.getBufferIdentifier()), - SMLoc()); - - std::vector CheckStrings; - if (ReadCheckFile(SM, CheckFileText, PrefixRE, CheckStrings)) - return 2; - - // Open the file to check and add it to SourceMgr. - ErrorOr> InputFileOrErr = - MemoryBuffer::getFileOrSTDIN(InputFilename); - if (std::error_code EC = InputFileOrErr.getError()) { - errs() << "Could not open input file '" << InputFilename - << "': " << EC.message() << '\n'; - return 2; - } - MemoryBuffer &InputFile = *InputFileOrErr.get(); - - if (InputFile.getBufferSize() == 0 && !AllowEmptyInput) { - errs() << "FileCheck error: '" << InputFilename << "' is empty.\n"; - DumpCommandLine(argc, argv); - return 2; - } - - SmallString<4096> InputFileBuffer; - StringRef InputFileText = CanonicalizeFile(InputFile, InputFileBuffer); - - SM.AddNewSourceBuffer(MemoryBuffer::getMemBuffer( - InputFileText, InputFile.getBufferIdentifier()), - SMLoc()); - - return CheckInput(SM, InputFileText, CheckStrings) ? EXIT_SUCCESS : 1; -} diff --git a/utils/not.cpp b/utils/not.cpp index 2631f92cdd5..40157d094ea 100644 --- a/utils/not.cpp +++ b/utils/not.cpp @@ -51,13 +51,7 @@ int main(int argc, const char **argv) { #endif std::string ErrMsg; - int Result = sys::ExecuteAndWait(*Program, Argv, Env, -#if LDC_LLVM_VER >= 600 - {}, -#else - nullptr, -#endif - 0, 0, &ErrMsg); + int Result = sys::ExecuteAndWait(*Program, Argv, Env, {}, 0, 0, &ErrMsg); #ifdef _WIN32 // Handle abort() in msvcrt -- It has exit code as 3. abort(), aka // unreachable, should be recognized as a crash. However, some binaries use