diff --git a/.gitignore b/.gitignore
index 06c0fa6..b408ec8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1 @@
-SOURCES/hans-gpg-key.asc
-SOURCES/llvm-11.0.0.src.tar.xz
+SOURCES/llvm-11.0.1.src.tar.xz
diff --git a/.llvm.metadata b/.llvm.metadata
index 10f8833..4eb6ec8 100644
--- a/.llvm.metadata
+++ b/.llvm.metadata
@@ -1,2 +1 @@
-32fa4b0193960f05064f2ab31b5a89c7cf48a0b9 SOURCES/hans-gpg-key.asc
-5723ae20d1e6e9ccfda208cb9a8cf2f87c3a6107 SOURCES/llvm-11.0.0.src.tar.xz
+1a911295260d4e41116b72788eb602702b4bb252 SOURCES/llvm-11.0.1.src.tar.xz
diff --git a/SOURCES/0001-SelectionDAG-Avoid-aliasing-analysis-if-the-object-s.patch b/SOURCES/0001-SelectionDAG-Avoid-aliasing-analysis-if-the-object-s.patch
new file mode 100644
index 0000000..33a53b6
--- /dev/null
+++ b/SOURCES/0001-SelectionDAG-Avoid-aliasing-analysis-if-the-object-s.patch
@@ -0,0 +1,427 @@
+From 153232761304a2746ea9a11d9da3aa5e5a7c26d0 Mon Sep 17 00:00:00 2001
+From: Hsiangkai Wang <kai.wang@sifive.com>
+Date: Fri, 20 Nov 2020 08:52:03 +0800
+Subject: [PATCH] [SelectionDAG] Avoid aliasing analysis if the object size is
+ unknown.
+
+If the size of memory access is unknown, do not use it to analysis. One
+example of unknown size memory access is to load/store scalable vector
+objects on the stack.
+
+Differential Revision: https://reviews.llvm.org/D91833
+---
+ .../SelectionDAGAddressAnalysis.cpp | 31 +-
+ llvm/unittests/CodeGen/CMakeLists.txt | 1 +
+ .../SelectionDAGAddressAnalysisTest.cpp | 337 ++++++++++++++++++
+ 3 files changed, 359 insertions(+), 10 deletions(-)
+ create mode 100644 llvm/unittests/CodeGen/SelectionDAGAddressAnalysisTest.cpp
+
+diff --git a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGAddressAnalysis.cpp b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGAddressAnalysis.cpp
+index 3a53ab9717a4..20c7d771bfb6 100644
+--- a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGAddressAnalysis.cpp
++++ b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGAddressAnalysis.cpp
+@@ -7,6 +7,7 @@
+ //===----------------------------------------------------------------------===//
+
+ #include "llvm/CodeGen/SelectionDAGAddressAnalysis.h"
++#include "llvm/Analysis/MemoryLocation.h"
+ #include "llvm/CodeGen/ISDOpcodes.h"
+ #include "llvm/CodeGen/MachineFrameInfo.h"
+ #include "llvm/CodeGen/MachineFunction.h"
+@@ -96,18 +97,28 @@ bool BaseIndexOffset::computeAliasing(const SDNode *Op0,
+ int64_t PtrDiff;
+ if (NumBytes0.hasValue() && NumBytes1.hasValue() &&
+ BasePtr0.equalBaseIndex(BasePtr1, DAG, PtrDiff)) {
++ // If the size of memory access is unknown, do not use it to analysis.
++ // One example of unknown size memory access is to load/store scalable
++ // vector objects on the stack.
+ // BasePtr1 is PtrDiff away from BasePtr0. They alias if none of the
+ // following situations arise:
+- IsAlias = !(
+- // [----BasePtr0----]
+- // [---BasePtr1--]
+- // ========PtrDiff========>
+- (*NumBytes0 <= PtrDiff) ||
+- // [----BasePtr0----]
+- // [---BasePtr1--]
+- // =====(-PtrDiff)====>
+- (PtrDiff + *NumBytes1 <= 0)); // i.e. *NumBytes1 < -PtrDiff.
+- return true;
++ if (PtrDiff >= 0 &&
++ *NumBytes0 != static_cast<int64_t>(MemoryLocation::UnknownSize)) {
++ // [----BasePtr0----]
++ // [---BasePtr1--]
++ // ========PtrDiff========>
++ IsAlias = !(*NumBytes0 <= PtrDiff);
++ return true;
++ }
++ if (PtrDiff < 0 &&
++ *NumBytes1 != static_cast<int64_t>(MemoryLocation::UnknownSize)) {
++ // [----BasePtr0----]
++ // [---BasePtr1--]
++ // =====(-PtrDiff)====>
++ IsAlias = !((PtrDiff + *NumBytes1) <= 0);
++ return true;
++ }
++ return false;
+ }
+ // If both BasePtr0 and BasePtr1 are FrameIndexes, we will not be
+ // able to calculate their relative offset if at least one arises
+diff --git a/llvm/unittests/CodeGen/CMakeLists.txt b/llvm/unittests/CodeGen/CMakeLists.txt
+index fa3cb1fa7669..2fe525f1b413 100644
+--- a/llvm/unittests/CodeGen/CMakeLists.txt
++++ b/llvm/unittests/CodeGen/CMakeLists.txt
+@@ -21,6 +21,7 @@ add_llvm_unittest(CodeGenTests
+ MachineInstrTest.cpp
+ MachineOperandTest.cpp
+ ScalableVectorMVTsTest.cpp
++ SelectionDAGAddressAnalysisTest.cpp
+ TypeTraitsTest.cpp
+ TargetOptionsTest.cpp
+ )
+diff --git a/llvm/unittests/CodeGen/SelectionDAGAddressAnalysisTest.cpp b/llvm/unittests/CodeGen/SelectionDAGAddressAnalysisTest.cpp
+new file mode 100644
+index 000000000000..c00b6c518e70
+--- /dev/null
++++ b/llvm/unittests/CodeGen/SelectionDAGAddressAnalysisTest.cpp
+@@ -0,0 +1,337 @@
++//===- llvm/unittest/CodeGen/SelectionDAGAddressAnalysisTest.cpp ---------===//
++//
++// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
++// See https://llvm.org/LICENSE.txt for license information.
++// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
++//
++//===----------------------------------------------------------------------===//
++
++#include "llvm/CodeGen/SelectionDAGAddressAnalysis.h"
++#include "llvm/Analysis/MemoryLocation.h"
++#include "llvm/Analysis/OptimizationRemarkEmitter.h"
++#include "llvm/AsmParser/Parser.h"
++#include "llvm/CodeGen/MachineModuleInfo.h"
++#include "llvm/CodeGen/SelectionDAG.h"
++#include "llvm/CodeGen/TargetLowering.h"
++#include "llvm/Support/SourceMgr.h"
++#include "llvm/Support/TargetRegistry.h"
++#include "llvm/Support/TargetSelect.h"
++#include "llvm/Target/TargetMachine.h"
++#include "gtest/gtest.h"
++
++namespace llvm {
++
++class SelectionDAGAddressAnalysisTest : public testing::Test {
++protected:
++ static void SetUpTestCase() {
++ InitializeAllTargets();
++ InitializeAllTargetMCs();
++ }
++
++ void SetUp() override {
++ StringRef Assembly = "@g = global i32 0\n"
++ "define i32 @f() {\n"
++ " %1 = load i32, i32* @g\n"
++ " ret i32 %1\n"
++ "}";
++
++ Triple TargetTriple("aarch64--");
++ std::string Error;
++ const Target *T = TargetRegistry::lookupTarget("", TargetTriple, Error);
++ // FIXME: These tests do not depend on AArch64 specifically, but we have to
++ // initialize a target. A skeleton Target for unittests would allow us to
++ // always run these tests.
++ if (!T)
++ return;
++
++ TargetOptions Options;
++ TM = std::unique_ptr<LLVMTargetMachine>(static_cast<LLVMTargetMachine *>(
++ T->createTargetMachine("AArch64", "", "+sve", Options, None, None,
++ CodeGenOpt::Aggressive)));
++ if (!TM)
++ return;
++
++ SMDiagnostic SMError;
++ M = parseAssemblyString(Assembly, SMError, Context);
++ if (!M)
++ report_fatal_error(SMError.getMessage());
++ M->setDataLayout(TM->createDataLayout());
++
++ F = M->getFunction("f");
++ if (!F)
++ report_fatal_error("F?");
++ G = M->getGlobalVariable("g");
++ if (!G)
++ report_fatal_error("G?");
++
++ MachineModuleInfo MMI(TM.get());
++
++ MF = std::make_unique<MachineFunction>(*F, *TM, *TM->getSubtargetImpl(*F),
++ 0, MMI);
++
++ DAG = std::make_unique<SelectionDAG>(*TM, CodeGenOpt::None);
++ if (!DAG)
++ report_fatal_error("DAG?");
++ OptimizationRemarkEmitter ORE(F);
++ DAG->init(*MF, ORE, nullptr, nullptr, nullptr, nullptr, nullptr);
++ }
++
++ TargetLoweringBase::LegalizeTypeAction getTypeAction(EVT VT) {
++ return DAG->getTargetLoweringInfo().getTypeAction(Context, VT);
++ }
++
++ EVT getTypeToTransformTo(EVT VT) {
++ return DAG->getTargetLoweringInfo().getTypeToTransformTo(Context, VT);
++ }
++
++ LLVMContext Context;
++ std::unique_ptr<LLVMTargetMachine> TM;
++ std::unique_ptr<Module> M;
++ Function *F;
++ GlobalVariable *G;
++ std::unique_ptr<MachineFunction> MF;
++ std::unique_ptr<SelectionDAG> DAG;
++};
++
++TEST_F(SelectionDAGAddressAnalysisTest, sameFrameObject) {
++ if (!TM)
++ return;
++ SDLoc Loc;
++ auto Int8VT = EVT::getIntegerVT(Context, 8);
++ auto VecVT = EVT::getVectorVT(Context, Int8VT, 4);
++ SDValue FIPtr = DAG->CreateStackTemporary(VecVT);
++ int FI = cast<FrameIndexSDNode>(FIPtr.getNode())->getIndex();
++ MachinePointerInfo PtrInfo = MachinePointerInfo::getFixedStack(*MF, FI);
++ TypeSize Offset = TypeSize::Fixed(0);
++ SDValue Value = DAG->getConstant(0, Loc, VecVT);
++ SDValue Index = DAG->getMemBasePlusOffset(FIPtr, Offset, Loc);
++ SDValue Store = DAG->getStore(DAG->getEntryNode(), Loc, Value, Index,
++ PtrInfo.getWithOffset(Offset));
++ Optional<int64_t> NumBytes = MemoryLocation::getSizeOrUnknown(
++ cast<StoreSDNode>(Store)->getMemoryVT().getStoreSize());
++
++ bool IsAlias;
++ bool IsValid = BaseIndexOffset::computeAliasing(
++ Store.getNode(), NumBytes, Store.getNode(), NumBytes, *DAG, IsAlias);
++
++ EXPECT_TRUE(IsValid);
++ EXPECT_TRUE(IsAlias);
++}
++
++TEST_F(SelectionDAGAddressAnalysisTest, noAliasingFrameObjects) {
++ if (!TM)
++ return;
++ SDLoc Loc;
++ auto Int8VT = EVT::getIntegerVT(Context, 8);
++ // <4 x i8>
++ auto VecVT = EVT::getVectorVT(Context, Int8VT, 4);
++ // <2 x i8>
++ auto SubVecVT = EVT::getVectorVT(Context, Int8VT, 2);
++ SDValue FIPtr = DAG->CreateStackTemporary(VecVT);
++ int FI = cast<FrameIndexSDNode>(FIPtr.getNode())->getIndex();
++ MachinePointerInfo PtrInfo = MachinePointerInfo::getFixedStack(*MF, FI);
++ SDValue Value = DAG->getConstant(0, Loc, SubVecVT);
++ TypeSize Offset0 = TypeSize::Fixed(0);
++ TypeSize Offset1 = SubVecVT.getStoreSize();
++ SDValue Index0 = DAG->getMemBasePlusOffset(FIPtr, Offset0, Loc);
++ SDValue Index1 = DAG->getMemBasePlusOffset(FIPtr, Offset1, Loc);
++ SDValue Store0 = DAG->getStore(DAG->getEntryNode(), Loc, Value, Index0,
++ PtrInfo.getWithOffset(Offset0));
++ SDValue Store1 = DAG->getStore(DAG->getEntryNode(), Loc, Value, Index1,
++ PtrInfo.getWithOffset(Offset1));
++ Optional<int64_t> NumBytes0 = MemoryLocation::getSizeOrUnknown(
++ cast<StoreSDNode>(Store0)->getMemoryVT().getStoreSize());
++ Optional<int64_t> NumBytes1 = MemoryLocation::getSizeOrUnknown(
++ cast<StoreSDNode>(Store1)->getMemoryVT().getStoreSize());
++
++ bool IsAlias;
++ bool IsValid = BaseIndexOffset::computeAliasing(
++ Store0.getNode(), NumBytes0, Store1.getNode(), NumBytes1, *DAG, IsAlias);
++
++ EXPECT_TRUE(IsValid);
++ EXPECT_FALSE(IsAlias);
++}
++
++TEST_F(SelectionDAGAddressAnalysisTest, unknownSizeFrameObjects) {
++ if (!TM)
++ return;
++ SDLoc Loc;
++ auto Int8VT = EVT::getIntegerVT(Context, 8);
++ // <vscale x 4 x i8>
++ auto VecVT = EVT::getVectorVT(Context, Int8VT, 4, true);
++ // <vscale x 2 x i8>
++ auto SubVecVT = EVT::getVectorVT(Context, Int8VT, 2, true);
++ SDValue FIPtr = DAG->CreateStackTemporary(VecVT);
++ int FI = cast<FrameIndexSDNode>(FIPtr.getNode())->getIndex();
++ MachinePointerInfo PtrInfo = MachinePointerInfo::getFixedStack(*MF, FI);
++ SDValue Value = DAG->getConstant(0, Loc, SubVecVT);
++ TypeSize Offset0 = TypeSize::Fixed(0);
++ TypeSize Offset1 = SubVecVT.getStoreSize();
++ SDValue Index0 = DAG->getMemBasePlusOffset(FIPtr, Offset0, Loc);
++ SDValue Index1 = DAG->getMemBasePlusOffset(FIPtr, Offset1, Loc);
++ SDValue Store0 = DAG->getStore(DAG->getEntryNode(), Loc, Value, Index0,
++ PtrInfo.getWithOffset(Offset0));
++ SDValue Store1 = DAG->getStore(DAG->getEntryNode(), Loc, Value, Index1,
++ PtrInfo.getWithOffset(Offset1));
++ Optional<int64_t> NumBytes0 = MemoryLocation::getSizeOrUnknown(
++ cast<StoreSDNode>(Store0)->getMemoryVT().getStoreSize());
++ Optional<int64_t> NumBytes1 = MemoryLocation::getSizeOrUnknown(
++ cast<StoreSDNode>(Store1)->getMemoryVT().getStoreSize());
++
++ bool IsAlias;
++ bool IsValid = BaseIndexOffset::computeAliasing(
++ Store0.getNode(), NumBytes0, Store1.getNode(), NumBytes1, *DAG, IsAlias);
++
++ EXPECT_FALSE(IsValid);
++}
++
++TEST_F(SelectionDAGAddressAnalysisTest, globalWithFrameObject) {
++ if (!TM)
++ return;
++ SDLoc Loc;
++ auto Int8VT = EVT::getIntegerVT(Context, 8);
++ // <vscale x 4 x i8>
++ auto VecVT = EVT::getVectorVT(Context, Int8VT, 4, true);
++ SDValue FIPtr = DAG->CreateStackTemporary(VecVT);
++ int FI = cast<FrameIndexSDNode>(FIPtr.getNode())->getIndex();
++ MachinePointerInfo PtrInfo = MachinePointerInfo::getFixedStack(*MF, FI);
++ SDValue Value = DAG->getConstant(0, Loc, VecVT);
++ TypeSize Offset = TypeSize::Fixed(0);
++ SDValue Index = DAG->getMemBasePlusOffset(FIPtr, Offset, Loc);
++ SDValue Store = DAG->getStore(DAG->getEntryNode(), Loc, Value, Index,
++ PtrInfo.getWithOffset(Offset));
++ Optional<int64_t> NumBytes = MemoryLocation::getSizeOrUnknown(
++ cast<StoreSDNode>(Store)->getMemoryVT().getStoreSize());
++ EVT GTy = DAG->getTargetLoweringInfo().getValueType(DAG->getDataLayout(),
++ G->getType());
++ SDValue GValue = DAG->getConstant(0, Loc, GTy);
++ SDValue GAddr = DAG->getGlobalAddress(G, Loc, GTy);
++ SDValue GStore = DAG->getStore(DAG->getEntryNode(), Loc, GValue, GAddr,
++ MachinePointerInfo(G, 0));
++ Optional<int64_t> GNumBytes = MemoryLocation::getSizeOrUnknown(
++ cast<StoreSDNode>(GStore)->getMemoryVT().getStoreSize());
++
++ bool IsAlias;
++ bool IsValid = BaseIndexOffset::computeAliasing(
++ Store.getNode(), NumBytes, GStore.getNode(), GNumBytes, *DAG, IsAlias);
++
++ EXPECT_TRUE(IsValid);
++ EXPECT_FALSE(IsAlias);
++}
++
++TEST_F(SelectionDAGAddressAnalysisTest, fixedSizeFrameObjectsWithinDiff) {
++ if (!TM)
++ return;
++ SDLoc Loc;
++ auto Int8VT = EVT::getIntegerVT(Context, 8);
++ // <vscale x 4 x i8>
++ auto VecVT = EVT::getVectorVT(Context, Int8VT, 4, true);
++ // <vscale x 2 x i8>
++ auto SubVecVT = EVT::getVectorVT(Context, Int8VT, 2, true);
++ // <2 x i8>
++ auto SubFixedVecVT2xi8 = EVT::getVectorVT(Context, Int8VT, 2);
++ SDValue FIPtr = DAG->CreateStackTemporary(VecVT);
++ int FI = cast<FrameIndexSDNode>(FIPtr.getNode())->getIndex();
++ MachinePointerInfo PtrInfo = MachinePointerInfo::getFixedStack(*MF, FI);
++ SDValue Value0 = DAG->getConstant(0, Loc, SubFixedVecVT2xi8);
++ SDValue Value1 = DAG->getConstant(0, Loc, SubVecVT);
++ TypeSize Offset0 = TypeSize::Fixed(0);
++ TypeSize Offset1 = SubFixedVecVT2xi8.getStoreSize();
++ SDValue Index0 = DAG->getMemBasePlusOffset(FIPtr, Offset0, Loc);
++ SDValue Index1 = DAG->getMemBasePlusOffset(FIPtr, Offset1, Loc);
++ SDValue Store0 = DAG->getStore(DAG->getEntryNode(), Loc, Value0, Index0,
++ PtrInfo.getWithOffset(Offset0));
++ SDValue Store1 = DAG->getStore(DAG->getEntryNode(), Loc, Value1, Index1,
++ PtrInfo.getWithOffset(Offset1));
++ Optional<int64_t> NumBytes0 = MemoryLocation::getSizeOrUnknown(
++ cast<StoreSDNode>(Store0)->getMemoryVT().getStoreSize());
++ Optional<int64_t> NumBytes1 = MemoryLocation::getSizeOrUnknown(
++ cast<StoreSDNode>(Store1)->getMemoryVT().getStoreSize());
++
++ bool IsAlias;
++ bool IsValid = BaseIndexOffset::computeAliasing(
++ Store0.getNode(), NumBytes0, Store1.getNode(), NumBytes1, *DAG, IsAlias);
++ EXPECT_TRUE(IsValid);
++ EXPECT_FALSE(IsAlias);
++
++ IsValid = BaseIndexOffset::computeAliasing(
++ Store1.getNode(), NumBytes1, Store0.getNode(), NumBytes0, *DAG, IsAlias);
++ EXPECT_TRUE(IsValid);
++ EXPECT_FALSE(IsAlias);
++}
++
++TEST_F(SelectionDAGAddressAnalysisTest, fixedSizeFrameObjectsOutOfDiff) {
++ if (!TM)
++ return;
++ SDLoc Loc;
++ auto Int8VT = EVT::getIntegerVT(Context, 8);
++ // <vscale x 4 x i8>
++ auto VecVT = EVT::getVectorVT(Context, Int8VT, 4, true);
++ // <vscale x 2 x i8>
++ auto SubVecVT = EVT::getVectorVT(Context, Int8VT, 2, true);
++ // <2 x i8>
++ auto SubFixedVecVT2xi8 = EVT::getVectorVT(Context, Int8VT, 2);
++ // <4 x i8>
++ auto SubFixedVecVT4xi8 = EVT::getVectorVT(Context, Int8VT, 4);
++ SDValue FIPtr = DAG->CreateStackTemporary(VecVT);
++ int FI = cast<FrameIndexSDNode>(FIPtr.getNode())->getIndex();
++ MachinePointerInfo PtrInfo = MachinePointerInfo::getFixedStack(*MF, FI);
++ SDValue Value0 = DAG->getConstant(0, Loc, SubFixedVecVT4xi8);
++ SDValue Value1 = DAG->getConstant(0, Loc, SubVecVT);
++ TypeSize Offset0 = TypeSize::Fixed(0);
++ TypeSize Offset1 = SubFixedVecVT2xi8.getStoreSize();
++ SDValue Index0 = DAG->getMemBasePlusOffset(FIPtr, Offset0, Loc);
++ SDValue Index1 = DAG->getMemBasePlusOffset(FIPtr, Offset1, Loc);
++ SDValue Store0 = DAG->getStore(DAG->getEntryNode(), Loc, Value0, Index0,
++ PtrInfo.getWithOffset(Offset0));
++ SDValue Store1 = DAG->getStore(DAG->getEntryNode(), Loc, Value1, Index1,
++ PtrInfo.getWithOffset(Offset1));
++ Optional<int64_t> NumBytes0 = MemoryLocation::getSizeOrUnknown(
++ cast<StoreSDNode>(Store0)->getMemoryVT().getStoreSize());
++ Optional<int64_t> NumBytes1 = MemoryLocation::getSizeOrUnknown(
++ cast<StoreSDNode>(Store1)->getMemoryVT().getStoreSize());
++
++ bool IsAlias;
++ bool IsValid = BaseIndexOffset::computeAliasing(
++ Store0.getNode(), NumBytes0, Store1.getNode(), NumBytes1, *DAG, IsAlias);
++ EXPECT_TRUE(IsValid);
++ EXPECT_TRUE(IsAlias);
++}
++
++TEST_F(SelectionDAGAddressAnalysisTest, twoFixedStackObjects) {
++ if (!TM)
++ return;
++ SDLoc Loc;
++ auto Int8VT = EVT::getIntegerVT(Context, 8);
++ // <vscale x 2 x i8>
++ auto VecVT = EVT::getVectorVT(Context, Int8VT, 2, true);
++ // <2 x i8>
++ auto FixedVecVT = EVT::getVectorVT(Context, Int8VT, 2);
++ SDValue FIPtr0 = DAG->CreateStackTemporary(FixedVecVT);
++ SDValue FIPtr1 = DAG->CreateStackTemporary(VecVT);
++ int FI0 = cast<FrameIndexSDNode>(FIPtr0.getNode())->getIndex();
++ int FI1 = cast<FrameIndexSDNode>(FIPtr1.getNode())->getIndex();
++ MachinePointerInfo PtrInfo0 = MachinePointerInfo::getFixedStack(*MF, FI0);
++ MachinePointerInfo PtrInfo1 = MachinePointerInfo::getFixedStack(*MF, FI1);
++ SDValue Value0 = DAG->getConstant(0, Loc, FixedVecVT);
++ SDValue Value1 = DAG->getConstant(0, Loc, VecVT);
++ TypeSize Offset0 = TypeSize::Fixed(0);
++ SDValue Index0 = DAG->getMemBasePlusOffset(FIPtr0, Offset0, Loc);
++ SDValue Index1 = DAG->getMemBasePlusOffset(FIPtr1, Offset0, Loc);
++ SDValue Store0 = DAG->getStore(DAG->getEntryNode(), Loc, Value0, Index0,
++ PtrInfo0.getWithOffset(Offset0));
++ SDValue Store1 = DAG->getStore(DAG->getEntryNode(), Loc, Value1, Index1,
++ PtrInfo1.getWithOffset(Offset0));
++ Optional<int64_t> NumBytes0 = MemoryLocation::getSizeOrUnknown(
++ cast<StoreSDNode>(Store0)->getMemoryVT().getStoreSize());
++ Optional<int64_t> NumBytes1 = MemoryLocation::getSizeOrUnknown(
++ cast<StoreSDNode>(Store1)->getMemoryVT().getStoreSize());
++
++ bool IsAlias;
++ bool IsValid = BaseIndexOffset::computeAliasing(
++ Store0.getNode(), NumBytes0, Store1.getNode(), NumBytes1, *DAG, IsAlias);
++ EXPECT_TRUE(IsValid);
++ EXPECT_FALSE(IsAlias);
++}
++
++} // end namespace llvm
+--
+2.26.2
+
diff --git a/SOURCES/llvm-11.0.0.src.tar.xz.sig b/SOURCES/llvm-11.0.0.src.tar.xz.sig
deleted file mode 100644
index a7df9b4..0000000
Binary files a/SOURCES/llvm-11.0.0.src.tar.xz.sig and /dev/null differ
diff --git a/SOURCES/llvm-11.0.1.src.tar.xz.sig b/SOURCES/llvm-11.0.1.src.tar.xz.sig
new file mode 100644
index 0000000..f8d90a1
Binary files /dev/null and b/SOURCES/llvm-11.0.1.src.tar.xz.sig differ
diff --git a/SPECS/llvm.spec b/SPECS/llvm.spec
index ad09a1b..0dd8cf8 100644
--- a/SPECS/llvm.spec
+++ b/SPECS/llvm.spec
@@ -17,7 +17,7 @@
%global llvm_srcdir llvm-%{version}%{?rc_ver:rc%{rc_ver}}.src
%global maj_ver 11
%global min_ver 0
-%global patch_ver 0
+%global patch_ver 1
%if %{with compat_build}
%global pkg_name llvm%{maj_ver}.%{min_ver}
@@ -54,7 +54,6 @@ License: NCSA
URL: http://llvm.org
Source0: https://github.com/llvm/llvm-project/releases/download/llvmorg-%{version}%{?rc_ver:-rc%{rc_ver}}/%{llvm_srcdir}.tar.xz
Source1: https://github.com/llvm/llvm-project/releases/download/llvmorg-%{version}%{?rc_ver:-rc%{rc_ver}}/%{llvm_srcdir}.tar.xz.sig
-Source2: https://prereleases.llvm.org/%{version}/hans-gpg-key.asc
%if %{without compat_build}
Source3: run-lit-tests
Source4: lit.fedora.cfg.py
@@ -64,6 +63,7 @@ Source4: lit.fedora.cfg.py
Patch1: 0001-SystemZ-Use-LA-instead-of-AGR-in-eliminateFrameIndex.patch
Patch2: 0001-CMake-Split-static-library-exports-into-their-own-ex.patch
Patch3: 0001-CMake-Split-test-binary-exports-into-their-own-expor.patch
+Patch4: 0001-SelectionDAG-Avoid-aliasing-analysis-if-the-object-s.patch
# RHEL-specific patches.
Patch101: 0001-Deactivate-markdown-doc.patch
@@ -164,14 +164,6 @@ Static libraries for the LLVM compiler infrastructure.
Summary: LLVM regression tests
Requires: %{name}%{?_isa} = %{version}-%{release}
Requires: %{name}-libs%{?_isa} = %{version}-%{release}
-Requires: python3-lit
-# The regression tests need gold.
-Requires: binutils
-# This is for llvm-config
-Requires: %{name}-devel%{?_isa} = %{version}-%{release}
-# Bugpoint tests require gcc
-Requires: gcc
-Requires: findutils
Provides: llvm-test(major) = %{maj_ver}
@@ -335,50 +327,6 @@ cp -R utils/unittest %{install_srcdir}/utils/
cp utils/update_cc_test_checks.py %{install_srcdir}/utils/
cp -R utils/UpdateTestChecks %{install_srcdir}/utils/
-# One of the lit tests references this file
-install -d %{install_srcdir}/docs/CommandGuide/
-install -m 0644 docs/CommandGuide/dsymutil.rst %{install_srcdir}/docs/CommandGuide/
-
-# Generate lit config files. Strip off the last lines that initiates the
-# test run, so we can customize the configuration.
-head -n -2 _build/test/lit.site.cfg.py >> %{lit_cfg}
-head -n -2 _build/test/Unit/lit.site.cfg.py >> %{lit_unit_cfg}
-
-# Install custom fedora config file
-cp %{SOURCE4} %{buildroot}%{lit_fedora_cfg}
-
-# Patch lit config files to load custom fedora config:
-for f in %{lit_cfg} %{lit_unit_cfg}; do
- echo "lit_config.load_config(config, '%{lit_fedora_cfg}')" >> $f
-done
-
-install -d %{buildroot}%{_libexecdir}/tests/llvm
-install -m 0755 %{SOURCE3} %{buildroot}%{_libexecdir}/tests/llvm
-
-# Install lit tests. We need to put these in a tarball otherwise rpm will complain
-# about some of the test inputs having the wrong object file format.
-install -d %{buildroot}%{_datadir}/llvm/
-
-# The various tar options are there to make sur the archive is the same on 32 and 64 bit arch, i.e.
-# the archive creation is reproducible. Move arch-specific content out of the tarball
-mv %{lit_cfg} %{install_srcdir}/%{_arch}.site.cfg.py
-mv %{lit_unit_cfg} %{install_srcdir}/%{_arch}.Unit.site.cfg.py
-tar --sort=name --mtime='UTC 2020-01-01' -c test/ | gzip -n > %{install_srcdir}/test.tar.gz
-
-# Install the unit test binaries
-mkdir -p %{build_llvm_libdir}
-cp -R _build/unittests %{build_llvm_libdir}/
-rm -rf `find %{build_llvm_libdir} -iname 'cmake*'`
-
-# Install libraries used for testing
-install -m 0755 %{build_libdir}/BugpointPasses.so %{buildroot}%{_libdir}
-install -m 0755 %{build_libdir}/LLVMHello.so %{buildroot}%{_libdir}
-
-# Install test inputs for PDB tests
-echo "%{_datadir}/llvm/src/unittests/DebugInfo/PDB" > %{build_llvm_libdir}/unittests/DebugInfo/PDB/llvm.srcdir.txt
-mkdir -p %{buildroot}%{_datadir}/llvm/src/unittests/DebugInfo/PDB/
-cp -R unittests/DebugInfo/PDB/Inputs %{buildroot}%{_datadir}/llvm/src/unittests/DebugInfo/PDB/
-
%if %{with gold}
# Add symlink to lto plugin in the binutils plugin directory.
%{__mkdir_p} %{buildroot}%{_libdir}/bfd-plugins/
@@ -531,22 +479,12 @@ fi
%files test
%license LICENSE.TXT
-%{_libexecdir}/tests/llvm/
-%{llvm_libdir}/unittests/
-%{_datadir}/llvm/src/unittests
-%{_datadir}/llvm/src/test.tar.gz
-%{_datadir}/llvm/src/%{_arch}.site.cfg.py
-%{_datadir}/llvm/src/%{_arch}.Unit.site.cfg.py
-%{_datadir}/llvm/lit.fedora.cfg.py
-%{_datadir}/llvm/src/docs/CommandGuide/dsymutil.rst
%{_bindir}/not
%{_bindir}/count
%{_bindir}/yaml-bench
%{_bindir}/lli-child-target
%{_bindir}/llvm-isel-fuzzer
%{_bindir}/llvm-opt-fuzzer
-%{_libdir}/BugpointPasses.so
-%{_libdir}/LLVMHello.so
%{_libdir}/cmake/llvm/LLVMTestExports.cmake
%files googletest
@@ -557,6 +495,15 @@ fi
%endif
%changelog
+* Sat Sep 04 2021 Tom Stellard <tstellar@redhat.com> - 11.0.1-2
+- Backport bpftrace fix
+
+* Wed Sep 01 2021 Tom Stellard <tstellar@redhat.com> - 11.0.1-1
+- 11.0.1 Release
+
+* Mon Jul 19 2021 Tom Stellard <tstellar@redhat.com> - 11.0.0-3
+- Stop installing lit tests
+
* Thu Oct 29 2020 sguelton@redhat.com - 11.0.0-2
- Remove obsolete patch