Merge branch 'amd-master' into 'amd-common'

bindings/go/llvm/DIBuilderBindings.cpp

@@ -40,8 +40,8 @@ LLVMMetadataRef LLVMDIBuilderCreateCompileUnit(LLVMDIBuilderRef Dref,
                                                int Optimized, const char *Flags,
                                                unsigned RuntimeVersion) {
   DIBuilder *D = unwrap(Dref);
-  return wrap(D->createCompileUnit(Lang, File, Dir, Producer, Optimized, Flags,
-                                   RuntimeVersion));
+  return wrap(D->createCompileUnit(Lang, D->createFile(File, Dir), Producer,
+                                   Optimized, Flags, RuntimeVersion));
 }
 
 LLVMMetadataRef LLVMDIBuilderCreateFile(LLVMDIBuilderRef Dref, const char *File,

cmake/modules/AddLLVM.cmake

@@ -1290,6 +1290,8 @@ endfunction()
 
 function(add_llvm_tool_symlink link_name target)
   cmake_parse_arguments(ARG "ALWAYS_GENERATE" "OUTPUT_DIR" "" ${ARGN})
+  set(dest_binary "$<TARGET_FILE:${target}>")
+
   # This got a bit gross... For multi-configuration generators the target
   # properties return the resolved value of the string, not the build system
   # expression. To reconstruct the platform-agnostic path we have to do some
@@ -1298,6 +1300,11 @@ function(add_llvm_tool_symlink link_name target)
   # and replace it with CMAKE_CFG_INTDIR. This allows the build step to be type
   # agnostic again. 
   if(NOT ARG_OUTPUT_DIR)
+    # If you're not overriding the OUTPUT_DIR, we can make the link relative in
+    # the same directory.
+    if(UNIX)
+      set(dest_binary "$<TARGET_FILE_NAME:${target}>")
+    endif()
     if(CMAKE_CONFIGURATION_TYPES)
       list(GET CMAKE_CONFIGURATION_TYPES 0 first_type)
       string(TOUPPER ${first_type} first_type_upper)
@@ -1323,10 +1330,8 @@ function(add_llvm_tool_symlink link_name target)
 
   if(UNIX)
     set(LLVM_LINK_OR_COPY create_symlink)
-    set(dest_binary "$<TARGET_FILE_NAME:${target}>")
   else()
     set(LLVM_LINK_OR_COPY copy)
-    set(dest_binary "$<TARGET_FILE:${target}>")
   endif()
 
   set(output_path "${ARG_OUTPUT_DIR}/${link_name}${CMAKE_EXECUTABLE_SUFFIX}")

cmake/modules/CheckCompilerVersion.cmake

@@ -1,5 +1,5 @@
 # Check if the host compiler is new enough. LLVM requires at least GCC 4.8,
-# MSVC 2013, or Clang 3.1.
+# MSVC 2015 (Update 3), or Clang 3.1.
 
 include(CheckCXXSourceCompiles)
 
@@ -17,8 +17,8 @@ if(NOT DEFINED LLVM_COMPILER_CHECKED)
       endif()
 
       if (CMAKE_CXX_SIMULATE_ID MATCHES "MSVC")
-        if (CMAKE_CXX_SIMULATE_VERSION VERSION_LESS 18.0)
-          message(FATAL_ERROR "Host Clang must have at least -fms-compatibility-version=18.0")
+        if (CMAKE_CXX_SIMULATE_VERSION VERSION_LESS 19.0)
+          message(FATAL_ERROR "Host Clang must have at least -fms-compatibility-version=19.0")
         endif()
         set(CLANG_CL 1)
       elseif(NOT LLVM_ENABLE_LIBCXX)
@@ -41,10 +41,10 @@ int main() { return (float)x; }"
         set(CMAKE_REQUIRED_LIBRARIES ${OLD_CMAKE_REQUIRED_LIBRARIES})
       endif()
     elseif(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
-      if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 18.0)
-        message(FATAL_ERROR "Host Visual Studio must be at least 2013")
-      elseif(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 18.0.31101)
-        message(WARNING "Host Visual Studio should at least be 2013 Update 4 (MSVC 18.0.31101)"
+      if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.0)
+        message(FATAL_ERROR "Host Visual Studio must be at least 2015")
+      elseif(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.00.24215.1)
+        message(WARNING "Host Visual Studio should at least be 2015 Update 3 (MSVC 19.00.24215.1)"
           "  due to miscompiles from earlier versions")
       endif()
     endif()

docs/CodingStandards.rst

@@ -131,9 +131,8 @@ unlikely to be supported by our host compilers.
 * Delegating constructors: N1986_
 * Default member initializers (non-static data member initializers): N2756_
 
-  * Only use these for scalar members that would otherwise be left
-    uninitialized. Non-scalar members generally have appropriate default
-    constructors.
+  * Feel free to use these wherever they make sense and where the `=`
+    syntax is allowed. Don't use braced initialization syntax.
 
 .. _N2118: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2118.html
 .. _N2439: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2439.htm

docs/GettingStarted.rst

@@ -262,7 +262,7 @@ our build systems:
 
 * Clang 3.1
 * GCC 4.8
-* Visual Studio 2015
+* Visual Studio 2015 (Update 3)
 
 Anything older than these toolchains *may* work, but will require forcing the
 build system with a special option and is not really a supported host platform.

docs/LibFuzzer.rst

@@ -341,9 +341,6 @@ possible event codes are:
 ``DONE``
   The fuzzer has completed operation because it has reached the specified
   iteration limit (``-runs``) or time limit (``-max_total_time``).
-``MIN<n>``
-  The fuzzer is minimizing the combination of input corpus directories into
-  a single unified corpus (due to the ``-merge`` command line option).
 ``RELOAD``
   The fuzzer is performing a periodic reload of inputs from the corpus
   directory; this allows it to discover any inputs discovered by other

docs/ProgrammersManual.rst

@@ -331,16 +331,15 @@ There are two ways to customize the formatting behavior for a type.
   to extend the mechanism for formatting a type that the library already knows how to
   format.  For that, we need something else.
 
-2. Provide a **format adapter** with a non-static format method.
+2. Provide a **format adapter** inheriting from ``llvm::FormatAdapter<T>``.
 
   .. code-block:: c++
 
     namespace anything {
-      struct format_int_custom {
-        int N;
-        explicit format_int_custom(int N) : N(N) {}
-        void format(llvm::raw_ostream &Stream, StringRef Style) {
-          // Do whatever is necessary to format ``N`` into ``Stream``
+      struct format_int_custom : public llvm::FormatAdapter<int> {
+        explicit format_int_custom(int N) : llvm::FormatAdapter<int>(N) {}
+        void format(llvm::raw_ostream &Stream, StringRef Style) override {
+          // Do whatever is necessary to format ``this->Item`` into ``Stream``
         }
       };
     }
@@ -350,9 +349,8 @@ There are two ways to customize the formatting behavior for a type.
       }
     }
 
-  If the search for a specialization of ``format_provider<T>`` for the given type
-  fails, ``formatv`` will subsequently check the argument for an instance method
-  named ``format`` with the signature described above.  If so, it will call the
+  If the type is detected to be derived from ``FormatAdapter<T>``, ``formatv``
+  will call the
   ``format`` method on the argument passing in the specified style.  This allows
   one to provide custom formatting of any type, including one which already has
   a builtin format provider.
@@ -2196,6 +2194,22 @@ reverse) is O(1) worst case.  Testing and setting bits within 128 bits (depends
 on size) of the current bit is also O(1).  As a general statement,
 testing/setting bits in a SparseBitVector is O(distance away from last set bit).
 
+.. _debugging:
+
+Debugging
+=========
+
+A handful of `GDB pretty printers
+<https://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html>`__ are
+provided for some of the core LLVM libraries. To use them, execute the
+following (or add it to your ``~/.gdbinit``)::
+
+  source /path/to/llvm/src/utils/gdb-scripts/prettyprinters.py
+
+It also might be handy to enable the `print pretty
+<http://ftp.gnu.org/old-gnu/Manuals/gdb/html_node/gdb_57.html>`__ option to
+avoid data structures being printed as a big block of text.
+
 .. _common:
 
 Helpful Hints for Common Operations

examples/BrainF/BrainFDriver.cpp

@@ -29,6 +29,7 @@
 #include "llvm/Bitcode/BitcodeWriter.h"
 #include "llvm/ExecutionEngine/ExecutionEngine.h"
 #include "llvm/ExecutionEngine/GenericValue.h"
+#include "llvm/ExecutionEngine/MCJIT.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DerivedTypes.h"
@@ -153,10 +154,15 @@ int main(int argc, char **argv) {
   //Write it out
   if (JIT) {
     InitializeNativeTarget();
+    InitializeNativeTargetAsmPrinter();
 
     outs() << "------- Running JIT -------\n";
     Module &M = *Mod;
     ExecutionEngine *ee = EngineBuilder(std::move(Mod)).create();
+    if (!ee) {
+      errs() << "Error: execution engine creation failed.\n";
+      abort();
+    }
     std::vector<GenericValue> args;
     Function *brainf_func = M.getFunction("brainf");
     GenericValue gv = ee->runFunction(brainf_func, args);

examples/BrainF/CMakeLists.txt

@@ -3,6 +3,7 @@ set(LLVM_LINK_COMPONENTS
   Core
   ExecutionEngine
   MC
+  MCJIT
   Support
   nativecodegen
   )

include/llvm/ADT/APFloat.h

@@ -671,41 +671,49 @@ class APFloat : public APFloatBase {
     Storage(const fltSemantics &Semantics, ArgTypes &&... Args) {
       if (usesLayout<IEEEFloat>(Semantics)) {
         new (&IEEE) IEEEFloat(Semantics, std::forward<ArgTypes>(Args)...);
-      } else if (usesLayout<DoubleAPFloat>(Semantics)) {
+        return;
+      }
+      if (usesLayout<DoubleAPFloat>(Semantics)) {
         new (&Double) DoubleAPFloat(Semantics, std::forward<ArgTypes>(Args)...);
-      } else {
-        llvm_unreachable("Unexpected semantics");
+        return;
       }
+      llvm_unreachable("Unexpected semantics");
     }
 
     ~Storage() {
       if (usesLayout<IEEEFloat>(*semantics)) {
         IEEE.~IEEEFloat();
-      } else if (usesLayout<DoubleAPFloat>(*semantics)) {
+        return;
+      }
+      if (usesLayout<DoubleAPFloat>(*semantics)) {
         Double.~DoubleAPFloat();
-      } else {
-        llvm_unreachable("Unexpected semantics");
+        return;
       }
+      llvm_unreachable("Unexpected semantics");
     }
 
     Storage(const Storage &RHS) {
       if (usesLayout<IEEEFloat>(*RHS.semantics)) {
         new (this) IEEEFloat(RHS.IEEE);
-      } else if (usesLayout<DoubleAPFloat>(*RHS.semantics)) {
+        return;
+      }
+      if (usesLayout<DoubleAPFloat>(*RHS.semantics)) {
         new (this) DoubleAPFloat(RHS.Double);
-      } else {
-        llvm_unreachable("Unexpected semantics");
+        return;
       }
+      llvm_unreachable("Unexpected semantics");
     }
 
     Storage(Storage &&RHS) {
       if (usesLayout<IEEEFloat>(*RHS.semantics)) {
         new (this) IEEEFloat(std::move(RHS.IEEE));
-      } else if (usesLayout<DoubleAPFloat>(*RHS.semantics)) {
+        return;
+      }
+      if (usesLayout<DoubleAPFloat>(*RHS.semantics)) {
         new (this) DoubleAPFloat(std::move(RHS.Double));
-      } else {
-        llvm_unreachable("Unexpected semantics");
+        return;
       }
+      llvm_unreachable("Unexpected semantics");
     }
 
     Storage &operator=(const Storage &RHS) {
@@ -747,35 +755,29 @@ class APFloat : public APFloatBase {
   }
 
   IEEEFloat &getIEEE() {
-    if (usesLayout<IEEEFloat>(*U.semantics)) {
+    if (usesLayout<IEEEFloat>(*U.semantics))
       return U.IEEE;
-    } else if (usesLayout<DoubleAPFloat>(*U.semantics)) {
+    if (usesLayout<DoubleAPFloat>(*U.semantics))
       return U.Double.getFirst().U.IEEE;
-    } else {
-      llvm_unreachable("Unexpected semantics");
-    }
+    llvm_unreachable("Unexpected semantics");
   }
 
   const IEEEFloat &getIEEE() const {
-    if (usesLayout<IEEEFloat>(*U.semantics)) {
+    if (usesLayout<IEEEFloat>(*U.semantics))
       return U.IEEE;
-    } else if (usesLayout<DoubleAPFloat>(*U.semantics)) {
+    if (usesLayout<DoubleAPFloat>(*U.semantics))
       return U.Double.getFirst().U.IEEE;
-    } else {
-      llvm_unreachable("Unexpected semantics");
-    }
+    llvm_unreachable("Unexpected semantics");
   }
 
   void makeZero(bool Neg) { getIEEE().makeZero(Neg); }
 
   void makeInf(bool Neg) {
-    if (usesLayout<IEEEFloat>(*U.semantics)) {
+    if (usesLayout<IEEEFloat>(*U.semantics))
       return U.IEEE.makeInf(Neg);
-    } else if (usesLayout<DoubleAPFloat>(*U.semantics)) {
+    if (usesLayout<DoubleAPFloat>(*U.semantics))
       return U.Double.makeInf(Neg);
-    } else {
-      llvm_unreachable("Unexpected semantics");
-    }
+    llvm_unreachable("Unexpected semantics");
   }
 
   void makeNaN(bool SNaN, bool Neg, const APInt *fill) {
@@ -803,13 +805,11 @@ class APFloat : public APFloatBase {
 
   cmpResult compareAbsoluteValue(const APFloat &RHS) const {
     assert(&getSemantics() == &RHS.getSemantics());
-    if (usesLayout<IEEEFloat>(getSemantics())) {
+    if (usesLayout<IEEEFloat>(getSemantics()))
       return U.IEEE.compareAbsoluteValue(RHS.U.IEEE);
-    } else if (usesLayout<DoubleAPFloat>(getSemantics())) {
+    if (usesLayout<DoubleAPFloat>(getSemantics()))
       return U.Double.compareAbsoluteValue(RHS.U.Double);
-    } else {
-      llvm_unreachable("Unexpected semantics");
-    }
+    llvm_unreachable("Unexpected semantics");
   }
 
 public:
@@ -828,13 +828,11 @@ class APFloat : public APFloatBase {
   ~APFloat() = default;
 
   bool needsCleanup() const {
-    if (usesLayout<IEEEFloat>(getSemantics())) {
+    if (usesLayout<IEEEFloat>(getSemantics()))
       return U.IEEE.needsCleanup();
-    } else if (usesLayout<DoubleAPFloat>(getSemantics())) {
+    if (usesLayout<DoubleAPFloat>(getSemantics()))
       return U.Double.needsCleanup();
-    } else {
-      llvm_unreachable("Unexpected semantics");
-    }
+    llvm_unreachable("Unexpected semantics");
   }
 
   /// Factory for Positive and Negative Zero.
@@ -925,22 +923,18 @@ class APFloat : public APFloatBase {
   void Profile(FoldingSetNodeID &NID) const { getIEEE().Profile(NID); }
 
   opStatus add(const APFloat &RHS, roundingMode RM) {
-    if (usesLayout<IEEEFloat>(getSemantics())) {
+    if (usesLayout<IEEEFloat>(getSemantics()))
       return U.IEEE.add(RHS.U.IEEE, RM);
-    } else if (usesLayout<DoubleAPFloat>(getSemantics())) {
+    if (usesLayout<DoubleAPFloat>(getSemantics()))
       return U.Double.add(RHS.U.Double, RM);
-    } else {
-      llvm_unreachable("Unexpected semantics");
-    }
+    llvm_unreachable("Unexpected semantics");
   }
   opStatus subtract(const APFloat &RHS, roundingMode RM) {
-    if (usesLayout<IEEEFloat>(getSemantics())) {
+    if (usesLayout<IEEEFloat>(getSemantics()))
       return U.IEEE.subtract(RHS.U.IEEE, RM);
-    } else if (usesLayout<DoubleAPFloat>(getSemantics())) {
+    if (usesLayout<DoubleAPFloat>(getSemantics()))
       return U.Double.subtract(RHS.U.Double, RM);
-    } else {
-      llvm_unreachable("Unexpected semantics");
-    }
+    llvm_unreachable("Unexpected semantics");
   }
   opStatus multiply(const APFloat &RHS, roundingMode RM) {
     return getIEEE().multiply(RHS.getIEEE(), RM);

include/llvm/ADT/MapVector.h

@@ -30,6 +30,7 @@ template<typename KeyT, typename ValueT,
          typename MapType = llvm::DenseMap<KeyT, unsigned>,
          typename VectorType = std::vector<std::pair<KeyT, ValueT> > >
 class MapVector {
+  typedef typename VectorType::value_type value_type;
   typedef typename VectorType::size_type size_type;
 
   MapType Map;
@@ -41,6 +42,12 @@ class MapVector {
   typedef typename VectorType::reverse_iterator reverse_iterator;
   typedef typename VectorType::const_reverse_iterator const_reverse_iterator;
 
+  /// Clear the MapVector and return the underlying vector.
+  VectorType takeVector() {
+    Map.clear();
+    return std::move(Vector);
+  }
+
   size_type size() const { return Vector.size(); }
 
   iterator begin() { return Vector.begin(); }

include/llvm/ADT/SetVector.h

@@ -63,6 +63,12 @@ class SetVector {
 
   ArrayRef<T> getArrayRef() const { return vector_; }
 
+  /// Clear the SetVector and return the underlying vector.
+  Vector takeVector() {
+    set_.clear();
+    return std::move(vector_);
+  }
+
   /// \brief Determine if the SetVector is empty or not.
   bool empty() const {
     return vector_.empty();