d/freebsd-dev
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge ^/vendor/llvm-project/release-10.x up to its last change (upstream

Browse Source 
commit llvmorg-10.0.0-rc3-1-gc290cb61fdc), and bump versions.
This commit is contained in:
Dimitry Andric 2020-03-05 18:11:47 +00:00
commit 8c27c5541e
Notes: svn2git 2020-12-20 02:59:44 +00:00 
svn path=/projects/clang1000-import/; revision=358682
35 changed files with 166 additions and 137 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
contrib/llvm-project/clang/include/clang/AST/Expr.h
View File

@ -3955,14 +3955,14 @@ class StmtExpr : public Expr {
Stmt *SubStmt;
SourceLocation LParenLoc, RParenLoc;
public:
// FIXME: Does type-dependence need to be computed differently?
// FIXME: Do we need to compute instantiation instantiation-dependence for
// statements? (ugh!)
StmtExpr(CompoundStmt *substmt, QualType T,
SourceLocation lp, SourceLocation rp) :
SourceLocation lp, SourceLocation rp, bool InDependentContext) :
// Note: we treat a statement-expression in a dependent context as always
// being value- and instantiation-dependent. This matches the behavior of
// lambda-expressions and GCC.
Expr(StmtExprClass, T, VK_RValue, OK_Ordinary,
T->isDependentType(), false, false, false),
SubStmt(substmt), LParenLoc(lp), RParenLoc(rp) { }
T->isDependentType(), InDependentContext, InDependentContext, false),
SubStmt(substmt), LParenLoc(lp), RParenLoc(rp) {}
/// Build an empty statement expression.
explicit StmtExpr(EmptyShell Empty) : Expr(StmtExprClass, Empty) { }

2
contrib/llvm-project/clang/include/clang/Sema/Sema.h
View File

@ -4923,7 +4923,7 @@ class Sema final {
LabelDecl *TheDecl);
void ActOnStartStmtExpr();
ExprResult ActOnStmtExpr(SourceLocation LPLoc, Stmt *SubStmt,
ExprResult ActOnStmtExpr(Scope *S, SourceLocation LPLoc, Stmt *SubStmt,
SourceLocation RPLoc); // "({..})"
// Handle the final expression in a statement expression.
ExprResult ActOnStmtExprResult(ExprResult E);

5
contrib/llvm-project/clang/lib/AST/ASTImporter.cpp
View File

@ -6724,8 +6724,9 @@ ExpectedStmt ASTNodeImporter::VisitStmtExpr(StmtExpr *E) {
SourceLocation ToLParenLoc, ToRParenLoc;
std::tie(ToSubStmt, ToType, ToLParenLoc, ToRParenLoc) = *Imp;
return new (Importer.getToContext()) StmtExpr(
ToSubStmt, ToType, ToLParenLoc, ToRParenLoc);
return new (Importer.getToContext())
StmtExpr(ToSubStmt, ToType, ToLParenLoc, ToRParenLoc,
E->isInstantiationDependent());
}
ExpectedStmt ASTNodeImporter::VisitUnaryOperator(UnaryOperator *E) {

15
contrib/llvm-project/clang/lib/Format/TokenAnnotator.cpp
View File

@ -2707,10 +2707,17 @@ bool TokenAnnotator::spaceRequiredBetween(const AnnotatedLine &Line,
return false;
if (Right.isOneOf(tok::star, tok::amp, tok::ampamp) &&
(Left.is(tok::identifier) || Left.isSimpleTypeSpecifier()) &&
Left.Previous && Left.Previous->is(tok::kw_operator))
// Space between the type and the *
// operator void*(), operator char*(), operator Foo*() dependant
// on PointerAlignment style.
// Space between the type and the * in:
// operator void*()
// operator char*()
// operator /*comment*/ const char*()
// operator volatile /*comment*/ char*()
// operator Foo*()
// dependent on PointerAlignment style.
Left.Previous &&
(Left.Previous->endsSequence(tok::kw_operator) ||
Left.Previous->endsSequence(tok::kw_const, tok::kw_operator) ||
Left.Previous->endsSequence(tok::kw_volatile, tok::kw_operator)))
return (Style.PointerAlignment != FormatStyle::PAS_Left);
const auto SpaceRequiredForArrayInitializerLSquare =
[](const FormatToken &LSquareTok, const FormatStyle &Style) {

3
contrib/llvm-project/clang/lib/Parse/ParseExpr.cpp
View File

@ -2655,7 +2655,8 @@ Parser::ParseParenExpression(ParenParseOption &ExprType, bool stopIfCastExpr,
// If the substmt parsed correctly, build the AST node.
if (!Stmt.isInvalid()) {
Result = Actions.ActOnStmtExpr(OpenLoc, Stmt.get(), Tok.getLocation());
Result = Actions.ActOnStmtExpr(getCurScope(), OpenLoc, Stmt.get(),
Tok.getLocation());
} else {
Actions.ActOnStmtExprError();
}

16
contrib/llvm-project/clang/lib/Sema/SemaExpr.cpp
View File

@ -13908,9 +13908,8 @@ void Sema::ActOnStmtExprError() {
PopExpressionEvaluationContext();
}
ExprResult
Sema::ActOnStmtExpr(SourceLocation LPLoc, Stmt *SubStmt,
SourceLocation RPLoc) { // "({..})"
ExprResult Sema::ActOnStmtExpr(Scope *S, SourceLocation LPLoc, Stmt *SubStmt,
SourceLocation RPLoc) { // "({..})"
assert(SubStmt && isa<CompoundStmt>(SubStmt) && "Invalid action invocation!");
CompoundStmt *Compound = cast<CompoundStmt>(SubStmt);
@ -13939,9 +13938,18 @@ Sema::ActOnStmtExpr(SourceLocation LPLoc, Stmt *SubStmt,
}
}
bool IsDependentContext = false;
if (S)
IsDependentContext = S->getTemplateParamParent() != nullptr;
else
// FIXME: This is not correct when substituting inside a templated
// context that isn't a DeclContext (such as a variable template).
IsDependentContext = CurContext->isDependentContext();
// FIXME: Check that expression type is complete/non-abstract; statement
// expressions are not lvalues.
Expr *ResStmtExpr = new (Context) StmtExpr(Compound, Ty, LPLoc, RPLoc);
Expr *ResStmtExpr =
new (Context) StmtExpr(Compound, Ty, LPLoc, RPLoc, IsDependentContext);
if (StmtExprMayBindToTemp)
return MaybeBindToTemporary(ResStmtExpr);
return ResStmtExpr;

5
contrib/llvm-project/clang/lib/Sema/SemaExprCXX.cpp
View File

@ -6800,8 +6800,9 @@ Stmt *Sema::MaybeCreateStmtWithCleanups(Stmt *SubStmt) {
// a new AsmStmtWithTemporaries.
CompoundStmt *CompStmt = CompoundStmt::Create(
Context, SubStmt, SourceLocation(), SourceLocation());
Expr *E = new (Context) StmtExpr(CompStmt, Context.VoidTy, SourceLocation(),
SourceLocation());
Expr *E = new (Context)
StmtExpr(CompStmt, Context.VoidTy, SourceLocation(), SourceLocation(),
CurContext->isDependentContext());
return MaybeCreateExprWithCleanups(E);
}

9
contrib/llvm-project/clang/lib/Sema/TreeTransform.h
View File

@ -2526,10 +2526,9 @@ class TreeTransform {
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildStmtExpr(SourceLocation LParenLoc,
Stmt *SubStmt,
SourceLocation RParenLoc) {
return getSema().ActOnStmtExpr(LParenLoc, SubStmt, RParenLoc);
ExprResult RebuildStmtExpr(SourceLocation LParenLoc, Stmt *SubStmt,
SourceLocation RParenLoc) {
return getSema().ActOnStmtExpr(nullptr, LParenLoc, SubStmt, RParenLoc);
}
/// Build a new __builtin_choose_expr expression.
@ -11801,6 +11800,8 @@ TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) {
NewTrailingRequiresClause = getDerived().TransformExpr(TRC);
// Create the local class that will describe the lambda.
// FIXME: KnownDependent below is wrong when substituting inside a templated
// context that isn't a DeclContext (such as a variable template).
CXXRecordDecl *OldClass = E->getLambdaClass();
CXXRecordDecl *Class
= getSema().createLambdaClosureType(E->getIntroducerRange(),

84
contrib/llvm-project/lld/docs/ReleaseNotes.rst
View File

@ -5,10 +5,6 @@ lld 10.0.0 Release Notes
.. contents::
:local:
.. warning::
These are in-progress notes for the upcoming LLVM 10.0.0 release.
Release notes for previous releases can be found on
`the Download Page <https://releases.llvm.org/download.html>`_.
Introduction
============
@ -33,51 +29,95 @@ ELF Improvements
* New ``elf32btsmipn32_fbsd`` and ``elf32ltsmipn32_fbsd`` emulations
are supported.
* Relax MIPS ``jalr``and ``jr`` instructions marked by the ``R_MIPS_JALR``
* Relax MIPS ``jalr`` and ``jr`` instructions marked by the ``R_MIPS_JALR``
relocation.
* For certain "undefined symbol" errors, a definition with a close spelling will be suggested.
(`D67039 <https://reviews.llvm.org/D67039>`_)
* ``extern "C"`` is suggested if an undefined reference is mangled(unmangled) while there
is a likely unmangled(mangled) definition.
(`D69592 <https://reviews.llvm.org/D69592>`_ `D69650 <https://reviews.llvm.org/D69650>`_)
* New ``-z noseparate-code``, ``-z separate-code`` and ``-z separate-loadable-segments``.
``-z noseparate-code`` is the default, which can reduce sizes of linked binaries by up to
3 times maxpagesize.
(`D64903 <https://reviews.llvm.org/D64903>`_ `D67481 <https://reviews.llvm.org/D67481>`_)
* ``-z force-bti`` and ``-z pac-plt`` are added for AArch64 Branch Target Identification and Pointer Authentication.
(`D62609 <https://reviews.llvm.org/D62609>`_)
* ``--fix-cortex-a8`` is added to fix erratum 657417.
(`D67284 <https://reviews.llvm.org/D67284>`_)
* ``-z force-ibt`` and ``-z shstk`` are added for Intel Control-flow Enforcement Technology.
(`D59780 <https://reviews.llvm.org/D59780>`_)
* ``PT_GNU_PROPERTY`` is added to help loaders locate the ``.note.gnu.property`` section.
It may be used by a future Linux kernel.
(`D70961 <https://reviews.llvm.org/D70961>`_)
* For ``--compress-debug-sections=zlib``, ``-O0`` and ``-O1`` enable compression level 1
while ``-O2`` enables compression level 6. ``-O1`` (default) is faster than before.
(`D70658 <https://reviews.llvm.org/D70658>`_)
* Range extension thunks with addends are implemented for AArch64, PowerPC32 and PowerPC64.
(`D70637 <https://reviews.llvm.org/D70637>`_ `D70937 <https://reviews.llvm.org/D70937>`_
`D73424 <https://reviews.llvm.org/D73424>`_)
* ``R_RISCV_ALIGN`` will be errored because linker relaxation for RISC-V is not supported.
Pass ``-mno-relax`` to disable ``R_RISCV_ALIGN``.
(`D71820 <https://reviews.llvm.org/D71820>`_)
* The ARM port will no longer insert interworking thunks for non STT_FUNC symbols.
(`D73474 <https://reviews.llvm.org/D73474>`_)
* The quality of PowerPC32 port has been greatly improved (canonical PLT, copy
relocations, non-preemptible IFUNC, range extension thunks with addends).
It can link FreeBSD 13.0 userland.
* The PowerPC64 port supports non-preemptible IFUNC.
(`D71509 <https://reviews.llvm.org/D71509>`_)
* lld creates a RO PT_LOAD and a RX PT_LOAD without a linker script.
lld creates a unified RX PT_LOAD with a linker script.
A future release will eliminate this difference and use a RO PT_LOAD and a RX PT_LOAD by default.
The linker script case will require ``--no-rosegment`` to restore the current behavior.
* GNU style compressed debug sections ``.zdebug`` (obsoleted by ``SHF_COMPRESSED``)
are supported for input files, but not for the output.
A future release may drop ``.zdebug`` support.
* Reduced size of linked MIPS binaries.
Breaking changes
----------------
COFF Improvements
-----------------
* ``-Ttext=$base`` (base is usually 0) is no longer supported.
If PT_PHDR is needed, use ``--image-base=$base`` instead.
If PT_PHDR is not needed, use a linker script with `.text 0 : { *(.text*) }` as the first
output section description.
See https://bugs.llvm.org/show_bug.cgi?id=44715 for more information.
(`D67325 <https://reviews.llvm.org/D67325>`_)
* ``-Ttext-segment`` is no longer supported. Its meaning was different from GNU ld's and
could cause subtle bugs.
(`D70468 <https://reviews.llvm.org/D70468>`_)
* ...
MinGW Improvements
------------------
* Allow using custom .edata sections from input object files (for use
by Wine)
(`dadc6f248868 <https://reviews.llvm.org/rGdadc6f248868>`)
(`dadc6f248868 <https://reviews.llvm.org/rGdadc6f248868>`_)
* Don't implicitly create import libraries unless requested
(`6540e55067e3 <https://reviews.llvm.org/rG6540e55067e3>`)
(`6540e55067e3 <https://reviews.llvm.org/rG6540e55067e3>`_)
* Support merging multiple resource object files
(`3d3a9b3b413d <https://reviews.llvm.org/rG3d3a9b3b413d>`)
(`3d3a9b3b413d <https://reviews.llvm.org/rG3d3a9b3b413d>`_)
and properly handle the default manifest object files that GCC can pass
(`d581dd501381 <https://reviews.llvm.org/rGd581dd501381>`)
(`d581dd501381 <https://reviews.llvm.org/rGd581dd501381>`_)
* Demangle itanium symbol names in warnings/error messages
(`a66fc1c99f3e <https://reviews.llvm.org/rGa66fc1c99f3e>`)
(`a66fc1c99f3e <https://reviews.llvm.org/rGa66fc1c99f3e>`_)
* Print source locations for undefined references and duplicate symbols,
if possible
(`1d06d48bb346 <https://reviews.llvm.org/rG1d06d48bb346>`)
(`1d06d48bb346 <https://reviews.llvm.org/rG1d06d48bb346>`_)
and
(`b38f577c015c <https://reviews.llvm.org/rGb38f577c015c>`)
(`b38f577c015c <https://reviews.llvm.org/rGb38f577c015c>`_)
* Look for more filename patterns when resolving ``-l`` options
(`0226c35262df <https://reviews.llvm.org/rG0226c35262df>`)
(`0226c35262df <https://reviews.llvm.org/rG0226c35262df>`_)
* Don't error out on duplicate absolute symbols with the same value
(which can happen for the default-null symbol for weak symbols)
(`1737cc750c46 <https://reviews.llvm.org/rG1737cc750c46>`)
(`1737cc750c46 <https://reviews.llvm.org/rG1737cc750c46>`_)
MachO Improvements
------------------
* Item 1.
WebAssembly Improvements
------------------------

4
contrib/llvm-project/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp
View File

@ -50,7 +50,7 @@
#include <compression.h>
#endif
#if LLVM_ENABLE_ZLIB
#if defined(HAVE_LIBZ)
#include <zlib.h>
#endif
@ -582,7 +582,7 @@ bool GDBRemoteCommunication::DecompressPacket() {
}
#endif
#if LLVM_ENABLE_ZLIB
#if defined(HAVE_LIBZ)
if (decompressed_bytes == 0 && decompressed_bufsize != ULONG_MAX &&
decompressed_buffer != nullptr &&
m_compression_type == CompressionType::ZlibDeflate) {

2
contrib/llvm-project/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp
View File

@ -1045,7 +1045,7 @@ void GDBRemoteCommunicationClient::MaybeEnableCompression(
}
#endif
#if LLVM_ENABLE_ZLIB
#if defined(HAVE_LIBZ)
if (avail_type == CompressionType::None) {
for (auto compression : supported_compressions) {
if (compression == "zlib-deflate") {

0
contrib/llvm-project/llvm/lib/Support/Windows/WindowsSupport.h → contrib/llvm-project/llvm/include/llvm/Support/Windows/WindowsSupport.h
View File

3
contrib/llvm-project/llvm/include/llvm/module.modulemap
View File

@ -380,6 +380,9 @@ module LLVM_Utils {
umbrella "Support"
module * { export * }
// Exclude this; it should only be used on Windows.
exclude header "Support/Windows/WindowsSupport.h"
// Exclude these; they are fundamentally non-modular.
exclude header "Support/PluginLoader.h"

3
contrib/llvm-project/llvm/lib/Analysis/TargetLibraryInfo.cpp
View File

@ -470,6 +470,9 @@ static void initialize(TargetLibraryInfoImpl &TLI, const Triple &T,
TLI.setUnavailable(LibFunc_tmpfile64);
// Relaxed math functions are included in math-finite.h on Linux (GLIBC).
// Note that math-finite.h is no longer supported by top-of-tree GLIBC,
// so we keep these functions around just so that they're recognized by
// the ConstantFolder.
TLI.setUnavailable(LibFunc_acos_finite);
TLI.setUnavailable(LibFunc_acosf_finite);
TLI.setUnavailable(LibFunc_acosl_finite);

73
contrib/llvm-project/llvm/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp
View File

@ -3867,7 +3867,6 @@ void SelectionDAGLegalize::ConvertNodeToLibcall(SDNode *Node) {
SmallVector<SDValue, 8> Results;
SDLoc dl(Node);
// FIXME: Check flags on the node to see if we can use a finite call.
bool CanUseFiniteLibCall = TM.Options.NoInfsFPMath && TM.Options.NoNaNsFPMath;
unsigned Opc = Node->getOpcode();
switch (Opc) {
case ISD::ATOMIC_FENCE: {
@ -3976,68 +3975,28 @@ void SelectionDAGLegalize::ConvertNodeToLibcall(SDNode *Node) {
break;
case ISD::FLOG:
case ISD::STRICT_FLOG:
if (CanUseFiniteLibCall && DAG.getLibInfo().has(LibFunc_log_finite))
ExpandFPLibCall(Node, RTLIB::LOG_FINITE_F32,
RTLIB::LOG_FINITE_F64,
RTLIB::LOG_FINITE_F80,
RTLIB::LOG_FINITE_F128,
RTLIB::LOG_FINITE_PPCF128, Results);
else
ExpandFPLibCall(Node, RTLIB::LOG_F32, RTLIB::LOG_F64,
RTLIB::LOG_F80, RTLIB::LOG_F128,
RTLIB::LOG_PPCF128, Results);
ExpandFPLibCall(Node, RTLIB::LOG_F32, RTLIB::LOG_F64, RTLIB::LOG_F80,
RTLIB::LOG_F128, RTLIB::LOG_PPCF128, Results);
break;
case ISD::FLOG2:
case ISD::STRICT_FLOG2:
if (CanUseFiniteLibCall && DAG.getLibInfo().has(LibFunc_log2_finite))
ExpandFPLibCall(Node, RTLIB::LOG2_FINITE_F32,
RTLIB::LOG2_FINITE_F64,
RTLIB::LOG2_FINITE_F80,
RTLIB::LOG2_FINITE_F128,
RTLIB::LOG2_FINITE_PPCF128, Results);
else
ExpandFPLibCall(Node, RTLIB::LOG2_F32, RTLIB::LOG2_F64,
RTLIB::LOG2_F80, RTLIB::LOG2_F128,
RTLIB::LOG2_PPCF128, Results);
ExpandFPLibCall(Node, RTLIB::LOG2_F32, RTLIB::LOG2_F64, RTLIB::LOG2_F80,
RTLIB::LOG2_F128, RTLIB::LOG2_PPCF128, Results);
break;
case ISD::FLOG10:
case ISD::STRICT_FLOG10:
if (CanUseFiniteLibCall && DAG.getLibInfo().has(LibFunc_log10_finite))
ExpandFPLibCall(Node, RTLIB::LOG10_FINITE_F32,
RTLIB::LOG10_FINITE_F64,
RTLIB::LOG10_FINITE_F80,
RTLIB::LOG10_FINITE_F128,
RTLIB::LOG10_FINITE_PPCF128, Results);
else
ExpandFPLibCall(Node, RTLIB::LOG10_F32, RTLIB::LOG10_F64,
RTLIB::LOG10_F80, RTLIB::LOG10_F128,
RTLIB::LOG10_PPCF128, Results);
ExpandFPLibCall(Node, RTLIB::LOG10_F32, RTLIB::LOG10_F64, RTLIB::LOG10_F80,
RTLIB::LOG10_F128, RTLIB::LOG10_PPCF128, Results);
break;
case ISD::FEXP:
case ISD::STRICT_FEXP:
if (CanUseFiniteLibCall && DAG.getLibInfo().has(LibFunc_exp_finite))
ExpandFPLibCall(Node, RTLIB::EXP_FINITE_F32,
RTLIB::EXP_FINITE_F64,
RTLIB::EXP_FINITE_F80,
RTLIB::EXP_FINITE_F128,
RTLIB::EXP_FINITE_PPCF128, Results);
else
ExpandFPLibCall(Node, RTLIB::EXP_F32, RTLIB::EXP_F64,
RTLIB::EXP_F80, RTLIB::EXP_F128,
RTLIB::EXP_PPCF128, Results);
ExpandFPLibCall(Node, RTLIB::EXP_F32, RTLIB::EXP_F64, RTLIB::EXP_F80,
RTLIB::EXP_F128, RTLIB::EXP_PPCF128, Results);
break;
case ISD::FEXP2:
case ISD::STRICT_FEXP2:
if (CanUseFiniteLibCall && DAG.getLibInfo().has(LibFunc_exp2_finite))
ExpandFPLibCall(Node, RTLIB::EXP2_FINITE_F32,
RTLIB::EXP2_FINITE_F64,
RTLIB::EXP2_FINITE_F80,
RTLIB::EXP2_FINITE_F128,
RTLIB::EXP2_FINITE_PPCF128, Results);
else
ExpandFPLibCall(Node, RTLIB::EXP2_F32, RTLIB::EXP2_F64,
RTLIB::EXP2_F80, RTLIB::EXP2_F128,
RTLIB::EXP2_PPCF128, Results);
ExpandFPLibCall(Node, RTLIB::EXP2_F32, RTLIB::EXP2_F64, RTLIB::EXP2_F80,
RTLIB::EXP2_F128, RTLIB::EXP2_PPCF128, Results);
break;
case ISD::FTRUNC:
case ISD::STRICT_FTRUNC:
@ -4107,16 +4066,8 @@ void SelectionDAGLegalize::ConvertNodeToLibcall(SDNode *Node) {
}
case ISD::FPOW:
case ISD::STRICT_FPOW:
if (CanUseFiniteLibCall && DAG.getLibInfo().has(LibFunc_pow_finite))
ExpandFPLibCall(Node, RTLIB::POW_FINITE_F32,
RTLIB::POW_FINITE_F64,
RTLIB::POW_FINITE_F80,
RTLIB::POW_FINITE_F128,
RTLIB::POW_FINITE_PPCF128, Results);
else
ExpandFPLibCall(Node, RTLIB::POW_F32, RTLIB::POW_F64,
RTLIB::POW_F80, RTLIB::POW_F128,
RTLIB::POW_PPCF128, Results);
ExpandFPLibCall(Node, RTLIB::POW_F32, RTLIB::POW_F64, RTLIB::POW_F80,
RTLIB::POW_F128, RTLIB::POW_PPCF128, Results);
break;
case ISD::LROUND:
case ISD::STRICT_LROUND:

2
contrib/llvm-project/llvm/lib/Support/CRC.cpp
View File

@ -25,7 +25,7 @@
using namespace llvm;
#if !LLVM_ENABLE_ZLIB
#if LLVM_ENABLE_ZLIB == 0 || !HAVE_ZLIB_H
static const uint32_t CRCTable[256] = {
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,

4
contrib/llvm-project/llvm/lib/Support/Compression.cpp
View File

@ -17,13 +17,13 @@
#include "llvm/Support/Compiler.h"
#include "llvm/Support/Error.h"
#include "llvm/Support/ErrorHandling.h"
#if LLVM_ENABLE_ZLIB
#if LLVM_ENABLE_ZLIB == 1 && HAVE_ZLIB_H
#include <zlib.h>
#endif
using namespace llvm;
#if LLVM_ENABLE_ZLIB
#if LLVM_ENABLE_ZLIB == 1 && HAVE_LIBZ
static Error createError(StringRef Err) {
return make_error<StringError>(Err, inconvertibleErrorCode());
}

2
contrib/llvm-project/llvm/lib/Support/CrashRecoveryContext.cpp
View File

@ -254,7 +254,7 @@ bool CrashRecoveryContext::RunSafely(function_ref<void()> Fn) {
// XP, so if support for older versions of Windows is required,
// it will have to be added.
#include "Windows/WindowsSupport.h"
#include "llvm/Support/Windows/WindowsSupport.h"
static LONG CALLBACK ExceptionHandler(PEXCEPTION_POINTERS ExceptionInfo)
{

2
contrib/llvm-project/llvm/lib/Support/InitLLVM.cpp
View File

@ -15,7 +15,7 @@
#include <string>
#ifdef _WIN32
#include "Windows/WindowsSupport.h"
#include "llvm/Support/Windows/WindowsSupport.h"
#endif
using namespace llvm;

2
contrib/llvm-project/llvm/lib/Support/RandomNumberGenerator.cpp
View File

@ -17,7 +17,7 @@
#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"
#ifdef _WIN32
#include "Windows/WindowsSupport.h"
#include "llvm/Support/Windows/WindowsSupport.h"
#else
#include "Unix/Unix.h"
#endif

2
contrib/llvm-project/llvm/lib/Support/Windows/DynamicLibrary.inc
View File

@ -10,7 +10,7 @@
//
//===----------------------------------------------------------------------===//
#include "WindowsSupport.h"
#include "llvm/Support/Windows/WindowsSupport.h"
#include "llvm/Support/ConvertUTF.h"
#include "llvm/Support/raw_ostream.h"

2
contrib/llvm-project/llvm/lib/Support/Windows/Host.inc
View File

@ -10,7 +10,7 @@
//
//===----------------------------------------------------------------------===//
#include "WindowsSupport.h"
#include "llvm/Support/Windows/WindowsSupport.h"
#include <cstdio>
#include <string>

2
contrib/llvm-project/llvm/lib/Support/Windows/Memory.inc
View File

@ -17,7 +17,7 @@
#include "llvm/Support/WindowsError.h"
// The Windows.h header must be the last one included.
#include "WindowsSupport.h"
#include "llvm/Support/Windows/WindowsSupport.h"
static DWORD getWindowsProtectionFlags(unsigned Flags) {
switch (Flags & llvm::sys::Memory::MF_RWE_MASK) {

2
contrib/llvm-project/llvm/lib/Support/Windows/Path.inc
View File

@ -25,7 +25,7 @@
// These two headers must be included last, and make sure shlobj is required
// after Windows.h to make sure it picks up our definition of _WIN32_WINNT
#include "WindowsSupport.h"
#include "llvm/Support/Windows/WindowsSupport.h"
#include <shellapi.h>
#include <shlobj.h>

2
contrib/llvm-project/llvm/lib/Support/Windows/Process.inc
View File

@ -19,7 +19,7 @@
#include <malloc.h>
// The Windows.h header must be after LLVM and standard headers.
#include "WindowsSupport.h"
#include "llvm/Support/Windows/WindowsSupport.h"
#include <direct.h>
#include <io.h>

2
contrib/llvm-project/llvm/lib/Support/Windows/Program.inc
View File

@ -10,7 +10,7 @@
//
//===----------------------------------------------------------------------===//
#include "WindowsSupport.h"
#include "llvm/Support/Windows/WindowsSupport.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/Support/ConvertUTF.h"
#include "llvm/Support/Errc.h"

2
contrib/llvm-project/llvm/lib/Support/Windows/Signals.inc
View File

@ -23,7 +23,7 @@
#include "llvm/Support/raw_ostream.h"
// The Windows.h header must be after LLVM and standard headers.
#include "WindowsSupport.h"
#include "llvm/Support/Windows/WindowsSupport.h"
#ifdef __MINGW32__
#include <imagehlp.h>

2
contrib/llvm-project/llvm/lib/Support/Windows/ThreadLocal.inc
View File

@ -15,7 +15,7 @@
//=== is guaranteed to work on *all* Win32 variants.
//===----------------------------------------------------------------------===//
#include "WindowsSupport.h"
#include "llvm/Support/Windows/WindowsSupport.h"
#include "llvm/Support/ThreadLocal.h"
namespace llvm {

2
contrib/llvm-project/llvm/lib/Support/Windows/Threading.inc
View File

@ -13,7 +13,7 @@
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/Twine.h"
#include "WindowsSupport.h"
#include "llvm/Support/Windows/WindowsSupport.h"
#include <process.h>
// Windows will at times define MemoryFence.

2
contrib/llvm-project/llvm/lib/Support/raw_ostream.cpp
View File

@ -60,7 +60,7 @@
#ifdef _WIN32
#include "llvm/Support/ConvertUTF.h"
#include "Windows/WindowsSupport.h"
#include "llvm/Support/Windows/WindowsSupport.h"
#endif
using namespace llvm;

18
contrib/llvm-project/llvm/lib/Transforms/InstCombine/InstCombinePHI.cpp
View File

@ -218,13 +218,21 @@ Instruction *InstCombiner::FoldIntegerTypedPHI(PHINode &PN) {
return nullptr;
// If any of the operand that requires casting is a terminator
// instruction, do not do it.
// instruction, do not do it. Similarly, do not do the transform if the value
// is PHI in a block with no insertion point, for example, a catchswitch
// block, since we will not be able to insert a cast after the PHI.
if (any_of(AvailablePtrVals, [&](Value *V) {
if (V->getType() == IntToPtr->getType())
return false;
auto *Inst = dyn_cast<Instruction>(V);
return Inst && Inst->isTerminator();
if (!Inst)
return false;
if (Inst->isTerminator())
return true;
auto *BB = Inst->getParent();
if (isa<PHINode>(Inst) && BB->getFirstInsertionPt() == BB->end())
return true;
return false;
}))
return nullptr;
@ -264,8 +272,10 @@ Instruction *InstCombiner::FoldIntegerTypedPHI(PHINode &PN) {
if (auto *IncomingI = dyn_cast<Instruction>(IncomingVal)) {
BasicBlock::iterator InsertPos(IncomingI);
InsertPos++;
BasicBlock *BB = IncomingI->getParent();
if (isa<PHINode>(IncomingI))
InsertPos = IncomingI->getParent()->getFirstInsertionPt();
InsertPos = BB->getFirstInsertionPt();
assert(InsertPos != BB->end() && "should have checked above");
InsertNewInstBefore(CI, *InsertPos);
} else {
auto *InsertBB = &IncomingBB->getParent()->getEntryBlock();

4
contrib/llvm-project/llvm/lib/Transforms/Scalar/SROA.cpp
View File

@ -2519,6 +2519,8 @@ class llvm::sroa::AllocaSliceRewriter
NewLI->setAAMetadata(AATags);
if (LI.isVolatile())
NewLI->setAtomic(LI.getOrdering(), LI.getSyncScopeID());
if (NewLI->isAtomic())
NewLI->setAlignment(LI.getAlign());
// Any !nonnull metadata or !range metadata on the old load is also valid
// on the new load. This is even true in some cases even when the loads
@ -2709,6 +2711,8 @@ class llvm::sroa::AllocaSliceRewriter
NewSI->setAAMetadata(AATags);
if (SI.isVolatile())
NewSI->setAtomic(SI.getOrdering(), SI.getSyncScopeID());
if (NewSI->isAtomic())
NewSI->setAlignment(SI.getAlign());
Pass.DeadInsts.insert(&SI);
deleteIfTriviallyDead(OldOp);

3
contrib/llvm-project/llvm/tools/llvm-ar/llvm-ar.cpp
View File

@ -45,8 +45,7 @@
#endif
#ifdef _WIN32
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include "llvm/Support/Windows/WindowsSupport.h"
#endif
using namespace llvm;

8
lib/clang/include/VCSVersion.inc
View File

@ -1,14 +1,14 @@
// $FreeBSD$
#define LLVM_REVISION "llvmorg-10.0.0-rc2-70-ge5cb70267e7"
#define LLVM_REVISION "llvmorg-10.0.0-rc3-1-gc290cb61fdc"
#define LLVM_REPOSITORY "git@github.com:llvm/llvm-project.git"
#define CLANG_REVISION "llvmorg-10.0.0-rc2-70-ge5cb70267e7"
#define CLANG_REVISION "llvmorg-10.0.0-rc3-1-gc290cb61fdc"
#define CLANG_REPOSITORY "git@github.com:llvm/llvm-project.git"
// <Upstream revision at import>-<Local identifier in __FreeBSD_version style>
#define LLD_REVISION "llvmorg-10.0.0-rc2-70-ge5cb70267e7-1300007"
#define LLD_REVISION "llvmorg-10.0.0-rc3-1-gc290cb61fdc-1300007"
#define LLD_REPOSITORY "FreeBSD"
#define LLDB_REVISION "llvmorg-10.0.0-rc2-70-ge5cb70267e7"
#define LLDB_REVISION "llvmorg-10.0.0-rc3-1-gc290cb61fdc"
#define LLDB_REPOSITORY "git@github.com:llvm/llvm-project.git"

2
lib/clang/include/llvm/Support/VCSRevision.h
View File

@ -1,3 +1,3 @@
/* $FreeBSD$ */
#define LLVM_REVISION "llvmorg-10.0.0-rc2-70-ge5cb70267e7"
#define LLVM_REVISION "llvmorg-10.0.0-rc3-1-gc290cb61fdc"
#define LLVM_REPOSITORY "git@github.com:llvm/llvm-project.git"