[Openmp-commits] [clang] [libclc] [libcxx] [lld] [llvm] [openmp] llvm encode decode (PR #87187)

Jiang zixian via Openmp-commits openmp-commits at lists.llvm.org
Sun Mar 31 08:54:36 PDT 2024


https://github.com/jiang-zixian updated https://github.com/llvm/llvm-project/pull/87187

>From ccf42e2d5e200aabe75e8d328a20c364cdb488cb Mon Sep 17 00:00:00 2001
From: x-codingman <xinhuishao1996 at gmail.com>
Date: Wed, 18 Jan 2023 20:02:45 +0800
Subject: [PATCH 1/6] update Hello.cpp

---
 llvm/lib/Transforms/Hello/Hello.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/llvm/lib/Transforms/Hello/Hello.cpp b/llvm/lib/Transforms/Hello/Hello.cpp
index b0adb5401f8912..5218d0897000d5 100644
--- a/llvm/lib/Transforms/Hello/Hello.cpp
+++ b/llvm/lib/Transforms/Hello/Hello.cpp
@@ -31,6 +31,7 @@ namespace {
       ++HelloCounter;
       errs() << "Hello: ";
       errs().write_escaped(F.getName()) << '\n';
+      F.setSectionPrefix("mySection")
       return false;
     }
   };

>From adfc72708c57e490d0829344982d5d2c5132e0a1 Mon Sep 17 00:00:00 2001
From: xcodingman <xinhuishao1996 at gmail.com>
Date: Fri, 10 Feb 2023 20:59:20 +0800
Subject: [PATCH 2/6] port shadow stack pass

---
 lld/ELF/Arch/ARM.cpp                          |  12 +
 llvm/include/llvm/CodeGen/MachineBasicBlock.h |  14 +
 llvm/lib/Target/ARM/ARMInstrThumb2.td         |  21 +
 llvm/lib/Target/ARM/ARMRandezvousCLR.cpp      | 335 +++++++
 llvm/lib/Target/ARM/ARMRandezvousCLR.h        |  54 ++
 .../Target/ARM/ARMRandezvousInstrumentor.cpp  | 824 +++++++++++++++++
 .../Target/ARM/ARMRandezvousInstrumentor.h    | 178 ++++
 llvm/lib/Target/ARM/ARMRandezvousOptions.cpp  | 210 +++++
 llvm/lib/Target/ARM/ARMRandezvousOptions.h    |  63 ++
 .../Target/ARM/ARMRandezvousShadowStack.cpp   | 861 ++++++++++++++++++
 .../lib/Target/ARM/ARMRandezvousShadowStack.h |  40 +
 llvm/lib/Target/ARM/ARMTargetMachine.cpp      |   9 +
 llvm/lib/Target/ARM/CMakeLists.txt            |   9 +
 .../Target/ARM/MCTargetDesc/ARMAsmBackend.cpp |  30 +
 .../ARM/MCTargetDesc/ARMELFObjectWriter.cpp   |  12 +
 .../Target/ARM/MCTargetDesc/ARMFixupKinds.h   |   3 +-
 .../ARM/MCTargetDesc/ARMMCCodeEmitter.cpp     |   4 +
 llvm/lib/Transforms/Hello/Hello.cpp           |   2 +-
 18 files changed, 2679 insertions(+), 2 deletions(-)
 create mode 100644 llvm/lib/Target/ARM/ARMRandezvousCLR.cpp
 create mode 100644 llvm/lib/Target/ARM/ARMRandezvousCLR.h
 create mode 100644 llvm/lib/Target/ARM/ARMRandezvousInstrumentor.cpp
 create mode 100644 llvm/lib/Target/ARM/ARMRandezvousInstrumentor.h
 create mode 100644 llvm/lib/Target/ARM/ARMRandezvousOptions.cpp
 create mode 100644 llvm/lib/Target/ARM/ARMRandezvousOptions.h
 create mode 100644 llvm/lib/Target/ARM/ARMRandezvousShadowStack.cpp
 create mode 100644 llvm/lib/Target/ARM/ARMRandezvousShadowStack.h

diff --git a/lld/ELF/Arch/ARM.cpp b/lld/ELF/Arch/ARM.cpp
index 24d78ebf58203c..49ca1dab20ee8e 100644
--- a/lld/ELF/Arch/ARM.cpp
+++ b/lld/ELF/Arch/ARM.cpp
@@ -848,6 +848,18 @@ int64_t ARM::getImplicitAddend(const uint8_t *buf, RelType type) const {
                             ((lo & 0x7000) >> 4) |  // imm3
                             (lo & 0x00ff));         // imm8
   }
+
+  case R_ARM_PRIVATE_14:
+    // Encoding T2: A = imm4:imm12
+    write16le(loc, (read16le(loc) & ~0x000f) | ((val >> 28) & 0x000f));
+    write16le(loc + 2, (read16le(loc + 2) & ~0x0fff) | ((val >> 16) & 0x0fff));
+    break;
+  case R_ARM_PRIVATE_15:
+    // Encoding T2: A = imm4:imm12
+    write16le(loc, (read16le(loc) & ~0x000f) | ((val >> 12) & 0x000f));
+    write16le(loc + 2, (read16le(loc + 2) & ~0x0fff) | (val & 0x0fff));
+    break;
+    
   case R_ARM_ALU_PC_G0:
   case R_ARM_ALU_PC_G0_NC:
   case R_ARM_ALU_PC_G1:
diff --git a/llvm/include/llvm/CodeGen/MachineBasicBlock.h b/llvm/include/llvm/CodeGen/MachineBasicBlock.h
index 1ab24b554f5b5e..6e4da3676929f4 100644
--- a/llvm/include/llvm/CodeGen/MachineBasicBlock.h
+++ b/llvm/include/llvm/CodeGen/MachineBasicBlock.h
@@ -185,6 +185,9 @@ class MachineBasicBlock
   /// Indicate that this basic block is the indirect dest of an INLINEASM_BR.
   bool IsInlineAsmBrIndirectTarget = false;
 
+  /// Indicate that this basic block is a trap block inserted by ARM Randezvous
+  /// Code Layout Randomization pass.
+  bool IsRandezvousTrapBlock = false;
   /// since getSymbol is a relatively heavy-weight operation, the symbol
   /// is only computed once and is cached.
   mutable MCSymbol *CachedMCSymbol = nullptr;
@@ -667,7 +670,18 @@ class MachineBasicBlock
   void setIsInlineAsmBrIndirectTarget(bool V = true) {
     IsInlineAsmBrIndirectTarget = V;
   }
+  
+  /// Returns true if this is a trap block inserted by ARM Randezvous Code
+  /// Layout Randomization pass.
+  bool isRandezvousTrapBlock() const {
+    return IsRandezvousTrapBlock;
+  }
 
+  /// Indicates if this is a trap block inserted by ARM Randezvous Code Layout
+  /// Randomization pass.
+  void setIsRandezvousTrapBlock(bool V = true) {
+    IsRandezvousTrapBlock = V;
+  }
   /// Returns true if it is legal to hoist instructions into this block.
   bool isLegalToHoistInto() const;
 
diff --git a/llvm/lib/Target/ARM/ARMInstrThumb2.td b/llvm/lib/Target/ARM/ARMInstrThumb2.td
index d8721cbebd2dc2..248362b108d0c3 100644
--- a/llvm/lib/Target/ARM/ARMInstrThumb2.td
+++ b/llvm/lib/Target/ARM/ARMInstrThumb2.td
@@ -1506,6 +1506,14 @@ def : T2Pat<(extloadi16 (ARMWrapper tconstpool:$addr)),
 //        not via pattern.
 
 // Indexed loads
+let isReturn = 1, isTerminator = 1, isBarrier = 1, mayLoad = 1,
+    hasSideEffects = 0, isCodeGenOnly = 1 in
+def t2LDR_PRE_RET : T2Ipreldst<0, 0b10, 1, 1, (outs GPR:$Rt, GPR:$Rn_wb),
+                               (ins t2addrmode_imm8_pre:$addr),
+                               AddrModeT2_i8, IndexModePre, IIC_iLoad_iu,
+                               "ldr", "\t$Rt, $addr!", "$addr.base = $Rn_wb",
+                               []>,
+                    Sched<[WriteLd]>;
 
 let mayLoad = 1, hasSideEffects = 0 in {
 def t2LDR_PRE  : T2Ipreldst<0, 0b10, 1, 1, (outs GPR:$Rt, GPR:$Rn_wb),
@@ -2846,6 +2854,19 @@ def t2UDF : T2XI<(outs), (ins imm0_65535:$imm16), IIC_Br, "udf.w\t$imm16",
   let Inst{11-0} = imm16{11-0};
 }
 
+let isCodeGenOnly = 1 in
+def t2UDF_ga : T2XI<(outs), (ins imm0_65535_expr:$imm16), IIC_Br,
+                    "udf.w\t$imm16", []>, Sched<[WriteBr]> {
+  bits<16> imm16;
+  let Inst{31-29} = 0b111;
+  let Inst{28-27} = 0b10;
+  let Inst{26-20} = 0b1111111;
+  let Inst{19-16} = imm16{15-12};
+  let Inst{15} = 0b1;
+  let Inst{14-12} = 0b010;
+  let Inst{11-0} = imm16{11-0};
+}
+
 // A8.6.18  BFI - Bitfield insert (Encoding T1)
 let Constraints = "$src = $Rd" in {
   def t2BFI : T2TwoRegBitFI<(outs rGPR:$Rd),
diff --git a/llvm/lib/Target/ARM/ARMRandezvousCLR.cpp b/llvm/lib/Target/ARM/ARMRandezvousCLR.cpp
new file mode 100644
index 00000000000000..3beda9b8f9018f
--- /dev/null
+++ b/llvm/lib/Target/ARM/ARMRandezvousCLR.cpp
@@ -0,0 +1,335 @@
+//===- ARMRandezvousCLR.cpp - ARM Randezvous Code Layout Randomization ----===//
+//
+// Copyright (c) 2021-2022, University of Rochester
+//
+// Part of the Randezvous Project, under the Apache License v2.0 with
+// LLVM Exceptions.  See LICENSE.txt in the llvm directory for license
+// information.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains the implementation of a pass that randomizes the code
+// layout of ARM machine code.
+//
+//===----------------------------------------------------------------------===//
+
+#define DEBUG_TYPE "arm-randezvous-clr"
+
+#include "ARMRandezvousCLR.h"
+#include "ARMRandezvousOptions.h"
+#include "llvm/ADT/Statistic.h"
+#include "llvm/CodeGen/MachineModuleInfo.h"
+#include "llvm/IR/IRBuilder.h"
+
+using namespace llvm;
+
+char ARMRandezvousCLR::ID = 0;
+
+STATISTIC(NumTraps, "Number of trap instructions inserted");
+STATISTIC(NumFuncsBBLR, "Number of functions with basic blocks reordered");
+STATISTIC(NumJumps4BBLR, "Number of jump instructions inserted due to BBLR");
+STATISTIC(NumFuncsBBCLR, "Number of functions with basic block clusters reordered");
+
+ARMRandezvousCLR::ARMRandezvousCLR(bool LateStage)
+    : ModulePass(ID), LateStage(LateStage) {
+}
+
+StringRef
+ARMRandezvousCLR::getPassName() const {
+  return "ARM Randezvous Code Layout Randomization Pass";
+}
+
+void
+ARMRandezvousCLR::getAnalysisUsage(AnalysisUsage & AU) const {
+  // We need this to access MachineFunctions
+  AU.addRequired<MachineModuleInfoWrapperPass>();
+
+  AU.setPreservesCFG();
+  ModulePass::getAnalysisUsage(AU);
+}
+
+//
+// Method: shuffleMachineBasicBlocks()
+//
+// Description:
+//   This method shuffles the order of MachineBasicBlocks in a MachineFunction.
+//   It shuffles all the basic blocks except the entry block, so fall-through
+//   blocks will be taken apart and branch instructions will be inserted
+//   appropriately to preserve the CFG.
+//
+// Input:
+//   MF - A reference to the MachineFunction.
+//
+// Output:
+//   MF - The transformed MachineFunction.
+//
+void
+ARMRandezvousCLR::shuffleMachineBasicBlocks(MachineFunction & MF) {
+  // Shuffling has no effect on functions with fewer than 3 MachineBasicBlocks
+  // (because we are not reordering the entry block)
+  if (MF.size() < 3) {
+    return;
+  }
+
+  // Add an unconditional branch to all MachineBasicBlocks that fall through so
+  // that we can safely take them apart from their fall-through blocks
+  std::vector<MachineBasicBlock *> MBBs;
+  const TargetInstrInfo * TII = MF.getSubtarget().getInstrInfo();
+  for (MachineBasicBlock & MBB : MF) {
+    MachineBasicBlock * FallThruMBB = MBB.getFallThrough();
+    if (FallThruMBB != nullptr) {
+      BuildMI(MBB, MBB.end(), DebugLoc(), TII->get(ARM::t2B))
+      .addMBB(FallThruMBB)
+      .add(predOps(ARMCC::AL));
+      ++NumJumps4BBLR;
+    }
+    MBBs.push_back(&MBB);
+  }
+
+  // Now do shuffling; ilist (iplist_impl) does not support iterator
+  // increment/decrement so we have to first do out-of-place shuffling and then
+  // do in-place removal and insertion
+  auto & MBBList = (&MF)->*(MachineFunction::getSublistAccess)(nullptr);
+  llvm::shuffle(MBBs.begin() + 1, MBBs.end(), *RNG);
+  for (MachineBasicBlock * MBB : MBBs) {
+    MBBList.remove(MBB);
+  }
+  for (MachineBasicBlock * MBB : MBBs) {
+    MBBList.push_back(MBB);
+  }
+  ++NumFuncsBBLR;
+}
+
+//
+// Method: shuffleMachineBasicBlockClusters()
+//
+// Description:
+//   This method shuffles the order of clusters of MachineBasicBlocks that fall
+//   through in the order as they appear.  It shuffles all the basic block
+//   clusters except the entry cluster.
+//
+// Input:
+//   MF - A reference to the MachineFunction.
+//
+// Output:
+//   MF - The transformed MachineFunction.
+//
+void
+ARMRandezvousCLR::shuffleMachineBasicBlockClusters(MachineFunction & MF) {
+  auto & MBBList = (&MF)->*(MachineFunction::getSublistAccess)(nullptr);
+
+  // Construct a list of clusters
+  std::vector<std::vector<MachineBasicBlock *> *> Clusters;
+  std::vector<MachineBasicBlock *> * CurrentCluster = nullptr;
+  for (MachineBasicBlock & MBB : MF) {
+    if (CurrentCluster == nullptr) {
+      CurrentCluster = new std::vector<MachineBasicBlock *>();
+    }
+    CurrentCluster->push_back(&MBB);
+    if (!MBB.canFallThrough()) {
+      Clusters.push_back(CurrentCluster);
+      CurrentCluster = nullptr;
+    }
+  }
+
+  do {
+    // Shuffling has no effect on functions with fewer than 3 clusters (because
+    // we are not reordering the entry cluster)
+    if (Clusters.size() < 3) {
+      break;
+    }
+
+    // Now do shuffling; ilist (iplist_impl) does not support iterator
+    // increment/decrement so we have to first do out-of-place shuffling and
+    // then do in-place removal and insertion
+    llvm::shuffle(Clusters.begin() + 1, Clusters.end(), *RNG);
+    for (auto * Cluster : Clusters) {
+      for (MachineBasicBlock * MBB : *Cluster) {
+        MBBList.remove(MBB);
+      }
+    }
+    for (auto * Cluster : Clusters) {
+      for (MachineBasicBlock * MBB : *Cluster) {
+        MBBList.push_back(MBB);
+      }
+    }
+    ++NumFuncsBBCLR;
+  } while (false);
+
+  // Garbage collection
+  for (auto * Cluster : Clusters) {
+    delete Cluster;
+  }
+}
+
+//
+// Method: insertTrapBlocks()
+//
+// Description:
+//   This method inserts a given number of trap instructions into a Function
+//   and keeps track of each inserted trap instruction as a single basic block.
+//
+// Inputs:
+//   F            - A reference to the Function.
+//   MF           - A reference to the MachineFunction to which F corresponds.
+//   NumTrapInsts - Total number of trap instructions to insert.
+//
+// Output:
+//   MF - The transformed MachineFunction.
+//
+void
+ARMRandezvousCLR::insertTrapBlocks(Function & F, MachineFunction & MF,
+                                   uint64_t NumTrapInsts) {
+  LLVMContext & Ctx = F.getContext();
+  const TargetInstrInfo * TII = MF.getSubtarget().getInstrInfo();
+
+  //
+  // In machine IR, disperse trap blocks throughout the MachineFunction, where
+  // the insertion points are the MachineBasicBlocks that do not fall through;
+  // this allows us to preserve the CFG while adding randomness to the inside
+  // of the MachineFunction.
+  //
+  // In LLVM IR, simply place trap blocks at the end of the Function.
+  //
+
+  // Determine where to insert trap instructions
+  std::vector<MachineBasicBlock *> InsertionPts;
+  for (MachineBasicBlock & MBB : MF) {
+    if (!MBB.canFallThrough() && !MBB.isRandezvousTrapBlock()) {
+      InsertionPts.push_back(&MBB);
+    }
+  }
+
+  // Determine the numbers of trap instructions to insert at each point
+  uint64_t SumShares = 0;
+  std::vector<uint64_t> Shares(InsertionPts.size());
+  for (uint64_t i = 0; i < InsertionPts.size(); ++i) {
+    Shares[i] = (*RNG)() & 0xffffffff; // Prevent overflow
+    SumShares += Shares[i];
+  }
+  for (uint64_t i = 0; i < InsertionPts.size(); ++i) {
+    Shares[i] = Shares[i] * NumTrapInsts / SumShares;
+  }
+
+  // Do insertion
+  for (uint64_t i = 0; i < InsertionPts.size(); ++i) {
+    for (uint64_t j = 0; j < Shares[i]; ++j) {
+      // Build an IR basic block
+      BasicBlock * BB = BasicBlock::Create(Ctx, "", &F);
+      IRBuilder<> IRB(BB);
+      IRB.CreateUnreachable();
+
+      // Build a machine IR basic block
+      MachineBasicBlock * MBB = MF.CreateMachineBasicBlock(BB);
+      BuildMI(MBB, DebugLoc(), TII->get(ARM::t2UDF_ga)).addImm(0);
+      MF.push_back(MBB);
+      MBB->moveAfter(InsertionPts[i]);
+      MBB->setMachineBlockAddressTaken();
+      MBB->setIsRandezvousTrapBlock();
+
+      ++NumTraps;
+    }
+  }
+}
+
+//
+// Method: runOnModule()
+//
+// Description:
+//   This method is called when the PassManager wants this pass to transform
+//   the specified Module.  This method shuffles the order of functions within
+//   the module and/or the order of basic blocks within each function, and
+//   inserts trap instructions to fill the text section.
+//
+// Input:
+//   M - A reference to the Module to transform.
+//
+// Output:
+//   M - The transformed Module.
+//
+// Return value:
+//   true  - The Module was transformed.
+//   false - The Module was not transformed.
+//
+bool
+ARMRandezvousCLR::runOnModule(Module & M) {
+  if (!EnableRandezvousCLR) {
+    return false;
+  }
+
+  MachineModuleInfo & MMI = getAnalysis<MachineModuleInfoWrapperPass>().getMMI();
+  Twine RNGName = getPassName() + "-" + Twine(RandezvousCLRSeed);
+  RNG = M.createRNG(RNGName.str());
+
+  // First, shuffle the order of basic blocks in each function (if requested
+  // and at the late stage) and calculate how much space existing functions
+  // have taken up
+  uint64_t TotalTextSize = 0;
+  std::vector<std::pair<Function *, MachineFunction *> > Functions;
+  for (Function & F : M) {
+    MachineFunction * MF = MMI.getMachineFunction(F);
+    if (MF == nullptr) {
+      continue;
+    }
+
+    if (LateStage) {
+      if (EnableRandezvousBBLR) {
+        shuffleMachineBasicBlocks(*MF);
+      } else if (EnableRandezvousBBCLR) {
+        shuffleMachineBasicBlockClusters(*MF);
+      }
+    }
+
+    uint64_t TextSize = getFunctionCodeSize(*MF);
+    if (TextSize != 0) {
+      Functions.push_back(std::make_pair(&F, MF));
+      TotalTextSize += TextSize;
+    }
+  }
+  assert(TotalTextSize <= RandezvousMaxTextSize && "Text size exceeds the limit");
+
+  if (LateStage) {
+    // Second, shuffle the order of functions; SymbolTableList (iplist_impl)
+    // does not support iterator increment/decrement so we have to first do
+    // out-of-place shuffling and then do in-place removal and insertion
+    SymbolTableList<Function> & FunctionList = M.getFunctionList();
+    llvm::shuffle(Functions.begin(), Functions.end(), *RNG);
+    for (auto & FMF : Functions) {
+      FunctionList.remove(FMF.first);
+    }
+    for (auto & FMF : Functions) {
+      FunctionList.push_back(FMF.first);
+    }
+  }
+
+  // Third, determine the numbers of trap instructions to insert
+  uint64_t NumTrapInsts = (RandezvousMaxTextSize - TotalTextSize) / 4;
+  uint64_t SumShares = 0;
+  std::vector<uint64_t> Shares(Functions.size());
+  if (!LateStage) {
+    // Insert 80% of trap instructions during the early stage; this allows most
+    // of trap blocks to be consumed by later passes while still keeping a
+    // considerable code size budget for later passes and the late-stage CLR
+    // pass
+    NumTrapInsts = NumTrapInsts * 80 / 100;
+  }
+  for (uint64_t i = 0; i < Functions.size(); ++i) {
+    Shares[i] = (*RNG)() & 0xffffffff; // Prevent overflow
+    SumShares += Shares[i];
+  }
+  for (uint64_t i = 0; i < Functions.size(); ++i) {
+    Shares[i] = Shares[i] * NumTrapInsts / SumShares;
+  }
+
+  // Lastly, insert trap instructions into each function
+  for (uint64_t i = 0; i < Functions.size(); ++i) {
+    insertTrapBlocks(*Functions[i].first, *Functions[i].second, Shares[i]);
+  }
+
+  return true;
+}
+
+ModulePass *
+llvm::createARMRandezvousCLR(bool EarlyTrapInsertion) {
+  return new ARMRandezvousCLR(EarlyTrapInsertion);
+}
\ No newline at end of file
diff --git a/llvm/lib/Target/ARM/ARMRandezvousCLR.h b/llvm/lib/Target/ARM/ARMRandezvousCLR.h
new file mode 100644
index 00000000000000..b54e6438c8ff25
--- /dev/null
+++ b/llvm/lib/Target/ARM/ARMRandezvousCLR.h
@@ -0,0 +1,54 @@
+//===- ARMRandezvousCLR.h - ARM Randezvous Code Layout Randomization ------===//
+//
+// Copyright (c) 2021-2022, University of Rochester
+//
+// Part of the Randezvous Project, under the Apache License v2.0 with
+// LLVM Exceptions.  See LICENSE.txt in the llvm directory for license
+// information.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the interfaces of a pass that randomizes the code layout
+// of ARM machine code.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef ARM_RANDEZVOUS_CLR
+#define ARM_RANDEZVOUS_CLR
+
+#include "ARMRandezvousInstrumentor.h"
+#include "llvm/Pass.h"
+#include "llvm/Support/RandomNumberGenerator.h"
+
+namespace llvm {
+  struct ARMRandezvousCLR : public ModulePass, ARMRandezvousInstrumentor {
+    // Pass Identifier
+    static char ID;
+
+    ARMRandezvousCLR(bool LateStage);
+    virtual StringRef getPassName() const override;
+    void getAnalysisUsage(AnalysisUsage & AU) const override;
+    virtual bool runOnModule(Module & M) override;
+
+  private:
+    // Which stage we are at:
+    //
+    // * Early stage: insert most of trap instructions for trap block consumers
+    //                between early and late stages
+    //
+    // * Late stage: shuffle code layout and insert the rest of trap
+    //               instructions
+    bool LateStage = false;
+
+    std::unique_ptr<RandomNumberGenerator> RNG;
+
+    void shuffleMachineBasicBlocks(MachineFunction & MF);
+    void shuffleMachineBasicBlockClusters(MachineFunction & MF);
+    void insertTrapBlocks(Function & F, MachineFunction & MF,
+                          uint64_t NumTrapInsts);
+  };
+
+  ModulePass * createARMRandezvousCLR(bool LateStage);
+}
+
+#endif
\ No newline at end of file
diff --git a/llvm/lib/Target/ARM/ARMRandezvousInstrumentor.cpp b/llvm/lib/Target/ARM/ARMRandezvousInstrumentor.cpp
new file mode 100644
index 00000000000000..af62fc2de7604b
--- /dev/null
+++ b/llvm/lib/Target/ARM/ARMRandezvousInstrumentor.cpp
@@ -0,0 +1,824 @@
+//===- ARMRandezvousInstrumentor.cpp - A helper class for instrumentation -===//
+//
+// Copyright (c) 2021-2022, University of Rochester
+//
+// Part of the Randezvous Project, under the Apache License v2.0 with
+// LLVM Exceptions.  See LICENSE.txt in the llvm directory for license
+// information.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains the implementation of a class that can help passes of
+// its subclass easily instrument ARM machine IR without concerns of breaking
+// IT blocks.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ARMRandezvousInstrumentor.h"
+#include "llvm/CodeGen/LivePhysRegs.h"
+#include "llvm/CodeGen/MachineInstrBuilder.h"
+
+using namespace llvm;
+
+//
+// Method: getITBlockSize()
+//
+// Description:
+//   This method computes how many predicated instructions an IT instruction
+//   covers.
+//
+// Input:
+//   IT - A reference to an IT instruction.
+//
+// Return value:
+//   The number of predicated instructions IT covers.
+//
+unsigned
+ARMRandezvousInstrumentor::getITBlockSize(const MachineInstr & IT) {
+  assert(IT.getOpcode() == ARM::t2IT && "Not an IT instruction!");
+
+  unsigned Mask = IT.getOperand(1).getImm() & 0xf;
+  assert(Mask != 0 && "Invalid IT mask!");
+
+  if (Mask & 0x1) {
+    return 4;
+  } else if (Mask & 0x2) {
+    return 3;
+  } else if (Mask & 0x4) {
+    return 2;
+  } else {
+    return 1;
+  }
+}
+
+//
+// Method: findIT()
+//
+// Description:
+//   This method finds the IT instruction that forms an IT block containing a
+//   given instruction MI.  It also computes the distance (from 0 to 4, 0 means
+//   MI itself is IT) between the IT and MI.  If there is no such IT, a null
+//   pointer is returned.
+//
+// Input:
+//   MI - A reference to an instruction from which to find IT.
+//
+// Output:
+//   distance - A reference to an unsigned to store the distance.
+//
+// Return value:
+//   A pointer to IT if found, nullptr otherwise.
+//
+MachineInstr *
+ARMRandezvousInstrumentor::findIT(MachineInstr & MI, unsigned & distance) {
+  MachineInstr * Prev = &MI;
+  unsigned dist = 0;
+  while (Prev != nullptr && dist < 5 && Prev->getOpcode() != ARM::t2IT) {
+    // Only count non-meta instructions
+    if (!Prev->isMetaInstruction()) {
+      ++dist;
+    }
+    Prev = Prev->getPrevNode();
+  }
+  if (Prev != nullptr && dist < 5 && Prev->getOpcode() == ARM::t2IT) {
+    if (getITBlockSize(*Prev) >= dist) {
+      distance = dist;
+      return Prev;
+    }
+  }
+  return nullptr;
+}
+
+//
+// Method: findIT()
+//
+// Description:
+//   This method finds the IT instruction that forms an IT block containing a
+//   given instruction MI.  It also computes the distance (from 0 to 4, 0 means
+//   MI itself is IT) between the IT and MI.  If there is no such IT, a null
+//   pointer is returned.
+//
+// Input:
+//   MI - A const reference to an instruction from which to find IT.
+//
+// Output:
+//   distance - A reference to an unsigned to store the distance.
+//
+// Return value:
+//   A const pointer to IT if found, nullptr otherwise.
+//
+const MachineInstr *
+ARMRandezvousInstrumentor::findIT(const MachineInstr & MI, unsigned & distance) {
+  return findIT(const_cast<MachineInstr &>(MI), distance);
+}
+
+//
+// Method: insertInstBefore()
+//
+// Description:
+//   This method inserts an instruction Inst before a given instruction MI.  If
+//   MI is a predicated instruction within an IT block, then Inst will have the
+//   same predicate as MI and also end up in an IT block.
+//
+// Inputs:
+//   MI   - A reference to an instruction before which to insert Inst.
+//   Inst - A pointer to an instruction to insert.
+//
+void
+ARMRandezvousInstrumentor::insertInstBefore(MachineInstr & MI,
+                                            MachineInstr * Inst) {
+  insertInstsBefore(MI, { Inst });
+}
+
+//
+// Method: insertInstAfter()
+//
+// Description:
+//   This method inserts an instruction Inst after a given instruction MI.  If
+//   MI is a predicated instruction within an IT block, then Inst will have the
+//   same predicate as MI and also end up in an IT block.
+//
+// Inputs:
+//   MI   - A reference to an instruction after which to insert Inst.
+//   Inst - A pointer to an instruction to insert.
+//
+void
+ARMRandezvousInstrumentor::insertInstAfter(MachineInstr & MI,
+                                           MachineInstr * Inst) {
+  insertInstsAfter(MI, { Inst });
+}
+
+//
+// Method: insertInstsBefore()
+//
+// Description:
+//   This method inserts a group of instructions contained in an array before a
+//   given instruction MI.  If MI is a predicated instruction within an IT
+//   block, then the new instructions will have the same predicate as MI and
+//   also end up in one or more IT blocks.
+//
+// Inputs:
+//   MI    - A reference to an instruction before which to insert instructions.
+//   Insts - A reference to an array containing the instructions.
+//
+void
+ARMRandezvousInstrumentor::insertInstsBefore(MachineInstr & MI,
+                                             ArrayRef<MachineInstr *> Insts) {
+  assert(!MI.isMetaInstruction() && "Cannot instrument meta instruction!");
+
+  MachineFunction & MF = *MI.getMF();
+  MachineBasicBlock & MBB = *MI.getParent();
+  const TargetInstrInfo * TII = MF.getSubtarget().getInstrInfo();
+
+  unsigned distance;
+  MachineInstr * IT = findIT(MI, distance);
+
+  // Do insert new instructions before MI
+  for (MachineInstr * Inst : Insts) {
+    MBB.insert(MI, Inst);
+  }
+
+  // If MI is inside an IT block, we should make sure to cover all new
+  // instructions with IT(s)
+  if (IT != nullptr && distance != 0) {
+    unsigned ITBlockSize = getITBlockSize(*IT);
+    unsigned Mask = IT->getOperand(1).getImm() & 0xf;
+    ARMCC::CondCodes firstCond = (ARMCC::CondCodes)IT->getOperand(0).getImm();
+    std::deque<bool> DQMask = decodeITMask(Mask);
+    bool sameAsFirstCond = DQMask[distance - 1];
+
+    // Find the range of instructions that are supposed to be in IT block(s)
+    MachineBasicBlock::iterator firstMI(IT->getNextNode()); // Inclusive
+    MachineBasicBlock::iterator lastMI(MI);                 // Non-inclusive
+    for (unsigned i = distance; i <= ITBlockSize; ) {
+      ++lastMI;
+      // Skip meta instructions if we have not reached the end
+      if (i == ITBlockSize || !lastMI->isMetaInstruction()) {
+        ++i;
+      }
+    }
+
+    // Track new non-meta instructions in DQMask
+    auto it = DQMask.begin();
+    for (unsigned i = 0; i < distance - 1; ++i) {
+      it++;
+    }
+    size_t NumRealInsts = Insts.size();
+    for (MachineInstr * Inst : Insts) {
+      if (Inst->isMetaInstruction()) {
+        --NumRealInsts;
+      }
+    }
+    DQMask.insert(it, NumRealInsts, sameAsFirstCond);
+
+    // Insert ITs to cover instructions in [firstMI, lastMI)
+    for (MachineBasicBlock::iterator i(firstMI); i != lastMI; ) {
+      std::deque<bool> NewDQMask;
+      MachineBasicBlock::iterator j(i);
+      for (unsigned k = 0; k < 4 && j != lastMI; ++j) {
+        if (j->isMetaInstruction()) {
+          continue;
+        }
+        NewDQMask.push_back(DQMask.front());
+        DQMask.pop_front();
+        ++k;
+      }
+      bool flip = false;
+      if (!NewDQMask[0]) {
+        for (unsigned k = 0; k < NewDQMask.size(); ++k) {
+          NewDQMask[k] = !NewDQMask[k];
+        }
+        flip = true;
+      }
+      BuildMI(MBB, i, IT->getDebugLoc(), TII->get(ARM::t2IT))
+      .addImm(flip ? ARMCC::getOppositeCondition(firstCond) : firstCond)
+      .addImm(encodeITMask(NewDQMask));
+      i = j; // Update i here
+    }
+
+    // Remove the original IT
+    IT->eraseFromParent();
+  }
+}
+
+//
+// Method: insertInstsAfter()
+//
+// Description:
+//   This method inserts a group of instructions contained in an array after a
+//   given instruction MI.  If MI is a predicated instruction within an IT
+//   block, then the new instructions will have the same predicate as MI and
+//   also end up in one or more IT blocks.
+//
+// Inputs:
+//   MI    - A reference to an instruction after which to insert instructions.
+//   Insts - A reference to an array containing the instructions.
+//
+void
+ARMRandezvousInstrumentor::insertInstsAfter(MachineInstr & MI,
+                                            ArrayRef<MachineInstr *> Insts) {
+  assert(!MI.isMetaInstruction() && "Cannot instrument meta instruction!");
+
+  MachineFunction & MF = *MI.getMF();
+  MachineBasicBlock & MBB = *MI.getParent();
+  const TargetInstrInfo * TII = MF.getSubtarget().getInstrInfo();
+  MachineBasicBlock::iterator NextMI(MI); ++NextMI;
+
+  unsigned distance;
+  MachineInstr * IT = findIT(MI, distance);
+
+  // Do insert new instructions after MI
+  for (MachineInstr * Inst : Insts) {
+    MBB.insert(NextMI, Inst);
+  }
+
+  // If MI is inside an IT block, we should make sure to cover all new
+  // instructions with IT(s)
+  if (IT != nullptr && distance != 0) {
+    unsigned ITBlockSize = getITBlockSize(*IT);
+    unsigned Mask = IT->getOperand(1).getImm() & 0xf;
+    ARMCC::CondCodes firstCond = (ARMCC::CondCodes)IT->getOperand(0).getImm();
+    std::deque<bool> DQMask = decodeITMask(Mask);
+    bool sameAsFirstCond = DQMask[distance - 1];
+
+    // Find the range of instructions that are supposed to be in IT block(s)
+    MachineBasicBlock::iterator firstMI(IT->getNextNode()); // Inclusive
+    MachineBasicBlock::iterator lastMI(Insts.back());       // Non-inclusive
+    for (unsigned i = distance; i <= ITBlockSize; ) {
+      ++lastMI;
+      // Skip meta instructions if we have not reached the end
+      if (i == ITBlockSize || !lastMI->isMetaInstruction()) {
+        ++i;
+      }
+    }
+
+    // Track new non-meta instructions in DQMask
+    auto it = DQMask.begin();
+    for (unsigned i = 0; i <= distance - 1; ++i) {
+      it++;
+    }
+    size_t NumRealInsts = Insts.size();
+    for (MachineInstr * Inst : Insts) {
+      if (Inst->isMetaInstruction()) {
+        --NumRealInsts;
+      }
+    }
+    DQMask.insert(it, NumRealInsts, sameAsFirstCond);
+
+    // Insert ITs to cover instructions in [firstMI, lastMI)
+    for (MachineBasicBlock::iterator i(firstMI); i != lastMI; ) {
+      std::deque<bool> NewDQMask;
+      MachineBasicBlock::iterator j(i);
+      for (unsigned k = 0; k < 4 && j != lastMI; ++j) {
+        if (j->isMetaInstruction()) {
+          continue;
+        }
+        NewDQMask.push_back(DQMask.front());
+        DQMask.pop_front();
+        ++k;
+      }
+      bool flip = false;
+      if (!NewDQMask[0]) {
+        for (unsigned k = 0; k < NewDQMask.size(); ++k) {
+          NewDQMask[k] = !NewDQMask[k];
+        }
+        flip = true;
+      }
+      BuildMI(MBB, i, IT->getDebugLoc(), TII->get(ARM::t2IT))
+      .addImm(flip ? ARMCC::getOppositeCondition(firstCond) : firstCond)
+      .addImm(encodeITMask(NewDQMask));
+      i = j; // Update i here
+    }
+
+    // Remove the original IT
+    IT->eraseFromParent();
+  }
+}
+
+//
+// Method: removeInst()
+//
+// Description:
+//   This method removes a given instruction MI from machine IR.  If MI is a
+//   predicated instruction within an IT block, then its corresponding IT
+//   instruction will be updated or removed as well.  Note that MI cannot be an
+//   IT instruction itself.
+//
+// Input:
+//   MI - A reference to the instruction to remove.
+//
+void
+ARMRandezvousInstrumentor::removeInst(MachineInstr & MI) {
+  assert(!MI.isMetaInstruction() && "Cannot instrument meta instruction!");
+
+  unsigned distance;
+  MachineInstr * IT = findIT(MI, distance);
+
+  // If MI was inside an IT block, we should make sure to update/remove the IT
+  // instruction
+  if (IT != nullptr) {
+    assert(distance != 0 && "Cannot remove an IT instruction directly!");
+
+    unsigned Mask = IT->getOperand(1).getImm() & 0xf;
+    ARMCC::CondCodes firstCond = (ARMCC::CondCodes)IT->getOperand(0).getImm();
+    std::deque<bool> DQMask = decodeITMask(Mask);
+
+    // Remove MI's entry from DQMask
+    auto it = DQMask.begin();
+    for (unsigned i = 0; i < distance - 1; ++i) {
+      it++;
+    }
+    DQMask.erase(it);
+
+    // Remove IT as well if MI was the only instruction in the IT block
+    if (DQMask.empty()) {
+      IT->eraseFromParent();
+    } else {
+      // If MI was the first instruction in the IT block, removing MI might
+      // change the first condition, in which case we need to flip it
+      if (!DQMask[0]) {
+        for (unsigned i = 0; i < DQMask.size(); ++i) {
+          DQMask[i] = !DQMask[i];
+        }
+        IT->getOperand(0).setImm(ARMCC::getOppositeCondition(firstCond));
+      }
+      // Update the IT mask
+      IT->getOperand(1).setImm(encodeITMask(DQMask));
+    }
+  }
+
+  // Now do remove MI
+  MI.eraseFromParent();
+}
+
+//
+// Method: splitBasicBlockBefore()
+//
+// Description:
+//   This method splits a basic block into two basic blocks at the point right
+//   before a given instruction MI.  If MI is the first instruction in the
+//   basic block, an empty basic block will be created.  If MI is a predicated
+//   instruction within an IT block, then a new IT instruction will be inserted
+//   at the beginning of the new basic block to cover MI and any succeeding
+//   instructions that were in the original IT block.  In that case, the old IT
+//   instruction will also be updated accordingly.
+//
+// Input:
+//   MI - A reference to an instruction before which to split the basic block.
+//
+// Return value:
+//   A pointer to the new basic block that contains MI.
+//
+MachineBasicBlock *
+ARMRandezvousInstrumentor::splitBasicBlockBefore(MachineInstr & MI) {
+  assert(!MI.isMetaInstruction() && "Cannot instrument meta instruction!");
+
+  unsigned distance;
+  MachineInstr * IT = findIT(MI, distance);
+
+  MachineFunction & MF = *MI.getMF();
+  MachineBasicBlock & MBB = *MI.getParent();
+  const TargetInstrInfo * TII = MF.getSubtarget().getInstrInfo();
+
+  // Create a new basic block
+  MachineBasicBlock & NewMBB = *MF.CreateMachineBasicBlock(MBB.getBasicBlock());
+  MF.push_back(&NewMBB);
+  NewMBB.moveAfter(&MBB);
+
+  // Move instructions from the old basic block to the new basic block
+  NewMBB.splice(NewMBB.end(), &MBB, &MI, MBB.end());
+
+  // Move successors from the old basic block to the new basic block
+  NewMBB.transferSuccessors(&MBB);
+  MBB.addSuccessor(&NewMBB);
+
+  // If MI was inside an IT block (but not the IT instruction itself), we
+  // should make sure to update/remove the IT instruction and insert a new IT
+  // in the new basic block
+  if (IT != nullptr && distance > 0) {
+    // Shortcut for just moving the IT over
+    if (distance == 1) {
+      NewMBB.splice(&MI, &MBB, IT);
+    } else {
+      unsigned Mask = IT->getOperand(1).getImm() & 0xf;
+      ARMCC::CondCodes firstCond = (ARMCC::CondCodes)IT->getOperand(0).getImm();
+      std::deque<bool> DQMask = decodeITMask(Mask);
+
+      // Create a new DQMask and adjust both
+      auto it = DQMask.begin();
+      for (unsigned i = 0; i < distance - 1; ++i) {
+        it++;
+      }
+      std::deque<bool> NewDQMask(it, DQMask.end());
+      DQMask.erase(it, DQMask.end());
+
+      // Update the old IT mask
+      IT->getOperand(1).setImm(encodeITMask(DQMask));
+
+      // Create a new IT
+      bool flip = false;
+      if (!NewDQMask[0]) {
+        for (unsigned i = 0; i < NewDQMask.size(); ++i) {
+          NewDQMask[i] = !NewDQMask[i];
+        }
+        flip = true;
+      }
+      BuildMI(NewMBB, MI, IT->getDebugLoc(), TII->get(ARM::t2IT))
+      .addImm(flip ? ARMCC::getOppositeCondition(firstCond) : firstCond)
+      .addImm(encodeITMask(NewDQMask));
+    }
+  }
+
+  return &NewMBB;
+}
+
+//
+// Method: splitBasicBlockAfter()
+//
+// Description:
+//   This method splits a basic block into two basic blocks at the point right
+//   after a given instruction MI.  If MI is the last instruction in the basic
+//   block, an empty basic block will be created.  If MI is a predicated
+//   instruction within an IT block and is not the last one, then a new IT
+//   instruction will be inserted at the beginning of the new basic block to
+//   cover MI's succeeding instructions that were in the original IT block.  In
+//   that case, the old IT instruction will also be updated accordingly.
+//
+// Input:
+//   MI - A reference to an instruction after which to split the basic block.
+//
+// Return value:
+//   A pointer to the new basic block that contains MI's next instruction if
+//   the split was done, nullptr otherwise.
+//
+MachineBasicBlock *
+ARMRandezvousInstrumentor::splitBasicBlockAfter(MachineInstr & MI) {
+  assert(!MI.isMetaInstruction() && "Cannot instrument meta instruction!");
+
+  unsigned distance;
+  MachineInstr * IT = findIT(MI, distance);
+
+  MachineFunction & MF = *MI.getMF();
+  MachineBasicBlock & MBB = *MI.getParent();
+  const TargetInstrInfo * TII = MF.getSubtarget().getInstrInfo();
+
+  // Create a new basic block
+  MachineBasicBlock & NewMBB = *MF.CreateMachineBasicBlock(MBB.getBasicBlock());
+  MF.push_back(&NewMBB);
+  NewMBB.moveAfter(&MBB);
+
+  // Move instructions from the old basic block to the new basic block
+  MachineBasicBlock::iterator next = ++MI.getIterator();
+  NewMBB.splice(NewMBB.end(), &MBB, next, MBB.end());
+
+  // Move successors from the old basic block to the new basic block
+  NewMBB.transferSuccessors(&MBB);
+  MBB.addSuccessor(&NewMBB);
+
+  // If MI was inside an IT block and is not the last one, we should make sure
+  // to update/remove the IT instruction and insert a new IT in the new basic
+  // block
+  if (IT != nullptr && distance < 4) {
+    // Shortcut for just moving the IT over
+    if (distance == 0) {
+      NewMBB.splice(NewMBB.begin(), &MBB, IT);
+    } else {
+      unsigned Mask = IT->getOperand(1).getImm() & 0xf;
+      ARMCC::CondCodes firstCond = (ARMCC::CondCodes)IT->getOperand(0).getImm();
+      std::deque<bool> DQMask = decodeITMask(Mask);
+
+      // Create a new DQMask and adjust both
+      auto it = DQMask.begin();
+      for (unsigned i = 0; i < distance; ++i) {
+        it++;
+      }
+      std::deque<bool> NewDQMask(it, DQMask.end());
+      DQMask.erase(it, DQMask.end());
+
+      // Update the old IT mask
+      IT->getOperand(1).setImm(encodeITMask(DQMask));
+
+      // Create a new IT
+      bool flip = false;
+      if (!NewDQMask[0]) {
+        for (unsigned i = 0; i < NewDQMask.size(); ++i) {
+          NewDQMask[i] = !NewDQMask[i];
+        }
+        flip = true;
+      }
+      BuildMI(NewMBB, NewMBB.begin(), IT->getDebugLoc(), TII->get(ARM::t2IT))
+      .addImm(flip ? ARMCC::getOppositeCondition(firstCond) : firstCond)
+      .addImm(encodeITMask(NewDQMask));
+    }
+  }
+
+  return &NewMBB;
+}
+
+//
+// Method: decodeITMask()
+//
+// Description:
+//   This method decodes an IT mask in LLVM's representation and puts a list of
+//   boolean values in a deque to return.  The boolean values represent whether
+//   their corresponding instructions in an IT block have the same predicate as
+//   the first one (which indicates that the first boolean value is always
+//   true).
+//
+// Input:
+//   Mask - The IT mask in LLVM's representation (immediate value of the second
+//          operand of a t2IT instruction).
+//
+// Return value:
+//   A deque of boolean values (see the above description).
+//
+std::deque<bool>
+ARMRandezvousInstrumentor::decodeITMask(unsigned Mask) {
+  Mask &= 0xf;
+  assert(Mask != 0 && "Invalid IT mask!");
+
+  std::deque<bool> DQMask { true };
+  unsigned size = 4;
+  for (unsigned i = 0x1; i < 0x10; i <<= 1) {
+    if (Mask & i) {
+      break;
+    }
+    --size;
+  }
+  for (unsigned i = 3; i > 4 - size; --i) {
+    DQMask.push_back((Mask & (1 << i)) == 0);
+  }
+
+  return DQMask;
+}
+
+//
+// Method: encodeITMask()
+//
+// Description:
+//   This method takes an IT mask in the form of a list of boolean values and
+//   encodes it into LLVM's representation.  The boolean values represent
+//   whether their corresponding instructions in an IT block have the same
+//   predicate as the first one (which requires that the first boolean value
+//   be always true).
+//
+// Input:
+//   DQMask - An IT mask in the form of a list of boolean values.
+//
+// Return value:
+//   The IT mask in LLVM's representation (immediate value of the second
+//   operand of a t2IT instruction).
+//
+unsigned
+ARMRandezvousInstrumentor::encodeITMask(std::deque<bool> DQMask) {
+  assert(!DQMask.empty() && "Invalid deque representation of an IT mask!");
+  assert(DQMask.size() <= 4 && "Invalid deque representation of an IT mask!");
+  assert(DQMask[0] && "Invalid deque representation of an IT mask!");
+
+  unsigned Mask = 0;
+  for (unsigned i = 1; i < DQMask.size(); ++i) {
+    Mask |= DQMask[i] ? 0 : 1;
+    Mask <<= 1;
+  }
+  Mask |= 1;
+  Mask <<= (4 - DQMask.size());
+
+  return Mask;
+}
+
+//
+// Method: findFreeRegistersBefore()
+//
+// Description:
+//   This method computes the liveness of ARM core registers before a given
+//   instruction MI and returns a list of free core registers that can be
+//   used for instrumentation purposes.
+//
+// Inputs:
+//   MI    - A reference to the instruction before which to find free
+//           registers.
+//   Thumb - Whether we are looking for Thumb registers (low registers, i,e,,
+//           R0 -- R7) or ARM registers (both low and high registers, i.e.,
+//           R0 -- R12 and LR).
+//
+// Return value:
+//   A vector of free registers (might be empty, if none is found).
+//
+std::vector<Register>
+ARMRandezvousInstrumentor::findFreeRegistersBefore(const MachineInstr & MI,
+                                                   bool Thumb) {
+  assert(!MI.isMetaInstruction() && "Cannot instrument meta instruction!");
+
+  unsigned distance;
+  const MachineInstr * IT = findIT(MI, distance);
+
+  Register PredReg;
+  ARMCC::CondCodes Pred = getInstrPredicate(MI, PredReg);
+
+  const MachineFunction & MF = *MI.getMF();
+  const MachineBasicBlock & MBB = *MI.getParent();
+  const MachineRegisterInfo & MRI = MF.getRegInfo();
+  const TargetRegisterInfo * TRI = MF.getSubtarget().getRegisterInfo();
+  LivePhysRegs UsedRegs(*TRI);
+
+  // First add live-out registers of MBB; these registers are considered live
+  // at the end of MBB
+  UsedRegs.addLiveOuts(MBB);
+
+  // Then move backward step by step to compute live registers before MI
+  MachineBasicBlock::const_iterator MBBI(MI);
+  MachineBasicBlock::const_iterator I = MBB.end();
+  while (I != MBBI) {
+    unsigned distance2;
+    const MachineInstr * IT2 = findIT(*--I, distance2);
+    Register PredReg2;
+    ARMCC::CondCodes Pred2 = getInstrPredicate(*I, PredReg2);
+
+    if (IT2 != nullptr && IT == IT2) {
+      // Skip instructions in the same IT block but with a different predicate
+      if (Pred != Pred2) {
+        continue;
+      }
+
+      // A return in the same IT block with the same predicate can reset live
+      // registers to the callee-saved registers
+      if (I->isReturn()) {
+        UsedRegs.init(*TRI);
+        for (auto CSR = MRI.getCalleeSavedRegs(); CSR && *CSR; ++CSR) {
+          UsedRegs.addReg(*CSR);
+        }
+      }
+    }
+
+    UsedRegs.stepBackward(*I);
+  }
+
+  // Now add registers that are neither reserved nor live to a free list
+  const auto LoGPRs = {
+    ARM::R0, ARM::R1, ARM::R2, ARM::R3, ARM::R4, ARM::R5, ARM::R6, ARM::R7,
+  };
+  const auto HiGPRs = {
+    ARM::R8, ARM::R9, ARM::R10, ARM::R11, ARM::R12, ARM::LR,
+  };
+  std::vector<Register> FreeRegs;
+  for (Register Reg : LoGPRs) {
+    if (!MRI.isReserved(Reg) && !UsedRegs.contains(Reg)) {
+      FreeRegs.push_back(Reg);
+    }
+  }
+  if (!Thumb) {
+    for (Register Reg : HiGPRs) {
+      if (!MRI.isReserved(Reg) && !UsedRegs.contains(Reg)) {
+        FreeRegs.push_back(Reg);
+      }
+    }
+  }
+
+  return FreeRegs;
+}
+
+//
+// Method: findFreeRegistersAfter()
+//
+// Description:
+//   This method computes the liveness of ARM core registers after a given
+//   instruction MI and returns a list of free core registers that can be
+//   used for instrumentation purposes.
+//
+// Inputs:
+//   MI    - A reference to the instruction after which to find free
+//           registers.
+//   Thumb - Whether we are looking for Thumb registers (low registers, i,e,,
+//           R0 -- R7) or ARM registers (both low and high registers, i.e.,
+//           R0 -- R12 and LR).
+//
+// Return value:
+//   A vector of free registers (might be empty, if none is found).
+//
+std::vector<Register>
+ARMRandezvousInstrumentor::findFreeRegistersAfter(const MachineInstr & MI,
+                                                  bool Thumb) {
+  assert(!MI.isMetaInstruction() && "Cannot instrument meta instruction!");
+
+  unsigned distance;
+  const MachineInstr * IT = findIT(MI, distance);
+
+  Register PredReg;
+  ARMCC::CondCodes Pred = getInstrPredicate(MI, PredReg);
+
+  const MachineFunction & MF = *MI.getMF();
+  const MachineBasicBlock & MBB = *MI.getParent();
+  const MachineRegisterInfo & MRI = MF.getRegInfo();
+  const TargetRegisterInfo * TRI = MF.getSubtarget().getRegisterInfo();
+  LivePhysRegs UsedRegs(*TRI);
+
+  // First add live-out registers of MBB; these registers are considered live
+  // at the end of MBB
+  UsedRegs.addLiveOuts(MBB);
+
+  // If there is a return, add registers used by the return as well; here the
+  // rationale is that, if MI is the return, MI will not be stepped over and
+  // therefore the (potentially live) registers used in MI would not be counted
+  MachineBasicBlock::const_iterator Terminator = MBB.getLastNonDebugInstr();
+  if (Terminator != MBB.end() && Terminator->isReturn()) {
+    UsedRegs.addUses(*Terminator);
+  }
+
+  // Then move backward step by step to compute live registers after MI
+  MachineBasicBlock::const_iterator MBBI(MI);
+  MachineBasicBlock::const_iterator I = MBB.end();
+  while (I != MBBI) {
+    unsigned distance2;
+    const MachineInstr * IT2 = findIT(*--I, distance2);
+    Register PredReg2;
+    ARMCC::CondCodes Pred2 = getInstrPredicate(*I, PredReg2);
+
+    if (IT2 != nullptr && IT == IT2) {
+      // Skip instructions in the same IT block but with a different predicate
+      if (Pred != Pred2) {
+        continue;
+      }
+
+      // A return in the same IT block with the same predicate can reset live
+      // registers to the callee-saved registers
+      if (I->isReturn()) {
+        UsedRegs.init(*TRI);
+        for (auto CSR = MRI.getCalleeSavedRegs(); CSR && *CSR; ++CSR) {
+          UsedRegs.addReg(*CSR);
+        }
+
+        // Add registers used by the return; if MI is the return, MI will not
+        // be stepped over and therefore the (potentially live) registers used
+        // in MI would not be counted
+        UsedRegs.addUses(*I);
+      }
+    }
+
+    if (I != MBBI) {
+      UsedRegs.stepBackward(*I);
+    }
+  }
+
+  // Now add registers that are neither reserved nor live to a free list
+  const auto LoGPRs = {
+    ARM::R0, ARM::R1, ARM::R2, ARM::R3, ARM::R4, ARM::R5, ARM::R6, ARM::R7,
+  };
+  const auto HiGPRs = {
+    ARM::R8, ARM::R9, ARM::R10, ARM::R11, ARM::R12, ARM::LR,
+  };
+  std::vector<Register> FreeRegs;
+  for (Register Reg : LoGPRs) {
+    if (!MRI.isReserved(Reg) && !UsedRegs.contains(Reg)) {
+      FreeRegs.push_back(Reg);
+    }
+  }
+  if (!Thumb) {
+    for (Register Reg : HiGPRs) {
+      if (!MRI.isReserved(Reg) && !UsedRegs.contains(Reg)) {
+        FreeRegs.push_back(Reg);
+      }
+    }
+  }
+
+  return FreeRegs;
+}
\ No newline at end of file
diff --git a/llvm/lib/Target/ARM/ARMRandezvousInstrumentor.h b/llvm/lib/Target/ARM/ARMRandezvousInstrumentor.h
new file mode 100644
index 00000000000000..c84c430e7e3149
--- /dev/null
+++ b/llvm/lib/Target/ARM/ARMRandezvousInstrumentor.h
@@ -0,0 +1,178 @@
+//===- ARMRandezvousInstrumentor.h - A helper class for instrumentation ---===//
+//
+// Copyright (c) 2021-2022, University of Rochester
+//
+// Part of the Randezvous Project, under the Apache License v2.0 with
+// LLVM Exceptions.  See LICENSE.txt in the llvm directory for license
+// information.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the interfaces of a class that can help passes of its
+// subclass easily instrument ARM machine IR without concerns of breaking IT
+// blocks.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef ARM_RANDEZVOUS_INSTRUMENTOR
+#define ARM_RANDEZVOUS_INSTRUMENTOR
+
+#include "ARMBaseInstrInfo.h"
+#include <deque>
+namespace llvm {
+  //====================================================================
+  // Static inline functions.
+  //====================================================================
+
+  static inline size_t getBasicBlockCodeSize(const MachineBasicBlock & MBB) {
+    const MachineFunction & MF = *MBB.getParent();
+    const TargetInstrInfo * TII = MF.getSubtarget().getInstrInfo();
+
+    size_t CodeSize = 0ul;
+    for (const MachineInstr & MI : MBB) {
+      CodeSize += TII->getInstSizeInBytes(MI);
+    }
+
+    return CodeSize;
+  }
+
+  //
+  // Function: getFunctionCodeSize()
+  //
+  // Description:
+  //   This function computes the code size of a machine function.
+  //
+  // Input:
+  //   MF - A reference to the target machine function.
+  //
+  // Return value:
+  //   The size (in bytes) of the machine function.
+  //
+  static inline size_t getFunctionCodeSize(const MachineFunction & MF) {
+    size_t CodeSize = 0ul;
+    for (const MachineBasicBlock & MBB : MF) {
+      CodeSize += getBasicBlockCodeSize(MBB);
+    }
+
+    return CodeSize;
+  }
+
+  //
+  // Function: containsFunctionPointerType()
+  //
+  // Description:
+  //   This function examines a Type to see whether it can explicitly contain one
+  //   or more function pointers.  Note that this function recurses on aggregate
+  //   types.
+  //
+  // Input:
+  //   Ty - A pointer to a Type to examine.
+  //
+  // Return value:
+  //   true  - The Type can contain one or more function pointers.
+  //   false - The Type does not contain a function pointer.
+  //
+//   static inline bool
+//   containsFunctionPointerType(Type * Ty) {
+//     // Pointer
+//     if (PointerType * PtrTy = dyn_cast<PointerType>(Ty)) {
+//       return PtrTy->getParamElementType()->isFunctionTy();
+//     }
+
+//     // Array
+//     if (ArrayType * ArrayTy = dyn_cast<ArrayType>(Ty)) {
+//       return containsFunctionPointerType(ArrayTy->getElementType());
+//     }
+
+//     // Struct
+//     if (StructType * StructTy = dyn_cast<StructType>(Ty)) {
+//       for (Type * ElementTy : StructTy->elements()) {
+//         if (containsFunctionPointerType(ElementTy)) {
+//           return true;
+//         }
+//       }
+//     }
+
+//     // Other types do not contain function pointers
+//     return false;
+//   }
+
+  //
+  // Function: createNonZeroInitializerFor()
+  //
+  // Description:
+  //   This function creates a non-zero Constant initializer for a give Type,
+  //   which is supposed to contain one or more function pointers.  Note that
+  //   this function recurses on aggregate types.
+  //
+  // Input:
+  //   Ty - A pointer to a Type for which to create an initializer.
+  //
+  // Return value:
+  //   A pointer to a created Constant.
+  //
+  static inline Constant *
+  createNonZeroInitializerFor(Type * Ty) {
+    // Pointer: this is where we insert non-zero values
+    if (PointerType * PtrTy = dyn_cast<PointerType>(Ty)) {
+      return ConstantExpr::getIntToPtr(
+        ConstantInt::get(Type::getInt32Ty(Ty->getContext()), 1), Ty
+      );
+    }
+
+    // Array
+    if (ArrayType * ArrayTy = dyn_cast<ArrayType>(Ty)) {
+      std::vector<Constant *> InitArray;
+      for (uint64_t i = 0; i < ArrayTy->getNumElements(); ++i) {
+        InitArray.push_back(createNonZeroInitializerFor(ArrayTy->getElementType()));
+      }
+      return ConstantArray::get(ArrayTy, InitArray);
+    }
+
+    // Struct
+    if (StructType * StructTy = dyn_cast<StructType>(Ty)) {
+      std::vector<Constant *> InitArray;
+      for (unsigned i = 0; i < StructTy->getNumElements(); ++i) {
+        InitArray.push_back(createNonZeroInitializerFor(StructTy->getElementType(i)));
+      }
+      return ConstantStruct::get(StructTy, InitArray);
+    }
+
+    // Zeroing out other types are fine
+    return Constant::getNullValue(Ty);
+  }
+
+  //====================================================================
+  // Class ARMRandezvousInstrumentor.
+  //====================================================================
+
+  struct ARMRandezvousInstrumentor {
+    void insertInstBefore(MachineInstr & MI, MachineInstr * Inst);
+
+    void insertInstAfter(MachineInstr & MI, MachineInstr * Inst);
+
+    void insertInstsBefore(MachineInstr & MI, ArrayRef<MachineInstr *> Insts);
+
+    void insertInstsAfter(MachineInstr & MI, ArrayRef<MachineInstr *> Insts);
+
+    void removeInst(MachineInstr & MI);
+
+    MachineBasicBlock * splitBasicBlockBefore(MachineInstr & MI);
+
+    MachineBasicBlock * splitBasicBlockAfter(MachineInstr & MI);
+
+    std::vector<Register> findFreeRegistersBefore(const MachineInstr & MI,
+                                                  bool Thumb = false);
+    std::vector<Register> findFreeRegistersAfter(const MachineInstr & MI,
+                                                 bool Thumb = false);
+
+  private:
+    unsigned getITBlockSize(const MachineInstr & IT);
+    MachineInstr * findIT(MachineInstr & MI, unsigned & distance);
+    const MachineInstr * findIT(const MachineInstr & MI, unsigned & distance);
+    std::deque<bool> decodeITMask(unsigned Mask);
+    unsigned encodeITMask(std::deque<bool> DQMask);
+  };
+}
+
+#endif
\ No newline at end of file
diff --git a/llvm/lib/Target/ARM/ARMRandezvousOptions.cpp b/llvm/lib/Target/ARM/ARMRandezvousOptions.cpp
new file mode 100644
index 00000000000000..58dbfca265ad4a
--- /dev/null
+++ b/llvm/lib/Target/ARM/ARMRandezvousOptions.cpp
@@ -0,0 +1,210 @@
+//===- ARMRandezvousOptions.cpp - ARM Randezvous Command Line Options -----===//
+//
+// Copyright (c) 2021-2022, University of Rochester
+//
+// Part of the Randezvous Project, under the Apache License v2.0 with
+// LLVM Exceptions.  See LICENSE.txt in the llvm directory for license
+// information.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the command line options for ARM Randezvous passes.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ARMRandezvousOptions.h"
+#include "llvm/Support/CommandLine.h"
+
+using namespace llvm;
+
+//===----------------------------------------------------------------------===//
+// Randezvous pass enablers
+//===----------------------------------------------------------------------===//
+
+bool EnableRandezvousCLR;
+static cl::opt<bool, true>
+CLR("arm-randezvous-clr",
+    cl::Hidden,
+    cl::desc("Enable ARM Randezvous Code Layout Randomization"),
+    cl::location(EnableRandezvousCLR),
+    cl::init(false));
+
+bool EnableRandezvousBBLR;
+static cl::opt<bool, true>
+BBLR("arm-randezvous-bblr",
+     cl::Hidden,
+     cl::desc("Enable Basic Block Layout Randomization for ARM Randezvous CLR"),
+     cl::location(EnableRandezvousBBLR),
+     cl::init(false));
+
+bool EnableRandezvousBBCLR;
+static cl::opt<bool, true>
+BBCLR("arm-randezvous-bbclr",
+      cl::Hidden,
+      cl::desc("Enable Basic Block Cluster Layout Randomization for ARM Randezvous CLR"),
+      cl::location(EnableRandezvousBBCLR),
+      cl::init(false));
+
+bool EnableRandezvousPicoXOM;
+static cl::opt<bool, true>
+PicoXOM("arm-randezvous-picoxom",
+        cl::Hidden,
+        cl::desc("Enable ARM Randezvous Execute-Only Memory"),
+        cl::location(EnableRandezvousPicoXOM),
+        cl::init(false));
+
+bool EnableRandezvousGDLR;
+static cl::opt<bool, true>
+GDLR("arm-randezvous-gdlr",
+     cl::Hidden,
+     cl::desc("Enable ARM Randezvous Global Data Layout Randomization"),
+     cl::location(EnableRandezvousGDLR),
+     cl::init(false));
+
+bool EnableRandezvousDecoyPointers;
+static cl::opt<bool, true>
+DecoyPointers("arm-randezvous-dp",
+              cl::Hidden,
+              cl::desc("Enable ARM Randezvous Decoy Pointers"),
+              cl::location(EnableRandezvousDecoyPointers),
+              cl::init(false));
+
+bool EnableRandezvousGlobalGuard;
+static cl::opt<bool, true>
+GlobalGuard("arm-randezvous-global-guard",
+            cl::Hidden,
+            cl::desc("Enable ARM Randezvou Global Guard"),
+            cl::location(EnableRandezvousGlobalGuard),
+            cl::init(false));
+
+bool EnableRandezvousShadowStack;
+static cl::opt<bool, true>
+ShadowStack("arm-randezvous-shadow-stack",
+            cl::Hidden,
+            cl::desc("Enable ARM Randezvous Shadow Stack"),
+            cl::location(EnableRandezvousShadowStack),
+            cl::init(false));
+
+bool EnableRandezvousRAN;
+static cl::opt<bool, true>
+RAN("arm-randezvous-ran",
+    cl::Hidden,
+    cl::desc("Enable ARM Randezvous Return Address Nullification"),
+    cl::location(EnableRandezvousRAN),
+    cl::init(false));
+
+bool EnableRandezvousLGPromote;
+static cl::opt<bool, true>
+LGPromote("arm-randezvous-lgp",
+          cl::Hidden,
+          cl::desc("Enable ARM Randezvous Local-to-Global Promotion"),
+          cl::location(EnableRandezvousLGPromote),
+          cl::init(false));
+
+bool EnableRandezvousICallLimiter;
+static cl::opt<bool, true>
+ICallLimiter("arm-randezvous-icall-limiter",
+             cl::Hidden,
+             cl::desc("Enable ARM Randezvous Indirect Call Limiter"),
+             cl::location(EnableRandezvousICallLimiter),
+             cl::init(false));
+
+//===----------------------------------------------------------------------===//
+// Randezvous pass seeds
+//===----------------------------------------------------------------------===//
+
+uint64_t RandezvousCLRSeed;
+static cl::opt<uint64_t, true>
+CLRSeed("arm-randezvous-clr-seed",
+        cl::Hidden,
+        cl::desc("Seed for the RNG used in ARM Randezvous CLR"),
+        cl::location(RandezvousCLRSeed),
+        cl::init(0));
+
+uint64_t RandezvousGDLRSeed;
+static cl::opt<uint64_t, true>
+GDLRSeed("arm-randezvous-gdlr-seed",
+         cl::Hidden,
+         cl::desc("Seed for the RNG used in ARM Randezvous GDLR"),
+         cl::location(RandezvousGDLRSeed),
+         cl::init(0));
+
+uint64_t RandezvousShadowStackSeed;
+static cl::opt<uint64_t, true>
+ShadowStackSeed("arm-randezvous-shadow-stack-seed",
+                cl::Hidden,
+                cl::desc("Seed for the RNG used in ARM Randezvous Shadow Stack"),
+                cl::location(RandezvousShadowStackSeed),
+                cl::init(0));
+
+//===----------------------------------------------------------------------===//
+// Size options used by Randezvous passes
+//===----------------------------------------------------------------------===//
+
+size_t RandezvousMaxTextSize;
+static cl::opt<size_t, true>
+MaxTextSize("arm-randezvous-max-text-size",
+            cl::Hidden,
+            cl::desc("Maximum text section size in bytes"),
+            cl::location(RandezvousMaxTextSize),
+            cl::init(0x1e0000));   // 2 MB - 128 KB
+
+size_t RandezvousMaxRodataSize;
+static cl::opt<size_t, true>
+MaxRodataSize("arm-randezvous-max-rodata-size",
+              cl::Hidden,
+              cl::desc("Maximum rodata section size in bytes"),
+              cl::location(RandezvousMaxRodataSize),
+              cl::init(0x10000));  // 64 KB
+
+size_t RandezvousMaxDataSize;
+static cl::opt<size_t, true>
+MaxDataSize("arm-randezvous-max-data-size",
+            cl::Hidden,
+            cl::desc("Maximum data section size in bytes"),
+            cl::location(RandezvousMaxDataSize),
+            cl::init(0x10000));    // 64 KB
+
+size_t RandezvousMaxBssSize;
+static cl::opt<size_t, true>
+MaxBssSize("arm-randezvous-max-bss-size",
+           cl::Hidden,
+           cl::desc("Maximum bss section size in bytes"),
+           cl::location(RandezvousMaxBssSize),
+           cl::init(0x10000));     // 64 KB
+
+size_t RandezvousShadowStackSize;
+static cl::opt<size_t, true>
+ShadowStackSize("arm-randezvous-shadow-stack-size",
+                cl::Hidden,
+                cl::desc("ARM Randezvous Shadow Stack size in bytes"),
+                cl::location(RandezvousShadowStackSize),
+                cl::init(0x8000)); // 32 KB
+
+//===----------------------------------------------------------------------===//
+// Miscellaneous options used by Randezvous passes
+//===----------------------------------------------------------------------===//
+
+unsigned RandezvousShadowStackStrideLength;
+static cl::opt<unsigned, true>
+ShadowStackStrideLength("arm-randezvous-shadow-stack-stride-length",
+                        cl::Hidden,
+                        cl::desc("Number of bits for ARM Randezvous Shadow Stack stride"),
+                        cl::location(RandezvousShadowStackStrideLength),
+                        cl::init(8));
+
+unsigned RandezvousNumGlobalGuardCandidates;
+static cl::opt<unsigned, true>
+NumGlobalGuardCandidates("arm-randezvous-num-global-guard-candidates",
+                         cl::Hidden,
+                         cl::desc("Number of global guard candidates to generate"),
+                         cl::location(RandezvousNumGlobalGuardCandidates),
+                         cl::init(64));
+
+uintptr_t RandezvousRNGAddress;
+static cl::opt<uintptr_t, true>
+RNGAddress("arm-randezvous-rng-addr",
+           cl::Hidden,
+           cl::desc("Address of a dynamic RNG"),
+           cl::location(RandezvousRNGAddress),
+           cl::init(0));
\ No newline at end of file
diff --git a/llvm/lib/Target/ARM/ARMRandezvousOptions.h b/llvm/lib/Target/ARM/ARMRandezvousOptions.h
new file mode 100644
index 00000000000000..3757fd09e07f42
--- /dev/null
+++ b/llvm/lib/Target/ARM/ARMRandezvousOptions.h
@@ -0,0 +1,63 @@
+//===- ARMRandezvousOptions.h - ARM Randezvous Command Line Options -------===//
+//
+// Copyright (c) 2021-2022, University of Rochester
+//
+// Part of the Randezvous Project, under the Apache License v2.0 with
+// LLVM Exceptions.  See LICENSE.txt in the llvm directory for license
+// information.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares the command line options for ARM Randezvous passes.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef ARM_RANDEZVOUS_OPTIONS
+#define ARM_RANDEZVOUS_OPTIONS
+
+#include <cstddef>
+#include <cstdint>
+
+//===----------------------------------------------------------------------===//
+// Randezvous pass enablers
+//===----------------------------------------------------------------------===//
+
+extern bool EnableRandezvousCLR;
+extern bool EnableRandezvousBBLR;
+extern bool EnableRandezvousBBCLR;
+extern bool EnableRandezvousPicoXOM;
+extern bool EnableRandezvousGDLR;
+extern bool EnableRandezvousDecoyPointers;
+extern bool EnableRandezvousGlobalGuard;
+extern bool EnableRandezvousShadowStack;
+extern bool EnableRandezvousRAN;
+extern bool EnableRandezvousLGPromote;
+extern bool EnableRandezvousICallLimiter;
+
+//===----------------------------------------------------------------------===//
+// Randezvous pass seeds
+//===----------------------------------------------------------------------===//
+
+extern uint64_t RandezvousCLRSeed;
+extern uint64_t RandezvousGDLRSeed;
+extern uint64_t RandezvousShadowStackSeed;
+
+//===----------------------------------------------------------------------===//
+// Size options used by Randezvous passes
+//===----------------------------------------------------------------------===//
+
+extern size_t RandezvousMaxTextSize;
+extern size_t RandezvousMaxRodataSize;
+extern size_t RandezvousMaxDataSize;
+extern size_t RandezvousMaxBssSize;
+extern size_t RandezvousShadowStackSize;
+
+//===----------------------------------------------------------------------===//
+// Miscellaneous options used by Randezvous passes
+//===----------------------------------------------------------------------===//
+
+extern unsigned RandezvousShadowStackStrideLength;
+extern unsigned RandezvousNumGlobalGuardCandidates;
+extern uintptr_t RandezvousRNGAddress;
+
+#endif
\ No newline at end of file
diff --git a/llvm/lib/Target/ARM/ARMRandezvousShadowStack.cpp b/llvm/lib/Target/ARM/ARMRandezvousShadowStack.cpp
new file mode 100644
index 00000000000000..e0593fabe65e4d
--- /dev/null
+++ b/llvm/lib/Target/ARM/ARMRandezvousShadowStack.cpp
@@ -0,0 +1,861 @@
+//===- ARMRandezvousShadowStack.cpp - ARM Randezvous Shadow Stack ---------===//
+//
+// Copyright (c) 2021-2022, University of Rochester
+//
+// Part of the Randezvous Project, under the Apache License v2.0 with
+// LLVM Exceptions.  See LICENSE.txt in the llvm directory for license
+// information.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains the implementation of a pass that instruments ARM machine
+// code to save/load the return address to/from a randomized compact shadow
+// stack.
+//
+//===----------------------------------------------------------------------===//
+
+#define DEBUG_TYPE "arm-randezvous-shadow-stack"
+
+#include "ARMRandezvousCLR.h"
+#include "ARMRandezvousOptions.h"
+#include "ARMRandezvousShadowStack.h"
+#include "MCTargetDesc/ARMAddressingModes.h"
+#include "llvm/ADT/Statistic.h"
+#include "llvm/CodeGen/MachineFrameInfo.h"
+#include "llvm/CodeGen/MachineModuleInfo.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/Support/RandomNumberGenerator.h"
+#include "llvm/Transforms/Utils/ModuleUtils.h"
+
+using namespace llvm;
+
+STATISTIC(NumPrologues, "Number of prologues transformed to use shadow stack");
+STATISTIC(NumEpilogues, "Number of epilogues transformed to use shadow stack");
+STATISTIC(NumNullified, "Number of return addresses nullified");
+
+char ARMRandezvousShadowStack::ID = 0;
+
+ARMRandezvousShadowStack::ARMRandezvousShadowStack() : ModulePass(ID) {
+}
+
+StringRef
+ARMRandezvousShadowStack::getPassName() const {
+  return "ARM Randezvous Shadow Stack Pass";
+}
+
+void
+ARMRandezvousShadowStack::getAnalysisUsage(AnalysisUsage & AU) const {
+  // We need this to access MachineFunctions
+  AU.addRequired<MachineModuleInfoWrapperPass>();
+
+  AU.setPreservesCFG();
+  ModulePass::getAnalysisUsage(AU);
+}
+
+void
+ARMRandezvousShadowStack::releaseMemory() {
+  TrapBlocks.clear();
+}
+
+//
+// Method: createShadowStack()
+//
+// Description:
+//   This method creates a GlobalVariable as the shadow stack.  The shadow
+//   stack is initialized either as zeroed memory or with addresses of randomly
+//   picked trap blocks.
+//
+// Input:
+//   M - A reference to the Module in which to create the shadow stack.
+//
+// Return value:
+//   A pointer to the created GlobalVariable.
+//
+GlobalVariable *
+ARMRandezvousShadowStack::createShadowStack(Module & M) {
+  // Create types for the shadow stack
+  uint64_t PtrSize = M.getDataLayout().getPointerSize();
+  LLVMContext & Ctx = M.getContext();
+  PointerType * RetAddrTy = PointerType::getUnqual(Type::getInt8Ty(Ctx));
+  ArrayType * SSTy = ArrayType::get(RetAddrTy,
+                                    RandezvousShadowStackSize / PtrSize);
+
+  // Create the shadow stack
+  Constant * CSS = M.getOrInsertGlobal(ShadowStackName, SSTy);
+  GlobalVariable * SS = dyn_cast<GlobalVariable>(CSS);
+  assert(SS != nullptr && "Shadow stack has wrong type!");
+  SS->setLinkage(GlobalVariable::LinkOnceAnyLinkage);
+
+  // Initialize the shadow stack if not initialized
+  if (!SS->hasInitializer()) {
+    Constant * SSInit = nullptr;
+    if (EnableRandezvousDecoyPointers) {
+      // Initialize the shadow stack with an array of random values; they are
+      // either random trap block addresses or purely random values with the
+      // LSB set
+      std::vector<Constant *> SSInitArray;
+      for (unsigned i = 0; i < SSTy->getNumElements(); ++i) {
+        if (!TrapBlocks.empty()) {
+          uint64_t Idx = (*RNG)() % TrapBlocks.size();
+          const BasicBlock * BB = TrapBlocks[Idx]->getBasicBlock();
+          SSInitArray.push_back(BlockAddress::get(const_cast<BasicBlock *>(BB)));
+        } else {
+          APInt A(8 * PtrSize, (*RNG)() | 0x1);
+          SSInitArray.push_back(Constant::getIntegerValue(RetAddrTy, A));
+        }
+      }
+      SSInit = ConstantArray::get(SSTy, SSInitArray);
+    } else {
+      // Initialize the shadow stack with zeros
+      SSInit = ConstantArray::getNullValue(SSTy);
+    }
+    SS->setInitializer(SSInit);
+  }
+
+  // Add the shadow stack to @llvm.used
+  appendToUsed(M, { SS });
+
+  return SS;
+}
+
+//
+// Method: createInitFunction()
+//
+// Description:
+//   This method creates a function (both Function and MachineFunction) that
+//   initializes the reserved registers for the shadow stack.
+//
+// Inputs:
+//   M  - A reference to the Module in which to create the function.
+//   SS - A reference to the shadow stack global variable.
+//
+// Return value:
+//   A pointer to the created Function.
+//
+Function *
+ARMRandezvousShadowStack::createInitFunction(Module & M, GlobalVariable & SS) {
+  // Create types for the init function
+  LLVMContext & Ctx = M.getContext();
+  FunctionType * FuncTy = FunctionType::get(Type::getVoidTy(Ctx), false);
+
+  // Create the init function
+  FunctionCallee FC = M.getOrInsertFunction(InitFuncName, FuncTy);
+  Function * F = dyn_cast<Function>(FC.getCallee());
+  assert(F != nullptr && "Init function has wrong type!");
+  MachineModuleInfo & MMI = getAnalysis<MachineModuleInfoWrapperPass>().getMMI();
+  MachineFunction & MF = MMI.getOrCreateMachineFunction(*F);
+
+  // Set necessary attributes and properties
+  F->setLinkage(GlobalVariable::LinkOnceAnyLinkage);
+  if (!F->hasFnAttribute(Attribute::Naked)) {
+    F->addFnAttr(Attribute::Naked);
+  }
+  if (!F->hasFnAttribute(Attribute::NoUnwind)) {
+    F->addFnAttr(Attribute::NoUnwind);
+  }
+  if (!F->hasFnAttribute(Attribute::WillReturn)) {
+    F->addFnAttr(Attribute::WillReturn);
+  }
+  using Property = MachineFunctionProperties::Property;
+  if (!MF.getProperties().hasProperty(Property::NoVRegs)) {
+    MF.getProperties().set(Property::NoVRegs);
+  }
+
+  // Create a basic block if not created
+  if (F->empty()) {
+    assert(MF.empty() && "Machine IR basic block already there!");
+
+    // Build an IR basic block
+    BasicBlock * BB = BasicBlock::Create(Ctx, "", F);
+    IRBuilder<> IRB(BB);
+    IRB.CreateRetVoid(); // At this point, what the IR basic block contains
+                         // doesn't matter so just place a return there
+
+    // Build machine IR basic block(s)
+    const TargetInstrInfo * TII = MF.getSubtarget().getInstrInfo();
+    MachineBasicBlock * MBB = MF.CreateMachineBasicBlock(BB);
+    MachineBasicBlock * MBB2 = nullptr;
+    MachineBasicBlock * MBB3 = nullptr;
+    MachineBasicBlock * RetMBB = MBB;
+    MF.push_back(MBB);
+    // MOVi16 SSPtrReg, @SS_lo
+    BuildMI(MBB, DebugLoc(), TII->get(ARM::t2MOVi16), ShadowStackPtrReg)
+    .addGlobalAddress(&SS, 0, ARMII::MO_LO16)
+    .add(predOps(ARMCC::AL));
+    // MOVTi16 SSPtrReg, @SS_hi
+    BuildMI(MBB, DebugLoc(), TII->get(ARM::t2MOVTi16), ShadowStackPtrReg)
+    .addReg(ShadowStackPtrReg)
+    .addGlobalAddress(&SS, 0, ARMII::MO_HI16)
+    .add(predOps(ARMCC::AL));
+    if (RandezvousRNGAddress != 0) {
+      // User provided an RNG address, so load a random stride from the RNG
+      if (ARM_AM::getT2SOImmVal(RandezvousRNGAddress) != -1) {
+        // Use MOVi if the address can be encoded in Thumb modified constant
+        BuildMI(MBB, DebugLoc(), TII->get(ARM::t2MOVi), ARM::R0)
+        .addImm(RandezvousRNGAddress)
+        .add(predOps(ARMCC::AL))
+        .add(condCodeOp()); // No 'S' bit
+      } else {
+        // Otherwise use MOVi16/MOVTi16 to encode lower/upper 16 bits of the
+        // address
+        BuildMI(MBB, DebugLoc(), TII->get(ARM::t2MOVi16), ARM::R0)
+        .addImm(RandezvousRNGAddress & 0xffff)
+        .add(predOps(ARMCC::AL));
+        BuildMI(MBB, DebugLoc(), TII->get(ARM::t2MOVTi16), ARM::R0)
+        .addReg(ARM::R0)
+        .addImm((RandezvousRNGAddress >> 16) & 0xffff)
+        .add(predOps(ARMCC::AL));
+      }
+
+      MBB2 = MF.CreateMachineBasicBlock(BB);
+      MF.push_back(MBB2);
+      MBB->addSuccessor(MBB2);
+      MBB2->addSuccessor(MBB2);
+      // LDRi12 SSStrideReg, [R0, #0]
+      BuildMI(MBB2, DebugLoc(), TII->get(ARM::t2LDRi12), ShadowStackStrideReg)
+      .addReg(ARM::R0)
+      .addImm(0)
+      .add(predOps(ARMCC::AL));
+      // CMPi8 SSStrideReg, #0
+      BuildMI(MBB2, DebugLoc(), TII->get(ARM::t2CMPri))
+      .addReg(ShadowStackStrideReg)
+      .addImm(0)
+      .add(predOps(ARMCC::AL));
+      // BEQ MBB2
+      BuildMI(MBB2, DebugLoc(), TII->get(ARM::t2Bcc))
+      .addMBB(MBB2)
+      .addImm(ARMCC::EQ)
+      .addReg(ARM::CPSR, RegState::Kill);
+
+      MBB3 = MF.CreateMachineBasicBlock(BB);
+      MF.push_back(MBB3);
+      MBB2->addSuccessor(MBB3);
+      // BFC SSStrideReg, #(SSStrideLength - 1), #(33 - SSStrideLength)
+      BuildMI(MBB3, DebugLoc(), TII->get(ARM::t2BFC), ShadowStackStrideReg)
+      .addReg(ShadowStackStrideReg)
+      .addImm((1 << (RandezvousShadowStackStrideLength - 1)) - 1)
+      .add(predOps(ARMCC::AL));
+      // BFC SSStrideReg, #0, #2
+      BuildMI(MBB3, DebugLoc(), TII->get(ARM::t2BFC), ShadowStackStrideReg)
+      .addReg(ShadowStackStrideReg)
+      .addImm(~0x3)
+      .add(predOps(ARMCC::AL));
+      RetMBB = MBB3;
+    } else {
+      // Generate a static random stride
+      uint64_t Stride = (*RNG)();
+      Stride &= (1ul << (RandezvousShadowStackStrideLength - 1)) - 1;
+      Stride &= ~0x3ul;
+      if (ARM_AM::getT2SOImmVal(Stride) != -1) {
+        // Use MOVi if the stride can be encoded in Thumb modified constant
+        BuildMI(MBB, DebugLoc(), TII->get(ARM::t2MOVi), ShadowStackStrideReg)
+        .addImm(Stride)
+        .add(predOps(ARMCC::AL))
+        .add(condCodeOp()); // No 'S' bit
+      } else {
+        // Otherwise use MOVi16/MOVTi16 to encode lower/upper 16 bits of the
+        // stride
+        BuildMI(MBB, DebugLoc(), TII->get(ARM::t2MOVi16), ShadowStackStrideReg)
+        .addImm(Stride & 0xffff)
+        .add(predOps(ARMCC::AL));
+        BuildMI(MBB, DebugLoc(), TII->get(ARM::t2MOVTi16), ShadowStackStrideReg)
+        .addReg(ShadowStackStrideReg)
+        .addImm((Stride >> 16) & 0xffff)
+        .add(predOps(ARMCC::AL));
+      }
+    }
+    // BX_RET
+    BuildMI(RetMBB, DebugLoc(), TII->get(ARM::tBX_RET))
+    .add(predOps(ARMCC::AL));
+  }
+
+  // Add the init function to @llvm.used
+  appendToUsed(M, { F });
+
+  return F;
+}
+
+//
+// Method: pushToShadowStack()
+//
+// Description:
+//   This method modifies a PUSH instruction to not save LR to the stack and
+//   inserts new instructions that save LR to the shadow stack.
+//
+// Inputs:
+//   MI     - A reference to a PUSH instruction that saves LR to the stack.
+//   LR     - A reference to the LR operand of the PUSH.
+//   Stride - A static stride to use.
+//
+// Return value:
+//   true - The machine code was modified.
+//
+bool
+ARMRandezvousShadowStack::pushToShadowStack(MachineInstr & MI,
+                                            MachineOperand & LR,
+                                            uint32_t Stride) {
+  MachineFunction & MF = *MI.getMF();
+  const TargetInstrInfo * TII = MF.getSubtarget().getInstrInfo();
+  const DebugLoc & DL = MI.getDebugLoc();
+
+  Register PredReg;
+  ARMCC::CondCodes Pred = getInstrPredicate(MI, PredReg);
+
+  // Build the following instruction sequence
+  //
+  // STR_POST LR, [SSPtrReg], #Stride
+  // ADDrr    SSPtrReg, SSPtrReg, SSStrideReg
+  std::vector<MachineInstr *> NewInsts;
+  NewInsts.push_back(BuildMI(MF, DL, TII->get(ARM::t2STR_POST), ShadowStackPtrReg)
+                     .addReg(ARM::LR)
+                     .addReg(ShadowStackPtrReg)
+                     .addImm(Stride)
+                     .add(predOps(Pred, PredReg)));
+  NewInsts.push_back(BuildMI(MF, DL, TII->get(ARM::t2ADDrr), ShadowStackPtrReg)
+                     .addReg(ShadowStackPtrReg)
+                     .addReg(ShadowStackStrideReg)
+                     .add(predOps(Pred, PredReg))
+                     .add(condCodeOp()));
+
+  // Now insert these new instructions into the basic block
+  insertInstsBefore(MI, NewInsts);
+
+  // At last, replace the old PUSH with a new one that doesn't push LR to the
+  // stack
+  switch (MI.getOpcode()) {
+  case ARM::t2STMDB_UPD:
+    // STMDB_UPD should store at least two registers; if it happens to be two,
+    // we replace it with a STR_PRE
+    assert(MI.getNumExplicitOperands() >= 6 && "Buggy STMDB_UPD!");
+    if (MI.getNumExplicitOperands() > 6) {
+      MI.removeOperand(MI.getOperandNo(&LR));
+    } else {
+      unsigned Idx = MI.getOperandNo(&LR);
+      Idx = Idx == 4 ? 5 : 4;
+      insertInstBefore(MI, BuildMI(MF, DL, TII->get(ARM::t2STR_PRE), ARM::SP)
+                           .add(MI.getOperand(Idx))
+                           .addReg(ARM::SP)
+                           .addImm(-4)
+                           .add(predOps(Pred, PredReg))
+                           .setMIFlags(MI.getFlags()));
+      removeInst(MI);
+    }
+    break;
+
+  case ARM::tPUSH:
+    // PUSH should store at least one register; if it happens to be one, we
+    // just remove it
+    assert(MI.getNumExplicitOperands() >= 3 && "Buggy PUSH!");
+    if (MI.getNumExplicitOperands() > 3) {
+      MI.removeOperand(MI.getOperandNo(&LR));
+    } else {
+      removeInst(MI);
+    }
+    break;
+
+  // ARM::t2STR_PRE
+  default:
+    // STR_PRE only stores one register, so we just remove it
+    removeInst(MI);
+    break;
+  }
+
+  ++NumPrologues;
+  return true;
+}
+
+//
+// Method: popFromShadowStack()
+//
+// Description:
+//   This method modifies a POP instruction to not write to PC/LR and inserts
+//   new instructions that load the return address from the shadow stack into
+//   PC/LR.
+//
+// Inputs:
+//   MI     - A reference to a POP instruction that writes to LR or PC.
+//   PCLR   - A reference to the PC or LR operand of the POP.
+//   Stride - A static stride to use.
+//
+// Return value:
+//   true - The machine code was modified.
+//
+bool
+ARMRandezvousShadowStack::popFromShadowStack(MachineInstr & MI,
+                                             MachineOperand & PCLR,
+                                             uint32_t Stride) {
+  MachineFunction & MF = *MI.getMF();
+  const TargetInstrInfo * TII = MF.getSubtarget().getInstrInfo();
+  const DebugLoc & DL = MI.getDebugLoc();
+
+  Register PredReg;
+  ARMCC::CondCodes Pred = getInstrPredicate(MI, PredReg);
+
+  // Build the following instruction sequence
+  //
+  // SUBrr    SSPtrReg, SSPtrReg, SSStrideReg
+  // LDR_PRE  PC/LR, [SSPtrReg, #-Stride]!
+  std::vector<MachineInstr *> NewInsts;
+  NewInsts.push_back(BuildMI(MF, DL, TII->get(ARM::t2SUBrr), ShadowStackPtrReg)
+                     .addReg(ShadowStackPtrReg)
+                     .addReg(ShadowStackStrideReg)
+                     .add(predOps(Pred, PredReg))
+                     .add(condCodeOp()));
+  NewInsts.push_back(BuildMI(MF, DL, TII->get(PCLR.getReg() == ARM::PC ?
+                                              ARM::t2LDR_PRE_RET :
+                                              ARM::t2LDR_PRE),
+                             PCLR.getReg())
+                     .addReg(ShadowStackPtrReg, RegState::Define)
+                     .addReg(ShadowStackPtrReg)
+                     .addImm(-Stride)
+                     .add(predOps(Pred, PredReg)));
+
+  // Now insert these new instructions into the basic block
+  insertInstsAfter(MI, NewInsts);
+
+  // Replace the old POP with a new one that doesn't write to PC/LR
+  switch (MI.getOpcode()) {
+  case ARM::t2LDMIA_RET:
+    MI.setDesc(TII->get(ARM::t2LDMIA_UPD));
+    NewInsts[1]->copyImplicitOps(MF, MI);
+    for (unsigned i = MI.getNumOperands() - 1, e = MI.getNumExplicitOperands();
+         i >= e; --i) {
+      MI.removeOperand(i);
+    }
+    LLVM_FALLTHROUGH;
+  case ARM::t2LDMIA_UPD:
+    // LDMIA_UPD should load at least two registers; if it happens to be two,
+    // we replace it with a LDR_POST
+    assert(MI.getNumExplicitOperands() >= 6 && "Buggy LDMIA_UPD!");
+    if (MI.getNumExplicitOperands() > 6) {
+      MI.removeOperand(MI.getOperandNo(&PCLR));
+    } else {
+      unsigned Idx = MI.getOperandNo(&PCLR);
+      Idx = Idx == 4 ? 5 : 4;
+      insertInstAfter(MI, BuildMI(MF, DL, TII->get(ARM::t2LDR_POST),
+                                  MI.getOperand(Idx).getReg())
+                          .addReg(ARM::SP, RegState::Define)
+                          .addReg(ARM::SP)
+                          .addImm(4)
+                          .add(predOps(Pred, PredReg))
+                          .setMIFlags(MI.getFlags()));
+      removeInst(MI);
+    }
+    break;
+
+  case ARM::tPOP_RET:
+    MI.setDesc(TII->get(ARM::tPOP));
+    NewInsts[1]->copyImplicitOps(MF, MI);
+    for (unsigned i = MI.getNumOperands() - 1, e = MI.getNumExplicitOperands();
+         i >= e; --i) {
+      MI.removeOperand(i);
+    }
+    LLVM_FALLTHROUGH;
+  case ARM::tPOP:
+    // POP should load at least one register; if it happens to be one, we just
+    // remove it
+    assert(MI.getNumExplicitOperands() >= 3 && "Buggy POP!");
+    if (MI.getNumExplicitOperands() > 3) {
+      MI.removeOperand(MI.getOperandNo(&PCLR));
+    } else {
+      removeInst(MI);
+    }
+    break;
+
+  // ARM::t2LDR_POST
+  default:
+    // LDR_POST only loads one register, so we just remove it
+    removeInst(MI);
+    break;
+  }
+
+  if (EnableRandezvousRAN) {
+    // Nullify the return address in the shadow stack
+    nullifyReturnAddress(*NewInsts[1], NewInsts[1]->getOperand(0));
+  }
+
+  ++NumEpilogues;
+  return true;
+}
+
+//
+// Method: nullifyReturnAddress()
+//
+// Description:
+//   This method nullifies an in-memory return address by either zeroing it out
+//   or filling it with a null value (either the address of a randomly picked
+//   trap block or a purely random value).
+//
+// Inputs:
+//   MI   - A reference to a POP or LDR instruction that writes to LR or PC.
+//   PCLR - A reference to the PC or LR operand of MI.
+//
+// Return value:
+//   true - The machine code was modified.
+//
+bool
+ARMRandezvousShadowStack::nullifyReturnAddress(MachineInstr & MI,
+                                               MachineOperand & PCLR) {
+  MachineFunction & MF = *MI.getMF();
+  const TargetInstrInfo * TII = MF.getSubtarget().getInstrInfo();
+  const DebugLoc & DL = MI.getDebugLoc();
+
+  Register PredReg;
+  ARMCC::CondCodes Pred = getInstrPredicate(MI, PredReg);
+
+  // Mark LR as restored since we're going to use LR to hold the return address
+  // in all the cases
+  MachineFrameInfo & MFI = MF.getFrameInfo();
+  if (MFI.isCalleeSavedInfoValid()) {
+    for (CalleeSavedInfo & CSI : MFI.getCalleeSavedInfo()) {
+      if (CSI.getReg() == ARM::LR) {
+        CSI.setRestored(true);
+        break;
+      }
+    }
+  }
+
+  // We need to use a scratch register as the source register of a store.  If
+  // no free register is around, spill and use R4.
+  std::vector<Register> FreeRegs = findFreeRegistersAfter(MI);
+  bool Spill = FreeRegs.empty();
+  Register FreeReg = Spill ? ARM::R4 : FreeRegs[0];
+
+  std::vector<MachineInstr *> NewInsts;
+  switch (MI.getOpcode()) {
+  // LDMIA_RET SP!, {..., PC} -> LDMIA_UPD SP!, {..., LR}
+  //                             MOVi16    FreeReg, #0
+  //                             STRi8     FreeReg, [SP, #-4]
+  //                             BX_RET
+  case ARM::t2LDMIA_RET:
+    assert(PCLR.getReg() == ARM::PC && "Buggy POP!");
+    MI.setDesc(TII->get(ARM::t2LDMIA_UPD));
+    PCLR.setReg(ARM::LR);
+    insertInstAfter(MI, BuildMI(MF, DL, TII->get(ARM::tBX_RET))
+                        .add(predOps(Pred, PredReg)));
+    LLVM_FALLTHROUGH;
+  // LDMIA_UPD SP!, {..., LR} -> LDMIA_UPD SP!, {..., LR}
+  //                             MOVi16    FreeReg, #0
+  //                             STRi8     FreeReg, [SP, #-4]
+  case ARM::t2LDMIA_UPD:
+  // LDR_POST LR, [SP], #4 -> LDR_POST LR, [SP], #4
+  //                          MOVi16   FreeReg, #0
+  //                          STRi8    FreeReg, [SP, #-4]
+  case ARM::t2LDR_POST:
+    assert(PCLR.getReg() == ARM::LR && "Buggy POP!");
+    if (Spill) {
+      NewInsts.push_back(BuildMI(MF, DL, TII->get(ARM::tPUSH))
+                         .add(predOps(Pred, PredReg))
+                         .addReg(FreeReg));
+    }
+    NewInsts.push_back(BuildMI(MF, DL, TII->get(ARM::t2MOVi16), FreeReg)
+                       .addImm(0)
+                       .add(predOps(Pred, PredReg)));
+    NewInsts.push_back(BuildMI(MF, DL, TII->get(ARM::t2STRi8))
+                       .addReg(FreeReg)
+                       .addReg(ARM::SP)
+                       .addImm(-4)
+                       .add(predOps(Pred, PredReg)));
+    if (Spill) {
+      NewInsts.push_back(BuildMI(MF, DL, TII->get(ARM::tPOP))
+                         .add(predOps(Pred, PredReg))
+                         .addReg(FreeReg));
+    }
+    insertInstsAfter(MI, NewInsts);
+    break;
+
+  // POP(_RET) {..., PC} -> LDMIA_UPD SP!, {..., LR}
+  //                        MOVi16    FreeReg, #0
+  //                        STRi8     FreeReg, [SP, #-4]
+  //                        BX_RET
+  case ARM::tPOP:
+  case ARM::tPOP_RET: {
+    assert(PCLR.getReg() == ARM::PC && "Buggy POP!");
+    MachineInstrBuilder MIB = BuildMI(MF, DL, TII->get(ARM::t2LDMIA_UPD), ARM::SP)
+                              .addReg(ARM::SP);
+    for (MachineOperand & MO : MI.explicit_operands()) {
+      if (MO.isReg() && MO.getReg() == ARM::PC) {
+        MIB.addReg(ARM::LR, RegState::Define);
+      } else {
+        MIB.add(MO);
+      }
+    }
+    NewInsts.push_back(MIB);
+    if (Spill) {
+      NewInsts.push_back(BuildMI(MF, DL, TII->get(ARM::tPUSH))
+                         .add(predOps(Pred, PredReg))
+                         .addReg(FreeReg));
+    }
+    NewInsts.push_back(BuildMI(MF, DL, TII->get(ARM::t2MOVi16), FreeReg)
+                       .addImm(0)
+                       .add(predOps(Pred, PredReg)));
+    NewInsts.push_back(BuildMI(MF, DL, TII->get(ARM::t2STRi8))
+                       .addReg(FreeReg)
+                       .addReg(ARM::SP)
+                       .addImm(-4)
+                       .add(predOps(Pred, PredReg)));
+    if (Spill) {
+      NewInsts.push_back(BuildMI(MF, DL, TII->get(ARM::tPOP))
+                         .add(predOps(Pred, PredReg))
+                         .addReg(FreeReg));
+    }
+    NewInsts.push_back(BuildMI(MF, DL, TII->get(ARM::tBX_RET))
+                       .add(predOps(Pred, PredReg)));
+    insertInstsAfter(MI, NewInsts);
+    removeInst(MI);
+    break;
+  }
+
+  // LDR_PRE_RET PC, [SSPtrReg, #imm]! -> LDR_PRE LR, [SSPtrReg, #imm]!
+  //                                      MOVi16  FreeReg, #0
+  //                                      STRi12  FreeReg, [SSPtrReg, #0]
+  //                                      BX_RET
+  //
+  //                                   or LDR_PRE LR, [SSPtrReg, #imm]!
+  //                                      MOVi16  FreeReg, #null-lo16
+  //                                      MOVTi16 FreeReg, #null-hi16
+  //                                      STRi12  FreeReg, [SSPtrReg, #0]
+  //                                      BX_RET
+  case ARM::t2LDR_PRE_RET:
+    assert(PCLR.getReg() == ARM::PC && "Buggy POP!");
+    MI.setDesc(TII->get(ARM::t2LDR_PRE));
+    PCLR.setReg(ARM::LR);
+    insertInstAfter(MI, BuildMI(MF, DL, TII->get(ARM::tBX_RET))
+                        .add(predOps(Pred, PredReg)));
+    LLVM_FALLTHROUGH;
+  // LDR_PRE LR, [SSPtrReg, #imm]! -> LDR_PRE LR, [SSPtrReg, #imm]!
+  //                                  MOVi16  FreeReg, #0
+  //                                  STRi12  FreeReg, [SSPtrReg, #0]
+  //
+  //                               or LDR_PRE LR, [SSPtrReg, #imm]!
+  //                                  MOVi16  FreeReg, #null-lo16
+  //                                  MOVTi16 FreeReg, #null-hi16
+  //                                  STRi12  FreeReg, [SSPtrReg, #0]
+  default:
+    assert(MI.getOpcode() == ARM::t2LDR_PRE && "Unrecognized POP!");
+    assert(MI.getOperand(1).getReg() == ShadowStackPtrReg && "Buggy POP!");
+    assert(PCLR.getReg() == ARM::LR && "Buggy POP!");
+    if (Spill) {
+      NewInsts.push_back(BuildMI(MF, DL, TII->get(ARM::tPUSH))
+                         .add(predOps(Pred, PredReg))
+                         .addReg(FreeReg));
+    }
+    if (EnableRandezvousDecoyPointers) {
+      if (!TrapBlocks.empty()) {
+        // Use the address of a trap block as the null value
+        uint64_t Idx = (*RNG)() % TrapBlocks.size();
+        const BasicBlock * BB = TrapBlocks[Idx]->getBasicBlock();
+        BlockAddress * BA = BlockAddress::get(const_cast<BasicBlock *>(BB));
+        NewInsts.push_back(BuildMI(MF, DL, TII->get(ARM::t2MOVi16), FreeReg)
+                           .addBlockAddress(BA, 0, ARMII::MO_LO16)
+                           .add(predOps(Pred, PredReg)));
+        NewInsts.push_back(BuildMI(MF, DL, TII->get(ARM::t2MOVTi16), FreeReg)
+                           .addReg(FreeReg)
+                           .addBlockAddress(BA, 0, ARMII::MO_HI16)
+                           .add(predOps(Pred, PredReg)));
+      } else {
+        // Use a random value with the LSB set as the null value
+        uint32_t NullValue = (*RNG)() | 0x1;
+        if (ARM_AM::getT2SOImmVal(NullValue) != -1) {
+          NewInsts.push_back(BuildMI(MF, DL, TII->get(ARM::t2MOVi), FreeReg)
+                             .addImm(NullValue)
+                             .add(predOps(Pred, PredReg))
+                             .add(condCodeOp())); // No 'S' bit
+        } else {
+          NewInsts.push_back(BuildMI(MF, DL, TII->get(ARM::t2MOVi16), FreeReg)
+                             .addImm(NullValue & 0xffff)
+                             .add(predOps(Pred, PredReg)));
+          NewInsts.push_back(BuildMI(MF, DL, TII->get(ARM::t2MOVTi16), FreeReg)
+                             .addReg(FreeReg)
+                             .addImm((NullValue >> 16) & 0xffff)
+                             .add(predOps(Pred, PredReg)));
+        }
+      }
+    } else {
+      NewInsts.push_back(BuildMI(MF, DL, TII->get(ARM::t2MOVi16), FreeReg)
+                         .addImm(0)
+                         .add(predOps(Pred, PredReg)));
+    }
+    NewInsts.push_back(BuildMI(MF, DL, TII->get(ARM::t2STRi12))
+                       .addReg(FreeReg)
+                       .addReg(ShadowStackPtrReg)
+                       .addImm(0)
+                       .add(predOps(Pred, PredReg)));
+    if (Spill) {
+      NewInsts.push_back(BuildMI(MF, DL, TII->get(ARM::tPOP))
+                         .add(predOps(Pred, PredReg))
+                         .addReg(FreeReg));
+    }
+    insertInstsAfter(MI, NewInsts);
+    break;
+  }
+
+  ++NumNullified;
+  return true;
+}
+
+//
+// Method: runOnModule()
+//
+// Description:
+//   This method is called when the PassManager wants this pass to transform
+//   the specified Module.  This method
+//
+//   * creates a global variable as the shadow stack,
+//
+//   * creates a function that initializes the reserved registers for the
+//     shadow stack, and
+//
+//   * transforms the Module to utilize the shadow stack for saving/restoring
+//     return addresses and/or to nullify a saved return address on returns.
+//
+// Input:
+//   M - A reference to the Module to transform.
+//
+// Output:
+//   M - The transformed Module.
+//
+// Return value:
+//   true  - The Module was transformed.
+//   false - The Module was not transformed.
+//
+bool
+ARMRandezvousShadowStack::runOnModule(Module & M) {
+  if (!EnableRandezvousShadowStack && !EnableRandezvousRAN) {
+    return false;
+  }
+
+  MachineModuleInfo & MMI = getAnalysis<MachineModuleInfoWrapperPass>().getMMI();
+  Twine RNGName = getPassName() + "-" + Twine(RandezvousShadowStackSeed);
+  RNG = M.createRNG(RNGName.str());
+
+  // Find trap blocks inserted by CLR
+  for (Function & F : M) {
+    MachineFunction * MF = MMI.getMachineFunction(F);
+    if (MF != nullptr) {
+      for (MachineBasicBlock & MBB : *MF) {
+        if (MBB.isRandezvousTrapBlock()) {
+          TrapBlocks.push_back(&MBB);
+        }
+      }
+    }
+  }
+
+  if (EnableRandezvousShadowStack) {
+    assert((RandezvousShadowStackStrideLength > 2 &&
+            RandezvousShadowStackStrideLength <= 32) && "Invalid stride length!");
+
+    // Create and initialize a global variable for the shadow stack
+    GlobalVariable * SS = createShadowStack(M);
+
+    // Create an init function that:
+    // * loads the address of the shadow stack to the shadow stack pointer
+    //   register, and
+    // * generates a random stride (either dynamic or static) to the shadow
+    //   stack stride register
+    createInitFunction(M, *SS);
+  }
+
+  // Instrument pushes and pops in each function
+  bool changed = false;
+  for (Function & F : M) {
+    MachineFunction * MF = MMI.getMachineFunction(F);
+    if (MF == nullptr) {
+      continue;
+    }
+
+    // Find out all pushes that write LR to the stack and all pops that read a
+    // return address from the stack to LR or PC
+    std::vector<std::pair<MachineInstr *, MachineOperand *> > Pushes;
+    std::vector<std::pair<MachineInstr *, MachineOperand *> > Pops;
+    for (MachineBasicBlock & MBB : *MF) {
+      for (MachineInstr & MI : MBB) {
+        switch (MI.getOpcode()) {
+        // Frame-setup instructions in function prologue
+        case ARM::t2STR_PRE:
+        case ARM::t2STMDB_UPD:
+          // STR_PRE and STMDB_UPD are considered as PUSH if they write to SP!
+          if (MI.getOperand(0).getReg() != ARM::SP) {
+            break;
+          }
+          LLVM_FALLTHROUGH;
+        case ARM::tPUSH:
+          if (MI.getFlag(MachineInstr::FrameSetup)) {
+            for (MachineOperand & MO : MI.explicit_operands()) {
+              if (MO.isReg() && MO.getReg() == ARM::LR) {
+                Pushes.push_back(std::make_pair(&MI, &MO));
+                break;
+              }
+            }
+          }
+          break;
+
+        // Frame-destroy instructions in function epilogue
+        case ARM::t2LDR_POST:
+        case ARM::t2LDMIA_UPD:
+        case ARM::t2LDMIA_RET:
+          // LDR_POST and LDMIA_(UPD|RET) are considered as POP if they read
+          // from SP!
+          if (MI.getOperand(1).getReg() != ARM::SP) {
+            break;
+          }
+          LLVM_FALLTHROUGH;
+        case ARM::tPOP:
+        case ARM::tPOP_RET:
+          if (MI.getFlag(MachineInstr::FrameDestroy)) {
+            // Handle 2 cases:
+            // (1) Pop writing to LR
+            // (2) Pop writing to PC
+            for (MachineOperand & MO : MI.explicit_operands()) {
+              if (MO.isReg()) {
+                if (MO.getReg() == ARM::LR || MO.getReg() == ARM::PC) {
+                  Pops.push_back(std::make_pair(&MI, &MO));
+                  break;
+                }
+              }
+            }
+          }
+          break;
+
+        default:
+          break;
+        }
+      }
+    }
+
+    // Instrument each push and pop
+    if (EnableRandezvousShadowStack) {
+      // Generate a per-function static stride
+      uint32_t Stride = (*RNG)();
+      Stride &= (1ul << (RandezvousShadowStackStrideLength - 1)) - 1;
+      Stride &= ~0x3ul;
+      // Limit the static stride to be within 8 bits, so that it can fit in
+      // STR_POST and LDR_PRE as an immediate
+      Stride &= 0xfful;
+      // Don't generate an empty stride; either the dynamic stride or the
+      // static stride needs to make sure of it, so just do it on the static to
+      // leave more room for the dynamic
+      if (Stride == 0u) {
+        Stride = 4u;
+      }
+
+      for (auto & MIMO : Pushes) {
+        changed |= pushToShadowStack(*MIMO.first, *MIMO.second, Stride);
+      }
+      for (auto & MIMO : Pops) {
+        changed |= popFromShadowStack(*MIMO.first, *MIMO.second, Stride);
+      }
+    } else if (EnableRandezvousRAN) {
+      for (auto & MIMO : Pops) {
+        changed |= nullifyReturnAddress(*MIMO.first, *MIMO.second);
+      }
+    }
+  }
+
+  return changed;
+}
+
+ModulePass *
+llvm::createARMRandezvousShadowStack(void) {
+  return new ARMRandezvousShadowStack();
+}
\ No newline at end of file
diff --git a/llvm/lib/Target/ARM/ARMRandezvousShadowStack.h b/llvm/lib/Target/ARM/ARMRandezvousShadowStack.h
new file mode 100644
index 00000000000000..5b9fcd61105b50
--- /dev/null
+++ b/llvm/lib/Target/ARM/ARMRandezvousShadowStack.h
@@ -0,0 +1,40 @@
+#ifndef ARM_RANDEZVOUS_SHADOW_STACK
+#define ARM_RANDEZVOUS_SHADOW_STACK
+
+#include "ARMRandezvousInstrumentor.h"
+#include "llvm/Pass.h"
+#include "llvm/Support/RandomNumberGenerator.h"
+
+namespace llvm {
+  struct ARMRandezvousShadowStack : public ModulePass, ARMRandezvousInstrumentor {
+    // Pass Identifier
+    static char ID;
+
+    static constexpr Register ShadowStackPtrReg = ARM::R8;
+    static constexpr Register ShadowStackStrideReg = ARM::R9;
+    static constexpr StringRef ShadowStackName = "__randezvous_shadow_stack";
+    static constexpr StringRef InitFuncName = "__randezvous_shadow_stack_init";
+
+    ARMRandezvousShadowStack();
+    virtual StringRef getPassName() const override;
+    void getAnalysisUsage(AnalysisUsage & AU) const override;
+    void releaseMemory() override;
+    virtual bool runOnModule(Module & M) override;
+
+  private:
+    std::unique_ptr<RandomNumberGenerator> RNG;
+    std::vector<MachineBasicBlock *> TrapBlocks;
+
+    GlobalVariable * createShadowStack(Module & M);
+    Function * createInitFunction(Module & M, GlobalVariable & SS);
+    bool pushToShadowStack(MachineInstr & MI, MachineOperand & LR,
+                           uint32_t Stride);
+    bool popFromShadowStack(MachineInstr & MI, MachineOperand & PCLR,
+                            uint32_t Stride);
+    bool nullifyReturnAddress(MachineInstr & MI, MachineOperand & PCLR);
+  };
+
+  ModulePass * createARMRandezvousShadowStack(void);
+}
+
+#endif
\ No newline at end of file
diff --git a/llvm/lib/Target/ARM/ARMTargetMachine.cpp b/llvm/lib/Target/ARM/ARMTargetMachine.cpp
index 775d098fbaed57..bfd0d0ec4cecda 100644
--- a/llvm/lib/Target/ARM/ARMTargetMachine.cpp
+++ b/llvm/lib/Target/ARM/ARMTargetMachine.cpp
@@ -9,6 +9,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "ARMRandezvousInstrumentor.h"
+#include "ARMRandezvousShadowStack.h"
 #include "ARMTargetMachine.h"
 #include "ARM.h"
 #include "ARMMachineFunctionInfo.h"
@@ -610,6 +612,13 @@ void ARMPassConfig::addPreEmitPass2() {
   // sizes will only be decreased by this pass.
   addPass(createARMLowOverheadLoopsPass());
 
+  // Inserts sxh pass
+
+  // Add Randezvous CodeGen passes
+
+  addPass(createARMRandezvousShadowStack());
+
+
   if (TM->getTargetTriple().isOSWindows()) {
     // Identify valid longjmp targets for Windows Control Flow Guard.
     addPass(createCFGuardLongjmpPass());
diff --git a/llvm/lib/Target/ARM/CMakeLists.txt b/llvm/lib/Target/ARM/CMakeLists.txt
index a0f4290cb48db2..d4dd215b84ab83 100644
--- a/llvm/lib/Target/ARM/CMakeLists.txt
+++ b/llvm/lib/Target/ARM/CMakeLists.txt
@@ -19,6 +19,14 @@ tablegen(LLVM ARMGenSystemRegister.inc -gen-searchable-tables)
 
 add_public_tablegen_target(ARMCommonTableGen)
 
+
+set(ARMRandezvous_SOURCES
+  ARMRandezvousInstrumentor.cpp
+  ARMRandezvousShadowStack.cpp
+  ARMRandezvousOptions.cpp
+  ARMRandezvousCLR.cpp
+)
+
 add_llvm_target(ARMCodeGen
   A15SDOptimizer.cpp
   ARMAsmPrinter.cpp
@@ -68,6 +76,7 @@ add_llvm_target(ARMCodeGen
   Thumb2ITBlockPass.cpp
   Thumb2InstrInfo.cpp
   Thumb2SizeReduction.cpp
+  ${ARMRandezvous_SOURCES}
 
   LINK_COMPONENTS
   ARMDesc
diff --git a/llvm/lib/Target/ARM/MCTargetDesc/ARMAsmBackend.cpp b/llvm/lib/Target/ARM/MCTargetDesc/ARMAsmBackend.cpp
index dfa305a3b968d7..1a2cab20ee07c3 100644
--- a/llvm/lib/Target/ARM/MCTargetDesc/ARMAsmBackend.cpp
+++ b/llvm/lib/Target/ARM/MCTargetDesc/ARMAsmBackend.cpp
@@ -115,6 +115,10 @@ const MCFixupKindInfo &ARMAsmBackend::getFixupKindInfo(MCFixupKind Kind) const {
       {"fixup_arm_movw_lo16", 0, 20, 0},
       {"fixup_t2_movt_hi16", 0, 20, 0},
       {"fixup_t2_movw_lo16", 0, 20, 0},
+
+      {"fixup_t2_udf_hi16", 0, 20, 0},
+      {"fixup_t2_udf_lo16", 0, 20, 0},
+
       {"fixup_arm_mod_imm", 0, 12, 0},
       {"fixup_t2_so_imm", 0, 26, 0},
       {"fixup_bf_branch", 0, 32, MCFixupKindInfo::FKF_IsPCRel},
@@ -169,6 +173,10 @@ const MCFixupKindInfo &ARMAsmBackend::getFixupKindInfo(MCFixupKind Kind) const {
       {"fixup_arm_movw_lo16", 12, 20, 0},
       {"fixup_t2_movt_hi16", 12, 20, 0},
       {"fixup_t2_movw_lo16", 12, 20, 0},
+
+      {"fixup_t2_udf_hi16", 12, 20, 0},
+      {"fixup_t2_udf_lo16", 12, 20, 0},
+
       {"fixup_arm_mod_imm", 20, 12, 0},
       {"fixup_t2_so_imm", 26, 6, 0},
       {"fixup_bf_branch", 0, 32, MCFixupKindInfo::FKF_IsPCRel},
@@ -443,6 +451,7 @@ unsigned ARMAsmBackend::adjustFixupValue(const MCAssembler &Asm,
         A->getSymbol().isExternal() &&
         (Kind == FK_Data_4 || Kind == ARM::fixup_arm_movw_lo16 ||
          Kind == ARM::fixup_arm_movt_hi16 || Kind == ARM::fixup_t2_movw_lo16 ||
+         Kind == ARM::fixup_t2_movt_hi16 || Kind == ARM::fixup_t2_udf_lo16 ||
          Kind == ARM::fixup_t2_movt_hi16))
       Value |= 1;
   }
@@ -472,6 +481,19 @@ unsigned ARMAsmBackend::adjustFixupValue(const MCAssembler &Asm,
     Value = (Hi4 << 16) | (Lo12);
     return Value;
   }
+  case ARM::fixup_t2_udf_hi16:
+    assert(STI != nullptr);
+    if (IsResolved || !STI->getTargetTriple().isOSBinFormatELF())
+      Value >>= 16;
+    LLVM_FALLTHROUGH;
+  case ARM::fixup_t2_udf_lo16: {
+    unsigned Hi4 = (Value & 0xF000) >> 12;
+    unsigned Lo12 = Value & 0x0FFF;
+    // inst{19-16} = Hi4;
+    // inst{11-0} = Lo12;
+    Value = (Hi4 << 16) | (Lo12);
+    return swapHalfWords(Value, Endian == support::little);
+  }
   case ARM::fixup_t2_movt_hi16:
     assert(STI != nullptr);
     if (IsResolved || !STI->getTargetTriple().isOSBinFormatELF())
@@ -967,6 +989,10 @@ static unsigned getFixupKindNumBytes(unsigned Kind) {
   case ARM::fixup_arm_movw_lo16:
   case ARM::fixup_t2_movt_hi16:
   case ARM::fixup_t2_movw_lo16:
+
+  case ARM::fixup_t2_udf_hi16:
+  case ARM::fixup_t2_udf_lo16:
+
   case ARM::fixup_t2_so_imm:
   case ARM::fixup_bf_branch:
   case ARM::fixup_bf_target:
@@ -1028,6 +1054,10 @@ static unsigned getFixupKindContainerSizeBytes(unsigned Kind) {
   case ARM::fixup_arm_movw_lo16:
   case ARM::fixup_t2_movt_hi16:
   case ARM::fixup_t2_movw_lo16:
+
+  case ARM::fixup_t2_udf_hi16:
+  case ARM::fixup_t2_udf_lo16:
+  
   case ARM::fixup_arm_mod_imm:
   case ARM::fixup_t2_so_imm:
   case ARM::fixup_bf_branch:
diff --git a/llvm/lib/Target/ARM/MCTargetDesc/ARMELFObjectWriter.cpp b/llvm/lib/Target/ARM/MCTargetDesc/ARMELFObjectWriter.cpp
index df8f54d14a8690..b424bb8e74b603 100644
--- a/llvm/lib/Target/ARM/MCTargetDesc/ARMELFObjectWriter.cpp
+++ b/llvm/lib/Target/ARM/MCTargetDesc/ARMELFObjectWriter.cpp
@@ -155,6 +155,11 @@ unsigned ARMELFObjectWriter::GetRelocTypeInner(const MCValue &Target,
       return ELF::R_ARM_THM_BF12;
     case ARM::fixup_bfl_target:
       return ELF::R_ARM_THM_BF18;
+
+    case ARM::fixup_t2_udf_hi16:
+      return ELF::R_ARM_PRIVATE_14;
+    case ARM::fixup_t2_udf_lo16:
+      return ELF::R_ARM_PRIVATE_15;
     }
   }
   switch (Kind) {
@@ -233,6 +238,8 @@ unsigned ARMELFObjectWriter::GetRelocTypeInner(const MCValue &Target,
     case MCSymbolRefExpr::VK_ARM_SBREL:
       return ELF::R_ARM_MOVT_BREL;
     }
+
+    
   case ARM::fixup_arm_movw_lo16:
     switch (Modifier) {
     default:
@@ -265,6 +272,11 @@ unsigned ARMELFObjectWriter::GetRelocTypeInner(const MCValue &Target,
     case MCSymbolRefExpr::VK_ARM_SBREL:
       return ELF::R_ARM_THM_MOVW_BREL_NC;
     }
+
+    case ARM::fixup_t2_udf_hi16:
+      return ELF::R_ARM_PRIVATE_14;
+    case ARM::fixup_t2_udf_lo16:
+      return ELF::R_ARM_PRIVATE_15;
   }
 }
 
diff --git a/llvm/lib/Target/ARM/MCTargetDesc/ARMFixupKinds.h b/llvm/lib/Target/ARM/MCTargetDesc/ARMFixupKinds.h
index 53258a88c7fa27..d59b8f6fd5fefd 100644
--- a/llvm/lib/Target/ARM/MCTargetDesc/ARMFixupKinds.h
+++ b/llvm/lib/Target/ARM/MCTargetDesc/ARMFixupKinds.h
@@ -98,7 +98,8 @@ enum Fixups {
   fixup_arm_movw_lo16, // :lower16:
   fixup_t2_movt_hi16,  // :upper16:
   fixup_t2_movw_lo16,  // :lower16:
-
+  fixup_t2_udf_hi16,   // :upper16:
+  fixup_t2_udf_lo16,   // :lower16:
   // Fixup for mod_imm
   fixup_arm_mod_imm,
 
diff --git a/llvm/lib/Target/ARM/MCTargetDesc/ARMMCCodeEmitter.cpp b/llvm/lib/Target/ARM/MCTargetDesc/ARMMCCodeEmitter.cpp
index bafc0f85375605..7f194e345d5eae 100644
--- a/llvm/lib/Target/ARM/MCTargetDesc/ARMMCCodeEmitter.cpp
+++ b/llvm/lib/Target/ARM/MCTargetDesc/ARMMCCodeEmitter.cpp
@@ -1230,6 +1230,10 @@ ARMMCCodeEmitter::getHiLo16ImmOpValue(const MCInst &MI, unsigned OpIdx,
     case ARMMCExpr::VK_ARM_LO16:
       Kind = MCFixupKind(isThumb(STI) ? ARM::fixup_t2_movw_lo16
                                       : ARM::fixup_arm_movw_lo16);
+
+      if (MI.getOpcode() == ARM::t2UDF_ga) {
+        Kind = MCFixupKind(ARM::fixup_t2_udf_lo16);
+      }
       break;
     }
 
diff --git a/llvm/lib/Transforms/Hello/Hello.cpp b/llvm/lib/Transforms/Hello/Hello.cpp
index 5218d0897000d5..92aa1e449f53ab 100644
--- a/llvm/lib/Transforms/Hello/Hello.cpp
+++ b/llvm/lib/Transforms/Hello/Hello.cpp
@@ -30,8 +30,8 @@ namespace {
     bool runOnFunction(Function &F) override {
       ++HelloCounter;
       errs() << "Hello: ";
+      F.setSectionPrefix("mySection");
       errs().write_escaped(F.getName()) << '\n';
-      F.setSectionPrefix("mySection")
       return false;
     }
   };

>From 081cf99bbfa9125f764fc4ee53174b2ead3d4119 Mon Sep 17 00:00:00 2001
From: jiang-zixian <980485445 at qq.com>
Date: Sun, 31 Mar 2024 14:49:19 +0800
Subject: [PATCH 3/6] encode and decode is over!

---
 .../Driver/Inputs/CUDA-symlinks/usr/bin/ptxas |   1 -
 .../usr/bin/i386-unknown-linux-gnu-ld         |   2 +-
 .../usr/bin/x86_64-unknown-linux-gnu-ld       |   2 +-
 .../usr/i386-unknown-linux-gnu/bin/ld         |   2 +-
 .../usr/x86_64-unknown-linux-gnu/bin/ld       |   2 +-
 .../multilib_32bit_linux_tree/usr/bin/as      |   2 +-
 .../multilib_32bit_linux_tree/usr/bin/ld      |   2 +-
 .../usr/i386-unknown-linux/bin/as             |   2 +-
 .../usr/i386-unknown-linux/bin/ld             |   2 +-
 .../multilib_64bit_linux_tree/usr/bin/as      |   2 +-
 .../multilib_64bit_linux_tree/usr/bin/ld      |   2 +-
 .../usr/x86_64-unknown-linux/bin/as           |   2 +-
 .../usr/x86_64-unknown-linux/bin/ld           |   2 +-
 libclc/amdgcn-mesa3d                          |   1 -
 libclc/amdgcn-mesa3d/lib/SOURCES              |   3 +
 .../lib/workitem/get_global_size.cl           |  23 +
 .../lib/workitem/get_local_size.cl            |  29 +
 .../lib/workitem/get_num_groups.cl            |  12 +
 libclc/clspv64                                |   1 -
 libclc/clspv64/lib/SOURCES                    |  48 ++
 libclc/clspv64/lib/math/fma.cl                | 256 +++++++
 libclc/clspv64/lib/math/nextafter.cl          |   5 +
 libclc/clspv64/lib/math/nextafter.inc         |   3 +
 libclc/clspv64/lib/subnormal_config.cl        |  31 +
 libcxx/test/std/pstl                          |   1 -
 .../alg.merge/inplace_merge.pass.cpp          | 159 +++++
 .../pstl/algorithms/alg.merge/merge.pass.cpp  | 113 ++++
 .../alg.copy/copy_if.pass.cpp                 | 147 ++++
 .../alg.partitions/is_partitioned.pass.cpp    | 101 +++
 .../alg.partitions/partition.pass.cpp         | 178 +++++
 .../alg.partitions/partition_copy.pass.cpp    | 116 ++++
 .../alg.reverse/reverse.pass.cpp              | 104 +++
 .../alg.reverse/reverse_copy.pass.cpp         | 130 ++++
 .../copy_move.pass.cpp                        | 197 ++++++
 .../alg.modifying.operations/fill.pass.cpp    | 100 +++
 .../generate.pass.cpp                         | 104 +++
 .../alg.modifying.operations/remove.pass.cpp  | 161 +++++
 .../remove_copy.pass.cpp                      |  91 +++
 .../alg.modifying.operations/replace.pass.cpp | 160 +++++
 .../replace_copy.pass.cpp                     | 105 +++
 .../alg.modifying.operations/rotate.pass.cpp  | 176 +++++
 .../rotate_copy.pass.cpp                      | 146 ++++
 .../swap_ranges.pass.cpp                      | 133 ++++
 .../transform_binary.pass.cpp                 | 122 ++++
 .../transform_unary.pass.cpp                  |  91 +++
 .../alg.modifying.operations/unique.pass.cpp  | 163 +++++
 .../unique_copy_equal.pass.cpp                | 135 ++++
 .../alg.nonmodifying/adjacent_find.pass.cpp   | 114 ++++
 .../alg.nonmodifying/all_of.pass.cpp          | 117 ++++
 .../alg.nonmodifying/any_of.pass.cpp          | 103 +++
 .../alg.nonmodifying/count.pass.cpp           | 108 +++
 .../alg.nonmodifying/equal.pass.cpp           | 168 +++++
 .../algorithms/alg.nonmodifying/find.pass.cpp |  96 +++
 .../alg.nonmodifying/find_end.pass.cpp        | 123 ++++
 .../alg.nonmodifying/find_first_of.pass.cpp   | 112 ++++
 .../alg.nonmodifying/find_if.pass.cpp         | 109 +++
 .../alg.nonmodifying/for_each.pass.cpp        | 102 +++
 .../alg.nonmodifying/mismatch.pass.cpp        | 132 ++++
 .../alg.nonmodifying/none_of.pass.cpp         | 101 +++
 .../alg.nonmodifying/nth_element.pass.cpp     | 175 +++++
 .../alg.nonmodifying/search_n.pass.cpp        | 109 +++
 .../alg.heap.operations/is_heap.pass.cpp      | 146 ++++
 .../lexicographical_compare.pass.cpp          | 175 +++++
 .../alg.min.max/minmax_element.pass.cpp       | 192 ++++++
 .../alg.set.operations/includes.pass.cpp      | 106 +++
 .../alg.set.operations/set.pass.cpp           | 280 ++++++++
 .../algorithms/alg.sorting/is_sorted.pass.cpp | 100 +++
 .../alg.sorting/partial_sort.pass.cpp         | 149 +++++
 .../alg.sorting/partial_sort_copy.pass.cpp    | 196 ++++++
 .../pstl/algorithms/alg.sorting/sort.pass.cpp | 247 +++++++
 libcxx/test/std/pstl/lit.local.cfg            |   2 +
 .../numeric.ops/adjacent_difference.pass.cpp  | 170 +++++
 .../pstl/numerics/numeric.ops/reduce.pass.cpp | 114 ++++
 .../pstl/numerics/numeric.ops/scan.fail.cpp   |  28 +
 .../pstl/numerics/numeric.ops/scan.pass.cpp   | 201 ++++++
 .../numeric.ops/transform_reduce.pass.cpp     | 129 ++++
 .../numeric.ops/transform_scan.pass.cpp       | 177 +++++
 .../uninitialized_construct.pass.cpp          | 123 ++++
 .../uninitialized_copy_move.pass.cpp          | 143 ++++
 .../uninitialized_fill_destroy.pass.cpp       |  93 +++
 llvm/lib/Target/ARM/ARMEncodeDecode.cpp       | 628 ++++++++++++++++++
 llvm/lib/Target/ARM/ARMEncodeDecode.h         |  38 ++
 llvm/lib/Target/ARM/ARMRandezvousOptions.cpp  |  36 +
 llvm/lib/Target/ARM/ARMRandezvousOptions.h    |   4 +
 llvm/lib/Target/ARM/ARMTargetMachine.cpp      |   8 +
 llvm/lib/Target/ARM/CMakeLists.txt            |   4 +
 openmp/tools/analyzer/llvm-openmp-analyzer++  |  46 +-
 87 files changed, 8557 insertions(+), 17 deletions(-)
 mode change 120000 => 100755 clang/test/Driver/Inputs/CUDA-symlinks/usr/bin/ptxas
 mode change 120000 => 100755 clang/test/Driver/Inputs/basic_cross_linux_tree/usr/bin/i386-unknown-linux-gnu-ld
 mode change 120000 => 100755 clang/test/Driver/Inputs/basic_cross_linux_tree/usr/bin/x86_64-unknown-linux-gnu-ld
 mode change 120000 => 100755 clang/test/Driver/Inputs/basic_cross_linux_tree/usr/i386-unknown-linux-gnu/bin/ld
 mode change 120000 => 100755 clang/test/Driver/Inputs/basic_cross_linux_tree/usr/x86_64-unknown-linux-gnu/bin/ld
 mode change 120000 => 100755 clang/test/Driver/Inputs/multilib_32bit_linux_tree/usr/bin/as
 mode change 120000 => 100755 clang/test/Driver/Inputs/multilib_32bit_linux_tree/usr/bin/ld
 mode change 120000 => 100755 clang/test/Driver/Inputs/multilib_32bit_linux_tree/usr/i386-unknown-linux/bin/as
 mode change 120000 => 100755 clang/test/Driver/Inputs/multilib_32bit_linux_tree/usr/i386-unknown-linux/bin/ld
 mode change 120000 => 100755 clang/test/Driver/Inputs/multilib_64bit_linux_tree/usr/bin/as
 mode change 120000 => 100755 clang/test/Driver/Inputs/multilib_64bit_linux_tree/usr/bin/ld
 mode change 120000 => 100755 clang/test/Driver/Inputs/multilib_64bit_linux_tree/usr/x86_64-unknown-linux/bin/as
 mode change 120000 => 100755 clang/test/Driver/Inputs/multilib_64bit_linux_tree/usr/x86_64-unknown-linux/bin/ld
 delete mode 120000 libclc/amdgcn-mesa3d
 create mode 100644 libclc/amdgcn-mesa3d/lib/SOURCES
 create mode 100644 libclc/amdgcn-mesa3d/lib/workitem/get_global_size.cl
 create mode 100644 libclc/amdgcn-mesa3d/lib/workitem/get_local_size.cl
 create mode 100644 libclc/amdgcn-mesa3d/lib/workitem/get_num_groups.cl
 delete mode 120000 libclc/clspv64
 create mode 100644 libclc/clspv64/lib/SOURCES
 create mode 100644 libclc/clspv64/lib/math/fma.cl
 create mode 100644 libclc/clspv64/lib/math/nextafter.cl
 create mode 100644 libclc/clspv64/lib/math/nextafter.inc
 create mode 100644 libclc/clspv64/lib/subnormal_config.cl
 delete mode 120000 libcxx/test/std/pstl
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.merge/inplace_merge.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.merge/merge.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.modifying.operations/alg.copy/copy_if.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.modifying.operations/alg.partitions/is_partitioned.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.modifying.operations/alg.partitions/partition.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.modifying.operations/alg.partitions/partition_copy.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.modifying.operations/alg.reverse/reverse.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.modifying.operations/alg.reverse/reverse_copy.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.modifying.operations/copy_move.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.modifying.operations/fill.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.modifying.operations/generate.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.modifying.operations/remove.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.modifying.operations/remove_copy.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.modifying.operations/replace.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.modifying.operations/replace_copy.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.modifying.operations/rotate.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.modifying.operations/rotate_copy.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.modifying.operations/swap_ranges.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.modifying.operations/transform_binary.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.modifying.operations/transform_unary.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.modifying.operations/unique.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.modifying.operations/unique_copy_equal.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.nonmodifying/adjacent_find.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.nonmodifying/all_of.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.nonmodifying/any_of.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.nonmodifying/count.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.nonmodifying/equal.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.nonmodifying/find.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.nonmodifying/find_end.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.nonmodifying/find_first_of.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.nonmodifying/find_if.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.nonmodifying/for_each.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.nonmodifying/mismatch.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.nonmodifying/none_of.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.nonmodifying/nth_element.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.nonmodifying/search_n.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.sorting/alg.heap.operations/is_heap.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.sorting/alg.min.max/minmax_element.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.sorting/alg.set.operations/includes.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.sorting/alg.set.operations/set.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.sorting/is_sorted.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.sorting/partial_sort.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.sorting/partial_sort_copy.pass.cpp
 create mode 100644 libcxx/test/std/pstl/algorithms/alg.sorting/sort.pass.cpp
 create mode 100644 libcxx/test/std/pstl/lit.local.cfg
 create mode 100644 libcxx/test/std/pstl/numerics/numeric.ops/adjacent_difference.pass.cpp
 create mode 100644 libcxx/test/std/pstl/numerics/numeric.ops/reduce.pass.cpp
 create mode 100644 libcxx/test/std/pstl/numerics/numeric.ops/scan.fail.cpp
 create mode 100644 libcxx/test/std/pstl/numerics/numeric.ops/scan.pass.cpp
 create mode 100644 libcxx/test/std/pstl/numerics/numeric.ops/transform_reduce.pass.cpp
 create mode 100644 libcxx/test/std/pstl/numerics/numeric.ops/transform_scan.pass.cpp
 create mode 100644 libcxx/test/std/pstl/utilities/memory/specialized.algorithms/uninitialized_construct.pass.cpp
 create mode 100644 libcxx/test/std/pstl/utilities/memory/specialized.algorithms/uninitialized_copy_move.pass.cpp
 create mode 100644 libcxx/test/std/pstl/utilities/memory/specialized.algorithms/uninitialized_fill_destroy.pass.cpp
 create mode 100755 llvm/lib/Target/ARM/ARMEncodeDecode.cpp
 create mode 100755 llvm/lib/Target/ARM/ARMEncodeDecode.h
 mode change 100644 => 100755 llvm/lib/Target/ARM/ARMRandezvousOptions.cpp
 mode change 100644 => 100755 llvm/lib/Target/ARM/ARMRandezvousOptions.h
 mode change 100644 => 100755 llvm/lib/Target/ARM/ARMTargetMachine.cpp
 mode change 100644 => 100755 llvm/lib/Target/ARM/CMakeLists.txt
 mode change 120000 => 100755 openmp/tools/analyzer/llvm-openmp-analyzer++

diff --git a/clang/test/Driver/Inputs/CUDA-symlinks/usr/bin/ptxas b/clang/test/Driver/Inputs/CUDA-symlinks/usr/bin/ptxas
deleted file mode 120000
index 59eefd95a9023c..00000000000000
--- a/clang/test/Driver/Inputs/CUDA-symlinks/usr/bin/ptxas
+++ /dev/null
@@ -1 +0,0 @@
-../../opt/cuda/bin/ptxas
\ No newline at end of file
diff --git a/clang/test/Driver/Inputs/CUDA-symlinks/usr/bin/ptxas b/clang/test/Driver/Inputs/CUDA-symlinks/usr/bin/ptxas
new file mode 100755
index 00000000000000..e69de29bb2d1d6
diff --git a/clang/test/Driver/Inputs/basic_cross_linux_tree/usr/bin/i386-unknown-linux-gnu-ld b/clang/test/Driver/Inputs/basic_cross_linux_tree/usr/bin/i386-unknown-linux-gnu-ld
deleted file mode 120000
index 7e0a9cfe2ddbd6..00000000000000
--- a/clang/test/Driver/Inputs/basic_cross_linux_tree/usr/bin/i386-unknown-linux-gnu-ld
+++ /dev/null
@@ -1 +0,0 @@
-i386-unknown-linux-gnu-ld.gold
\ No newline at end of file
diff --git a/clang/test/Driver/Inputs/basic_cross_linux_tree/usr/bin/i386-unknown-linux-gnu-ld b/clang/test/Driver/Inputs/basic_cross_linux_tree/usr/bin/i386-unknown-linux-gnu-ld
new file mode 100755
index 00000000000000..b23e55619b2ff0
--- /dev/null
+++ b/clang/test/Driver/Inputs/basic_cross_linux_tree/usr/bin/i386-unknown-linux-gnu-ld
@@ -0,0 +1 @@
+#!/bin/true
diff --git a/clang/test/Driver/Inputs/basic_cross_linux_tree/usr/bin/x86_64-unknown-linux-gnu-ld b/clang/test/Driver/Inputs/basic_cross_linux_tree/usr/bin/x86_64-unknown-linux-gnu-ld
deleted file mode 120000
index ce36ac093b6176..00000000000000
--- a/clang/test/Driver/Inputs/basic_cross_linux_tree/usr/bin/x86_64-unknown-linux-gnu-ld
+++ /dev/null
@@ -1 +0,0 @@
-x86_64-unknown-linux-gnu-ld.gold
\ No newline at end of file
diff --git a/clang/test/Driver/Inputs/basic_cross_linux_tree/usr/bin/x86_64-unknown-linux-gnu-ld b/clang/test/Driver/Inputs/basic_cross_linux_tree/usr/bin/x86_64-unknown-linux-gnu-ld
new file mode 100755
index 00000000000000..b23e55619b2ff0
--- /dev/null
+++ b/clang/test/Driver/Inputs/basic_cross_linux_tree/usr/bin/x86_64-unknown-linux-gnu-ld
@@ -0,0 +1 @@
+#!/bin/true
diff --git a/clang/test/Driver/Inputs/basic_cross_linux_tree/usr/i386-unknown-linux-gnu/bin/ld b/clang/test/Driver/Inputs/basic_cross_linux_tree/usr/i386-unknown-linux-gnu/bin/ld
deleted file mode 120000
index 6cd03701cdda78..00000000000000
--- a/clang/test/Driver/Inputs/basic_cross_linux_tree/usr/i386-unknown-linux-gnu/bin/ld
+++ /dev/null
@@ -1 +0,0 @@
-ld.gold
\ No newline at end of file
diff --git a/clang/test/Driver/Inputs/basic_cross_linux_tree/usr/i386-unknown-linux-gnu/bin/ld b/clang/test/Driver/Inputs/basic_cross_linux_tree/usr/i386-unknown-linux-gnu/bin/ld
new file mode 100755
index 00000000000000..b23e55619b2ff0
--- /dev/null
+++ b/clang/test/Driver/Inputs/basic_cross_linux_tree/usr/i386-unknown-linux-gnu/bin/ld
@@ -0,0 +1 @@
+#!/bin/true
diff --git a/clang/test/Driver/Inputs/basic_cross_linux_tree/usr/x86_64-unknown-linux-gnu/bin/ld b/clang/test/Driver/Inputs/basic_cross_linux_tree/usr/x86_64-unknown-linux-gnu/bin/ld
deleted file mode 120000
index 6cd03701cdda78..00000000000000
--- a/clang/test/Driver/Inputs/basic_cross_linux_tree/usr/x86_64-unknown-linux-gnu/bin/ld
+++ /dev/null
@@ -1 +0,0 @@
-ld.gold
\ No newline at end of file
diff --git a/clang/test/Driver/Inputs/basic_cross_linux_tree/usr/x86_64-unknown-linux-gnu/bin/ld b/clang/test/Driver/Inputs/basic_cross_linux_tree/usr/x86_64-unknown-linux-gnu/bin/ld
new file mode 100755
index 00000000000000..b23e55619b2ff0
--- /dev/null
+++ b/clang/test/Driver/Inputs/basic_cross_linux_tree/usr/x86_64-unknown-linux-gnu/bin/ld
@@ -0,0 +1 @@
+#!/bin/true
diff --git a/clang/test/Driver/Inputs/multilib_32bit_linux_tree/usr/bin/as b/clang/test/Driver/Inputs/multilib_32bit_linux_tree/usr/bin/as
deleted file mode 120000
index 0065315cfd1de8..00000000000000
--- a/clang/test/Driver/Inputs/multilib_32bit_linux_tree/usr/bin/as
+++ /dev/null
@@ -1 +0,0 @@
-i386-unknown-linux-gnu-as
\ No newline at end of file
diff --git a/clang/test/Driver/Inputs/multilib_32bit_linux_tree/usr/bin/as b/clang/test/Driver/Inputs/multilib_32bit_linux_tree/usr/bin/as
new file mode 100755
index 00000000000000..b23e55619b2ff0
--- /dev/null
+++ b/clang/test/Driver/Inputs/multilib_32bit_linux_tree/usr/bin/as
@@ -0,0 +1 @@
+#!/bin/true
diff --git a/clang/test/Driver/Inputs/multilib_32bit_linux_tree/usr/bin/ld b/clang/test/Driver/Inputs/multilib_32bit_linux_tree/usr/bin/ld
deleted file mode 120000
index 9e5574285c70e4..00000000000000
--- a/clang/test/Driver/Inputs/multilib_32bit_linux_tree/usr/bin/ld
+++ /dev/null
@@ -1 +0,0 @@
-i386-unknown-linux-gnu-ld
\ No newline at end of file
diff --git a/clang/test/Driver/Inputs/multilib_32bit_linux_tree/usr/bin/ld b/clang/test/Driver/Inputs/multilib_32bit_linux_tree/usr/bin/ld
new file mode 100755
index 00000000000000..b23e55619b2ff0
--- /dev/null
+++ b/clang/test/Driver/Inputs/multilib_32bit_linux_tree/usr/bin/ld
@@ -0,0 +1 @@
+#!/bin/true
diff --git a/clang/test/Driver/Inputs/multilib_32bit_linux_tree/usr/i386-unknown-linux/bin/as b/clang/test/Driver/Inputs/multilib_32bit_linux_tree/usr/i386-unknown-linux/bin/as
deleted file mode 120000
index 2aa12fdef91620..00000000000000
--- a/clang/test/Driver/Inputs/multilib_32bit_linux_tree/usr/i386-unknown-linux/bin/as
+++ /dev/null
@@ -1 +0,0 @@
-../../bin/i386-unknown-linux-gnu-as
\ No newline at end of file
diff --git a/clang/test/Driver/Inputs/multilib_32bit_linux_tree/usr/i386-unknown-linux/bin/as b/clang/test/Driver/Inputs/multilib_32bit_linux_tree/usr/i386-unknown-linux/bin/as
new file mode 100755
index 00000000000000..b23e55619b2ff0
--- /dev/null
+++ b/clang/test/Driver/Inputs/multilib_32bit_linux_tree/usr/i386-unknown-linux/bin/as
@@ -0,0 +1 @@
+#!/bin/true
diff --git a/clang/test/Driver/Inputs/multilib_32bit_linux_tree/usr/i386-unknown-linux/bin/ld b/clang/test/Driver/Inputs/multilib_32bit_linux_tree/usr/i386-unknown-linux/bin/ld
deleted file mode 120000
index 5aeaff619662a8..00000000000000
--- a/clang/test/Driver/Inputs/multilib_32bit_linux_tree/usr/i386-unknown-linux/bin/ld
+++ /dev/null
@@ -1 +0,0 @@
-../../bin/i386-unknown-linux-gnu-ld
\ No newline at end of file
diff --git a/clang/test/Driver/Inputs/multilib_32bit_linux_tree/usr/i386-unknown-linux/bin/ld b/clang/test/Driver/Inputs/multilib_32bit_linux_tree/usr/i386-unknown-linux/bin/ld
new file mode 100755
index 00000000000000..b23e55619b2ff0
--- /dev/null
+++ b/clang/test/Driver/Inputs/multilib_32bit_linux_tree/usr/i386-unknown-linux/bin/ld
@@ -0,0 +1 @@
+#!/bin/true
diff --git a/clang/test/Driver/Inputs/multilib_64bit_linux_tree/usr/bin/as b/clang/test/Driver/Inputs/multilib_64bit_linux_tree/usr/bin/as
deleted file mode 120000
index 477cbc9635fcbf..00000000000000
--- a/clang/test/Driver/Inputs/multilib_64bit_linux_tree/usr/bin/as
+++ /dev/null
@@ -1 +0,0 @@
-x86_64-unknown-linux-gnu-as
\ No newline at end of file
diff --git a/clang/test/Driver/Inputs/multilib_64bit_linux_tree/usr/bin/as b/clang/test/Driver/Inputs/multilib_64bit_linux_tree/usr/bin/as
new file mode 100755
index 00000000000000..b23e55619b2ff0
--- /dev/null
+++ b/clang/test/Driver/Inputs/multilib_64bit_linux_tree/usr/bin/as
@@ -0,0 +1 @@
+#!/bin/true
diff --git a/clang/test/Driver/Inputs/multilib_64bit_linux_tree/usr/bin/ld b/clang/test/Driver/Inputs/multilib_64bit_linux_tree/usr/bin/ld
deleted file mode 120000
index 5343caf34d8f34..00000000000000
--- a/clang/test/Driver/Inputs/multilib_64bit_linux_tree/usr/bin/ld
+++ /dev/null
@@ -1 +0,0 @@
-x86_64-unknown-linux-gnu-ld
\ No newline at end of file
diff --git a/clang/test/Driver/Inputs/multilib_64bit_linux_tree/usr/bin/ld b/clang/test/Driver/Inputs/multilib_64bit_linux_tree/usr/bin/ld
new file mode 100755
index 00000000000000..b23e55619b2ff0
--- /dev/null
+++ b/clang/test/Driver/Inputs/multilib_64bit_linux_tree/usr/bin/ld
@@ -0,0 +1 @@
+#!/bin/true
diff --git a/clang/test/Driver/Inputs/multilib_64bit_linux_tree/usr/x86_64-unknown-linux/bin/as b/clang/test/Driver/Inputs/multilib_64bit_linux_tree/usr/x86_64-unknown-linux/bin/as
deleted file mode 120000
index 84a9113f2671f4..00000000000000
--- a/clang/test/Driver/Inputs/multilib_64bit_linux_tree/usr/x86_64-unknown-linux/bin/as
+++ /dev/null
@@ -1 +0,0 @@
-../../bin/x86_64-unknown-linux-gnu-as
\ No newline at end of file
diff --git a/clang/test/Driver/Inputs/multilib_64bit_linux_tree/usr/x86_64-unknown-linux/bin/as b/clang/test/Driver/Inputs/multilib_64bit_linux_tree/usr/x86_64-unknown-linux/bin/as
new file mode 100755
index 00000000000000..b23e55619b2ff0
--- /dev/null
+++ b/clang/test/Driver/Inputs/multilib_64bit_linux_tree/usr/x86_64-unknown-linux/bin/as
@@ -0,0 +1 @@
+#!/bin/true
diff --git a/clang/test/Driver/Inputs/multilib_64bit_linux_tree/usr/x86_64-unknown-linux/bin/ld b/clang/test/Driver/Inputs/multilib_64bit_linux_tree/usr/x86_64-unknown-linux/bin/ld
deleted file mode 120000
index c417e3afaa4945..00000000000000
--- a/clang/test/Driver/Inputs/multilib_64bit_linux_tree/usr/x86_64-unknown-linux/bin/ld
+++ /dev/null
@@ -1 +0,0 @@
-../../bin/x86_64-unknown-linux-gnu-ld
\ No newline at end of file
diff --git a/clang/test/Driver/Inputs/multilib_64bit_linux_tree/usr/x86_64-unknown-linux/bin/ld b/clang/test/Driver/Inputs/multilib_64bit_linux_tree/usr/x86_64-unknown-linux/bin/ld
new file mode 100755
index 00000000000000..b23e55619b2ff0
--- /dev/null
+++ b/clang/test/Driver/Inputs/multilib_64bit_linux_tree/usr/x86_64-unknown-linux/bin/ld
@@ -0,0 +1 @@
+#!/bin/true
diff --git a/libclc/amdgcn-mesa3d b/libclc/amdgcn-mesa3d
deleted file mode 120000
index 400782833efe6c..00000000000000
--- a/libclc/amdgcn-mesa3d
+++ /dev/null
@@ -1 +0,0 @@
-amdgcn-amdhsa
\ No newline at end of file
diff --git a/libclc/amdgcn-mesa3d/lib/SOURCES b/libclc/amdgcn-mesa3d/lib/SOURCES
new file mode 100644
index 00000000000000..8224b7721b2ca5
--- /dev/null
+++ b/libclc/amdgcn-mesa3d/lib/SOURCES
@@ -0,0 +1,3 @@
+workitem/get_global_size.cl
+workitem/get_local_size.cl
+workitem/get_num_groups.cl
diff --git a/libclc/amdgcn-mesa3d/lib/workitem/get_global_size.cl b/libclc/amdgcn-mesa3d/lib/workitem/get_global_size.cl
new file mode 100644
index 00000000000000..62bd2ba283523f
--- /dev/null
+++ b/libclc/amdgcn-mesa3d/lib/workitem/get_global_size.cl
@@ -0,0 +1,23 @@
+#include <clc/clc.h>
+
+#if __clang_major__ >= 8
+#define CONST_AS __constant
+#elif __clang_major__ >= 7
+#define CONST_AS __attribute__((address_space(4)))
+#else
+#define CONST_AS __attribute__((address_space(2)))
+#endif
+
+#if __clang_major__ >= 6
+#define __dispatch_ptr __builtin_amdgcn_dispatch_ptr
+#else
+#define __dispatch_ptr __clc_amdgcn_dispatch_ptr
+CONST_AS uchar * __clc_amdgcn_dispatch_ptr(void) __asm("llvm.amdgcn.dispatch.ptr");
+#endif
+
+_CLC_DEF _CLC_OVERLOAD size_t get_global_size(uint dim) {
+  CONST_AS uint *ptr = (CONST_AS uint *)__dispatch_ptr();
+  if (dim < 3)
+    return ptr[3 + dim];
+  return 1;
+}
diff --git a/libclc/amdgcn-mesa3d/lib/workitem/get_local_size.cl b/libclc/amdgcn-mesa3d/lib/workitem/get_local_size.cl
new file mode 100644
index 00000000000000..9f09fd5a16ec66
--- /dev/null
+++ b/libclc/amdgcn-mesa3d/lib/workitem/get_local_size.cl
@@ -0,0 +1,29 @@
+#include <clc/clc.h>
+
+#if __clang_major__ >= 8
+#define CONST_AS __constant
+#elif __clang_major__ >= 7
+#define CONST_AS __attribute__((address_space(4)))
+#else
+#define CONST_AS __attribute__((address_space(2)))
+#endif
+
+#if __clang_major__ >= 6
+#define __dispatch_ptr __builtin_amdgcn_dispatch_ptr
+#else
+#define __dispatch_ptr __clc_amdgcn_dispatch_ptr
+CONST_AS char * __clc_amdgcn_dispatch_ptr(void) __asm("llvm.amdgcn.dispatch.ptr");
+#endif
+
+_CLC_DEF _CLC_OVERLOAD size_t get_local_size(uint dim) {
+  CONST_AS uint *ptr = (CONST_AS uint *)__dispatch_ptr();
+  switch (dim) {
+  case 0:
+    return ptr[1] & 0xffffu;
+  case 1:
+    return ptr[1] >> 16;
+  case 2:
+    return ptr[2] & 0xffffu;
+  }
+  return 1;
+}
diff --git a/libclc/amdgcn-mesa3d/lib/workitem/get_num_groups.cl b/libclc/amdgcn-mesa3d/lib/workitem/get_num_groups.cl
new file mode 100644
index 00000000000000..35dc2218852114
--- /dev/null
+++ b/libclc/amdgcn-mesa3d/lib/workitem/get_num_groups.cl
@@ -0,0 +1,12 @@
+
+#include <clc/clc.h>
+
+_CLC_DEF _CLC_OVERLOAD size_t get_num_groups(uint dim) {
+  size_t global_size = get_global_size(dim);
+  size_t local_size = get_local_size(dim);
+  size_t num_groups = global_size / local_size;
+  if (global_size % local_size != 0) {
+    num_groups++;
+  }
+  return num_groups;
+}
diff --git a/libclc/clspv64 b/libclc/clspv64
deleted file mode 120000
index ea01ba94bc6368..00000000000000
--- a/libclc/clspv64
+++ /dev/null
@@ -1 +0,0 @@
-clspv
\ No newline at end of file
diff --git a/libclc/clspv64/lib/SOURCES b/libclc/clspv64/lib/SOURCES
new file mode 100644
index 00000000000000..0466345cee0271
--- /dev/null
+++ b/libclc/clspv64/lib/SOURCES
@@ -0,0 +1,48 @@
+subnormal_config.cl
+../../generic/lib/geometric/distance.cl
+../../generic/lib/geometric/length.cl
+math/fma.cl
+math/nextafter.cl
+../../generic/lib/math/acosh.cl
+../../generic/lib/math/asinh.cl
+../../generic/lib/math/atan.cl
+../../generic/lib/math/atan2.cl
+../../generic/lib/math/atan2pi.cl
+../../generic/lib/math/atanh.cl
+../../generic/lib/math/atanpi.cl
+../../generic/lib/math/cbrt.cl
+../../generic/lib/math/clc_fmod.cl
+../../generic/lib/math/clc_hypot.cl
+../../generic/lib/math/clc_ldexp.cl
+../../generic/lib/math/clc_nextafter.cl
+../../generic/lib/math/clc_remainder.cl
+../../generic/lib/math/clc_remquo.cl
+../../generic/lib/math/clc_rootn.cl
+../../generic/lib/math/clc_sqrt.cl
+../../generic/lib/math/clc_tan.cl
+../../generic/lib/math/erf.cl
+../../generic/lib/math/erfc.cl
+../../generic/lib/math/fmod.cl
+../../generic/lib/math/fract.cl
+../../generic/lib/math/frexp.cl
+../../generic/lib/math/half_divide.cl
+../../generic/lib/math/half_recip.cl
+../../generic/lib/math/half_sqrt.cl
+../../generic/lib/math/hypot.cl
+../../generic/lib/math/ilogb.cl
+../../generic/lib/math/ldexp.cl
+../../generic/lib/math/lgamma.cl
+../../generic/lib/math/lgamma_r.cl
+../../generic/lib/math/logb.cl
+../../generic/lib/math/maxmag.cl
+../../generic/lib/math/minmag.cl
+../../generic/lib/math/modf.cl
+../../generic/lib/math/nan.cl
+../../generic/lib/math/remainder.cl
+../../generic/lib/math/remquo.cl
+../../generic/lib/math/rootn.cl
+../../generic/lib/math/rsqrt.cl
+../../generic/lib/math/sqrt.cl
+../../generic/lib/math/tables.cl
+../../generic/lib/math/tanh.cl
+../../generic/lib/math/tgamma.cl
diff --git a/libclc/clspv64/lib/math/fma.cl b/libclc/clspv64/lib/math/fma.cl
new file mode 100644
index 00000000000000..fdc8b8b296876c
--- /dev/null
+++ b/libclc/clspv64/lib/math/fma.cl
@@ -0,0 +1,256 @@
+/*
+ * Copyright (c) 2014 Advanced Micro Devices, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+// This version is derived from the generic fma software implementation
+// (__clc_sw_fma), but avoids the use of ulong in favor of uint2. The logic has
+// been updated as appropriate.
+
+#include <clc/clc.h>
+#include "../../../generic/lib/clcmacro.h"
+#include "../../../generic/lib/math/math.h"
+
+struct fp {
+  uint2 mantissa;
+  int exponent;
+  uint sign;
+};
+
+_CLC_DEF _CLC_OVERLOAD float fma(float a, float b, float c) {
+  /* special cases */
+  if (isnan(a) || isnan(b) || isnan(c) || isinf(a) || isinf(b)) {
+    return mad(a, b, c);
+  }
+
+  /* If only c is inf, and both a,b are regular numbers, the result is c*/
+  if (isinf(c)) {
+    return c;
+  }
+
+  a = __clc_flush_denormal_if_not_supported(a);
+  b = __clc_flush_denormal_if_not_supported(b);
+  c = __clc_flush_denormal_if_not_supported(c);
+
+  if (a == 0.0f || b == 0.0f) {
+    return c;
+  }
+
+  if (c == 0) {
+    return a * b;
+  }
+
+  struct fp st_a, st_b, st_c;
+
+  st_a.exponent = a == .0f ? 0 : ((as_uint(a) & 0x7f800000) >> 23) - 127;
+  st_b.exponent = b == .0f ? 0 : ((as_uint(b) & 0x7f800000) >> 23) - 127;
+  st_c.exponent = c == .0f ? 0 : ((as_uint(c) & 0x7f800000) >> 23) - 127;
+
+  st_a.mantissa.lo = a == .0f ? 0 : (as_uint(a) & 0x7fffff) | 0x800000;
+  st_b.mantissa.lo = b == .0f ? 0 : (as_uint(b) & 0x7fffff) | 0x800000;
+  st_c.mantissa.lo = c == .0f ? 0 : (as_uint(c) & 0x7fffff) | 0x800000;
+  st_a.mantissa.hi = 0;
+  st_b.mantissa.hi = 0;
+  st_c.mantissa.hi = 0;
+
+  st_a.sign = as_uint(a) & 0x80000000;
+  st_b.sign = as_uint(b) & 0x80000000;
+  st_c.sign = as_uint(c) & 0x80000000;
+
+  // Multiplication.
+  // Move the product to the highest bits to maximize precision
+  // mantissa is 24 bits => product is 48 bits, 2bits non-fraction.
+  // Add one bit for future addition overflow,
+  // add another bit to detect subtraction underflow
+  struct fp st_mul;
+  st_mul.sign = st_a.sign ^ st_b.sign;
+  st_mul.mantissa.hi = mul_hi(st_a.mantissa.lo, st_b.mantissa.lo);
+  st_mul.mantissa.lo = st_a.mantissa.lo * st_b.mantissa.lo;
+  uint upper_14bits = (st_mul.mantissa.lo >> 18) & 0x3fff;
+  st_mul.mantissa.lo <<= 14;
+  st_mul.mantissa.hi <<= 14;
+  st_mul.mantissa.hi |= upper_14bits;
+  st_mul.exponent = (st_mul.mantissa.lo != 0 || st_mul.mantissa.hi != 0)
+                        ? st_a.exponent + st_b.exponent
+                        : 0;
+
+// Mantissa is 23 fractional bits, shift it the same way as product mantissa
+#define C_ADJUST 37ul
+
+  // both exponents are bias adjusted
+  int exp_diff = st_mul.exponent - st_c.exponent;
+
+  uint abs_exp_diff = abs(exp_diff);
+  st_c.mantissa.hi = (st_c.mantissa.lo << 5);
+  st_c.mantissa.lo = 0;
+  uint2 cutoff_bits = (uint2)(0, 0);
+  uint2 cutoff_mask = (uint2)(0, 0);
+  if (abs_exp_diff < 32) {
+    cutoff_mask.lo = (1u << abs(exp_diff)) - 1u;
+  } else if (abs_exp_diff < 64) {
+    cutoff_mask.lo = 0xffffffff;
+    uint remaining = abs_exp_diff - 32;
+    cutoff_mask.hi = (1u << remaining) - 1u;
+  } else {
+    cutoff_mask = (uint2)(0, 0);
+  }
+  uint2 tmp = (exp_diff > 0) ? st_c.mantissa : st_mul.mantissa;
+  if (abs_exp_diff > 0) {
+    cutoff_bits = abs_exp_diff >= 64 ? tmp : (tmp & cutoff_mask);
+    if (abs_exp_diff < 32) {
+      // shift some of the hi bits into the shifted lo bits.
+      uint shift_mask = (1u << abs_exp_diff) - 1;
+      uint upper_saved_bits = tmp.hi & shift_mask;
+      upper_saved_bits = upper_saved_bits << (32 - abs_exp_diff);
+      tmp.hi >>= abs_exp_diff;
+      tmp.lo >>= abs_exp_diff;
+      tmp.lo |= upper_saved_bits;
+    } else if (abs_exp_diff < 64) {
+      tmp.lo = (tmp.hi >> (abs_exp_diff - 32));
+      tmp.hi = 0;
+    } else {
+      tmp = (uint2)(0, 0);
+    }
+  }
+  if (exp_diff > 0)
+    st_c.mantissa = tmp;
+  else
+    st_mul.mantissa = tmp;
+
+  struct fp st_fma;
+  st_fma.sign = st_mul.sign;
+  st_fma.exponent = max(st_mul.exponent, st_c.exponent);
+  st_fma.mantissa = (uint2)(0, 0);
+  if (st_c.sign == st_mul.sign) {
+    uint carry = (hadd(st_mul.mantissa.lo, st_c.mantissa.lo) >> 31) & 0x1;
+    st_fma.mantissa = st_mul.mantissa + st_c.mantissa;
+    st_fma.mantissa.hi += carry;
+  } else {
+    // cutoff bits borrow one
+    uint cutoff_borrow = ((cutoff_bits.lo != 0 || cutoff_bits.hi != 0) &&
+                          (st_mul.exponent > st_c.exponent))
+                             ? 1
+                             : 0;
+    uint borrow = 0;
+    if (st_c.mantissa.lo > st_mul.mantissa.lo) {
+      borrow = 1;
+    } else if (st_c.mantissa.lo == UINT_MAX && cutoff_borrow == 1) {
+      borrow = 1;
+    } else if ((st_c.mantissa.lo + cutoff_borrow) > st_mul.mantissa.lo) {
+      borrow = 1;
+    }
+
+    st_fma.mantissa.lo = st_mul.mantissa.lo - st_c.mantissa.lo - cutoff_borrow;
+    st_fma.mantissa.hi = st_mul.mantissa.hi - st_c.mantissa.hi - borrow;
+  }
+
+  // underflow: st_c.sign != st_mul.sign, and magnitude switches the sign
+  if (st_fma.mantissa.hi > INT_MAX) {
+    st_fma.mantissa = ~st_fma.mantissa;
+    uint carry = (hadd(st_fma.mantissa.lo, 1u) >> 31) & 0x1;
+    st_fma.mantissa.lo += 1;
+    st_fma.mantissa.hi += carry;
+
+    st_fma.sign = st_mul.sign ^ 0x80000000;
+  }
+
+  // detect overflow/underflow
+  uint leading_zeroes = clz(st_fma.mantissa.hi);
+  if (leading_zeroes == 32) {
+    leading_zeroes += clz(st_fma.mantissa.lo);
+  }
+  int overflow_bits = 3 - leading_zeroes;
+
+  // adjust exponent
+  st_fma.exponent += overflow_bits;
+
+  // handle underflow
+  if (overflow_bits < 0) {
+    uint shift = -overflow_bits;
+    if (shift < 32) {
+      uint shift_mask = (1u << shift) - 1;
+      uint saved_lo_bits = (st_fma.mantissa.lo >> (32 - shift)) & shift_mask;
+      st_fma.mantissa.lo <<= shift;
+      st_fma.mantissa.hi <<= shift;
+      st_fma.mantissa.hi |= saved_lo_bits;
+    } else if (shift < 64) {
+      st_fma.mantissa.hi = (st_fma.mantissa.lo << (64 - shift));
+      st_fma.mantissa.lo = 0;
+    } else {
+      st_fma.mantissa = (uint2)(0, 0);
+    }
+
+    overflow_bits = 0;
+  }
+
+  // rounding
+  // overflow_bits is now in the range of [0, 3] making the shift greater than
+  // 32 bits.
+  uint2 trunc_mask;
+  uint trunc_shift = C_ADJUST + overflow_bits - 32;
+  trunc_mask.hi = (1u << trunc_shift) - 1;
+  trunc_mask.lo = UINT_MAX;
+  uint2 trunc_bits = st_fma.mantissa & trunc_mask;
+  trunc_bits.lo |= (cutoff_bits.hi != 0 || cutoff_bits.lo != 0) ? 1 : 0;
+  uint2 last_bit;
+  last_bit.lo = 0;
+  last_bit.hi = st_fma.mantissa.hi & (1u << trunc_shift);
+  uint grs_shift = C_ADJUST - 3 + overflow_bits - 32;
+  uint2 grs_bits;
+  grs_bits.lo = 0;
+  grs_bits.hi = 0x4u << grs_shift;
+
+  // round to nearest even
+  if ((trunc_bits.hi > grs_bits.hi ||
+       (trunc_bits.hi == grs_bits.hi && trunc_bits.lo > grs_bits.lo)) ||
+      (trunc_bits.hi == grs_bits.hi && trunc_bits.lo == grs_bits.lo &&
+       last_bit.hi != 0)) {
+    uint shift = C_ADJUST + overflow_bits - 32;
+    st_fma.mantissa.hi += 1u << shift;
+  }
+
+        // Shift mantissa back to bit 23
+  st_fma.mantissa.lo = (st_fma.mantissa.hi >> (C_ADJUST + overflow_bits - 32));
+  st_fma.mantissa.hi = 0;
+
+  // Detect rounding overflow
+  if (st_fma.mantissa.lo > 0xffffff) {
+    ++st_fma.exponent;
+    st_fma.mantissa.lo >>= 1;
+  }
+
+  if (st_fma.mantissa.lo == 0) {
+    return 0.0f;
+  }
+
+  // Flating point range limit
+  if (st_fma.exponent > 127) {
+    return as_float(as_uint(INFINITY) | st_fma.sign);
+  }
+
+  // Flush denormals
+  if (st_fma.exponent <= -127) {
+    return as_float(st_fma.sign);
+  }
+
+  return as_float(st_fma.sign | ((st_fma.exponent + 127) << 23) |
+                  ((uint)st_fma.mantissa.lo & 0x7fffff));
+}
+_CLC_TERNARY_VECTORIZE(_CLC_DEF _CLC_OVERLOAD, float, fma, float, float, float)
diff --git a/libclc/clspv64/lib/math/nextafter.cl b/libclc/clspv64/lib/math/nextafter.cl
new file mode 100644
index 00000000000000..f05e7482136203
--- /dev/null
+++ b/libclc/clspv64/lib/math/nextafter.cl
@@ -0,0 +1,5 @@
+#include <clc/clc.h>
+#include <math/clc_nextafter.h>
+
+#define __CLC_BODY <nextafter.inc>
+#include <clc/math/gentype.inc>
diff --git a/libclc/clspv64/lib/math/nextafter.inc b/libclc/clspv64/lib/math/nextafter.inc
new file mode 100644
index 00000000000000..ee39be53b1e17c
--- /dev/null
+++ b/libclc/clspv64/lib/math/nextafter.inc
@@ -0,0 +1,3 @@
+_CLC_DEF _CLC_OVERLOAD __CLC_GENTYPE nextafter(__CLC_GENTYPE x, __CLC_GENTYPE y) {
+  return __clc_nextafter(x, y);
+}
diff --git a/libclc/clspv64/lib/subnormal_config.cl b/libclc/clspv64/lib/subnormal_config.cl
new file mode 100644
index 00000000000000..167fe1b1a1bcfd
--- /dev/null
+++ b/libclc/clspv64/lib/subnormal_config.cl
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2015 Advanced Micro Devices, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <clc/clc.h>
+
+#include "config.h"
+
+_CLC_DEF bool __clc_fp16_subnormals_supported() { return false; }
+
+_CLC_DEF bool __clc_fp32_subnormals_supported() { return false; }
+
+_CLC_DEF bool __clc_fp64_subnormals_supported() { return false; }
diff --git a/libcxx/test/std/pstl b/libcxx/test/std/pstl
deleted file mode 120000
index 27a2822d956696..00000000000000
--- a/libcxx/test/std/pstl
+++ /dev/null
@@ -1 +0,0 @@
-../../../pstl/test/std
\ No newline at end of file
diff --git a/libcxx/test/std/pstl/algorithms/alg.merge/inplace_merge.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.merge/inplace_merge.pass.cpp
new file mode 100644
index 00000000000000..3446d955093add
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.merge/inplace_merge.pass.cpp
@@ -0,0 +1,159 @@
+// -*- C++ -*-
+//===-- inplace_merge.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+#include "support/pstl_test_config.h"
+
+#include <execution>
+#include <algorithm>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+struct test_one_policy
+{
+#if defined(_PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) ||                                                             \
+    defined(_PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) // dummy specialization by policy type, in case of broken configuration
+    template <typename BiDirIt1, typename Size, typename Generator1, typename Generator2, typename Compare>
+    void
+    operator()(pstl::execution::unsequenced_policy, BiDirIt1 first1, BiDirIt1 last1, BiDirIt1 first2, BiDirIt1 last2,
+               Size n, Size m, Generator1 generator1, Generator2 generator2, Compare comp)
+    {
+    }
+
+    template <typename BiDirIt1, typename Size, typename Generator1, typename Generator2, typename Compare>
+    void
+    operator()(pstl::execution::parallel_unsequenced_policy, BiDirIt1 first1, BiDirIt1 last1, BiDirIt1 first2,
+               BiDirIt1 last2, Size n, Size m, Generator1 generator1, Generator2 generator2, Compare comp)
+    {
+    }
+#endif
+
+    // inplace_merge works with bidirectional iterators at least
+    template <typename Policy, typename BiDirIt1, typename Size, typename Generator1, typename Generator2,
+              typename Compare>
+    typename std::enable_if<!is_same_iterator_category<BiDirIt1, std::forward_iterator_tag>::value, void>::type
+    operator()(Policy&& exec, BiDirIt1 first1, BiDirIt1 last1, BiDirIt1 first2, BiDirIt1 last2, Size n, Size m,
+               Generator1 generator1, Generator2 generator2, Compare comp)
+    {
+        const BiDirIt1 mid1 = std::next(first1, m);
+        fill_data(first1, mid1, generator1);
+        fill_data(mid1, last1, generator2);
+
+        const BiDirIt1 mid2 = std::next(first2, m);
+        fill_data(first2, mid2, generator1);
+        fill_data(mid2, last2, generator2);
+
+        std::inplace_merge(first1, mid1, last1, comp);
+        std::inplace_merge(exec, first2, mid2, last2, comp);
+        EXPECT_EQ_N(first1, first2, n, "wrong effect from inplace_merge with predicate");
+    }
+
+    template <typename Policy, typename BiDirIt1, typename Size, typename Generator1, typename Generator2,
+              typename Compare>
+    typename std::enable_if<is_same_iterator_category<BiDirIt1, std::forward_iterator_tag>::value, void>::type
+    operator()(Policy&&, BiDirIt1, BiDirIt1, BiDirIt1, BiDirIt1, Size, Size, Generator1, Generator2, Compare)
+    {
+    }
+};
+
+template <typename T, typename Generator1, typename Generator2, typename Compare>
+void
+test_by_type(Generator1 generator1, Generator2 generator2, Compare comp)
+{
+    using namespace std;
+    size_t max_size = 100000;
+    Sequence<T> in1(max_size, [](size_t v) { return T(v); });
+    Sequence<T> exp(max_size, [](size_t v) { return T(v); });
+    size_t m;
+
+    for (size_t n = 0; n <= max_size; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
+    {
+        m = 0;
+        invoke_on_all_policies(test_one_policy(), in1.begin(), in1.begin() + n, exp.begin(), exp.begin() + n, n, m,
+                               generator1, generator2, comp);
+
+        m = n / 3;
+        invoke_on_all_policies(test_one_policy(), in1.begin(), in1.begin() + n, exp.begin(), exp.begin() + n, n, m,
+                               generator1, generator2, comp);
+
+        m = 2 * n / 3;
+        invoke_on_all_policies(test_one_policy(), in1.begin(), in1.begin() + n, exp.begin(), exp.begin() + n, n, m,
+                               generator1, generator2, comp);
+    }
+}
+
+template <typename T>
+struct LocalWrapper
+{
+    explicit LocalWrapper(int32_t k) : my_val(k) {}
+    LocalWrapper(LocalWrapper&& input) { my_val = std::move(input.my_val); }
+    LocalWrapper&
+    operator=(LocalWrapper&& input)
+    {
+        my_val = std::move(input.my_val);
+        return *this;
+    }
+    bool
+    operator<(const LocalWrapper<T>& w) const
+    {
+        return my_val < w.my_val;
+    }
+    friend bool
+    operator==(const LocalWrapper<T>& x, const LocalWrapper<T>& y)
+    {
+        return x.my_val == y.my_val;
+    }
+    friend std::ostream&
+    operator<<(std::ostream& stream, const LocalWrapper<T>& input)
+    {
+        return stream << input.my_val;
+    }
+
+  private:
+    T my_val;
+};
+
+template <typename T>
+struct test_non_const
+{
+    template <typename Policy, typename Iterator>
+    void
+    operator()(Policy&& exec, Iterator iter)
+    {
+        invoke_if(exec, [&]() { inplace_merge(exec, iter, iter, iter, non_const(std::less<T>())); });
+    }
+};
+
+int
+main()
+{
+    test_by_type<float64_t>([](int32_t i) { return -2 * i; }, [](int32_t i) { return -(2 * i + 1); },
+                            [](const float64_t x, const float64_t y) { return x > y; });
+
+    test_by_type<int32_t>([](int32_t i) { return 10 * i; }, [](int32_t i) { return i + 1; }, std::less<int32_t>());
+
+    test_by_type<LocalWrapper<float32_t>>([](int32_t i) { return LocalWrapper<float32_t>(2 * i + 1); },
+                                          [](int32_t i) { return LocalWrapper<float32_t>(2 * i); },
+                                          std::less<LocalWrapper<float32_t>>());
+
+    test_algo_basic_single<int32_t>(run_for_rnd_bi<test_non_const<int32_t>>());
+
+    test_by_type<MemoryChecker>(
+        [](std::size_t idx){ return MemoryChecker{std::int32_t(idx * 2)}; },
+        [](std::size_t idx){ return MemoryChecker{std::int32_t(idx * 2 + 1)}; },
+        [](const MemoryChecker& val1, const MemoryChecker& val2){ return val1.value() == val2.value(); });
+    EXPECT_FALSE(MemoryChecker::alive_objects() < 0, "wrong effect from inplace_merge: number of ctors calls < num of dtors calls");
+    EXPECT_FALSE(MemoryChecker::alive_objects() > 0, "wrong effect from inplace_merge: number of ctors calls > num of dtors calls");
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.merge/merge.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.merge/merge.pass.cpp
new file mode 100644
index 00000000000000..a09ef4223bf774
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.merge/merge.pass.cpp
@@ -0,0 +1,113 @@
+// -*- C++ -*-
+//===-- merge.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+#include "support/pstl_test_config.h"
+
+#include <execution>
+#include <algorithm>
+#include <functional>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+struct test_merge
+{
+    template <typename Policy, typename InputIterator1, typename InputIterator2, typename OutputIterator,
+              typename Compare>
+    void
+    operator()(Policy&& exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2,
+               OutputIterator out_first, OutputIterator out_last, Compare comp)
+    {
+        using namespace std;
+        {
+            const auto res = merge(exec, first1, last1, first2, last2, out_first, comp);
+            EXPECT_TRUE(res == out_last, "wrong return result from merge with predicate");
+            EXPECT_TRUE(is_sorted(out_first, res, comp), "wrong result from merge with predicate");
+            EXPECT_TRUE(includes(out_first, res, first1, last1, comp), "first sequence is not a part of result");
+            EXPECT_TRUE(includes(out_first, res, first2, last2, comp), "second sequence is not a part of result");
+        }
+        {
+            const auto res = merge(exec, first1, last1, first2, last2, out_first);
+            EXPECT_TRUE(res == out_last, "wrong return result from merge");
+            EXPECT_TRUE(is_sorted(out_first, res), "wrong result from merge");
+        }
+    }
+
+    // for reverse iterators
+    template <typename Policy, typename InputIterator1, typename InputIterator2, typename OutputIterator,
+              typename Compare>
+    void
+    operator()(Policy&& exec, std::reverse_iterator<InputIterator1> first1, std::reverse_iterator<InputIterator1> last1,
+               std::reverse_iterator<InputIterator2> first2, std::reverse_iterator<InputIterator2> last2,
+               std::reverse_iterator<OutputIterator> out_first, std::reverse_iterator<OutputIterator> out_last, Compare)
+    {
+        using namespace std;
+        typedef typename std::iterator_traits<std::reverse_iterator<InputIterator1>>::value_type T;
+        const auto res = merge(exec, first1, last1, first2, last2, out_first, std::greater<T>());
+
+        EXPECT_TRUE(res == out_last, "wrong return result from merge with predicate");
+        EXPECT_TRUE(is_sorted(out_first, res, std::greater<T>()), "wrong result from merge with predicate");
+        EXPECT_TRUE(includes(out_first, res, first1, last1, std::greater<T>()),
+                    "first sequence is not a part of result");
+        EXPECT_TRUE(includes(out_first, res, first2, last2, std::greater<T>()),
+                    "second sequence is not a part of result");
+    }
+};
+
+template <typename T, typename Generator1, typename Generator2>
+void
+test_merge_by_type(Generator1 generator1, Generator2 generator2)
+{
+    using namespace std;
+    size_t max_size = 100000;
+    Sequence<T> in1(max_size, generator1);
+    Sequence<T> in2(max_size / 2, generator2);
+    Sequence<T> out(in1.size() + in2.size());
+    std::sort(in1.begin(), in1.end());
+    std::sort(in2.begin(), in2.end());
+
+    for (size_t size = 0; size <= max_size; size = size <= 16 ? size + 1 : size_t(3.1415 * size))
+    {
+        invoke_on_all_policies(test_merge(), in1.cbegin(), in1.cbegin() + size, in2.data(), in2.data() + size / 2,
+                               out.begin(), out.begin() + 1.5 * size, std::less<T>());
+        invoke_on_all_policies(test_merge(), in1.data(), in1.data() + size, in2.cbegin(), in2.cbegin() + size / 2,
+                               out.begin(), out.begin() + 3 * size / 2, std::less<T>());
+    }
+}
+
+template <typename T>
+struct test_non_const
+{
+    template <typename Policy, typename InputIterator, typename OutputIterator>
+    void
+    operator()(Policy&& exec, InputIterator input_iter, OutputIterator out_iter)
+    {
+        merge(exec, input_iter, input_iter, input_iter, input_iter, out_iter, non_const(std::less<T>()));
+    }
+};
+
+int
+main()
+{
+    test_merge_by_type<int32_t>([](size_t v) { return (v % 2 == 0 ? v : -v) * 3; }, [](size_t v) { return v * 2; });
+    test_merge_by_type<float64_t>([](size_t v) { return float64_t(v); }, [](size_t v) { return float64_t(v - 100); });
+
+#if !defined(_PSTL_ICC_16_17_TEST_64_TIMEOUT)
+    test_merge_by_type<Wrapper<int16_t>>([](size_t v) { return Wrapper<int16_t>(v % 100); },
+                                         [](size_t v) { return Wrapper<int16_t>(v % 10); });
+#endif
+
+    test_algo_basic_double<int32_t>(run_for_rnd_fw<test_non_const<int32_t>>());
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.modifying.operations/alg.copy/copy_if.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.modifying.operations/alg.copy/copy_if.pass.cpp
new file mode 100644
index 00000000000000..692907e0f92e25
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.modifying.operations/alg.copy/copy_if.pass.cpp
@@ -0,0 +1,147 @@
+// -*- C++ -*-
+//===-- copy_if.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+// Tests for copy_if and remove_copy_if
+#include "support/pstl_test_config.h"
+
+#include <execution>
+#include <algorithm>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+struct run_copy_if
+{
+#if defined(_PSTL_ICC_16_VC14_TEST_PAR_TBB_RT_RELEASE_64_BROKEN) // dummy specializations to skip testing in case of broken configuration
+    template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size,
+              typename Predicate, typename T>
+    void
+    operator()(pstl::execution::parallel_policy, InputIterator first, InputIterator last, OutputIterator out_first,
+               OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size n,
+               Predicate pred, T trash)
+    {
+    }
+    template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size,
+              typename Predicate, typename T>
+    void
+    operator()(pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last,
+               OutputIterator out_first, OutputIterator out_last, OutputIterator2 expected_first,
+               OutputIterator2 expected_last, Size n, Predicate pred, T trash)
+    {
+    }
+#endif
+
+    template <typename Policy, typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size,
+              typename Predicate, typename T>
+    void
+    operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first,
+               OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2, Size n, Predicate pred,
+               T trash)
+    {
+        // Cleaning
+        std::fill_n(expected_first, n, trash);
+        std::fill_n(out_first, n, trash);
+
+        // Run copy_if
+        auto i = copy_if(first, last, expected_first, pred);
+        auto k = copy_if(exec, first, last, out_first, pred);
+        EXPECT_EQ_N(expected_first, out_first, n, "wrong copy_if effect");
+        for (size_t j = 0; j < GuardSize; ++j)
+        {
+            ++k;
+        }
+        EXPECT_TRUE(out_last == k, "wrong return value from copy_if");
+
+        // Cleaning
+        std::fill_n(expected_first, n, trash);
+        std::fill_n(out_first, n, trash);
+        // Run remove_copy_if
+        i = remove_copy_if(first, last, expected_first, [=](const T& x) { return !pred(x); });
+        k = remove_copy_if(exec, first, last, out_first, [=](const T& x) { return !pred(x); });
+        EXPECT_EQ_N(expected_first, out_first, n, "wrong remove_copy_if effect");
+        for (size_t j = 0; j < GuardSize; ++j)
+        {
+            ++k;
+        }
+        EXPECT_TRUE(out_last == k, "wrong return value from remove_copy_if");
+    }
+};
+
+template <typename T, typename Predicate, typename Convert>
+void
+test(T trash, Predicate pred, Convert convert, bool check_weakness = true)
+{
+    // Try sequences of various lengths.
+    for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
+    {
+        // count is number of output elements, plus a handful
+        // more for sake of detecting buffer overruns.
+        size_t count = GuardSize;
+        Sequence<T> in(n, [&](size_t k) -> T {
+            T val = convert(n ^ k);
+            count += pred(val) ? 1 : 0;
+            return val;
+        });
+
+        Sequence<T> out(count, [=](size_t) { return trash; });
+        Sequence<T> expected(count, [=](size_t) { return trash; });
+        if (check_weakness)
+        {
+            auto expected_result = copy_if(in.cfbegin(), in.cfend(), expected.begin(), pred);
+            size_t m = expected_result - expected.begin();
+            EXPECT_TRUE(n / 4 <= m && m <= 3 * (n + 1) / 4, "weak test for copy_if");
+        }
+        invoke_on_all_policies(run_copy_if(), in.begin(), in.end(), out.begin(), out.end(), expected.begin(),
+                               expected.end(), count, pred, trash);
+        invoke_on_all_policies(run_copy_if(), in.cbegin(), in.cend(), out.begin(), out.end(), expected.begin(),
+                               expected.end(), count, pred, trash);
+    }
+}
+
+struct test_non_const
+{
+    template <typename Policy, typename InputIterator, typename OutputInterator>
+    void
+    operator()(Policy&& exec, InputIterator input_iter, OutputInterator out_iter)
+    {
+        auto is_even = [&](float64_t v) {
+            uint32_t i = (uint32_t)v;
+            return i % 2 == 0;
+        };
+        copy_if(exec, input_iter, input_iter, out_iter, non_const(is_even));
+
+        invoke_if(exec, [&]() { remove_copy_if(exec, input_iter, input_iter, out_iter, non_const(is_even)); });
+    }
+};
+
+int
+main()
+{
+    test<float64_t>(-666.0, [](const float64_t& x) { return x * x <= 1024; },
+                    [](size_t j) { return ((j + 1) % 7 & 2) != 0 ? float64_t(j % 32) : float64_t(j % 33 + 34); });
+
+    test<int32_t>(-666, [](const int32_t& x) { return x != 42; },
+                  [](size_t j) { return ((j + 1) % 5 & 2) != 0 ? int32_t(j + 1) : 42; });
+
+#if !defined(_PSTL_ICC_17_TEST_MAC_RELEASE_32_BROKEN)
+    test<Number>(Number(42, OddTag()), IsMultiple(3, OddTag()), [](int32_t j) { return Number(j, OddTag()); });
+#endif
+
+#if !defined(_PSTL_ICC_16_17_TEST_REDUCTION_RELEASE_BROKEN)
+    test<int32_t>(-666, [](const int32_t&) { return true; }, [](size_t j) { return j; }, false);
+#endif
+
+    test_algo_basic_double<int32_t>(run_for_rnd_fw<test_non_const>());
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.modifying.operations/alg.partitions/is_partitioned.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.modifying.operations/alg.partitions/is_partitioned.pass.cpp
new file mode 100644
index 00000000000000..bd6b259c4d0afd
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.modifying.operations/alg.partitions/is_partitioned.pass.cpp
@@ -0,0 +1,101 @@
+// -*- C++ -*-
+//===-- is_partitioned.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+#include "support/pstl_test_config.h"
+
+#include <execution>
+#include <algorithm>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+struct test_one_policy
+{
+    //dummy specialization by policy type, in case of broken configuration
+#if defined(_PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) || defined(_PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN)
+
+    template <typename Iterator1, typename Predicate>
+    void
+    operator()(pstl::execution::unsequenced_policy, Iterator1 begin1, Iterator1 end1, Predicate pred)
+    {
+    }
+    template <typename Iterator1, typename Predicate>
+    void
+    operator()(pstl::execution::parallel_unsequenced_policy, Iterator1 begin1, Iterator1 end1, Predicate pred)
+    {
+    }
+#endif
+
+    template <typename ExecutionPolicy, typename Iterator1, typename Predicate>
+    void
+    operator()(ExecutionPolicy&& exec, Iterator1 begin1, Iterator1 end1, Predicate pred)
+    {
+        const bool expected = std::is_partitioned(begin1, end1, pred);
+        const bool actual = std::is_partitioned(exec, begin1, end1, pred);
+        EXPECT_TRUE(actual == expected, "wrong return result from is_partitioned");
+    }
+};
+
+template <typename T, typename Predicate>
+void
+test(Predicate pred)
+{
+
+    const std::size_t max_n = 1000000;
+    Sequence<T> in(max_n, [](std::size_t k) { return T(k); });
+
+    for (std::size_t n1 = 0; n1 <= max_n; n1 = n1 <= 16 ? n1 + 1 : std::size_t(3.1415 * n1))
+    {
+        invoke_on_all_policies(test_one_policy(), in.begin(), in.begin() + n1, pred);
+        std::partition(in.begin(), in.begin() + n1, pred);
+        invoke_on_all_policies(test_one_policy(), in.cbegin(), in.cbegin() + n1, pred);
+    }
+}
+
+template <typename T>
+struct LocalWrapper
+{
+    explicit LocalWrapper(std::size_t k) : my_val(k) {}
+
+  private:
+    T my_val;
+};
+
+struct test_non_const
+{
+    template <typename Policy, typename Iterator>
+    void
+    operator()(Policy&& exec, Iterator iter)
+    {
+        auto is_even = [&](float64_t v) {
+            uint32_t i = (uint32_t)v;
+            return i % 2 == 0;
+        };
+        invoke_if(exec, [&]() { is_partitioned(exec, iter, iter, non_const(is_even)); });
+    }
+};
+
+int
+main()
+{
+    test<float64_t>([](const float64_t x) { return x < 0; });
+    test<int32_t>([](const int32_t x) { return x > 1000; });
+    test<uint16_t>([](const uint16_t x) { return x % 5 < 3; });
+#if !defined(_PSTL_ICC_18_TEST_EARLY_EXIT_MONOTONIC_RELEASE_BROKEN) && !defined(_PSTL_ICC_19_TEST_IS_PARTITIONED_RELEASE_BROKEN)
+    test<LocalWrapper<float64_t>>([](const LocalWrapper<float64_t>&) { return true; });
+#endif
+
+    test_algo_basic_single<int32_t>(run_for_rnd_fw<test_non_const>());
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.modifying.operations/alg.partitions/partition.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.modifying.operations/alg.partitions/partition.pass.cpp
new file mode 100644
index 00000000000000..724f0ba6d3f4d9
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.modifying.operations/alg.partitions/partition.pass.cpp
@@ -0,0 +1,178 @@
+// -*- C++ -*-
+//===-- partition.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+// Tests for stable_partition and partition
+#include "support/pstl_test_config.h"
+
+#include <execution>
+#include <algorithm>
+#include <iterator>
+#include <type_traits>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+template <typename T>
+struct DataType
+{
+    explicit DataType(int32_t k) : my_val(k) {}
+    DataType(DataType&& input) { my_val = std::move(input.my_val); }
+    DataType&
+    operator=(DataType&& input)
+    {
+        my_val = std::move(input.my_val);
+        return *this;
+    }
+    T
+    get_val() const
+    {
+        return my_val;
+    }
+
+    friend std::ostream&
+    operator<<(std::ostream& stream, const DataType<T>& input)
+    {
+        return stream << input.my_val;
+    }
+
+  private:
+    T my_val;
+};
+
+template <typename Iterator>
+typename std::enable_if<std::is_trivial<typename std::iterator_traits<Iterator>::value_type>::value, bool>::type
+is_equal(Iterator first, Iterator last, Iterator d_first)
+{
+    return std::equal(first, last, d_first);
+}
+
+template <typename Iterator>
+typename std::enable_if<!std::is_trivial<typename std::iterator_traits<Iterator>::value_type>::value, bool>::type
+    is_equal(Iterator, Iterator, Iterator)
+{
+    return true;
+}
+
+struct test_one_policy
+{
+#if defined(_PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) ||                                                             \
+    defined(_PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) //dummy specializations to skip testing in case of broken configuration
+    template <typename BiDirIt, typename Size, typename UnaryOp, typename Generator>
+    void
+    operator()(pstl::execution::unsequenced_policy, BiDirIt first, BiDirIt last, BiDirIt exp_first, BiDirIt exp_last,
+               Size n, UnaryOp unary_op, Generator generator)
+    {
+    }
+
+    template <typename BiDirIt, typename Size, typename UnaryOp, typename Generator>
+    void
+    operator()(pstl::execution::parallel_unsequenced_policy, BiDirIt first, BiDirIt last, BiDirIt exp_first,
+               BiDirIt exp_last, Size n, UnaryOp unary_op, Generator generator)
+    {
+    }
+#elif defined(_PSTL_ICC_16_VC14_TEST_PAR_TBB_RT_RELEASE_64_BROKEN) //dummy specializations to skip testing in case of broken configuration
+    template <typename BiDirIt, typename Size, typename UnaryOp, typename Generator>
+    void
+    operator()(pstl::execution::parallel_policy, BiDirIt first, BiDirIt last, BiDirIt exp_first, BiDirIt exp_last,
+               Size n, UnaryOp unary_op, Generator generator)
+    {
+    }
+
+    template <typename BiDirIt, typename Size, typename UnaryOp, typename Generator>
+    void
+    operator()(pstl::execution::parallel_unsequenced_policy, BiDirIt first, BiDirIt last, BiDirIt exp_first,
+               BiDirIt exp_last, Size n, UnaryOp unary_op, Generator generator)
+    {
+    }
+#endif
+
+    template <typename Policy, typename BiDirIt, typename Size, typename UnaryOp, typename Generator>
+    typename std::enable_if<!is_same_iterator_category<BiDirIt, std::forward_iterator_tag>::value, void>::type
+    operator()(Policy&& exec, BiDirIt first, BiDirIt last, BiDirIt exp_first, BiDirIt exp_last, Size, UnaryOp unary_op,
+               Generator generator)
+    {
+        // partition
+        {
+            fill_data(first, last, generator);
+            BiDirIt actual_ret = std::partition(exec, first, last, unary_op);
+            EXPECT_TRUE(std::all_of(first, actual_ret, unary_op) && !std::any_of(actual_ret, last, unary_op),
+                        "wrong effect from partition");
+        }
+        // stable_partition
+        {
+            fill_data(exp_first, exp_last, generator);
+            BiDirIt exp_ret = std::stable_partition(exp_first, exp_last, unary_op);
+            fill_data(first, last, generator);
+            BiDirIt actual_ret = std::stable_partition(exec, first, last, unary_op);
+
+            EXPECT_TRUE(std::distance(first, actual_ret) == std::distance(exp_first, exp_ret),
+                        "wrong result from stable_partition");
+            EXPECT_TRUE((is_equal<BiDirIt>(exp_first, exp_last, first)), "wrong effect from stable_partition");
+        }
+    }
+    template <typename Policy, typename BiDirIt, typename Size, typename UnaryOp, typename Generator>
+    typename std::enable_if<is_same_iterator_category<BiDirIt, std::forward_iterator_tag>::value, void>::type
+    operator()(Policy&&, BiDirIt, BiDirIt, BiDirIt, BiDirIt, Size, UnaryOp, Generator)
+    {
+    }
+};
+
+template <typename T, typename Generator, typename UnaryPred>
+void
+test_by_type(Generator generator, UnaryPred pred)
+{
+
+    using namespace std;
+    size_t max_size = 100000;
+    Sequence<T> in(max_size, [](size_t v) { return T(v); });
+    Sequence<T> exp(max_size, [](size_t v) { return T(v); });
+
+    for (size_t n = 0; n <= max_size; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
+    {
+        invoke_on_all_policies(test_one_policy(), in.begin(), in.begin() + n, exp.begin(), exp.begin() + n, n, pred,
+                               generator);
+    }
+}
+
+struct test_non_const
+{
+    template <typename Policy, typename Iterator>
+    void
+    operator()(Policy&& exec, Iterator iter)
+    {
+        auto is_even = [&](float64_t v) {
+            uint32_t i = (uint32_t)v;
+            return i % 2 == 0;
+        };
+        invoke_if(exec, [&]() {
+            partition(exec, iter, iter, non_const(is_even));
+            stable_partition(exec, iter, iter, non_const(is_even));
+        });
+    }
+};
+
+int
+main()
+{
+#if !defined(_PSTL_ICC_16_17_TEST_REDUCTION_RELEASE_BROKEN)
+    test_by_type<int32_t>([](int32_t i) { return i; }, [](int32_t) { return true; });
+#endif
+    test_by_type<float64_t>([](int32_t i) { return -i; }, [](const float64_t x) { return x < 0; });
+    test_by_type<int64_t>([](int32_t i) { return i + 1; }, [](int64_t x) { return x % 3 == 0; });
+    test_by_type<DataType<float32_t>>([](int32_t i) { return DataType<float32_t>(2 * i + 1); },
+                                      [](const DataType<float32_t>& x) { return x.get_val() < 0; });
+
+    test_algo_basic_single<int32_t>(run_for_rnd_bi<test_non_const>());
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.modifying.operations/alg.partitions/partition_copy.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.modifying.operations/alg.partitions/partition_copy.pass.cpp
new file mode 100644
index 00000000000000..c621f8352f1dc7
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.modifying.operations/alg.partitions/partition_copy.pass.cpp
@@ -0,0 +1,116 @@
+// -*- C++ -*-
+//===-- partition_copy.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+// Tests for stable_partition and partition_copy
+#include "support/pstl_test_config.h"
+
+#include <algorithm>
+#include <cstdlib>
+#include <execution>
+#include <functional>
+#include <iterator>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+struct test_partition_copy
+{
+    template <typename Policy, typename InputIterator, typename OutputIterator, typename OutputIterator2,
+              typename UnaryOp>
+    void
+    operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator true_first, OutputIterator,
+               OutputIterator2 false_first, OutputIterator2, UnaryOp unary_op)
+    {
+
+        auto actual_ret = std::partition_copy(exec, first, last, true_first, false_first, unary_op);
+
+        EXPECT_TRUE(std::distance(true_first, actual_ret.first) == std::count_if(first, last, unary_op),
+                    "partition_copy has wrong effect from true sequence");
+        EXPECT_TRUE(std::distance(false_first, actual_ret.second) == std::count_if(first, last, std::not_fn(unary_op)),
+                    "partition_copy has wrong effect from false sequence");
+    }
+
+    //dummy specialization by iterator type and policy type, in case of broken configuration
+#if defined(_PSTL_ICC_1800_TEST_MONOTONIC_RELEASE_64_BROKEN)
+    template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename UnaryOp>
+    void
+    operator()(pstl::execution::unsequenced_policy, std::reverse_iterator<InputIterator> first,
+               std::reverse_iterator<InputIterator> last, std::reverse_iterator<OutputIterator> true_first,
+               std::reverse_iterator<OutputIterator> true_last, std::reverse_iterator<OutputIterator2> false_first,
+               OutputIterator2 false_last, UnaryOp unary_op)
+    {
+    }
+    template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename UnaryOp>
+    void
+    operator()(pstl::execution::parallel_unsequenced_policy, std::reverse_iterator<InputIterator> first,
+               std::reverse_iterator<InputIterator> last, std::reverse_iterator<OutputIterator> true_first,
+               std::reverse_iterator<OutputIterator> true_last, std::reverse_iterator<OutputIterator2> false_first,
+               OutputIterator2 false_last, UnaryOp unary_op)
+    {
+    }
+#endif
+};
+
+template <typename T, typename UnaryPred>
+void
+test(UnaryPred pred)
+{
+
+    const std::size_t max_size = 100000;
+    Sequence<T> in(max_size, [](std::size_t v) -> T { return T(v); });
+    Sequence<T> actual_true(max_size);
+    Sequence<T> actual_false(max_size);
+    for (std::size_t n = 0; n <= max_size; n = n <= 16 ? n + 1 : std::size_t(3.1415 * n))
+    {
+
+        // for non-const input iterators
+        invoke_on_all_policies(test_partition_copy(), in.begin(), in.begin() + n, actual_true.begin(),
+                               actual_true.begin() + n, actual_false.begin(), actual_false.begin() + n, pred);
+
+        // for const input iterators
+        invoke_on_all_policies(test_partition_copy(), in.cbegin(), in.cbegin() + n, actual_true.begin(),
+                               actual_true.begin() + n, actual_false.begin(), actual_false.begin() + n, pred);
+    }
+}
+
+struct test_non_const
+{
+    template <typename Policy, typename InputIterator, typename OutputInterator>
+    void
+    operator()(Policy&& exec, InputIterator input_iter, OutputInterator out_iter)
+    {
+        auto is_even = [&](float64_t v) {
+            uint32_t i = (uint32_t)v;
+            return i % 2 == 0;
+        };
+
+        partition_copy(exec, input_iter, input_iter, out_iter, out_iter, non_const(is_even));
+    }
+};
+
+int
+main()
+{
+    test<int32_t>([](const int32_t value) { return value % 2; });
+
+#if !defined(_PSTL_ICC_16_17_TEST_REDUCTION_RELEASE_BROKEN)
+    test<int32_t>([](const int32_t) { return true; });
+#endif
+
+    test<float64_t>([](const float64_t value) { return value > 2 << 6; });
+    test<Wrapper<float64_t>>([](const Wrapper<float64_t>& value) -> bool { return value.get_my_field() != nullptr; });
+
+    test_algo_basic_double<int32_t>(run_for_rnd_bi<test_non_const>());
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.modifying.operations/alg.reverse/reverse.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.modifying.operations/alg.reverse/reverse.pass.cpp
new file mode 100644
index 00000000000000..126454fd7272eb
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.modifying.operations/alg.reverse/reverse.pass.cpp
@@ -0,0 +1,104 @@
+// -*- C++ -*-
+//===-- reverse.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+#include "support/pstl_test_config.h"
+
+#include <iterator>
+#include <execution>
+#include <algorithm>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+struct test_one_policy
+{
+#if defined(_PSTL_ICC_18_VC141_TEST_SIMD_LAMBDA_RELEASE_BROKEN) || defined(_PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) ||       \
+    defined(_PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) // dummy specialization by policy type, in case of broken configuration
+    template <typename Iterator1, typename Iterator2>
+    typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
+    operator()(pstl::execution::unsequenced_policy, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b,
+               Iterator2 actual_e)
+    {
+    }
+    template <typename Iterator1, typename Iterator2>
+    typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
+    operator()(pstl::execution::parallel_unsequenced_policy, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b,
+               Iterator2 actual_e)
+    {
+    }
+#endif
+
+    template <typename ExecutionPolicy, typename Iterator1, typename Iterator2>
+    typename std::enable_if<!is_same_iterator_category<Iterator1, std::forward_iterator_tag>::value>::type
+    operator()(ExecutionPolicy&& exec, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b, Iterator2 actual_e)
+    {
+        using namespace std;
+
+        copy(data_b, data_e, actual_b);
+
+        reverse(exec, actual_b, actual_e);
+
+        bool check = equal(data_b, data_e, reverse_iterator<Iterator2>(actual_e));
+
+        EXPECT_TRUE(check, "wrong result of reverse");
+    }
+
+    template <typename ExecutionPolicy, typename Iterator1, typename Iterator2>
+    typename std::enable_if<is_same_iterator_category<Iterator1, std::forward_iterator_tag>::value>::type
+    operator()(ExecutionPolicy&&, Iterator1, Iterator1, Iterator2, Iterator2)
+    {
+    }
+};
+
+template <typename T>
+void
+test()
+{
+    const std::size_t max_len = 100000;
+
+    Sequence<T> actual(max_len);
+
+    Sequence<T> data(max_len, [](std::size_t i) { return T(i); });
+
+    for (std::size_t len = 0; len < max_len; len = len <= 16 ? len + 1 : std::size_t(3.1415 * len))
+    {
+        invoke_on_all_policies(test_one_policy(), data.begin(), data.begin() + len, actual.begin(),
+                               actual.begin() + len);
+    }
+}
+
+template <typename T>
+struct wrapper
+{
+    T t;
+    wrapper() {}
+    explicit wrapper(T t_) : t(t_) {}
+    bool
+    operator==(const wrapper<T>& a) const
+    {
+        return t == a.t;
+    }
+};
+
+int
+main()
+{
+    test<int32_t>();
+    test<uint16_t>();
+    test<float64_t>();
+#if !defined(_PSTL_ICC_17_TEST_MAC_RELEASE_32_BROKEN)
+    test<wrapper<float64_t>>();
+#endif
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.modifying.operations/alg.reverse/reverse_copy.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.modifying.operations/alg.reverse/reverse_copy.pass.cpp
new file mode 100644
index 00000000000000..533443896c3586
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.modifying.operations/alg.reverse/reverse_copy.pass.cpp
@@ -0,0 +1,130 @@
+// -*- C++ -*-
+//===-- reverse_copy.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+#include "support/pstl_test_config.h"
+
+#include <iterator>
+#include <execution>
+#include <algorithm>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+template <typename T>
+struct wrapper
+{
+    T t;
+    wrapper() {}
+    explicit wrapper(T t_) : t(t_) {}
+    wrapper&
+    operator=(const T& t_)
+    {
+        t = t_;
+        return *this;
+    }
+    bool
+    operator==(const wrapper& t_) const
+    {
+        return t == t_.t;
+    }
+};
+
+template <typename T1, typename T2>
+bool
+eq(const wrapper<T1>& a, const wrapper<T2>& b)
+{
+    return a.t == b.t;
+}
+
+template <typename T1, typename T2>
+bool
+eq(const T1& a, const T2& b)
+{
+    return a == b;
+}
+
+// we need to save state here, because we need to test with different types of iterators
+// due to the caller invoke_on_all_policies does forcing modification passed iterator type to cover additional usage cases.
+template <typename Iterator>
+struct test_one_policy
+{
+    Iterator data_b;
+    Iterator data_e;
+    test_one_policy(Iterator b, Iterator e) : data_b(b), data_e(e) {}
+
+#if defined(_PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) ||                                                             \
+    defined(_PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) // dummy specialization by policy type, in case of broken configuration
+    template <typename Iterator1>
+    typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
+    operator()(pstl::execution::unsequenced_policy, Iterator1 actual_b, Iterator1 actual_e)
+    {
+    }
+    template <typename Iterator1>
+    typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
+    operator()(pstl::execution::parallel_unsequenced_policy, Iterator1 actual_b, Iterator1 actual_e)
+    {
+    }
+#endif
+
+    template <typename ExecutionPolicy, typename Iterator1>
+    void
+    operator()(ExecutionPolicy&& exec, Iterator1 actual_b, Iterator1 actual_e)
+    {
+        using namespace std;
+        using T = typename iterator_traits<Iterator1>::value_type;
+
+        fill(actual_b, actual_e, T(-123));
+        Iterator1 actual_return = reverse_copy(exec, data_b, data_e, actual_b);
+
+        EXPECT_TRUE(actual_return == actual_e, "wrong result of reverse_copy");
+
+        const auto n = std::distance(data_b, data_e);
+        Sequence<T> res(n);
+        std::copy(std::reverse_iterator<Iterator>(data_e), std::reverse_iterator<Iterator>(data_b), res.begin());
+
+        EXPECT_EQ_N(res.begin(), actual_b, n, "wrong effect of reverse_copy");
+    }
+};
+
+template <typename T1, typename T2>
+void
+test()
+{
+    typedef typename Sequence<T1>::iterator iterator_type;
+    typedef typename Sequence<T1>::const_bidirectional_iterator cbi_iterator_type;
+
+    const std::size_t max_len = 100000;
+
+    Sequence<T2> actual(max_len);
+
+    Sequence<T1> data(max_len, [](std::size_t i) { return T1(i); });
+
+    for (std::size_t len = 0; len < max_len; len = len <= 16 ? len + 1 : std::size_t(3.1415 * len))
+    {
+        invoke_on_all_policies(test_one_policy<iterator_type>(data.begin(), data.begin() + len), actual.begin(),
+                               actual.begin() + len);
+        invoke_on_all_policies(test_one_policy<cbi_iterator_type>(data.cbibegin(), std::next(data.cbibegin(), len)),
+                               actual.begin(), actual.begin() + len);
+    }
+}
+
+int
+main()
+{
+    test<int16_t, int8_t>();
+    test<uint16_t, float32_t>();
+    test<float64_t, int64_t>();
+    test<wrapper<float64_t>, wrapper<float64_t>>();
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.modifying.operations/copy_move.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.modifying.operations/copy_move.pass.cpp
new file mode 100644
index 00000000000000..24b784383916e0
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.modifying.operations/copy_move.pass.cpp
@@ -0,0 +1,197 @@
+// -*- C++ -*-
+//===-- copy_move.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+// Tests for copy, move and copy_n
+#include "support/pstl_test_config.h"
+
+#include <execution>
+#include <algorithm>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+struct run_copy
+{
+
+#if defined(_PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) ||                                                             \
+    defined(_PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) //dummy specialization by policy type, in case of broken configuration
+    template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size, typename T>
+    void
+    operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first,
+               OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size size,
+               Size n, T trash)
+    {
+    }
+
+    template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size, typename T>
+    void
+    operator()(pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last,
+               OutputIterator out_first, OutputIterator out_last, OutputIterator2 expected_first,
+               OutputIterator2 expected_last, Size size, Size n, T trash)
+    {
+    }
+#endif
+
+    template <typename Policy, typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size,
+              typename T>
+    void
+    operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first,
+               OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2, Size size, Size n, T trash)
+    {
+        // Cleaning
+        std::fill_n(expected_first, size, trash);
+        std::fill_n(out_first, size, trash);
+
+        // Run copy
+        copy(first, last, expected_first);
+        auto k = copy(exec, first, last, out_first);
+        for (size_t j = 0; j < GuardSize; ++j)
+            ++k;
+        EXPECT_EQ_N(expected_first, out_first, size, "wrong effect from copy");
+        EXPECT_TRUE(out_last == k, "wrong return value from copy");
+
+        // Cleaning
+        std::fill_n(out_first, size, trash);
+        // Run copy_n
+        k = copy_n(exec, first, n, out_first);
+        for (size_t j = 0; j < GuardSize; ++j)
+            ++k;
+        EXPECT_EQ_N(expected_first, out_first, size, "wrong effect from copy_n");
+        EXPECT_TRUE(out_last == k, "wrong return value from copy_n");
+    }
+};
+
+template <typename T>
+struct run_move
+{
+
+#if defined(_PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) ||                                                             \
+    defined(_PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) //dummy specialization by policy type, in case of broken configuration
+    template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size>
+    void
+    operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first,
+               OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size size,
+               Size n, T trash)
+    {
+    }
+
+    template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size>
+    void
+    operator()(pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last,
+               OutputIterator out_first, OutputIterator out_last, OutputIterator2 expected_first,
+               OutputIterator2 expected_last, Size size, Size n, T trash)
+    {
+    }
+#endif
+
+    template <typename Policy, typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size>
+    void
+    operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first,
+               OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2, Size size, Size, T trash)
+    {
+        // Cleaning
+        std::fill_n(expected_first, size, trash);
+        std::fill_n(out_first, size, trash);
+
+        // Run move
+        move(first, last, expected_first);
+        auto k = move(exec, first, last, out_first);
+        for (size_t j = 0; j < GuardSize; ++j)
+            ++k;
+        EXPECT_EQ_N(expected_first, out_first, size, "wrong effect from move");
+        EXPECT_TRUE(out_last == k, "wrong return value from move");
+    }
+};
+
+template <typename T>
+struct run_move<Wrapper<T>>
+{
+
+#if defined(_PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) ||                                                             \
+    defined(_PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) //dummy specialization by policy type, in case of broken configuration
+    template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size>
+    void
+    operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first,
+               OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size size,
+               Size n, Wrapper<T> trash)
+    {
+    }
+
+    template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size>
+    void
+    operator()(pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last,
+               OutputIterator out_first, OutputIterator out_last, OutputIterator2 expected_first,
+               OutputIterator2 expected_last, Size size, Size n, Wrapper<T> trash)
+    {
+    }
+#endif
+
+    template <typename Policy, typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size>
+    void
+    operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first,
+               OutputIterator out_last, OutputIterator2, OutputIterator2, Size size, Size, Wrapper<T> trash)
+    {
+        // Cleaning
+        std::fill_n(out_first, size, trash);
+        Wrapper<T>::SetMoveCount(0);
+
+        // Run move
+        auto k = move(exec, first, last, out_first);
+        for (size_t j = 0; j < GuardSize; ++j)
+            ++k;
+        EXPECT_TRUE(Wrapper<T>::MoveCount() == size, "wrong effect from move");
+        EXPECT_TRUE(out_last == k, "wrong return value from move");
+    }
+};
+
+template <typename T, typename Convert>
+void
+test(T trash, Convert convert)
+{
+    // Try sequences of various lengths.
+    for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
+    {
+        // count is number of output elements, plus a handful
+        // more for sake of detecting buffer overruns.
+        Sequence<T> in(n, [&](size_t k) -> T {
+            T val = convert(n ^ k);
+            return val;
+        });
+
+        const size_t outN = n + GuardSize;
+        Sequence<T> out(outN, [=](size_t) { return trash; });
+        Sequence<T> expected(outN, [=](size_t) { return trash; });
+        invoke_on_all_policies(run_copy(), in.begin(), in.end(), out.begin(), out.end(), expected.begin(),
+                               expected.end(), outN, n, trash);
+        invoke_on_all_policies(run_copy(), in.cbegin(), in.cend(), out.begin(), out.end(), expected.begin(),
+                               expected.end(), outN, n, trash);
+        invoke_on_all_policies(run_move<T>(), in.begin(), in.end(), out.begin(), out.end(), expected.begin(),
+                               expected.end(), n, n, trash);
+
+        // For this test const iterator isn't suitable
+        // because const rvalue-reference call copy assignment operator
+    }
+}
+
+int
+main()
+{
+    test<int32_t>(-666, [](size_t j) { return int32_t(j); });
+    test<Wrapper<float64_t>>(Wrapper<float64_t>(-666.0), [](int32_t j) { return Wrapper<float64_t>(j); });
+
+#if !defined(_PSTL_ICC_16_17_TEST_64_TIMEOUT)
+    test<float64_t>(-666.0, [](size_t j) { return float64_t(j); });
+    test<Number>(Number(42, OddTag()), [](int32_t j) { return Number(j, OddTag()); });
+#endif
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.modifying.operations/fill.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.modifying.operations/fill.pass.cpp
new file mode 100644
index 00000000000000..d44a1a483c1975
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.modifying.operations/fill.pass.cpp
@@ -0,0 +1,100 @@
+// -*- C++ -*-
+//===-- fill.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+#include "support/pstl_test_config.h"
+
+#include <execution>
+#include <algorithm>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+struct test_fill
+{
+    template <typename It, typename T>
+    bool
+    check(It first, It last, const T& value)
+    {
+        for (; first != last; ++first)
+            if (*first != value)
+                return false;
+        return true;
+    }
+
+    template <typename Policy, typename Iterator, typename T>
+    void
+    operator()(Policy&& exec, Iterator first, Iterator last, const T& value)
+    {
+        fill(first, last, T(value + 1)); // initialize memory with different value
+
+        fill(exec, first, last, value);
+        EXPECT_TRUE(check(first, last, value), "fill wrong result");
+    }
+};
+
+struct test_fill_n
+{
+    template <typename It, typename Size, typename T>
+    bool
+    check(It first, Size n, const T& value)
+    {
+        for (Size i = 0; i < n; ++i, ++first)
+            if (*first != value)
+                return false;
+        return true;
+    }
+
+    template <typename Policy, typename Iterator, typename Size, typename T>
+    void
+    operator()(Policy&& exec, Iterator first, Size n, const T& value)
+    {
+        fill_n(first, n, T(value + 1)); // initialize memory with different value
+
+        const Iterator one_past_last = fill_n(exec, first, n, value);
+        const Iterator expected_return = std::next(first, n);
+
+        EXPECT_TRUE(expected_return == one_past_last, "fill_n should return Iterator to one past the element assigned");
+        EXPECT_TRUE(check(first, n, value), "fill_n wrong result");
+
+        //n == -1
+        const Iterator res = fill_n(exec, first, -1, value);
+        EXPECT_TRUE(res == first, "fill_n wrong result for n == -1");
+    }
+};
+
+template <typename T>
+void
+test_fill_by_type(std::size_t n)
+{
+    Sequence<T> in(n, [](std::size_t) -> T { return T(0); }); //fill with zeros
+    T value = -1;
+
+    invoke_on_all_policies(test_fill(), in.begin(), in.end(), value);
+    invoke_on_all_policies(test_fill_n(), in.begin(), n, value);
+}
+
+int
+main()
+{
+
+    const std::size_t N = 100000;
+
+    for (std::size_t n = 0; n < N; n = n < 16 ? n + 1 : size_t(3.1415 * n))
+    {
+        test_fill_by_type<int32_t>(n);
+        test_fill_by_type<float64_t>(n);
+    }
+
+    std::cout << done() << std::endl;
+
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.modifying.operations/generate.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.modifying.operations/generate.pass.cpp
new file mode 100644
index 00000000000000..92d87ea26e541b
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.modifying.operations/generate.pass.cpp
@@ -0,0 +1,104 @@
+// -*- C++ -*-
+//===-- generate.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+#include "support/pstl_test_config.h"
+
+#include <atomic>
+#include <execution>
+#include <algorithm>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+template <typename T>
+struct Generator_count
+{
+    const T def_val = T(-1);
+    T
+    operator()()
+    {
+        return def_val;
+    }
+    T
+    default_value() const
+    {
+        return def_val;
+    }
+};
+
+struct test_generate
+{
+    template <typename Policy, typename Iterator, typename Size>
+    void
+    operator()(Policy&& exec, Iterator first, Iterator last, Size n)
+    {
+        using namespace std;
+        typedef typename std::iterator_traits<Iterator>::value_type T;
+
+        // Try random-access iterator
+        {
+            Generator_count<T> g;
+            generate(exec, first, last, g);
+            Size count = std::count(first, last, g.default_value());
+            EXPECT_TRUE(count == n, "generate wrong result for generate");
+            std::fill(first, last, T(0));
+        }
+
+        {
+            Generator_count<T> g;
+            const auto m = n / 2;
+            auto actual_last = generate_n(exec, first, m, g);
+            Size count = std::count(first, actual_last, g.default_value());
+            EXPECT_TRUE(count == m && actual_last == std::next(first, m), "generate_n wrong result for generate_n");
+            std::fill(first, actual_last, T(0));
+        }
+    }
+};
+
+template <typename T>
+void
+test_generate_by_type()
+{
+    for (size_t n = 0; n <= 100000; n = n < 16 ? n + 1 : size_t(3.1415 * n))
+    {
+        Sequence<T> in(n, [](size_t) -> T { return T(0); }); //fill by zero
+
+        invoke_on_all_policies(test_generate(), in.begin(), in.end(), in.size());
+    }
+}
+
+template <typename T>
+struct test_non_const
+{
+    template <typename Policy, typename Iterator>
+    void
+    operator()(Policy&& exec, Iterator iter)
+    {
+        auto gen = []() { return T(0); };
+
+        generate(exec, iter, iter, non_const(gen));
+        generate_n(exec, iter, 0, non_const(gen));
+    }
+};
+
+int
+main()
+{
+
+    test_generate_by_type<int32_t>();
+    test_generate_by_type<float64_t>();
+
+    test_algo_basic_single<int32_t>(run_for_rnd_fw<test_non_const<int32_t>>());
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.modifying.operations/remove.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.modifying.operations/remove.pass.cpp
new file mode 100644
index 00000000000000..872b0d292caa7a
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.modifying.operations/remove.pass.cpp
@@ -0,0 +1,161 @@
+// -*- C++ -*-
+//===-- remove.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+// Test for remove, remove_if
+#include "support/pstl_test_config.h"
+
+#include <execution>
+#include <algorithm>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+struct run_remove
+{
+#if defined(_PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) ||                                                             \
+    defined(_PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) //dummy specialization by policy type, in case of broken configuration
+    template <typename InputIterator, typename OutputIterator, typename Size, typename T>
+    void
+    operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first,
+               OutputIterator out_last, OutputIterator expected_first, OutputIterator expected_last, Size n,
+               const T& value)
+    {
+    }
+    template <typename InputIterator, typename OutputIterator, typename Size, typename T>
+    void
+    operator()(pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last,
+               OutputIterator out_first, OutputIterator out_last, OutputIterator expected_first,
+               OutputIterator expected_last, Size n, const T& value)
+    {
+    }
+#endif
+
+    template <typename Policy, typename InputIterator, typename OutputIterator, typename Size, typename T>
+    void
+    operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first,
+               OutputIterator out_last, OutputIterator expected_first, OutputIterator expected_last, Size,
+               const T& value)
+    {
+        // Cleaning
+        std::copy(first, last, expected_first);
+        std::copy(first, last, out_first);
+
+        // Run remove
+        OutputIterator i = remove(expected_first, expected_last, value);
+        OutputIterator k = remove(exec, out_first, out_last, value);
+        EXPECT_TRUE(std::distance(expected_first, i) == std::distance(out_first, k), "wrong return value from remove");
+        EXPECT_EQ_N(expected_first, out_first, std::distance(expected_first, i), "wrong remove effect");
+    }
+};
+
+struct run_remove_if
+{
+#if defined(_PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) ||                                                             \
+    defined(_PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) //dummy specialization by policy type, in case of broken configuration
+    template <typename InputIterator, typename OutputIterator, typename Size, typename Predicate>
+    void
+    operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first,
+               OutputIterator out_last, OutputIterator expected_first, OutputIterator expected_last, Size n,
+               Predicate pred)
+    {
+    }
+    template <typename InputIterator, typename OutputIterator, typename Size, typename Predicate>
+    void
+    operator()(pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last,
+               OutputIterator out_first, OutputIterator out_last, OutputIterator expected_first,
+               OutputIterator expected_last, Size n, Predicate pred)
+    {
+    }
+#endif
+
+    template <typename Policy, typename InputIterator, typename OutputIterator, typename Size, typename Predicate>
+    void
+    operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first,
+               OutputIterator out_last, OutputIterator expected_first, OutputIterator expected_last, Size,
+               Predicate pred)
+    {
+        // Cleaning
+        std::copy(first, last, expected_first);
+        std::copy(first, last, out_first);
+
+        // Run remove_if
+        OutputIterator i = remove_if(expected_first, expected_last, pred);
+        OutputIterator k = remove_if(exec, out_first, out_last, pred);
+        EXPECT_TRUE(std::distance(expected_first, i) == std::distance(out_first, k),
+                    "wrong return value from remove_if");
+        EXPECT_EQ_N(expected_first, out_first, std::distance(expected_first, i), "wrong remove_if effect");
+    }
+};
+
+template <typename T, typename Predicate, typename Convert>
+void
+test(T trash, const T& value, Predicate pred, Convert convert)
+{
+    const std::size_t max_size = 100000;
+    Sequence<T> out(max_size, [trash](size_t) { return trash; });
+    Sequence<T> expected(max_size, [trash](size_t) { return trash; });
+
+    for (size_t n = 0; n <= max_size; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
+    {
+        Sequence<T> data(n, [&](size_t k) -> T { return convert(k); });
+
+        invoke_on_all_policies(run_remove(), data.begin(), data.end(), out.begin(), out.begin() + n, expected.begin(),
+                               expected.begin() + n, n, value);
+        invoke_on_all_policies(run_remove_if(), data.begin(), data.end(), out.begin(), out.begin() + n,
+                               expected.begin(), expected.begin() + n, n, pred);
+    }
+}
+
+struct test_non_const
+{
+    template <typename Policy, typename Iterator>
+    void
+    operator()(Policy&& exec, Iterator iter)
+    {
+        auto is_even = [&](float64_t v) {
+            uint32_t i = (uint32_t)v;
+            return i % 2 == 0;
+        };
+
+        invoke_if(exec, [&]() { remove_if(exec, iter, iter, non_const(is_even)); });
+    }
+};
+
+int
+main()
+{
+#if !defined(_PSTL_ICC_18_TEST_EARLY_EXIT_MONOTONIC_RELEASE_BROKEN)
+    test<int32_t>(666, 42, [](int32_t) { return true; }, [](size_t j) { return j; });
+#endif
+
+    test<int32_t>(666, 2001, [](const int32_t& val) { return val != 2001; },
+                  [](size_t j) { return ((j + 1) % 5 & 2) != 0 ? 2001 : -1 - int32_t(j); });
+    test<float64_t>(-666.0, 8.5, [](const float64_t& val) { return val != 8.5; },
+                    [](size_t j) { return ((j + 1) % 7 & 2) != 0 ? 8.5 : float64_t(j % 32 + j); });
+
+#if !defined(_PSTL_ICC_17_TEST_MAC_RELEASE_32_BROKEN)
+    test<Number>(Number(-666, OddTag()), Number(42, OddTag()), IsMultiple(3, OddTag()),
+                 [](int32_t j) { return Number(j, OddTag()); });
+#endif
+
+    test_algo_basic_single<int32_t>(run_for_rnd_fw<test_non_const>());
+
+    test<MemoryChecker>(MemoryChecker{0}, MemoryChecker{1},
+        [](const MemoryChecker& val){ return val.value() == 1; },
+        [](std::size_t idx){ return MemoryChecker{std::int32_t(idx % 3 == 0)}; }
+    );
+    EXPECT_FALSE(MemoryChecker::alive_objects() < 0, "wrong effect from remove,remove_if: number of ctors calls < num of dtors calls");
+    EXPECT_FALSE(MemoryChecker::alive_objects() > 0, "wrong effect from remove,remove_if: number of ctors calls > num of dtors calls");
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.modifying.operations/remove_copy.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.modifying.operations/remove_copy.pass.cpp
new file mode 100644
index 00000000000000..9cdd7d62a4f243
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.modifying.operations/remove_copy.pass.cpp
@@ -0,0 +1,91 @@
+// -*- C++ -*-
+//===-- remove_copy.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+#include "support/pstl_test_config.h"
+
+#include <execution>
+#include <algorithm>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+struct run_remove_copy
+{
+    template <typename Policy, typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size,
+              typename T>
+    void
+    operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first,
+               OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2, Size n, const T& value,
+               T trash)
+    {
+        // Cleaning
+        std::fill_n(expected_first, n, trash);
+        std::fill_n(out_first, n, trash);
+
+        // Run copy_if
+        auto i = std::remove_copy(first, last, expected_first, value);
+        (void)i;
+        auto k = std::remove_copy(exec, first, last, out_first, value);
+        EXPECT_EQ_N(expected_first, out_first, n, "wrong remove_copy effect");
+        for (size_t j = 0; j < GuardSize; ++j)
+        {
+            ++k;
+        }
+        EXPECT_TRUE(out_last == k, "wrong return value from remove_copy");
+    }
+};
+
+template <typename T, typename Convert>
+void
+test(T trash, const T& value, Convert convert, bool check_weakness = true)
+{
+    // Try sequences of various lengths.
+    for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
+    {
+        // count is number of output elements, plus a handful
+        // more for sake of detecting buffer overruns.
+        size_t count = GuardSize;
+        Sequence<T> in(n, [&](size_t k) -> T {
+            T x = convert(n ^ k);
+            count += !(x == value) ? 1 : 0;
+            return x;
+        });
+        using namespace std;
+
+        Sequence<T> out(count, [=](size_t) { return trash; });
+        Sequence<T> expected(count, [=](size_t) { return trash; });
+        if (check_weakness)
+        {
+            auto expected_result = remove_copy(in.cfbegin(), in.cfend(), expected.begin(), value);
+            size_t m = expected_result - expected.begin();
+            EXPECT_TRUE(n / 4 <= m && m <= 3 * (n + 1) / 4, "weak test for remove_copy");
+        }
+        invoke_on_all_policies(run_remove_copy(), in.begin(), in.end(), out.begin(), out.end(), expected.begin(),
+                               expected.end(), count, value, trash);
+        invoke_on_all_policies(run_remove_copy(), in.cbegin(), in.cend(), out.begin(), out.end(), expected.begin(),
+                               expected.end(), count, value, trash);
+    }
+}
+
+int
+main()
+{
+
+    test<float64_t>(-666.0, 8.5, [](size_t j) { return ((j + 1) % 7 & 2) != 0 ? 8.5 : float64_t(j % 32 + j); });
+
+    test<int32_t>(-666, 42, [](size_t j) { return ((j + 1) % 5 & 2) != 0 ? 42 : -1 - int32_t(j); });
+
+    test<Number>(Number(42, OddTag()), Number(2001, OddTag()),
+                 [](int32_t j) { return ((j + 1) % 3 & 2) != 0 ? Number(2001, OddTag()) : Number(j, OddTag()); });
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.modifying.operations/replace.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.modifying.operations/replace.pass.cpp
new file mode 100644
index 00000000000000..9c6ca1ea8c0faa
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.modifying.operations/replace.pass.cpp
@@ -0,0 +1,160 @@
+// -*- C++ -*-
+//===-- replace.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+#include "support/pstl_test_config.h"
+
+#include <execution>
+#include <algorithm>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+// This class is needed to check the self-copying
+struct copy_int
+{
+    int32_t value;
+    int32_t copied_times = 0;
+    constexpr explicit copy_int(int32_t val = 0) : value(val) {}
+    constexpr copy_int(copy_int const& other) : value(other.value), copied_times(other.copied_times) { }
+
+    constexpr copy_int&
+    operator=(const copy_int& other)
+    {
+        if (&other == this)
+            copied_times++;
+        else
+        {
+            value = other.value;
+            copied_times = other.copied_times;
+        }
+        return *this;
+    }
+
+    constexpr bool
+    operator==(const copy_int& other) const
+    {
+        return (value == other.value);
+    }
+};
+
+template <typename Iterator>
+struct test_one_policy
+{
+    std::size_t len;
+    Iterator data_b;
+    Iterator data_e;
+    test_one_policy(Iterator data_, std::size_t len_)
+    {
+        len = len_;
+        data_b = data_;
+        data_e = std::next(data_b, len);
+    }
+    template <typename ExecutionPolicy, typename Iterator1, typename Iterator2, typename T, typename Predicate>
+    void
+    operator()(ExecutionPolicy&& exec, Iterator1 expected_b, Iterator1 expected_e, Iterator2 actual_b,
+               Iterator2 actual_e, Predicate pred, const T& value, const T& old_value)
+    {
+        using namespace std;
+
+        copy(data_b, data_e, expected_b);
+        copy(data_b, data_e, actual_b);
+
+        replace(expected_b, expected_e, old_value, value);
+        replace(exec, actual_b, actual_e, old_value, value);
+
+        EXPECT_TRUE((check<T, Iterator2>(actual_b, actual_e)), "wrong result of self assignment check");
+        EXPECT_TRUE(equal(expected_b, expected_e, actual_b), "wrong result of replace");
+
+        copy(data_b, data_e, expected_b);
+        copy(data_b, data_e, actual_b);
+
+        replace_if(expected_b, expected_e, pred, value);
+        replace_if(exec, actual_b, actual_e, pred, value);
+        EXPECT_TRUE(equal(expected_b, expected_e, actual_b), "wrong result of replace_if");
+    }
+
+    template <typename T, typename Iterator1>
+    bool check(Iterator1, Iterator1)
+    {
+        return true;
+    }
+
+    template <typename T, typename Iterator1>
+    typename std::enable_if<std::is_same<T, copy_int>::value, bool>::type_t
+    check(Iterator1 b, Iterator1 e)
+    {
+        return std::all_of(b, e, [](const copy_int& elem) { return elem.copied_times == 0; });
+    }
+};
+
+template <typename T1, typename T2, typename Pred>
+void
+test(Pred pred)
+{
+    typedef typename Sequence<T2>::iterator iterator_type;
+
+    const std::size_t max_len = 100000;
+
+    static constexpr T1 value = T1(0);
+    static constexpr T1 new_value = T1(666);
+
+    Sequence<T2> expected(max_len);
+    Sequence<T2> actual(max_len);
+
+    Sequence<T2> data(max_len, [](std::size_t i) {
+        if (i % 3 == 2)
+        {
+            return T1(i);
+        }
+        else
+        {
+            return value;
+        }
+    });
+
+    for (std::size_t len = 0; len < max_len; len = len <= 16 ? len + 1 : std::size_t(3.1415 * len))
+    {
+        test_one_policy<iterator_type> temp(data.begin(), len);
+
+        invoke_on_all_policies(temp, expected.begin(), expected.begin() + len, actual.begin(), actual.begin() + len,
+                               pred, new_value, value);
+    }
+}
+
+template <typename T>
+struct test_non_const
+{
+    template <typename Policy, typename Iterator>
+    void
+    operator()(Policy&& exec, Iterator iter)
+    {
+        auto is_even = [&](float64_t v) {
+            uint32_t i = (uint32_t)v;
+            return i % 2 == 0;
+        };
+        invoke_if(exec, [&]() { replace_if(exec, iter, iter, non_const(is_even), T(0)); });
+    }
+};
+
+int
+main()
+{
+    test<int32_t, float32_t>(__pstl::__internal::__equal_value<int32_t>(666));
+    test<uint16_t, uint8_t>([](const uint16_t& elem) { return elem % 3 < 2; });
+    test<float64_t, int64_t>([](const float64_t& elem) { return elem * elem - 3.5 * elem > 10; });
+    test<copy_int, copy_int>([](const copy_int& val) { return val.value / 5 > 2; });
+
+    test_algo_basic_single<int32_t>(run_for_rnd_fw<test_non_const<int32_t>>());
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.modifying.operations/replace_copy.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.modifying.operations/replace_copy.pass.cpp
new file mode 100644
index 00000000000000..94d725fb1c500c
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.modifying.operations/replace_copy.pass.cpp
@@ -0,0 +1,105 @@
+// -*- C++ -*-
+//===-- replace_copy.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+// Tests for replace_copy and replace_copy_if
+
+#include "support/pstl_test_config.h"
+
+#include <execution>
+#include <algorithm>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+struct test_replace_copy
+{
+    template <typename Policy, typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size,
+              typename Predicate, typename T>
+    void
+    operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first,
+               OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2, Size n, Predicate pred,
+               const T& old_value, const T& new_value, T trash)
+    {
+        // Cleaning
+        std::fill_n(expected_first, n, trash);
+        std::fill_n(out_first, n, trash);
+        // Run replace_copy
+        auto i = std::replace_copy(first, last, expected_first, old_value, new_value);
+        auto k = std::replace_copy(exec, first, last, out_first, old_value, new_value);
+        EXPECT_EQ_N(expected_first, out_first, n, "wrong replace_copy effect");
+        EXPECT_TRUE(out_last == k, "wrong return value from replace_copy");
+
+        // Cleaning
+        std::fill_n(expected_first, n, trash);
+        std::fill_n(out_first, n, trash);
+        // Run replace_copy_if
+        i = replace_copy_if(first, last, expected_first, pred, new_value);
+        k = replace_copy_if(exec, first, last, out_first, pred, new_value);
+        EXPECT_EQ_N(expected_first, out_first, n, "wrong replace_copy_if effect");
+        EXPECT_TRUE(out_last == k, "wrong return value from replace_copy_if");
+    }
+};
+
+template <typename T, typename Convert, typename Predicate>
+void
+test(T trash, const T& old_value, const T& new_value, Predicate pred, Convert convert)
+{
+    // Try sequences of various lengths.
+    for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
+    {
+        Sequence<T> in(n, [&](size_t k) -> T { return convert(n ^ k); });
+        Sequence<T> out(n, [=](size_t) { return trash; });
+        Sequence<T> expected(n, [=](size_t) { return trash; });
+
+        invoke_on_all_policies(test_replace_copy(), in.begin(), in.end(), out.begin(), out.end(), expected.begin(),
+                               expected.end(), out.size(), pred, old_value, new_value, trash);
+        invoke_on_all_policies(test_replace_copy(), in.cbegin(), in.cend(), out.begin(), out.end(), expected.begin(),
+                               expected.end(), out.size(), pred, old_value, new_value, trash);
+    }
+}
+
+template <typename T>
+struct test_non_const
+{
+    template <typename Policy, typename InputIterator, typename OutputInterator>
+    void
+    operator()(Policy&& exec, InputIterator input_iter, OutputInterator out_iter)
+    {
+        auto is_even = [&](float64_t v) {
+            uint32_t i = (uint32_t)v;
+            return i % 2 == 0;
+        };
+
+        invoke_if(exec, [&]() { replace_copy_if(exec, input_iter, input_iter, out_iter, non_const(is_even), T(0)); });
+    }
+};
+
+int
+main()
+{
+
+    test<float64_t>(-666.0, 8.5, 0.33, [](const float64_t& x) { return x * x <= 1024; },
+                    [](size_t j) { return ((j + 1) % 7 & 2) != 0 ? 8.5 : float64_t(j % 32 + j); });
+
+    test<int32_t>(-666, 42, 99, [](const int32_t& x) { return x != 42; },
+                  [](size_t j) { return ((j + 1) % 5 & 2) != 0 ? 42 : -1 - int32_t(j); });
+
+#if !defined(_PSTL_ICC_17_TEST_MAC_RELEASE_32_BROKEN)
+    test<Number>(Number(42, OddTag()), Number(2001, OddTag()), Number(2017, OddTag()), IsMultiple(3, OddTag()),
+                 [](int32_t j) { return ((j + 1) % 3 & 2) != 0 ? Number(2001, OddTag()) : Number(j, OddTag()); });
+#endif
+
+    test_algo_basic_double<int32_t>(run_for_rnd_fw<test_non_const<int32_t>>());
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.modifying.operations/rotate.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.modifying.operations/rotate.pass.cpp
new file mode 100644
index 00000000000000..0d1cfeb4ae8e37
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.modifying.operations/rotate.pass.cpp
@@ -0,0 +1,176 @@
+// -*- C++ -*-
+//===-- rotate.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+#include "support/pstl_test_config.h"
+
+#include <iterator>
+#include <execution>
+#include <algorithm>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+template <typename T>
+struct wrapper
+{
+    T t;
+    int move_count;
+    explicit wrapper(T t_) : t(t_), move_count(0) {}
+    wrapper&
+    operator=(const T& t_)
+    {
+        t = t_;
+        return *this;
+    }
+
+    wrapper(const wrapper<T>& a) : move_count(0) { t = a.t; }
+
+    wrapper<T>&
+    operator=(wrapper<T>& a)
+    {
+        t = a.t;
+        return *this;
+    }
+
+    wrapper<T>&
+    operator=(wrapper<T>&& a)
+    {
+        t = a.t;
+        move_count += 1;
+        return *this;
+    }
+};
+
+template <typename T>
+struct compare
+{
+    bool
+    operator()(const T& a, const T& b)
+    {
+        return a == b;
+    }
+};
+
+template <typename T>
+struct compare<wrapper<T>>
+{
+    bool
+    operator()(const wrapper<T>& a, const wrapper<T>& b)
+    {
+        return a.t == b.t;
+    }
+};
+#include <typeinfo>
+
+struct test_one_policy
+{
+
+#if defined(_PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) ||                                                             \
+    defined(_PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) // dummy specializations to skip testing in case of broken configuration
+    template <typename Iterator, typename Size>
+    void
+    operator()(pstl::execution::unsequenced_policy, Iterator data_b, Iterator data_e, Iterator actual_b,
+               Iterator actual_e, Size shift)
+    {
+    }
+    template <typename Iterator, typename Size>
+    void
+    operator()(pstl::execution::parallel_unsequenced_policy, Iterator data_b, Iterator data_e, Iterator actual_b,
+               Iterator actual_e, Size shift)
+    {
+    }
+#endif
+
+    template <typename ExecutionPolicy, typename Iterator, typename Size>
+    void
+    operator()(ExecutionPolicy&& exec, Iterator data_b, Iterator data_e, Iterator actual_b, Iterator actual_e,
+               Size shift)
+    {
+        using namespace std;
+        using T = typename iterator_traits<Iterator>::value_type;
+        Iterator actual_m = std::next(actual_b, shift);
+
+        copy(data_b, data_e, actual_b);
+        Iterator actual_return = rotate(exec, actual_b, actual_m, actual_e);
+
+        EXPECT_TRUE(actual_return == std::next(actual_b, std::distance(actual_m, actual_e)), "wrong result of rotate");
+        auto comparator = compare<T>();
+        bool check = std::equal(actual_return, actual_e, data_b, comparator);
+        check = check && std::equal(actual_b, actual_return, std::next(data_b, shift), comparator);
+
+        EXPECT_TRUE(check, "wrong effect of rotate");
+        EXPECT_TRUE(check_move(exec, actual_b, actual_e, shift), "wrong move test of rotate");
+    }
+
+    template <typename ExecutionPolicy, typename Iterator, typename Size>
+    typename std::enable_if<
+        is_same_iterator_category<Iterator, std::random_access_iterator_tag>::value &&
+            !std::is_same<ExecutionPolicy, std::execution::sequenced_policy>::value &&
+            std::is_same<typename std::iterator_traits<Iterator>::value_type, wrapper<float32_t>>::value,
+        bool>::type
+    check_move(ExecutionPolicy&&, Iterator b, Iterator e, Size shift)
+    {
+        bool result = all_of(b, e, [](wrapper<float32_t>& a) {
+            bool temp = a.move_count > 0;
+            a.move_count = 0;
+            return temp;
+        });
+        return shift == 0 || result;
+    }
+
+    template <typename ExecutionPolicy, typename Iterator, typename Size>
+    typename std::enable_if<
+        !(is_same_iterator_category<Iterator, std::random_access_iterator_tag>::value &&
+          !std::is_same<ExecutionPolicy, std::execution::sequenced_policy>::value &&
+          std::is_same<typename std::iterator_traits<Iterator>::value_type, wrapper<float32_t>>::value),
+        bool>::type
+    check_move(ExecutionPolicy&&, Iterator, Iterator, Size)
+    {
+        return true;
+    }
+};
+
+template <typename T>
+void
+test()
+{
+    const int32_t max_len = 100000;
+
+    Sequence<T> actual(max_len, [](std::size_t i) { return T(i); });
+    Sequence<T> data(max_len, [](std::size_t i) { return T(i); });
+
+    for (int32_t len = 0; len < max_len; len = len <= 16 ? len + 1 : int32_t(3.1415 * len))
+    {
+        int32_t shifts[] = {0, 1, 2, len / 3, (2 * len) / 3, len - 1};
+        for (auto shift : shifts)
+        {
+            if (shift >= 0 && shift < len)
+            {
+                invoke_on_all_policies(test_one_policy(), data.begin(), data.begin() + len, actual.begin(),
+                                       actual.begin() + len, shift);
+            }
+        }
+    }
+}
+
+int
+main()
+{
+    test<int32_t>();
+    test<wrapper<float64_t>>();
+    test<MemoryChecker>();
+    EXPECT_FALSE(MemoryChecker::alive_objects() < 0, "wrong effect from rotate: number of ctors calls < num of dtors calls");
+    EXPECT_FALSE(MemoryChecker::alive_objects() > 0, "wrong effect from rotate: number of ctors calls > num of dtors calls");
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.modifying.operations/rotate_copy.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.modifying.operations/rotate_copy.pass.cpp
new file mode 100644
index 00000000000000..539cefc929d452
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.modifying.operations/rotate_copy.pass.cpp
@@ -0,0 +1,146 @@
+// -*- C++ -*-
+//===-- rotate_copy.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+#include "support/pstl_test_config.h"
+
+#include <iterator>
+#include <execution>
+#include <algorithm>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+template <typename T>
+struct wrapper;
+
+template <typename T>
+bool
+compare(const wrapper<T>& a, const wrapper<T>& b)
+{
+    return a.t == b.t;
+}
+
+template <typename T>
+bool
+compare(const T& a, const T& b)
+{
+    return a == b;
+}
+
+template <typename T>
+struct wrapper
+{
+    explicit wrapper(T t_) : t(t_) {}
+    wrapper&
+    operator=(const T& t_)
+    {
+        t = t_;
+        return *this;
+    }
+    friend bool
+    compare<T>(const wrapper<T>& a, const wrapper<T>& b);
+
+  private:
+    T t;
+};
+
+template <typename T, typename It1, typename It2>
+struct comparator
+{
+    using T1 = typename std::iterator_traits<It1>::value_type;
+    using T2 = typename std::iterator_traits<It2>::value_type;
+    bool
+    operator()(T1 a, T2 b)
+    {
+        T temp = a;
+        return compare(temp, b);
+    }
+};
+
+struct test_one_policy
+{
+
+#if defined(_PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) ||                                                             \
+    defined(_PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) // dummy specialization by policy type, in case of broken configuration
+    template <typename Iterator1, typename Iterator2>
+    typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
+    operator()(pstl::execution::unsequenced_policy, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b,
+               Iterator2 actual_e, std::size_t shift)
+    {
+    }
+    template <typename Iterator1, typename Iterator2>
+    typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
+    operator()(pstl::execution::parallel_unsequenced_policy, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b,
+               Iterator2 actual_e, std::size_t shift)
+    {
+    }
+#endif
+
+    template <typename ExecutionPolicy, typename Iterator1, typename Iterator2>
+    void
+    operator()(ExecutionPolicy&& exec, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b, Iterator2 actual_e,
+               std::size_t shift)
+    {
+        using namespace std;
+        using T = typename iterator_traits<Iterator2>::value_type;
+        Iterator1 data_m = std::next(data_b, shift);
+
+        fill(actual_b, actual_e, T(-123));
+        Iterator2 actual_return = rotate_copy(exec, data_b, data_m, data_e, actual_b);
+
+        EXPECT_TRUE(actual_return == actual_e, "wrong result of rotate_copy");
+        auto comparer = comparator<T, Iterator1, Iterator2>();
+        bool check = std::equal(data_m, data_e, actual_b, comparer);
+        check = check && std::equal(data_b, data_m, std::next(actual_b, std::distance(data_m, data_e)), comparer);
+
+        EXPECT_TRUE(check, "wrong effect of rotate_copy");
+    }
+};
+
+template <typename T1, typename T2>
+void
+test()
+{
+
+    const std::size_t max_len = 100000;
+
+    Sequence<T2> actual(max_len, [](std::size_t i) { return T1(i); });
+
+    Sequence<T1> data(max_len, [](std::size_t i) { return T1(i); });
+
+    for (std::size_t len = 0; len < max_len; len = len <= 16 ? len + 1 : std::size_t(3.1415 * len))
+    {
+        std::size_t shifts[] = {0, 1, 2, len / 3, (2 * len) / 3, len - 1};
+        for (std::size_t shift : shifts)
+        {
+            if (shift > 0 && shift < len)
+            {
+                invoke_on_all_policies(test_one_policy(), data.begin(), data.begin() + len, actual.begin(),
+                                       actual.begin() + len, shift);
+                invoke_on_all_policies(test_one_policy(), data.cbegin(), data.cbegin() + len, actual.begin(),
+                                       actual.begin() + len, shift);
+            }
+        }
+    }
+}
+
+int
+main()
+{
+    test<int32_t, int8_t>();
+    test<uint16_t, float32_t>();
+    test<float64_t, int64_t>();
+    test<wrapper<float64_t>, wrapper<float64_t>>();
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.modifying.operations/swap_ranges.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.modifying.operations/swap_ranges.pass.cpp
new file mode 100644
index 00000000000000..c3c3693af59426
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.modifying.operations/swap_ranges.pass.cpp
@@ -0,0 +1,133 @@
+// -*- C++ -*-
+//===-- swap_ranges.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+#include "support/pstl_test_config.h"
+
+#include <iterator>
+#include <execution>
+#include <algorithm>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+template <typename T>
+struct wrapper
+{
+    T t;
+    std::size_t number_of_swaps = 0;
+    wrapper() {}
+    explicit wrapper(T t_) : t(t_) {}
+    template <typename U>
+    void
+    operator=(const U& b)
+    {
+        t = b;
+    }
+    bool
+    operator==(const wrapper<T>& a) const
+    {
+        return t == a.t;
+    }
+};
+
+template <typename T>
+void
+swap(wrapper<T>& a, wrapper<T>& b)
+{
+    std::swap(a.t, b.t);
+    a.number_of_swaps++;
+    b.number_of_swaps++;
+}
+
+template <typename T>
+struct check_swap
+{
+    bool
+    operator()(T&)
+    {
+        return true;
+    }
+};
+
+template <typename T>
+struct check_swap<wrapper<T>>
+{
+    bool
+    operator()(wrapper<T>& a)
+    {
+        bool temp = (a.number_of_swaps == 1);
+        a.number_of_swaps = 0;
+        return temp;
+    }
+};
+
+struct test_one_policy
+{
+    template <typename ExecutionPolicy, typename Iterator1, typename Iterator2>
+    void
+    operator()(ExecutionPolicy&& exec, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b, Iterator2 actual_e)
+    {
+        using namespace std;
+        using T_ref = typename iterator_traits<Iterator1>::reference;
+        using T = typename iterator_traits<Iterator1>::value_type;
+
+        iota(data_b, data_e, 0);
+        iota(actual_b, actual_e, std::distance(data_b, data_e));
+
+        Iterator2 actual_return = swap_ranges(exec, data_b, data_e, actual_b);
+        bool check_return = (actual_return == actual_e);
+        EXPECT_TRUE(check_return, "wrong result of swap_ranges");
+        if (check_return)
+        {
+            std::size_t i = 0;
+            bool check = all_of(actual_b, actual_e, [&i](T_ref a) { return a == T(i++); }) &&
+                         all_of(data_b, data_e, [&i](T_ref a) { return a == T(i++); });
+
+            EXPECT_TRUE(check, "wrong effect of swap_ranges");
+
+            if (check)
+            {
+                bool swap_check =
+                    all_of(data_b, data_e, check_swap<T>()) && all_of(actual_b, actual_e, check_swap<T>());
+                EXPECT_TRUE(swap_check, "wrong effect of swap_ranges swap check");
+            }
+        }
+    }
+};
+
+template <typename T>
+void
+test()
+{
+    const std::size_t max_len = 100000;
+
+    Sequence<T> data(max_len);
+    Sequence<T> actual(max_len);
+
+    for (std::size_t len = 0; len < max_len; len = len <= 16 ? len + 1 : std::size_t(3.1415 * len))
+    {
+        invoke_on_all_policies(test_one_policy(), data.begin(), data.begin() + len, actual.begin(),
+                               actual.begin() + len);
+    }
+}
+
+int
+main()
+{
+    test<wrapper<uint16_t>>();
+    test<wrapper<float64_t>>();
+    test<int32_t>();
+    test<float32_t>();
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.modifying.operations/transform_binary.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.modifying.operations/transform_binary.pass.cpp
new file mode 100644
index 00000000000000..949e6f54ffb413
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.modifying.operations/transform_binary.pass.cpp
@@ -0,0 +1,122 @@
+// -*- C++ -*-
+//===-- transform_binary.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+#include "support/pstl_test_config.h"
+
+#include <execution>
+#include <algorithm>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+template <typename In1, typename In2, typename Out>
+class TheOperation
+{
+    Out val;
+
+  public:
+    TheOperation(Out v) : val(v) {}
+    Out
+    operator()(const In1& x, const In2& y) const
+    {
+        return Out(val + x - y);
+    }
+};
+
+template <typename InputIterator1, typename InputIterator2, typename OutputIterator>
+void
+check_and_reset(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator out_first)
+{
+    typedef typename std::iterator_traits<OutputIterator>::value_type Out;
+    typename std::iterator_traits<OutputIterator>::difference_type k = 0;
+    for (; first1 != last1; ++first1, ++first2, ++out_first, ++k)
+    {
+        // check
+        Out expected = Out(1.5) + *first1 - *first2;
+        Out actual = *out_first;
+        if (std::is_floating_point<Out>::value)
+        {
+            EXPECT_TRUE((expected > actual ? expected - actual : actual - expected) < 1e7,
+                        "wrong value in output sequence");
+        }
+        else
+        {
+            EXPECT_EQ(expected, actual, "wrong value in output sequence");
+        }
+        // reset
+        *out_first = k % 7 != 4 ? 7 * k - 5 : 0;
+    }
+}
+
+struct test_one_policy
+{
+    template <typename Policy, typename InputIterator1, typename InputIterator2, typename OutputIterator,
+              typename BinaryOp>
+    void
+    operator()(Policy&& exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2,
+               OutputIterator out_first, OutputIterator, BinaryOp op)
+    {
+        auto result = std::transform(exec, first1, last1, first2, out_first, op);
+        (void)result;
+        check_and_reset(first1, last1, first2, out_first);
+    }
+};
+
+template <typename In1, typename In2, typename Out, typename Predicate>
+void
+test(Predicate pred)
+{
+    for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
+    {
+        Sequence<In1> in1(n, [](size_t k) { return k % 5 != 1 ? 3 * k - 7 : 0; });
+        Sequence<In2> in2(n, [](size_t k) { return k % 7 != 2 ? 5 * k - 5 : 0; });
+
+        Sequence<Out> out(n, [](size_t) { return -1; });
+
+        invoke_on_all_policies(test_one_policy(), in1.begin(), in1.end(), in2.begin(), in2.end(), out.begin(),
+                               out.end(), pred);
+        invoke_on_all_policies(test_one_policy(), in1.cbegin(), in1.cend(), in2.cbegin(), in2.cend(), out.begin(),
+                               out.end(), pred);
+    }
+}
+
+template <typename T>
+struct test_non_const
+{
+    template <typename Policy, typename InputIterator, typename OutputInterator>
+    void
+    operator()(Policy&& exec, InputIterator input_iter, OutputInterator out_iter)
+    {
+        invoke_if(exec, [&]() {
+            InputIterator input_iter2 = input_iter;
+            transform(exec, input_iter, input_iter, input_iter2, out_iter, non_const(std::plus<T>()));
+        });
+    }
+};
+
+int
+main()
+{
+    //const operator()
+    test<int32_t, int32_t, int32_t>(TheOperation<int32_t, int32_t, int32_t>(1));
+    test<float32_t, float32_t, float32_t>(TheOperation<float32_t, float32_t, float32_t>(1.5));
+    //non-const operator()
+    test<int32_t, float32_t, float32_t>(non_const(TheOperation<int32_t, float32_t, float32_t>(1.5)));
+    test<int64_t, float64_t, float32_t>(non_const(TheOperation<int64_t, float64_t, float32_t>(1.5)));
+    //lambda
+    test<int8_t, float64_t, int8_t>([](const int8_t& x, const float64_t& y) { return int8_t(int8_t(1.5) + x - y); });
+
+    test_algo_basic_double<int32_t>(run_for_rnd_fw<test_non_const<int32_t>>());
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.modifying.operations/transform_unary.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.modifying.operations/transform_unary.pass.cpp
new file mode 100644
index 00000000000000..69a410c4cd6eb6
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.modifying.operations/transform_unary.pass.cpp
@@ -0,0 +1,91 @@
+// -*- C++ -*-
+//===-- transform_unary.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+#include "support/pstl_test_config.h"
+
+#include <execution>
+#include <algorithm>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+template <typename InputIterator, typename OutputIterator>
+void
+check_and_reset(InputIterator first, InputIterator last, OutputIterator out_first)
+{
+    typedef typename std::iterator_traits<OutputIterator>::value_type Out;
+    typename std::iterator_traits<OutputIterator>::difference_type k = 0;
+    for (; first != last; ++first, ++out_first, ++k)
+    {
+        // check
+        Out expected = 1 - *first;
+        Out actual = *out_first;
+        EXPECT_EQ(expected, actual, "wrong value in output sequence");
+        // reset
+        *out_first = k % 7 != 4 ? 7 * k - 5 : 0;
+    }
+}
+
+struct test_one_policy
+{
+    template <typename Policy, typename InputIterator, typename OutputIterator, typename UnaryOp>
+    void
+    operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first,
+               OutputIterator out_last, UnaryOp op)
+    {
+        auto orr = std::transform(exec, first, last, out_first, op);
+        EXPECT_TRUE(out_last == orr, "transform returned wrong iterator");
+        check_and_reset(first, last, out_first);
+    }
+};
+
+template <typename Tin, typename Tout>
+void
+test()
+{
+    for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
+    {
+        Sequence<Tin> in(n, [](int32_t k) { return k % 5 != 1 ? 3 * k - 7 : 0; });
+
+        Sequence<Tout> out(n);
+
+        const auto flip = Complement<Tin, Tout>(1);
+        invoke_on_all_policies(test_one_policy(), in.begin(), in.end(), out.begin(), out.end(), flip);
+        invoke_on_all_policies(test_one_policy(), in.cbegin(), in.cend(), out.begin(), out.end(), flip);
+    }
+}
+
+template <typename T>
+struct test_non_const
+{
+    template <typename Policy, typename InputIterator, typename OutputInterator>
+    void
+    operator()(Policy&& exec, InputIterator input_iter, OutputInterator out_iter)
+    {
+        invoke_if(exec, [&]() { transform(exec, input_iter, input_iter, out_iter, non_const(std::negate<T>())); });
+    }
+};
+
+int
+main()
+{
+    test<int32_t, int32_t>();
+    test<int32_t, float32_t>();
+    test<uint16_t, float32_t>();
+    test<float32_t, float64_t>();
+    test<float64_t, float64_t>();
+
+    test_algo_basic_double<int32_t>(run_for_rnd_fw<test_non_const<int32_t>>());
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.modifying.operations/unique.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.modifying.operations/unique.pass.cpp
new file mode 100644
index 00000000000000..fbd4742b7e4572
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.modifying.operations/unique.pass.cpp
@@ -0,0 +1,163 @@
+// -*- C++ -*-
+//===-- unique.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+// Test for unique
+#include "support/pstl_test_config.h"
+
+#include <execution>
+#include <algorithm>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+struct run_unique
+{
+#if defined(_PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) ||                                                             \
+    defined(_PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) //dummy specialization by policy type, in case of broken configuration
+    template <typename ForwardIt, typename Generator>
+    void
+    operator()(pstl::execution::unsequenced_policy, ForwardIt first1, ForwardIt last1, ForwardIt first2,
+               ForwardIt last2, Generator generator)
+    {
+    }
+
+    template <typename ForwardIt, typename Generator>
+    void
+    operator()(pstl::execution::parallel_unsequenced_policy, ForwardIt first1, ForwardIt last1, ForwardIt first2,
+               ForwardIt last2, Generator generator)
+    {
+    }
+
+    template <typename ForwardIt, typename BinaryPred, typename Generator>
+    void
+    operator()(pstl::execution::unsequenced_policy, ForwardIt first1, ForwardIt last1, ForwardIt first2,
+               ForwardIt last2, BinaryPred pred, Generator generator)
+    {
+    }
+
+    template <typename ForwardIt, typename BinaryPred, typename Generator>
+    void
+    operator()(pstl::execution::parallel_unsequenced_policy, ForwardIt first1, ForwardIt last1, ForwardIt first2,
+               ForwardIt last2, BinaryPred pred, Generator generator)
+    {
+    }
+#endif
+
+    template <typename Policy, typename ForwardIt, typename Generator>
+    void
+    operator()(Policy&& exec, ForwardIt first1, ForwardIt last1, ForwardIt first2, ForwardIt last2, Generator generator)
+    {
+        using namespace std;
+
+        // Preparation
+        fill_data(first1, last1, generator);
+        fill_data(first2, last2, generator);
+
+        ForwardIt i = unique(first1, last1);
+        ForwardIt k = unique(exec, first2, last2);
+
+        auto n = std::distance(first1, i);
+        EXPECT_TRUE(std::distance(first2, k) == n, "wrong return value from unique without predicate");
+        EXPECT_EQ_N(first1, first2, n, "wrong effect from unique without predicate");
+    }
+
+    template <typename Policy, typename ForwardIt, typename BinaryPred, typename Generator>
+    void
+    operator()(Policy&& exec, ForwardIt first1, ForwardIt last1, ForwardIt first2, ForwardIt last2, BinaryPred pred,
+               Generator generator)
+    {
+        using namespace std;
+
+        // Preparation
+        fill_data(first1, last1, generator);
+        fill_data(first2, last2, generator);
+
+        ForwardIt i = unique(first1, last1, pred);
+        ForwardIt k = unique(exec, first2, last2, pred);
+
+        auto n = std::distance(first1, i);
+        EXPECT_TRUE(std::distance(first2, k) == n, "wrong return value from unique with predicate");
+        EXPECT_EQ_N(first1, first2, n, "wrong effect from unique with predicate");
+    }
+};
+
+template <typename T, typename Generator, typename Predicate>
+void
+test(Generator generator, Predicate pred)
+{
+    const std::size_t max_size = 1000000;
+    Sequence<T> in(max_size, [](size_t v) { return T(v); });
+    Sequence<T> exp(max_size, [](size_t v) { return T(v); });
+
+    for (size_t n = 0; n <= max_size; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
+    {
+        invoke_on_all_policies(run_unique(), exp.begin(), exp.begin() + n, in.begin(), in.begin() + n, generator);
+        invoke_on_all_policies(run_unique(), exp.begin(), exp.begin() + n, in.begin(), in.begin() + n, pred, generator);
+    }
+}
+
+template <typename T>
+struct LocalWrapper
+{
+    T my_val;
+
+    explicit LocalWrapper(T k) : my_val(k) {}
+    LocalWrapper(LocalWrapper&& input) : my_val(std::move(input.my_val)) {}
+    LocalWrapper&
+    operator=(LocalWrapper&& input)
+    {
+        my_val = std::move(input.my_val);
+        return *this;
+    }
+    friend bool
+    operator==(const LocalWrapper<T>& x, const LocalWrapper<T>& y)
+    {
+        return x.my_val == y.my_val;
+    }
+};
+
+template <typename T>
+struct test_non_const
+{
+    template <typename Policy, typename Iterator>
+    void
+    operator()(Policy&& exec, Iterator iter)
+    {
+        invoke_if(exec, [&]() { unique(exec, iter, iter, non_const(std::equal_to<T>())); });
+    }
+};
+
+int
+main()
+{
+#if !defined(_PSTL_ICC_16_17_18_TEST_UNIQUE_MASK_RELEASE_BROKEN)
+    test<int32_t>([](size_t j) { return j / 3; },
+                  [](const int32_t& val1, const int32_t& val2) { return val1 * val1 == val2 * val2; });
+    test<float64_t>([](size_t) { return float64_t(1); },
+                    [](const float64_t& val1, const float64_t& val2) { return val1 != val2; });
+#endif
+    test<LocalWrapper<uint32_t>>([](size_t j) { return LocalWrapper<uint32_t>(j); },
+                                 [](const LocalWrapper<uint32_t>& val1, const LocalWrapper<uint32_t>& val2) {
+                                     return val1.my_val != val2.my_val;
+                                 });
+
+    test_algo_basic_single<int32_t>(run_for_rnd_fw<test_non_const<int32_t>>());
+
+    test<MemoryChecker>(
+        [](std::size_t idx){ return MemoryChecker{std::int32_t(idx / 3)}; },
+        [](const MemoryChecker& val1, const MemoryChecker& val2){ return val1.value() == val2.value(); });
+    EXPECT_FALSE(MemoryChecker::alive_objects() < 0, "wrong effect from unique: number of ctors calls < num of dtors calls");
+    EXPECT_FALSE(MemoryChecker::alive_objects() > 0, "wrong effect from unique: number of ctors calls > num of dtors calls");
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.modifying.operations/unique_copy_equal.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.modifying.operations/unique_copy_equal.pass.cpp
new file mode 100644
index 00000000000000..356d4d24aba674
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.modifying.operations/unique_copy_equal.pass.cpp
@@ -0,0 +1,135 @@
+// -*- C++ -*-
+//===-- unique_copy_equal.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+// Tests for unique_copy
+#include "support/pstl_test_config.h"
+
+#include <execution>
+#include <algorithm>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+struct run_unique_copy
+{
+#if defined(_PSTL_ICC_16_VC14_TEST_PAR_TBB_RT_RELEASE_64_BROKEN) // dummy specializations to skip testing in case of broken configuration
+    template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size,
+              typename Predicate, typename T>
+    void
+    operator()(pstl::execution::parallel_policy, InputIterator first, InputIterator last, OutputIterator out_first,
+               OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size n,
+               Predicate pred, T trash)
+    {
+    }
+
+    template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size,
+              typename Predicate, typename T>
+    void
+    operator()(pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last,
+               OutputIterator out_first, OutputIterator out_last, OutputIterator2 expected_first,
+               OutputIterator2 expected_last, Size n, Predicate pred, T trash)
+    {
+    }
+#endif
+
+    template <typename Policy, typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size,
+              typename Predicate, typename T>
+    void
+    operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first,
+               OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2, Size n, Predicate pred,
+               T trash)
+    {
+        // Cleaning
+        std::fill_n(expected_first, n, trash);
+        std::fill_n(out_first, n, trash);
+
+        // Run unique_copy
+        auto i = unique_copy(first, last, expected_first);
+        auto k = unique_copy(exec, first, last, out_first);
+        EXPECT_EQ_N(expected_first, out_first, n, "wrong unique_copy effect");
+        for (size_t j = 0; j < GuardSize; ++j)
+        {
+            ++k;
+        }
+        EXPECT_TRUE(out_last == k, "wrong return value from unique_copy");
+
+        // Cleaning
+        std::fill_n(expected_first, n, trash);
+        std::fill_n(out_first, n, trash);
+        // Run unique_copy with predicate
+        i = unique_copy(first, last, expected_first, pred);
+        k = unique_copy(exec, first, last, out_first, pred);
+        EXPECT_EQ_N(expected_first, out_first, n, "wrong unique_copy with predicate effect");
+        for (size_t j = 0; j < GuardSize; ++j)
+        {
+            ++k;
+        }
+        EXPECT_TRUE(out_last == k, "wrong return value from unique_copy with predicate");
+    }
+};
+
+template <typename T, typename BinaryPredicate, typename Convert>
+void
+test(T trash, BinaryPredicate pred, Convert convert, bool check_weakness = true)
+{
+    // Try sequences of various lengths.
+    for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
+    {
+        // count is number of output elements, plus a handful
+        // more for sake of detecting buffer overruns.
+        Sequence<T> in(n, [&](size_t k) -> T { return convert(k ^ n); });
+        using namespace std;
+        size_t count = GuardSize;
+        for (size_t k = 0; k < in.size(); ++k)
+            count += k == 0 || !pred(in[k], in[k - 1]) ? 1 : 0;
+        Sequence<T> out(count, [=](size_t) { return trash; });
+        Sequence<T> expected(count, [=](size_t) { return trash; });
+        if (check_weakness)
+        {
+            auto expected_result = unique_copy(in.begin(), in.end(), expected.begin(), pred);
+            size_t m = expected_result - expected.begin();
+            EXPECT_TRUE(n / (n < 10000 ? 4 : 6) <= m && m <= (3 * n + 1) / 4, "weak test for unique_copy");
+        }
+        invoke_on_all_policies(run_unique_copy(), in.begin(), in.end(), out.begin(), out.end(), expected.begin(),
+                               expected.end(), count, pred, trash);
+    }
+}
+
+template <typename T>
+struct test_non_const
+{
+    template <typename Policy, typename InputIterator, typename OutputInterator>
+    void
+    operator()(Policy&& exec, InputIterator input_iter, OutputInterator out_iter)
+    {
+        unique_copy(exec, input_iter, input_iter, out_iter, non_const(std::equal_to<T>()));
+    }
+};
+
+int
+main()
+{
+    test<Number>(Number(42, OddTag()), std::equal_to<Number>(),
+                 [](int32_t j) { return Number(3 * j / 13 ^ (j & 8), OddTag()); });
+
+    test<float32_t>(float32_t(42), std::equal_to<float32_t>(),
+                    [](int32_t j) { return float32_t(5 * j / 23 ^ (j / 7)); });
+#if !defined(_PSTL_ICC_16_17_TEST_REDUCTION_RELEASE_BROKEN)
+    test<float32_t>(float32_t(42), [](float32_t, float32_t) { return false; }, [](int32_t j) { return float32_t(j); },
+                    false);
+#endif
+
+    test_algo_basic_double<int32_t>(run_for_rnd_fw<test_non_const<int32_t>>());
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.nonmodifying/adjacent_find.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.nonmodifying/adjacent_find.pass.cpp
new file mode 100644
index 00000000000000..36a623bac42a4b
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.nonmodifying/adjacent_find.pass.cpp
@@ -0,0 +1,114 @@
+// -*- C++ -*-
+//===-- adjacent_find.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+#include "support/pstl_test_config.h"
+
+#include <execution>
+#include <algorithm>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+struct test_adjacent_find
+{
+    template <typename Policy, typename Iterator, typename Pred>
+    void
+    operator()(Policy&& exec, Iterator first, Iterator last, Pred pred)
+    {
+        using namespace std;
+
+        auto k = std::adjacent_find(first, last, pred);
+        auto i = adjacent_find(exec, first, last, pred);
+        EXPECT_TRUE(i == k, "wrong return value from adjacent_find with predicate");
+
+        i = adjacent_find(exec, first, last);
+        EXPECT_TRUE(i == k, "wrong return value from adjacent_find without predicate");
+    }
+};
+
+template <typename T>
+void
+test_adjacent_find_by_type()
+{
+
+    size_t counts[] = {2, 3, 500};
+    for (size_t c = 0; c < const_size(counts); ++c)
+    {
+
+        for (size_t e = 0; e < (counts[c] >= 64 ? 64 : (counts[c] == 2 ? 1 : 2)); ++e)
+        {
+            Sequence<T> in(counts[c], [](size_t v) -> T { return T(v); }); //fill 0...n
+            in[e] = in[e + 1] = -1;                                        //make an adjacent pair
+
+            auto i = std::adjacent_find(in.cbegin(), in.cend(), std::equal_to<T>());
+            EXPECT_TRUE(i == in.cbegin() + e, "std::adjacent_find returned wrong result");
+
+            invoke_on_all_policies(test_adjacent_find(), in.begin(), in.end(), std::equal_to<T>());
+            invoke_on_all_policies(test_adjacent_find(), in.cbegin(), in.cend(), std::equal_to<T>());
+        }
+    }
+
+    //special cases: size=0, size=1;
+    for (size_t expect = 0; expect < 1; ++expect)
+    {
+        Sequence<T> in(expect, [](size_t v) -> T { return T(v); }); //fill 0...n
+        auto i = std::adjacent_find(in.cbegin(), in.cend(), std::equal_to<T>());
+        EXPECT_TRUE(i == in.cbegin() + expect, "std::adjacent_find returned wrong result");
+
+        invoke_on_all_policies(test_adjacent_find(), in.begin(), in.end(), std::equal_to<T>());
+        invoke_on_all_policies(test_adjacent_find(), in.cbegin(), in.cend(), std::equal_to<T>());
+    }
+
+    //special cases:
+    Sequence<T> a1 = {5, 5, 5, 6, 7, 8, 9};
+    invoke_on_all_policies(test_adjacent_find(), a1.begin(), a1.end(), std::equal_to<T>());
+    invoke_on_all_policies(test_adjacent_find(), a1.begin() + 1, a1.end(), std::equal_to<T>());
+
+    invoke_on_all_policies(test_adjacent_find(), a1.cbegin(), a1.cend(), std::equal_to<T>());
+    invoke_on_all_policies(test_adjacent_find(), a1.cbegin() + 1, a1.cend(), std::equal_to<T>());
+
+    Sequence<T> a2 = {5, 6, 7, 8, 9, 9};
+    invoke_on_all_policies(test_adjacent_find(), a2.begin(), a2.end(), std::equal_to<T>());
+    invoke_on_all_policies(test_adjacent_find(), a2.begin(), a2.end() - 1, std::equal_to<T>());
+
+    invoke_on_all_policies(test_adjacent_find(), a2.cbegin(), a2.cend(), std::equal_to<T>());
+    invoke_on_all_policies(test_adjacent_find(), a2.cbegin(), a2.cend() - 1, std::equal_to<T>());
+
+    Sequence<T> a3 = {5, 6, 6, 6, 7, 9, 9, 9, 9};
+    invoke_on_all_policies(test_adjacent_find(), a3.begin(), a3.end(), std::equal_to<T>());
+
+    invoke_on_all_policies(test_adjacent_find(), a3.cbegin(), a3.cend(), std::equal_to<T>());
+}
+
+template <typename T>
+struct test_non_const
+{
+    template <typename Policy, typename Iterator>
+    void
+    operator()(Policy&& exec, Iterator iter)
+    {
+        adjacent_find(exec, iter, iter, non_const(std::equal_to<T>()));
+    }
+};
+
+int
+main()
+{
+
+    test_adjacent_find_by_type<int32_t>();
+    test_adjacent_find_by_type<float64_t>();
+
+    test_algo_basic_single<int32_t>(run_for_rnd_bi<test_non_const<int32_t>>());
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.nonmodifying/all_of.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.nonmodifying/all_of.pass.cpp
new file mode 100644
index 00000000000000..ec23dc47e2f940
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.nonmodifying/all_of.pass.cpp
@@ -0,0 +1,117 @@
+// -*- C++ -*-
+//===-- all_of.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+#include "support/pstl_test_config.h"
+
+#include <execution>
+#include <algorithm>
+
+#include "support/utils.h"
+
+/*
+  TODO: consider implementing the following tests for a better code coverage
+  - correctness
+  - bad input argument (if applicable)
+  - data corruption around/of input and output
+  - correctly work with nested parallelism
+  - check that algorithm does not require anything more than is described in its requirements section
+*/
+
+using namespace TestUtils;
+
+struct test_all_of
+{
+    template <typename ExecutionPolicy, typename Iterator, typename Predicate>
+    void
+    operator()(ExecutionPolicy&& exec, Iterator begin, Iterator end, Predicate pred, bool expected)
+    {
+
+        auto actualr = std::all_of(exec, begin, end, pred);
+        EXPECT_EQ(expected, actualr, "result for all_of");
+    }
+};
+
+template <typename T>
+struct Parity
+{
+    bool parity;
+
+  public:
+    Parity(bool parity_) : parity(parity_) {}
+    bool
+    operator()(T value) const
+    {
+        return (size_t(value) ^ parity) % 2 == 0;
+    }
+};
+
+template <typename T>
+void
+test(size_t bits)
+{
+    for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
+    {
+
+        // Sequence of odd values
+        Sequence<T> in(n, [n, bits](size_t) { return T(2 * HashBits(n, bits - 1) ^ 1); });
+
+        // Even value, or false when T is bool.
+        T spike(2 * HashBits(n, bits - 1));
+        Sequence<T> inCopy(in);
+
+        invoke_on_all_policies(test_all_of(), in.begin(), in.end(), Parity<T>(1), true);
+        invoke_on_all_policies(test_all_of(), in.cbegin(), in.cend(), Parity<T>(1), true);
+        EXPECT_EQ(in, inCopy, "all_of modified input sequence");
+        if (n > 0)
+        {
+            // Sprinkle in a miss
+            in[2 * n / 3] = spike;
+            invoke_on_all_policies(test_all_of(), in.begin(), in.end(), Parity<T>(1), false);
+            invoke_on_all_policies(test_all_of(), in.cbegin(), in.cend(), Parity<T>(1), false);
+
+            // Sprinkle in a few more misses
+            in[n / 2] = spike;
+            in[n / 3] = spike;
+            invoke_on_all_policies(test_all_of(), in.begin(), in.end(), Parity<T>(1), false);
+            invoke_on_all_policies(test_all_of(), in.cbegin(), in.cend(), Parity<T>(1), false);
+        }
+    }
+}
+
+struct test_non_const
+{
+    template <typename Policy, typename Iterator>
+    void
+    operator()(Policy&& exec, Iterator iter)
+    {
+        auto is_even = [&](float64_t v) {
+            uint32_t i = (uint32_t)v;
+            return i % 2 == 0;
+        };
+        all_of(exec, iter, iter, non_const(is_even));
+    }
+};
+
+int
+main()
+{
+    test<int32_t>(8 * sizeof(int32_t));
+    test<uint16_t>(8 * sizeof(uint16_t));
+    test<float64_t>(53);
+#if !defined(_PSTL_ICC_16_17_TEST_REDUCTION_BOOL_TYPE_RELEASE_64_BROKEN)
+    test<bool>(1);
+#endif
+
+    test_algo_basic_single<int32_t>(run_for_rnd_fw<test_non_const>());
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.nonmodifying/any_of.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.nonmodifying/any_of.pass.cpp
new file mode 100644
index 00000000000000..97d1691fa34ee1
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.nonmodifying/any_of.pass.cpp
@@ -0,0 +1,103 @@
+// -*- C++ -*-
+//===-- any_of.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+#include "support/pstl_test_config.h"
+
+#include <execution>
+#include <algorithm>
+
+#include "support/utils.h"
+
+/*
+  TODO: consider implementing the following tests for a better code coverage
+  - correctness
+  - bad input argument (if applicable)
+  - data corruption around/of input and output
+  - correctly work with nested parallelism
+  - check that algorithm does not require anything more than is described in its requirements section
+*/
+
+using namespace TestUtils;
+
+struct test_any_of
+{
+    template <typename ExecutionPolicy, typename Iterator, typename Predicate>
+    void
+    operator()(ExecutionPolicy&& exec, Iterator begin, Iterator end, Predicate pred, bool expected)
+    {
+
+        auto actualr = std::any_of(exec, begin, end, pred);
+        EXPECT_EQ(expected, actualr, "result for any_of");
+    }
+};
+
+template <typename T>
+void
+test(size_t bits)
+{
+    for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
+    {
+
+        // Sequence of odd values
+        Sequence<T> in(n, [n, bits](size_t) { return T(2 * HashBits(n, bits - 1) ^ 1); });
+
+        // Even value, or false when T is bool.
+        T spike(2 * HashBits(n, bits - 1));
+        Sequence<T> inCopy(in);
+
+        invoke_on_all_policies(test_any_of(), in.begin(), in.end(), is_equal_to<T>(spike), false);
+        invoke_on_all_policies(test_any_of(), in.cbegin(), in.cend(), is_equal_to<T>(spike), false);
+        EXPECT_EQ(in, inCopy, "any_of modified input sequence");
+        if (n > 0)
+        {
+            // Sprinkle in a hit
+            in[2 * n / 3] = spike;
+            invoke_on_all_policies(test_any_of(), in.begin(), in.end(), is_equal_to<T>(spike), true);
+            invoke_on_all_policies(test_any_of(), in.cbegin(), in.cend(), is_equal_to<T>(spike), true);
+
+            // Sprinkle in a few more hits
+            in[n / 2] = spike;
+            in[n / 3] = spike;
+            invoke_on_all_policies(test_any_of(), in.begin(), in.end(), is_equal_to<T>(spike), true);
+            invoke_on_all_policies(test_any_of(), in.cbegin(), in.cend(), is_equal_to<T>(spike), true);
+        }
+    }
+}
+
+struct test_non_const
+{
+    template <typename Policy, typename Iterator>
+    void
+    operator()(Policy&& exec, Iterator iter)
+    {
+        auto is_even = [&](float64_t v) {
+            uint32_t i = (uint32_t)v;
+            return i % 2 == 0;
+        };
+        any_of(exec, iter, iter, non_const(is_even));
+    }
+};
+
+int
+main()
+{
+    test<int32_t>(8 * sizeof(int32_t));
+    test<uint16_t>(8 * sizeof(uint16_t));
+    test<float64_t>(53);
+#if !defined(_PSTL_ICC_16_17_TEST_REDUCTION_BOOL_TYPE_RELEASE_64_BROKEN)
+    test<bool>(1);
+#endif
+
+    test_algo_basic_single<int32_t>(run_for_rnd_fw<test_non_const>());
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.nonmodifying/count.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.nonmodifying/count.pass.cpp
new file mode 100644
index 00000000000000..e8eca023d15aec
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.nonmodifying/count.pass.cpp
@@ -0,0 +1,108 @@
+// -*- C++ -*-
+//===-- count.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+// Tests for count and count_if
+#include "support/pstl_test_config.h"
+
+#include <execution>
+#include <algorithm>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+struct test_count
+{
+    template <typename Policy, typename Iterator, typename T>
+    void
+    operator()(Policy&& exec, Iterator first, Iterator last, T needle)
+    {
+        auto expected = std::count(first, last, needle);
+        auto result = std::count(exec, first, last, needle);
+        EXPECT_EQ(expected, result, "wrong count result");
+    }
+};
+
+struct test_count_if
+{
+    template <typename Policy, typename Iterator, typename Predicate>
+    void
+    operator()(Policy&& exec, Iterator first, Iterator last, Predicate pred)
+    {
+        auto expected = std::count_if(first, last, pred);
+        auto result = std::count_if(exec, first, last, pred);
+        EXPECT_EQ(expected, result, "wrong count_if result");
+    }
+};
+
+template <typename T>
+class IsEqual
+{
+    T value;
+
+  public:
+    IsEqual(T value_, OddTag) : value(value_) {}
+    bool
+    operator()(const T& x) const
+    {
+        return x == value;
+    }
+};
+
+template <typename In, typename T, typename Predicate, typename Convert>
+void
+test(T needle, Predicate pred, Convert convert)
+{
+    // Try sequences of various lengths.
+    for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
+    {
+        Sequence<In> in(n, [=](size_t k) -> In {
+            // Sprinkle "42" and "50" early, so that short sequences have non-zero count.
+            return convert((n - k - 1) % 3 == 0 ? 42 : (n - k - 2) % 5 == 0 ? 50 : 3 * (int(k) % 1000 - 500));
+        });
+        invoke_on_all_policies(test_count(), in.begin(), in.end(), needle);
+        invoke_on_all_policies(test_count_if(), in.begin(), in.end(), pred);
+
+        invoke_on_all_policies(test_count(), in.cbegin(), in.cend(), needle);
+        invoke_on_all_policies(test_count_if(), in.cbegin(), in.cend(), pred);
+    }
+}
+
+struct test_non_const
+{
+    template <typename Policy, typename Iterator>
+    void
+    operator()(Policy&& exec, Iterator iter)
+    {
+        auto is_even = [&](float64_t v) {
+            uint32_t i = (uint32_t)v;
+            return i % 2 == 0;
+        };
+        count_if(exec, iter, iter, non_const(is_even));
+    }
+};
+
+int
+main()
+{
+    test<int32_t>(42, IsEqual<int32_t>(50, OddTag()), [](int32_t j) { return j; });
+#if !defined(_PSTL_ICC_16_17_TEST_REDUCTION_RELEASE_BROKEN)
+    test<int32_t>(42, [](const int32_t&) { return true; }, [](int32_t j) { return j; });
+#endif
+    test<float64_t>(42, IsEqual<float64_t>(50, OddTag()), [](int32_t j) { return float64_t(j); });
+    test<Number>(Number(42, OddTag()), IsEqual<Number>(Number(50, OddTag()), OddTag()),
+                 [](int32_t j) { return Number(j, OddTag()); });
+
+    test_algo_basic_single<int32_t>(run_for_rnd_fw<test_non_const>());
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.nonmodifying/equal.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.nonmodifying/equal.pass.cpp
new file mode 100644
index 00000000000000..a6983eae2ff18d
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.nonmodifying/equal.pass.cpp
@@ -0,0 +1,168 @@
+// -*- C++ -*-
+//===-- equal.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+#include "support/pstl_test_config.h"
+
+#include <execution>
+#include <algorithm>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+#define CPP14_ENABLED 0
+
+struct UserType
+{
+    size_t key;
+    float32_t f;
+    float64_t d;
+    int32_t i;
+
+    bool
+    operator()(UserType a, UserType b)
+    {
+        return a.key < b.key;
+    }
+    bool
+    operator<(UserType a)
+    {
+        return a.key < key;
+    }
+    bool
+    operator>=(UserType a)
+    {
+        return a.key <= key;
+    }
+    bool
+    operator<=(UserType a)
+    {
+        return a.key >= key;
+    }
+    bool
+    operator==(UserType a)
+    {
+        return a.key == key;
+    }
+    bool
+    operator==(UserType a) const
+    {
+        return a.key == key;
+    }
+    bool
+    operator!=(UserType a)
+    {
+        return a.key != key;
+    }
+    UserType operator!()
+    {
+        UserType tmp;
+        tmp.key = !key;
+        return tmp;
+    }
+    friend std::ostream&
+    operator<<(std::ostream& stream, const UserType a)
+    {
+        stream << a.key;
+        return stream;
+    }
+
+    UserType() : key(-1), f(0.0f), d(0.0), i(0) {}
+    UserType(size_t Number) : key(Number), f(0.0f), d(0.0), i(0) {}
+    UserType&
+    operator=(const UserType& other)
+    {
+        key = other.key;
+        return *this;
+    }
+    UserType(const UserType& other) : key(other.key), f(other.f), d(other.d), i(other.i) {}
+    UserType(UserType&& other) : key(other.key), f(other.f), d(other.d), i(other.i)
+    {
+        other.key = -1;
+        other.f = 0.0f;
+        other.d = 0.0;
+        other.i = 0;
+    }
+};
+
+struct test_one_policy
+{
+    template <typename ExecutionPolicy, typename Iterator1, typename Iterator2>
+    void
+    operator()(ExecutionPolicy&& exec, Iterator1 first1, Iterator1 last1, Iterator2 first2, bool is_true_equal)
+    {
+        using namespace std;
+
+        auto expected = equal(first1, last1, first2);
+        auto actual = equal(exec, first1, last1, first2);
+        EXPECT_EQ(expected, actual, "result for equal for random-access iterator, checking against std::equal()");
+
+        // testing bool
+        EXPECT_TRUE(is_true_equal == actual, "result for equal for random-access iterator, bool");
+
+//add C++14 equal symantics tests
+//add more cases for inCopy size less than in
+#if CPP14_ENABLED
+        auto actualr14 = std::equal(in.cbegin(), in.cend(), inCopy.cbegin(), inCopy.cend());
+        EXPECT_EQ(expected, actualr14, "result for equal for random-access iterator");
+#endif
+    }
+};
+
+template <typename T>
+void
+test(size_t bits)
+{
+    for (size_t n = 1; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
+    {
+
+        // Sequence of odd values
+        Sequence<T> in(n, [bits](size_t k) { return T(2 * HashBits(k, bits - 1) ^ 1); });
+        Sequence<T> inCopy(in);
+
+        invoke_on_all_policies(test_one_policy(), in.begin(), in.end(), inCopy.begin(), true);
+        invoke_on_all_policies(test_one_policy(), in.cbegin(), in.cend(), inCopy.cbegin(), true);
+
+        // testing bool !equal()
+        inCopy[0] = !inCopy[0];
+        invoke_on_all_policies(test_one_policy(), in.begin(), in.end(), inCopy.begin(), false);
+        invoke_on_all_policies(test_one_policy(), in.cbegin(), in.cend(), inCopy.cbegin(), false);
+    }
+}
+
+template <typename T>
+struct test_non_const
+{
+    template <typename Policy, typename FirstIterator, typename SecondInterator>
+    void
+    operator()(Policy&& exec, FirstIterator first_iter, SecondInterator second_iter)
+    {
+        equal(exec, first_iter, first_iter, second_iter, second_iter, non_const(std::equal_to<T>()));
+    }
+};
+
+int
+main()
+{
+
+    test<int32_t>(8 * sizeof(int32_t));
+    test<uint16_t>(8 * sizeof(uint16_t));
+    test<float64_t>(53);
+#if !defined(_PSTL_ICC_16_17_TEST_REDUCTION_BOOL_TYPE_RELEASE_64_BROKEN)
+    test<bool>(1);
+#endif
+    test<UserType>(256);
+
+    test_algo_basic_double<int32_t>(run_for_rnd_fw<test_non_const<int32_t>>());
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.nonmodifying/find.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.nonmodifying/find.pass.cpp
new file mode 100644
index 00000000000000..54b25c27ea2fb0
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.nonmodifying/find.pass.cpp
@@ -0,0 +1,96 @@
+// -*- C++ -*-
+//===-- find.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+// Tests for find
+#include "support/pstl_test_config.h"
+
+#include <execution>
+#include <algorithm>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+struct test_find
+{
+#if defined(_PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) ||                                                             \
+    defined(_PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) //dummy specialization by policy type, in case of broken configuration
+    template <typename Iterator, typename Value>
+    void
+    operator()(pstl::execution::unsequenced_policy, Iterator first, Iterator last, Value value)
+    {
+    }
+    template <typename Iterator, typename Value>
+    void
+    operator()(pstl::execution::parallel_unsequenced_policy, Iterator first, Iterator last, Value value)
+    {
+    }
+#endif
+
+    template <typename Policy, typename Iterator, typename Value>
+    void
+    operator()(Policy&& exec, Iterator first, Iterator last, Value value)
+    {
+        auto i = std::find(first, last, value);
+        auto j = find(exec, first, last, value);
+        EXPECT_TRUE(i == j, "wrong return value from find");
+    }
+};
+
+template <typename T, typename Value, typename Hit, typename Miss>
+void
+test(Value value, Hit hit, Miss miss)
+{
+    // Try sequences of various lengths.
+    for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
+    {
+        Sequence<T> in(n, [&](size_t k) -> T { return miss(n ^ k); });
+        // Try different find positions, including not found.
+        // By going backwards, we can add extra matches that are *not* supposed to be found.
+        // The decreasing exponential gives us O(n) total work for the loop since each find takes O(m) time.
+        for (size_t m = n; m > 0; m *= 0.6)
+        {
+            if (m < n)
+                in[m] = hit(n ^ m);
+            invoke_on_all_policies(test_find(), in.begin(), in.end(), value);
+            invoke_on_all_policies(test_find(), in.cbegin(), in.cend(), value);
+        }
+    }
+}
+
+// Type defined for sake of checking that std::find works with asymmetric ==.
+class Weird
+{
+    Number value;
+
+  public:
+    friend bool
+    operator==(Number x, Weird y)
+    {
+        return x == y.value;
+    }
+    Weird(int32_t val, OddTag) : value(val, OddTag()) {}
+};
+
+int
+main()
+{
+    // Note that the "hit" and "miss" functions here avoid overflow issues.
+    test<Number>(Weird(42, OddTag()), [](int32_t) { return Number(42, OddTag()); }, // hit
+                 [](int32_t j) { return Number(j == 42 ? 0 : j, OddTag()); });      // miss
+
+    // Test with value that is equal to two different bit patterns (-0.0 and 0.0)
+    test<float32_t>(-0.0, [](int32_t j) { return j & 1 ? 0.0 : -0.0; }, // hit
+                    [](int32_t j) { return j == 0 ? ~j : j; });         // miss
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.nonmodifying/find_end.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.nonmodifying/find_end.pass.cpp
new file mode 100644
index 00000000000000..ed0185f7b0c5e0
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.nonmodifying/find_end.pass.cpp
@@ -0,0 +1,123 @@
+// -*- C++ -*-
+//===-- find_end.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+#include "support/pstl_test_config.h"
+
+#include <execution>
+#include <algorithm>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+struct test_one_policy
+{
+#if defined(_PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) ||                                                             \
+    defined(_PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) //dummy specialization by policy type, in case of broken configuration
+    template <typename Iterator1, typename Iterator2, typename Predicate>
+    void
+    operator()(pstl::execution::unsequenced_policy, Iterator1 b, Iterator1 e, Iterator2 bsub, Iterator2 esub,
+               Predicate pred)
+    {
+    }
+    template <typename Iterator1, typename Iterator2, typename Predicate>
+    void
+    operator()(pstl::execution::parallel_unsequenced_policy, Iterator1 b, Iterator1 e, Iterator2 bsub, Iterator2 esub,
+               Predicate pred)
+    {
+    }
+#endif
+
+    template <typename ExecutionPolicy, typename Iterator1, typename Iterator2, typename Predicate>
+    void
+    operator()(ExecutionPolicy&& exec, Iterator1 b, Iterator1 e, Iterator2 bsub, Iterator2 esub, Predicate pred)
+    {
+        using namespace std;
+        // For find_end
+        {
+            auto expected = find_end(b, e, bsub, esub, pred);
+            auto actual = find_end(exec, b, e, bsub, esub);
+            EXPECT_TRUE(actual == expected, "wrong return result from find_end");
+
+            actual = find_end(exec, b, e, bsub, esub, pred);
+            EXPECT_TRUE(actual == expected, "wrong return result from find_end with a predicate");
+        }
+
+        // For search
+        {
+            auto expected = search(b, e, bsub, esub, pred);
+            auto actual = search(exec, b, e, bsub, esub);
+            EXPECT_TRUE(actual == expected, "wrong return result from search");
+
+            actual = search(exec, b, e, bsub, esub, pred);
+            EXPECT_TRUE(actual == expected, "wrong return result from search with a predicate");
+        }
+    }
+};
+
+template <typename T>
+void
+test(const std::size_t bits)
+{
+
+    const std::size_t max_n1 = 1000;
+    const std::size_t max_n2 = (max_n1 * 10) / 8;
+    Sequence<T> in(max_n1, [bits](std::size_t) { return T(2 * HashBits(max_n1, bits - 1) ^ 1); });
+    Sequence<T> sub(max_n2, [bits](std::size_t) { return T(2 * HashBits(max_n1, bits - 1)); });
+    for (std::size_t n1 = 0; n1 <= max_n1; n1 = n1 <= 16 ? n1 + 1 : size_t(3.1415 * n1))
+    {
+        std::size_t sub_n[] = {0, 1, 3, n1, (n1 * 10) / 8};
+        std::size_t res[] = {0, 1, n1 / 2, n1};
+        for (auto n2 : sub_n)
+        {
+            for (auto r : res)
+            {
+                std::size_t i = r, isub = 0;
+                for (; i < n1 && isub < n2; ++i, ++isub)
+                    in[i] = sub[isub];
+                invoke_on_all_policies(test_one_policy(), in.begin(), in.begin() + n1, sub.begin(), sub.begin() + n2,
+                                       std::equal_to<T>());
+                invoke_on_all_policies(test_one_policy(), in.cbegin(), in.cbegin() + n1, sub.cbegin(),
+                                       sub.cbegin() + n2, std::equal_to<T>());
+            }
+        }
+    }
+}
+
+template <typename T>
+struct test_non_const
+{
+    template <typename Policy, typename FirstIterator, typename SecondInterator>
+    void
+    operator()(Policy&& exec, FirstIterator first_iter, SecondInterator second_iter)
+    {
+        invoke_if(exec, [&]() {
+            find_end(exec, first_iter, first_iter, second_iter, second_iter, non_const(std::equal_to<T>()));
+            search(exec, first_iter, first_iter, second_iter, second_iter, non_const(std::equal_to<T>()));
+        });
+    }
+};
+
+int
+main()
+{
+    test<int32_t>(8 * sizeof(int32_t));
+    test<uint16_t>(8 * sizeof(uint16_t));
+    test<float64_t>(53);
+#if !defined(_PSTL_ICC_16_17_TEST_REDUCTION_BOOL_TYPE_RELEASE_64_BROKEN)
+    test<bool>(1);
+#endif
+
+    test_algo_basic_double<int32_t>(run_for_rnd_fw<test_non_const<int32_t>>());
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.nonmodifying/find_first_of.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.nonmodifying/find_first_of.pass.cpp
new file mode 100644
index 00000000000000..5b4801e9b3a87b
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.nonmodifying/find_first_of.pass.cpp
@@ -0,0 +1,112 @@
+// -*- C++ -*-
+//===-- find_first_of.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+#include "support/pstl_test_config.h"
+
+#include <execution>
+#include <algorithm>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+struct test_one_policy
+{
+#if defined(_PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) ||                                                             \
+    defined(_PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) //dummy specialization by policy type, in case of broken configuration
+    template <typename Iterator1, typename Iterator2, typename Predicate>
+    void
+    operator()(pstl::execution::unsequenced_policy, Iterator1 b, Iterator1 e, Iterator2 bsub, Iterator2 esub,
+               Predicate pred)
+    {
+    }
+    template <typename Iterator1, typename Iterator2, typename Predicate>
+    void
+    operator()(pstl::execution::parallel_unsequenced_policy, Iterator1 b, Iterator1 e, Iterator2 bsub, Iterator2 esub,
+               Predicate pred)
+    {
+    }
+#endif
+
+    template <typename ExecutionPolicy, typename Iterator1, typename Iterator2, typename Predicate>
+    void
+    operator()(ExecutionPolicy&& exec, Iterator1 b, Iterator1 e, Iterator2 bsub, Iterator2 esub, Predicate pred)
+    {
+        using namespace std;
+        Iterator1 expected = find_first_of(b, e, bsub, esub, pred);
+        Iterator1 actual = find_first_of(exec, b, e, bsub, esub, pred);
+        EXPECT_TRUE(actual == expected, "wrong return result from find_first_of with a predicate");
+
+        expected = find_first_of(b, e, bsub, esub);
+        actual = find_first_of(exec, b, e, bsub, esub);
+        EXPECT_TRUE(actual == expected, "wrong return result from find_first_of");
+    }
+};
+
+template <typename T, typename Predicate>
+void
+test(Predicate pred)
+{
+
+    const std::size_t max_n1 = 1000;
+    const std::size_t max_n2 = (max_n1 * 10) / 8;
+    Sequence<T> in1(max_n1, [](std::size_t) { return T(1); });
+    Sequence<T> in2(max_n2, [](std::size_t) { return T(0); });
+    for (std::size_t n1 = 0; n1 <= max_n1; n1 = n1 <= 16 ? n1 + 1 : size_t(3.1415 * n1))
+    {
+        std::size_t sub_n[] = {0, 1, n1 / 3, n1, (n1 * 10) / 8};
+        for (const auto n2 : sub_n)
+        {
+            invoke_on_all_policies(test_one_policy(), in1.begin(), in1.begin() + n1, in2.data(), in2.data() + n2, pred);
+
+            in2[n2 / 2] = T(1);
+            invoke_on_all_policies(test_one_policy(), in1.cbegin(), in1.cbegin() + n1, in2.data(), in2.data() + n2,
+                                   pred);
+
+            if (n2 >= 3)
+            {
+                in2[2 * n2 / 3] = T(1);
+                invoke_on_all_policies(test_one_policy(), in1.cbegin(), in1.cbegin() + n1, in2.begin(),
+                                       in2.begin() + n2, pred);
+                in2[2 * n2 / 3] = T(0);
+            }
+            in2[n2 / 2] = T(0);
+        }
+    }
+    invoke_on_all_policies(test_one_policy(), in1.begin(), in1.begin() + max_n1 / 10, in1.data(),
+                           in1.data() + max_n1 / 10, pred);
+}
+
+template <typename T>
+struct test_non_const
+{
+    template <typename Policy, typename FirstIterator, typename SecondInterator>
+    void
+    operator()(Policy&& exec, FirstIterator first_iter, SecondInterator second_iter)
+    {
+        invoke_if(exec, [&]() {
+            find_first_of(exec, first_iter, first_iter, second_iter, second_iter, non_const(std::equal_to<T>()));
+        });
+    }
+};
+
+int
+main()
+{
+    test<int32_t>(std::equal_to<int32_t>());
+    test<uint16_t>(std::not_equal_to<uint16_t>());
+    test<float64_t>([](const float64_t x, const float64_t y) { return x * x == y * y; });
+
+    test_algo_basic_double<int32_t>(run_for_rnd_fw<test_non_const<int32_t>>());
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.nonmodifying/find_if.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.nonmodifying/find_if.pass.cpp
new file mode 100644
index 00000000000000..180d003996ddac
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.nonmodifying/find_if.pass.cpp
@@ -0,0 +1,109 @@
+// -*- C++ -*-
+//===-- find_if.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+// Tests for find_if and find_if_not
+#include "support/pstl_test_config.h"
+
+#include <execution>
+#include <algorithm>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+struct test_find_if
+{
+#if defined(_PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) ||                                                             \
+    defined(_PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) //dummy specialization by policy type, in case of broken configuration
+    template <typename Iterator, typename Predicate, typename NotPredicate>
+    void
+    operator()(pstl::execution::unsequenced_policy, Iterator first, Iterator last, Predicate pred,
+               NotPredicate not_pred)
+    {
+    }
+    template <typename Iterator, typename Predicate, typename NotPredicate>
+    void
+    operator()(pstl::execution::parallel_unsequenced_policy, Iterator first, Iterator last, Predicate pred,
+               NotPredicate not_pred)
+    {
+    }
+#endif
+
+    template <typename Policy, typename Iterator, typename Predicate, typename NotPredicate>
+    void
+    operator()(Policy&& exec, Iterator first, Iterator last, Predicate pred, NotPredicate not_pred)
+    {
+        auto i = std::find_if(first, last, pred);
+        auto j = find_if(exec, first, last, pred);
+        EXPECT_TRUE(i == j, "wrong return value from find_if");
+        auto i_not = find_if_not(exec, first, last, not_pred);
+        EXPECT_TRUE(i_not == i, "wrong return value from find_if_not");
+    }
+};
+
+template <typename T, typename Predicate, typename Hit, typename Miss>
+void
+test(Predicate pred, Hit hit, Miss miss)
+{
+    auto not_pred = [pred](T x) { return !pred(x); };
+    // Try sequences of various lengths.
+    for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
+    {
+        Sequence<T> in(n, [&](size_t k) -> T { return miss(n ^ k); });
+        // Try different find positions, including not found.
+        // By going backwards, we can add extra matches that are *not* supposed to be found.
+        // The decreasing exponential gives us O(n) total work for the loop since each find takes O(m) time.
+        for (size_t m = n; m > 0; m *= 0.6)
+        {
+            if (m < n)
+                in[m] = hit(n ^ m);
+            invoke_on_all_policies(test_find_if(), in.begin(), in.end(), pred, not_pred);
+            invoke_on_all_policies(test_find_if(), in.cbegin(), in.cend(), pred, not_pred);
+        }
+    }
+}
+
+struct test_non_const
+{
+    template <typename Policy, typename Iterator>
+    void
+    operator()(Policy&& exec, Iterator iter)
+    {
+        auto is_even = [&](float64_t v) {
+            uint32_t i = (uint32_t)v;
+            return i % 2 == 0;
+        };
+
+        invoke_if(exec, [&]() {
+            find_if(exec, iter, iter, non_const(is_even));
+            find_if_not(exec, iter, iter, non_const(is_even));
+        });
+    }
+};
+
+int
+main()
+{
+#if !defined(_PSTL_ICC_17_TEST_MAC_RELEASE_32_BROKEN)
+    // Note that the "hit" and "miss" functions here avoid overflow issues.
+    test<Number>(IsMultiple(5, OddTag()), [](int32_t j) { return Number(j - j % 5, OddTag()); }, // hit
+                 [](int32_t j) { return Number(j % 5 == 0 ? j ^ 1 : j, OddTag()); });            // miss
+#endif
+
+    // Try type for which algorithm can really be vectorized.
+    test<float32_t>([](float32_t x) { return x >= 0; }, [](float32_t j) { return j * j; },
+                    [](float32_t j) { return -1 - j * j; });
+
+    test_algo_basic_single<int32_t>(run_for_rnd_fw<test_non_const>());
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.nonmodifying/for_each.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.nonmodifying/for_each.pass.cpp
new file mode 100644
index 00000000000000..14a0ad4f32b124
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.nonmodifying/for_each.pass.cpp
@@ -0,0 +1,102 @@
+// -*- C++ -*-
+//===-- for_each.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+#include "support/pstl_test_config.h"
+
+#include <execution>
+#include <algorithm>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+template <typename Type>
+struct Gen
+{
+    Type
+    operator()(std::size_t k)
+    {
+        return Type(k % 5 != 1 ? 3 * k - 7 : 0);
+    };
+};
+
+template <typename T>
+struct Flip
+{
+    int32_t val;
+    Flip(int32_t y) : val(y) {}
+    T
+    operator()(T& x) const
+    {
+        return x = val - x;
+    }
+};
+
+struct test_one_policy
+{
+    template <typename Policy, typename Iterator, typename Size>
+    void
+    operator()(Policy&& exec, Iterator first, Iterator last, Iterator expected_first, Iterator expected_last, Size n)
+    {
+        typedef typename std::iterator_traits<Iterator>::value_type T;
+
+        // Try for_each
+        std::for_each(expected_first, expected_last, Flip<T>(1));
+        for_each(exec, first, last, Flip<T>(1));
+        EXPECT_EQ_N(expected_first, first, n, "wrong effect from for_each");
+
+        // Try for_each_n
+        std::for_each_n(std::execution::seq, expected_first, n, Flip<T>(1));
+        for_each_n(exec, first, n, Flip<T>(1));
+        EXPECT_EQ_N(expected_first, first, n, "wrong effect from for_each_n");
+    }
+};
+
+template <typename T>
+void
+test()
+{
+    for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
+    {
+        Sequence<T> inout(n, Gen<T>());
+        Sequence<T> expected(n, Gen<T>());
+        invoke_on_all_policies(test_one_policy(), inout.begin(), inout.end(), expected.begin(), expected.end(),
+                               inout.size());
+    }
+}
+
+struct test_non_const
+{
+    template <typename Policy, typename Iterator>
+    void
+    operator()(Policy&& exec, Iterator iter)
+    {
+        invoke_if(exec, [&]() {
+            auto f = [](typename std::iterator_traits<Iterator>::reference x) { x = x + 1; };
+
+            for_each(exec, iter, iter, non_const(f));
+            for_each_n(exec, iter, 0, non_const(f));
+        });
+    }
+};
+
+int
+main()
+{
+    test<int32_t>();
+    test<uint16_t>();
+    test<float64_t>();
+
+    test_algo_basic_single<int32_t>(run_for_rnd_fw<test_non_const>());
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.nonmodifying/mismatch.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.nonmodifying/mismatch.pass.cpp
new file mode 100644
index 00000000000000..4d83ad6de7824c
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.nonmodifying/mismatch.pass.cpp
@@ -0,0 +1,132 @@
+// -*- C++ -*-
+//===-- mismatch.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+#include "support/pstl_test_config.h"
+
+#include <execution>
+#include <algorithm>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+struct test_mismatch
+{
+    template <typename Policy, typename Iterator1, typename Iterator2>
+    void
+    operator()(Policy&& exec, Iterator1 first1, Iterator1 last1, Iterator2 first2)
+    {
+        using namespace std;
+        typedef typename iterator_traits<Iterator1>::value_type T;
+        {
+            const auto expected = std::mismatch(first1, last1, first2, std::equal_to<T>());
+            const auto res3 = mismatch(exec, first1, last1, first2, std::equal_to<T>());
+            EXPECT_TRUE(expected == res3, "wrong return result from mismatch");
+            const auto res4 = mismatch(exec, first1, last1, first2);
+            EXPECT_TRUE(expected == res4, "wrong return result from mismatch");
+        }
+    }
+    template <typename Policy, typename Iterator1, typename Iterator2>
+    void
+    operator()(Policy&& exec, Iterator1 first1, Iterator1 last1, Iterator2 first2, Iterator2 last2)
+    {
+        using namespace std;
+        typedef typename iterator_traits<Iterator1>::value_type T;
+        {
+            const auto expected = mismatch(std::execution::seq, first1, last1, first2, last2, std::equal_to<T>());
+            const auto res1 = mismatch(exec, first1, last1, first2, last2, std::equal_to<T>());
+            EXPECT_TRUE(expected == res1, "wrong return result from mismatch");
+            const auto res2 = mismatch(exec, first1, last1, first2, last2);
+            EXPECT_TRUE(expected == res2, "wrong return result from mismatch");
+        }
+    }
+};
+
+template <typename T>
+void
+test_mismatch_by_type()
+{
+    using namespace std;
+    for (size_t size = 0; size <= 100000; size = size <= 16 ? size + 1 : size_t(3.1415 * size))
+    {
+        const T val = T(-1);
+        Sequence<T> in(size, [](size_t v) -> T { return T(v % 100); });
+        {
+            Sequence<T> in2(in);
+            invoke_on_all_policies(test_mismatch(), in.begin(), in.end(), in2.begin(), in2.end());
+            invoke_on_all_policies(test_mismatch(), in.begin(), in.end(), in2.begin());
+
+            const size_t min_size = 3;
+            if (size > min_size)
+            {
+                const size_t idx_for_1 = size / min_size;
+                in[idx_for_1] = val, in[idx_for_1 + 1] = val, in[idx_for_1 + 2] = val;
+                invoke_on_all_policies(test_mismatch(), in.begin(), in.end(), in2.begin(), in2.end());
+                invoke_on_all_policies(test_mismatch(), in.begin(), in.end(), in2.begin());
+            }
+
+            const size_t idx_for_2 = 500;
+            if (size >= idx_for_2 - 1)
+            {
+                in2[size / idx_for_2] = val;
+                invoke_on_all_policies(test_mismatch(), in.cbegin(), in.cend(), in2.cbegin(), in2.cend());
+                invoke_on_all_policies(test_mismatch(), in.cbegin(), in.cend(), in2.cbegin());
+            }
+        }
+        {
+            Sequence<T> in2(100, [](size_t v) -> T { return T(v); });
+            invoke_on_all_policies(test_mismatch(), in2.begin(), in2.end(), in.begin(), in.end());
+            //  We can't call std::mismatch with semantic below when size of second sequence less than size of first sequence
+            if (in2.size() <= in.size())
+                invoke_on_all_policies(test_mismatch(), in2.begin(), in2.end(), in.begin());
+
+            const size_t idx = 97;
+            in2[idx] = val;
+            in2[idx + 1] = val;
+            invoke_on_all_policies(test_mismatch(), in.cbegin(), in.cend(), in2.cbegin(), in2.cend());
+            if (in.size() <= in2.size())
+                invoke_on_all_policies(test_mismatch(), in.cbegin(), in.cend(), in2.cbegin());
+        }
+        {
+            Sequence<T> in2({});
+            invoke_on_all_policies(test_mismatch(), in2.begin(), in2.end(), in.begin(), in.end());
+
+            invoke_on_all_policies(test_mismatch(), in.cbegin(), in.cend(), in2.cbegin(), in2.cend());
+            if (in.size() == 0)
+                invoke_on_all_policies(test_mismatch(), in.cbegin(), in.cend(), in2.cbegin());
+        }
+    }
+}
+
+template <typename T>
+struct test_non_const
+{
+    template <typename Policy, typename FirstIterator, typename SecondInterator>
+    void
+    operator()(Policy&& exec, FirstIterator first_iter, SecondInterator second_iter)
+    {
+        mismatch(exec, first_iter, first_iter, second_iter, second_iter, non_const(std::less<T>()));
+    }
+};
+
+int
+main()
+{
+
+    test_mismatch_by_type<int32_t>();
+    test_mismatch_by_type<float64_t>();
+    test_mismatch_by_type<Wrapper<int32_t>>();
+
+    test_algo_basic_double<int32_t>(run_for_rnd_fw<test_non_const<int32_t>>());
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.nonmodifying/none_of.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.nonmodifying/none_of.pass.cpp
new file mode 100644
index 00000000000000..dbdcd54438c439
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.nonmodifying/none_of.pass.cpp
@@ -0,0 +1,101 @@
+// -*- C++ -*-
+//===-- none_of.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+#include "support/pstl_test_config.h"
+
+#include <execution>
+#include <algorithm>
+
+#include "support/utils.h"
+
+/*
+  TODO: consider implementing the following tests for a better code coverage
+  - correctness
+  - bad input argument (if applicable)
+  - data corruption around/of input and output
+  - correctly work with nested parallelism
+  - check that algorithm does not require anything more than is described in its requirements section
+*/
+
+using namespace TestUtils;
+
+struct test_none_of
+{
+    template <typename ExecutionPolicy, typename Iterator, typename Predicate>
+    void
+    operator()(ExecutionPolicy&& exec, Iterator begin, Iterator end, Predicate pred, bool expected)
+    {
+
+        auto actualr = std::none_of(exec, begin, end, pred);
+        EXPECT_EQ(expected, actualr, "result for none_of");
+    }
+};
+
+template <typename T>
+void
+test(size_t bits)
+{
+    for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
+    {
+
+        // Sequence of odd values
+        Sequence<T> in(n, [n, bits](size_t) { return T(2 * HashBits(n, bits - 1) ^ 1); });
+
+        // Even value, or false when T is bool.
+        T spike(2 * HashBits(n, bits - 1));
+
+        invoke_on_all_policies(test_none_of(), in.begin(), in.end(), is_equal_to<T>(spike), true);
+        invoke_on_all_policies(test_none_of(), in.cbegin(), in.cend(), is_equal_to<T>(spike), true);
+        if (n > 0)
+        {
+            // Sprinkle in a hit
+            in[2 * n / 3] = spike;
+            invoke_on_all_policies(test_none_of(), in.begin(), in.end(), is_equal_to<T>(spike), false);
+            invoke_on_all_policies(test_none_of(), in.cbegin(), in.cend(), is_equal_to<T>(spike), false);
+
+            // Sprinkle in a few more hits
+            in[n / 3] = spike;
+            in[n / 2] = spike;
+            invoke_on_all_policies(test_none_of(), in.begin(), in.end(), is_equal_to<T>(spike), false);
+            invoke_on_all_policies(test_none_of(), in.cbegin(), in.cend(), is_equal_to<T>(spike), false);
+        }
+    }
+}
+
+struct test_non_const
+{
+    template <typename Policy, typename Iterator>
+    void
+    operator()(Policy&& exec, Iterator iter)
+    {
+        auto is_even = [&](float64_t v) {
+            uint32_t i = (uint32_t)v;
+            return i % 2 == 0;
+        };
+        none_of(exec, iter, iter, non_const(is_even));
+    }
+};
+
+int
+main()
+{
+    test<int32_t>(8 * sizeof(int32_t));
+    test<uint16_t>(8 * sizeof(uint16_t));
+    test<float64_t>(53);
+#if !defined(_PSTL_ICC_16_17_TEST_REDUCTION_BOOL_TYPE_RELEASE_64_BROKEN)
+    test<bool>(1);
+#endif
+
+    test_algo_basic_single<int32_t>(run_for_rnd_fw<test_non_const>());
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.nonmodifying/nth_element.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.nonmodifying/nth_element.pass.cpp
new file mode 100644
index 00000000000000..f3e43da39a3a91
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.nonmodifying/nth_element.pass.cpp
@@ -0,0 +1,175 @@
+// -*- C++ -*-
+//===-- nth_element.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+#include "support/pstl_test_config.h"
+
+#include <iostream>
+#include <execution>
+#include <algorithm>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+// User defined type with minimal requirements
+template <typename T>
+struct DataType
+{
+    explicit DataType(int32_t k) : my_val(k) {}
+    DataType(DataType&& input)
+    {
+        my_val = std::move(input.my_val);
+        input.my_val = T(0);
+    }
+    DataType&
+    operator=(DataType&& input)
+    {
+        my_val = std::move(input.my_val);
+        input.my_val = T(0);
+        return *this;
+    }
+    T
+    get_val() const
+    {
+        return my_val;
+    }
+
+    friend std::ostream&
+    operator<<(std::ostream& stream, const DataType<T>& input)
+    {
+        return stream << input.my_val;
+    }
+
+  private:
+    T my_val;
+};
+
+template <typename T>
+bool
+is_equal(const DataType<T>& x, const DataType<T>& y)
+{
+    return x.get_val() == y.get_val();
+}
+
+template <typename T>
+bool
+is_equal(const T& x, const T& y)
+{
+    return x == y;
+}
+
+struct test_one_policy
+{
+#if defined(_PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) ||                                                             \
+    defined(_PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) // dummy specialization by policy type, in case of broken configuration
+    template <typename Iterator1, typename Size, typename Generator1, typename Generator2, typename Compare>
+    typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
+    operator()(pstl::execution::unsequenced_policy, Iterator1 first1, Iterator1 last1, Iterator1 first2,
+               Iterator1 last2, Size n, Size m, Generator1 generator1, Generator2 generator2, Compare comp)
+    {
+    }
+    template <typename Iterator1, typename Size, typename Generator1, typename Generator2, typename Compare>
+    typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
+    operator()(pstl::execution::parallel_unsequenced_policy, Iterator1 first1, Iterator1 last1, Iterator1 first2,
+               Iterator1 last2, Size n, Size m, Generator1 generator1, Generator2 generator2, Compare comp)
+    {
+    }
+#endif
+
+    // nth_element works only with random access iterators
+    template <typename Policy, typename Iterator1, typename Size, typename Generator1, typename Generator2,
+              typename Compare>
+    typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
+    operator()(Policy&& exec, Iterator1 first1, Iterator1 last1, Iterator1 first2, Iterator1 last2, Size n, Size m,
+               Generator1 generator1, Generator2 generator2, Compare comp)
+    {
+
+        using T = typename std::iterator_traits<Iterator1>::value_type;
+        const Iterator1 mid1 = std::next(first1, m);
+        const Iterator1 mid2 = std::next(first2, m);
+
+        fill_data(first1, mid1, generator1);
+        fill_data(mid1, last1, generator2);
+        fill_data(first2, mid2, generator1);
+        fill_data(mid2, last2, generator2);
+        std::nth_element(first1, mid1, last1, comp);
+        std::nth_element(exec, first2, mid2, last2, comp);
+        if (m > 0 && m < n)
+        {
+            EXPECT_TRUE(is_equal(*mid1, *mid2), "wrong result from nth_element with predicate");
+        }
+        EXPECT_TRUE(std::find_first_of(first2, mid2, mid2, last2, [comp](T& x, T& y) { return comp(y, x); }) == mid2,
+                    "wrong effect from nth_element with predicate");
+    }
+
+    template <typename Policy, typename Iterator1, typename Size, typename Generator1, typename Generator2,
+              typename Compare>
+    typename std::enable_if<!is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
+    operator()(Policy&&, Iterator1, Iterator1, Iterator1, Iterator1, Size, Size, Generator1, Generator2, Compare)
+    {
+    }
+};
+
+template <typename T, typename Generator1, typename Generator2, typename Compare>
+void
+test_by_type(Generator1 generator1, Generator2 generator2, Compare comp)
+{
+    using namespace std;
+    size_t max_size = 10000;
+    Sequence<T> in1(max_size, [](size_t v) { return T(v); });
+    Sequence<T> exp(max_size, [](size_t v) { return T(v); });
+    size_t m;
+
+    for (size_t n = 0; n <= max_size; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
+    {
+        m = 0;
+        invoke_on_all_policies(test_one_policy(), exp.begin(), exp.begin() + n, in1.begin(), in1.begin() + n, n, m,
+                               generator1, generator2, comp);
+        m = n / 7;
+        invoke_on_all_policies(test_one_policy(), exp.begin(), exp.begin() + n, in1.begin(), in1.begin() + n, n, m,
+                               generator1, generator2, comp);
+        m = 3 * n / 5;
+        invoke_on_all_policies(test_one_policy(), exp.begin(), exp.begin() + n, in1.begin(), in1.begin() + n, n, m,
+                               generator1, generator2, comp);
+    }
+    invoke_on_all_policies(test_one_policy(), exp.begin(), exp.begin() + max_size, in1.begin(), in1.begin() + max_size,
+                           max_size, max_size, generator1, generator2, comp);
+}
+
+template <typename T>
+struct test_non_const
+{
+    template <typename Policy, typename Iterator>
+    void
+    operator()(Policy&& exec, Iterator iter)
+    {
+        invoke_if(exec, [&]() { nth_element(exec, iter, iter, iter, non_const(std::less<T>())); });
+    }
+};
+
+int
+main()
+{
+    test_by_type<int32_t>([](int32_t i) { return 10 * i; }, [](int32_t i) { return i + 1; }, std::less<int32_t>());
+    test_by_type<int32_t>([](int32_t) { return 0; }, [](int32_t) { return 0; }, std::less<int32_t>());
+
+    test_by_type<float64_t>([](int32_t i) { return -2 * i; }, [](int32_t i) { return -(2 * i + 1); },
+                            [](const float64_t x, const float64_t y) { return x > y; });
+
+    test_by_type<DataType<float32_t>>(
+        [](int32_t i) { return DataType<float32_t>(2 * i + 1); }, [](int32_t i) { return DataType<float32_t>(2 * i); },
+        [](const DataType<float32_t>& x, const DataType<float32_t>& y) { return x.get_val() < y.get_val(); });
+
+    test_algo_basic_single<int32_t>(run_for_rnd<test_non_const<int32_t>>());
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.nonmodifying/search_n.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.nonmodifying/search_n.pass.cpp
new file mode 100644
index 00000000000000..573f364edef21b
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.nonmodifying/search_n.pass.cpp
@@ -0,0 +1,109 @@
+// -*- C++ -*-
+//===-- search_n.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+#include "support/pstl_test_config.h"
+
+#include <execution>
+#include <algorithm>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+struct test_one_policy
+{
+#if defined(_PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) ||                                                             \
+    defined(_PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) //dummy specialization by policy type, in case of broken configuration
+    template <typename Iterator, typename Size, typename T, typename Predicate>
+    void
+    operator()(pstl::execution::unsequenced_policy, Iterator b, Iterator e, Size count, const T& value, Predicate pred)
+    {
+    }
+    template <typename Iterator, typename Size, typename T, typename Predicate>
+    void
+    operator()(pstl::execution::parallel_unsequenced_policy, Iterator b, Iterator e, Size count, const T& value,
+               Predicate pred)
+    {
+    }
+#endif
+
+    template <typename ExecutionPolicy, typename Iterator, typename Size, typename T, typename Predicate>
+    void
+    operator()(ExecutionPolicy&& exec, Iterator b, Iterator e, Size count, const T& value, Predicate pred)
+    {
+        using namespace std;
+        auto expected = search_n(b, e, count, value, pred);
+        auto actual = search_n(exec, b, e, count, value);
+        EXPECT_TRUE(actual == expected, "wrong return result from search_n");
+
+        actual = search_n(exec, b, e, count, value, pred);
+        EXPECT_TRUE(actual == expected, "wrong return result from search_n with a predicate");
+    }
+};
+
+template <typename T>
+void
+test()
+{
+
+    const std::size_t max_n1 = 100000;
+    const T value = T(1);
+    for (std::size_t n1 = 0; n1 <= max_n1; n1 = n1 <= 16 ? n1 + 1 : size_t(3.1415 * n1))
+    {
+        std::size_t sub_n[] = {0, 1, 3, n1, (n1 * 10) / 8};
+        std::size_t res[] = {0, 1, n1 / 2, n1};
+        for (auto n2 : sub_n)
+        {
+            // Some of standard libraries return "first" in this case. We return "last" according to the standard
+            if (n2 == 0)
+            {
+                continue;
+            }
+            for (auto r : res)
+            {
+                Sequence<T> in(n1, [](std::size_t) { return T(0); });
+                std::size_t i = r, isub = 0;
+                for (; i < n1 && isub < n2; ++i, ++isub)
+                    in[i] = value;
+
+                invoke_on_all_policies(test_one_policy(), in.begin(), in.begin() + n1, n2, value, std::equal_to<T>());
+                invoke_on_all_policies(test_one_policy(), in.cbegin(), in.cbegin() + n1, n2, value, std::equal_to<T>());
+            }
+        }
+    }
+}
+
+template <typename T>
+struct test_non_const
+{
+    template <typename Policy, typename Iterator>
+    void
+    operator()(Policy&& exec, Iterator iter)
+    {
+        invoke_if(exec, [&]() { search_n(exec, iter, iter, 0, T(0), non_const(std::equal_to<T>())); });
+    }
+};
+
+int
+main()
+{
+    test<int32_t>();
+    test<uint16_t>();
+    test<float64_t>();
+#if !defined(_PSTL_ICC_16_17_TEST_REDUCTION_BOOL_TYPE_RELEASE_64_BROKEN)
+    test<bool>();
+#endif
+
+    test_algo_basic_single<int32_t>(run_for_rnd_fw<test_non_const<int32_t>>());
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.sorting/alg.heap.operations/is_heap.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.sorting/alg.heap.operations/is_heap.pass.cpp
new file mode 100644
index 00000000000000..08eca8eed1c527
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.sorting/alg.heap.operations/is_heap.pass.cpp
@@ -0,0 +1,146 @@
+// -*- C++ -*-
+//===-- is_heap.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+// Tests for is_heap, is_heap_until
+#include "support/pstl_test_config.h"
+
+#include <execution>
+#include <algorithm>
+
+#include "support/utils.h"
+#include <iostream>
+
+using namespace TestUtils;
+
+struct WithCmpOp
+{
+    int32_t _first;
+    int32_t _second;
+    WithCmpOp() : _first(0), _second(0){};
+    explicit WithCmpOp(int32_t x) : _first(x), _second(x){};
+    bool
+    operator<(const WithCmpOp& rhs) const
+    {
+        return this->_first < rhs._first;
+    }
+};
+
+struct test_is_heap
+{
+#if defined(_PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) ||                                                             \
+    defined(_PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) //dummy specialization by policy type, in case of broken configuration
+    template <typename Iterator, typename Predicate>
+    typename std::enable_if<is_same_iterator_category<Iterator, std::random_access_iterator_tag>::value, void>::type
+    operator()(pstl::execution::unsequenced_policy, Iterator first, Iterator last, Predicate pred)
+    {
+    }
+    template <typename Iterator, typename Predicate>
+    typename std::enable_if<is_same_iterator_category<Iterator, std::random_access_iterator_tag>::value, void>::type
+    operator()(pstl::execution::parallel_unsequenced_policy, Iterator first, Iterator last, Predicate pred)
+    {
+    }
+#endif
+
+    template <typename Policy, typename Iterator, typename Predicate>
+    typename std::enable_if<is_same_iterator_category<Iterator, std::random_access_iterator_tag>::value, void>::type
+    operator()(Policy&& exec, Iterator first, Iterator last, Predicate pred)
+    {
+        using namespace std;
+        // is_heap
+        {
+            bool expected = is_heap(first, last);
+            bool actual = is_heap(exec, first, last);
+            EXPECT_TRUE(expected == actual, "wrong return value from is_heap");
+        }
+        // is_heap with predicate
+        {
+            bool expected = is_heap(first, last, pred);
+            bool actual = is_heap(exec, first, last, pred);
+            EXPECT_TRUE(expected == actual, "wrong return value from is_heap with predicate");
+        }
+        // is_heap_until
+        {
+            Iterator expected = is_heap_until(first, last);
+            Iterator actual = is_heap_until(exec, first, last);
+            EXPECT_TRUE(expected == actual, "wrong return value from is_heap_until");
+        }
+        // is_heap_until with predicate
+        {
+            const Iterator expected = is_heap_until(first, last, pred);
+            const auto y = std::distance(first, expected);
+            const Iterator actual = is_heap_until(exec, first, last, pred);
+            const auto x = std::distance(first, actual);
+            EXPECT_TRUE(expected == actual, "wrong return value from is_heap_until with predicate");
+            EXPECT_EQ(x, y, "both iterators should be the same distance away from 'first'");
+        }
+    }
+
+    // is_heap, is_heap_until works only with random access iterators
+    template <typename Policy, typename Iterator, typename Predicate>
+    typename std::enable_if<!is_same_iterator_category<Iterator, std::random_access_iterator_tag>::value, void>::type
+    operator()(Policy&&, Iterator, Iterator, Predicate)
+    {
+    }
+};
+
+template <typename T, typename Comp>
+void
+test_is_heap_by_type(Comp comp)
+{
+    using namespace std;
+
+    const size_t max_size = 100000;
+    for (size_t n = 0; n <= max_size; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
+    {
+        Sequence<T> in(n, [](size_t v) -> T { return T(v); });
+
+        invoke_on_all_policies(test_is_heap(), in.begin(), in.end(), comp);
+
+        std::make_heap(in.begin(), in.begin() + n / 4, comp);
+        invoke_on_all_policies(test_is_heap(), in.cbegin(), in.cend(), comp);
+
+        std::make_heap(in.begin(), in.begin() + n / 3, comp);
+        invoke_on_all_policies(test_is_heap(), in.begin(), in.end(), comp);
+
+        std::make_heap(in.begin(), in.end(), comp);
+        invoke_on_all_policies(test_is_heap(), in.cbegin(), in.cend(), comp);
+    }
+
+    Sequence<T> in(max_size / 10, [](size_t) -> T { return T(1); });
+    invoke_on_all_policies(test_is_heap(), in.begin(), in.end(), comp);
+}
+
+template <typename T>
+struct test_non_const
+{
+    template <typename Policy, typename Iterator>
+    void
+    operator()(Policy&& exec, Iterator iter)
+    {
+        invoke_if(exec, [&]() {
+            is_heap(exec, iter, iter, non_const(std::less<T>()));
+            is_heap_until(exec, iter, iter, non_const(std::less<T>()));
+        });
+    }
+};
+
+int
+main()
+{
+    test_is_heap_by_type<float32_t>(std::greater<float32_t>());
+    test_is_heap_by_type<WithCmpOp>(std::less<WithCmpOp>());
+    test_is_heap_by_type<uint64_t>([](uint64_t x, uint64_t y) { return x % 100 < y % 100; });
+
+    test_algo_basic_single<int32_t>(run_for_rnd<test_non_const<int32_t>>());
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare.pass.cpp
new file mode 100644
index 00000000000000..cb920574ba353f
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare.pass.cpp
@@ -0,0 +1,175 @@
+// -*- C++ -*-
+//===-- lexicographical_compare.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+#include "support/pstl_test_config.h"
+
+#include <iostream>
+#include <execution>
+#include <algorithm>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+struct test_one_policy
+{
+
+    template <typename ExecutionPolicy, typename Iterator1, typename Iterator2, typename Predicate>
+    void
+    operator()(ExecutionPolicy&& exec, Iterator1 begin1, Iterator1 end1, Iterator2 begin2, Iterator2 end2,
+               Predicate pred)
+    {
+        const bool expected = std::lexicographical_compare(begin1, end1, begin2, end2, pred);
+        const bool actual = std::lexicographical_compare(exec, begin1, end1, begin2, end2, pred);
+        EXPECT_TRUE(actual == expected, "wrong return result from lexicographical compare with predicate");
+    }
+
+    template <typename ExecutionPolicy, typename Iterator1, typename Iterator2>
+    void
+    operator()(ExecutionPolicy&& exec, Iterator1 begin1, Iterator1 end1, Iterator2 begin2, Iterator2 end2)
+    {
+        const bool expected = std::lexicographical_compare(begin1, end1, begin2, end2);
+        const bool actual = std::lexicographical_compare(exec, begin1, end1, begin2, end2);
+        EXPECT_TRUE(actual == expected, "wrong return result from lexicographical compare without predicate");
+    }
+};
+
+template <typename T1, typename T2, typename Predicate>
+void
+test(Predicate pred)
+{
+
+    const std::size_t max_n = 1000000;
+    Sequence<T1> in1(max_n, [](std::size_t k) { return T1(k); });
+    Sequence<T2> in2(2 * max_n, [](std::size_t k) { return T2(k); });
+
+    std::size_t n2;
+
+    // Test case: Call algorithm's version without predicate.
+    invoke_on_all_policies(test_one_policy(), in1.cbegin(), in1.cbegin() + max_n, in2.cbegin() + 3 * max_n / 10,
+                           in2.cbegin() + 5 * max_n / 10);
+
+    // Test case: If one range is a prefix of another, the shorter range is lexicographically less than the other.
+    std::size_t max_n2 = max_n / 10;
+    invoke_on_all_policies(test_one_policy(), in1.begin(), in1.begin() + max_n, in2.cbegin(), in2.cbegin() + max_n2,
+                           pred);
+    invoke_on_all_policies(test_one_policy(), in1.begin(), in1.begin() + max_n, in2.begin() + max_n2,
+                           in2.begin() + 3 * max_n2, pred);
+
+    // Test case: If one range is a prefix of another, the shorter range is lexicographically less than the other.
+    max_n2 = 2 * max_n;
+    invoke_on_all_policies(test_one_policy(), in1.cbegin(), in1.cbegin() + max_n, in2.begin(), in2.begin() + max_n2,
+                           pred);
+
+    for (std::size_t n1 = 0; n1 <= max_n; n1 = n1 <= 16 ? n1 + 1 : std::size_t(3.1415 * n1))
+    {
+        // Test case: If two ranges have equivalent elements and are of the same length, then the ranges are lexicographically equal.
+        n2 = n1;
+        invoke_on_all_policies(test_one_policy(), in1.begin(), in1.begin() + n1, in2.begin(), in2.begin() + n2, pred);
+
+        n2 = n1;
+        // Test case: two ranges have different elements and are of the same length (second sequence less than first)
+        std::size_t ind = n1 / 2;
+        in2[ind] = T2(-1);
+        invoke_on_all_policies(test_one_policy(), in1.begin(), in1.begin() + n1, in2.begin(), in2.begin() + n2, pred);
+        in2[ind] = T2(ind);
+
+        // Test case: two ranges have different elements and are of the same length (first sequence less than second)
+        ind = n1 / 5;
+        in1[ind] = T1(-1);
+        invoke_on_all_policies(test_one_policy(), in1.begin(), in1.begin() + n1, in2.cbegin(), in2.cbegin() + n2, pred);
+        in1[ind] = T1(ind);
+    }
+}
+
+template <typename Predicate>
+void
+test_string(Predicate pred)
+{
+
+    const std::size_t max_n = 1000000;
+    std::string in1 = "";
+    std::string in2 = "";
+    for (std::size_t n1 = 0; n1 <= max_n; ++n1)
+    {
+        in1 += n1;
+    }
+
+    for (std::size_t n1 = 0; n1 <= 2 * max_n; ++n1)
+    {
+        in2 += n1;
+    }
+
+    std::size_t n2;
+
+    for (std::size_t n1 = 0; n1 < in1.size(); n1 = n1 <= 16 ? n1 + 1 : std::size_t(3.1415 * n1))
+    {
+        // Test case: If two ranges have equivalent elements and are of the same length, then the ranges are lexicographically equal.
+        n2 = n1;
+        invoke_on_all_policies(test_one_policy(), in1.begin(), in1.begin() + n1, in2.begin(), in2.begin() + n2, pred);
+
+        n2 = n1;
+        // Test case: two ranges have different elements and are of the same length (second sequence less than first)
+        in2[n1 / 2] = 'a';
+        invoke_on_all_policies(test_one_policy(), in1.begin(), in1.begin() + n1, in2.begin(), in2.begin() + n2, pred);
+
+        // Test case: two ranges have different elements and are of the same length (first sequence less than second)
+        in1[n1 / 5] = 'a';
+        invoke_on_all_policies(test_one_policy(), in1.begin(), in1.begin() + n1, in2.cbegin(), in2.cbegin() + n2, pred);
+    }
+    invoke_on_all_policies(test_one_policy(), in1.cbegin(), in1.cbegin() + max_n, in2.cbegin() + 3 * max_n / 10,
+                           in2.cbegin() + 5 * max_n / 10);
+}
+
+template <typename T>
+struct LocalWrapper
+{
+    explicit LocalWrapper(std::size_t k) : my_val(k) {}
+    bool
+    operator<(const LocalWrapper<T>& w) const
+    {
+        return my_val < w.my_val;
+    }
+
+  private:
+    T my_val;
+};
+
+template <typename T>
+struct test_non_const
+{
+    template <typename Policy, typename FirstIterator, typename SecondInterator>
+    void
+    operator()(Policy&& exec, FirstIterator first_iter, SecondInterator second_iter)
+    {
+        invoke_if(exec, [&]() {
+            lexicographical_compare(exec, first_iter, first_iter, second_iter, second_iter, non_const(std::less<T>()));
+        });
+    }
+};
+
+int
+main()
+{
+    test<uint16_t, float64_t>(std::less<float64_t>());
+    test<float32_t, int32_t>(std::greater<float32_t>());
+#if !defined(_PSTL_ICC_18_TEST_EARLY_EXIT_AVX_RELEASE_BROKEN)
+    test<float64_t, int32_t>([](const float64_t x, const int32_t y) { return x * x < y * y; });
+#endif
+    test<LocalWrapper<int32_t>, LocalWrapper<int32_t>>(
+        [](const LocalWrapper<int32_t>& x, const LocalWrapper<int32_t>& y) { return x < y; });
+    test_string([](const char x, const char y) { return x < y; });
+
+    test_algo_basic_double<int32_t>(run_for_rnd_fw<test_non_const<int32_t>>());
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.sorting/alg.min.max/minmax_element.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.sorting/alg.min.max/minmax_element.pass.cpp
new file mode 100644
index 00000000000000..715b25014992da
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.sorting/alg.min.max/minmax_element.pass.cpp
@@ -0,0 +1,192 @@
+// -*- C++ -*-
+//===-- minmax_element.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+#include "support/pstl_test_config.h"
+
+#include <execution>
+#include <algorithm>
+#include <set>
+#include <cmath>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+struct check_minelement
+{
+    template <typename Policy, typename Iterator>
+    void
+    operator()(Policy&& exec, Iterator begin, Iterator end)
+    {
+        typedef typename std::iterator_traits<Iterator>::value_type T;
+        const Iterator expect = std::min_element(begin, end);
+        const Iterator result = std::min_element(exec, begin, end);
+        const Iterator result_pred = std::min_element(exec, begin, end, std::less<T>());
+        EXPECT_TRUE(expect == result, "wrong return result from min_element");
+        EXPECT_TRUE(expect == result_pred, "wrong return result from min_element");
+    }
+};
+
+struct check_maxelement
+{
+    template <typename Policy, typename Iterator>
+    void
+    operator()(Policy&& exec, Iterator begin, Iterator end)
+    {
+        typedef typename std::iterator_traits<Iterator>::value_type T;
+        const Iterator expect = std::max_element(begin, end);
+        const Iterator result = std::max_element(exec, begin, end);
+        const Iterator result_pred = std::max_element(exec, begin, end, std::less<T>());
+        EXPECT_TRUE(expect == result, "wrong return result from max_element");
+        EXPECT_TRUE(expect == result_pred, "wrong return result from max_element");
+    }
+};
+
+struct check_minmaxelement
+{
+    template <typename Policy, typename Iterator>
+    void
+    operator()(Policy&& exec, Iterator begin, Iterator end)
+    {
+        typedef typename std::iterator_traits<Iterator>::value_type T;
+        const std::pair<Iterator, Iterator> expect = std::minmax_element(begin, end);
+        const std::pair<Iterator, Iterator> got = std::minmax_element(exec, begin, end);
+        const std::pair<Iterator, Iterator> got_pred = std::minmax_element(exec, begin, end, std::less<T>());
+        EXPECT_TRUE(expect.first == got.first, "wrong return result from minmax_element (min part)");
+        EXPECT_TRUE(expect.second == got.second, "wrong return result from minmax_element (max part)");
+        EXPECT_TRUE(expect == got_pred, "wrong return result from minmax_element");
+    }
+};
+
+template <typename T>
+struct sequence_wrapper
+{
+    TestUtils::Sequence<T> seq;
+    const T min_value;
+    const T max_value;
+    static const std::size_t bits = 30; // We assume that T can handle signed 2^bits+1 value
+
+    // TestUtils::HashBits returns value between 0 and (1<<bits)-1,
+    // therefore we could threat 1<<bits as maximum and -(1<<bits) as a minimum
+    sequence_wrapper(std::size_t n) : seq(n), min_value(-(1 << bits)), max_value(1 << bits) {}
+
+    void
+    pattern_fill()
+    {
+        seq.fill([](std::size_t i) -> T { return T(TestUtils::HashBits(i, bits)); });
+    }
+
+    // sets first one at position `at` and bunch of them farther
+    void
+    set_desired_value(std::size_t at, T value)
+    {
+        if (seq.size() == 0)
+            return;
+        seq[at] = value;
+
+        //Producing serveral red herrings
+        for (std::size_t i = at + 1; i < seq.size(); i += 1 + TestUtils::HashBits(i, 5))
+            seq[i] = value;
+    }
+};
+
+template <typename T>
+void
+test_by_type(std::size_t n)
+{
+    sequence_wrapper<T> wseq(n);
+
+    // to avoid overtesing we use std::set to leave only unique indexes
+    std::set<std::size_t> targets{0};
+    if (n > 1)
+    {
+        targets.insert(1);
+        targets.insert(2.718282 * n / 3);
+        targets.insert(n / 2);
+        targets.insert(n / 7.389056);
+        targets.insert(n - 1); // last
+    }
+
+    for (std::set<std::size_t>::iterator it = targets.begin(); it != targets.end(); ++it)
+    {
+        wseq.pattern_fill();
+        wseq.set_desired_value(*it, wseq.min_value);
+        TestUtils::invoke_on_all_policies(check_minelement(), wseq.seq.cbegin(), wseq.seq.cend());
+        TestUtils::invoke_on_all_policies(check_minelement(), wseq.seq.begin(), wseq.seq.end());
+
+        wseq.set_desired_value(*it, wseq.max_value);
+        TestUtils::invoke_on_all_policies(check_maxelement(), wseq.seq.cbegin(), wseq.seq.cend());
+        TestUtils::invoke_on_all_policies(check_maxelement(), wseq.seq.begin(), wseq.seq.end());
+
+        if (targets.size() > 1)
+        {
+            for (std::set<std::size_t>::reverse_iterator rit = targets.rbegin(); rit != targets.rend(); ++rit)
+            {
+                if (*rit == *it) // we requires at least 2 unique indexes in targets
+                    break;
+                wseq.pattern_fill();
+                wseq.set_desired_value(*it, wseq.min_value);  // setting minimum element
+                wseq.set_desired_value(*rit, wseq.max_value); // setting maximum element
+                TestUtils::invoke_on_all_policies(check_minmaxelement(), wseq.seq.cbegin(), wseq.seq.cend());
+                TestUtils::invoke_on_all_policies(check_minmaxelement(), wseq.seq.begin(), wseq.seq.end());
+            }
+        }
+        else
+        { // we must check this corner case; it can not be tested in loop above
+            TestUtils::invoke_on_all_policies(check_minmaxelement(), wseq.seq.cbegin(), wseq.seq.cend());
+            TestUtils::invoke_on_all_policies(check_minmaxelement(), wseq.seq.begin(), wseq.seq.end());
+        }
+    }
+}
+
+// should provide minimal requirements only
+struct OnlyLessCompare
+{
+    int32_t val;
+    OnlyLessCompare() : val(0) {}
+    OnlyLessCompare(int32_t val_) : val(val_) {}
+    bool
+    operator<(const OnlyLessCompare& other) const
+    {
+        return val < other.val;
+    }
+};
+
+template <typename T>
+struct test_non_const
+{
+    template <typename Policy, typename Iterator>
+    void
+    operator()(Policy&& exec, Iterator iter)
+    {
+        max_element(exec, iter, iter, non_const(std::less<T>()));
+        min_element(exec, iter, iter, non_const(std::less<T>()));
+        minmax_element(exec, iter, iter, non_const(std::less<T>()));
+    }
+};
+
+int
+main()
+{
+    using TestUtils::float64_t;
+    const std::size_t N = 100000;
+
+    for (std::size_t n = 0; n < N; n = n < 16 ? n + 1 : size_t(3.14159 * n))
+    {
+        test_by_type<float64_t>(n);
+        test_by_type<OnlyLessCompare>(n);
+    }
+
+    test_algo_basic_single<int32_t>(run_for_rnd_fw<test_non_const<int32_t>>());
+
+    std::cout << TestUtils::done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.sorting/alg.set.operations/includes.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.sorting/alg.set.operations/includes.pass.cpp
new file mode 100644
index 00000000000000..778d265f9ca7f9
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.sorting/alg.set.operations/includes.pass.cpp
@@ -0,0 +1,106 @@
+// -*- C++ -*-
+//===-- includes.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+#include "support/pstl_test_config.h"
+
+#include <algorithm>
+#include <cmath>
+#include <execution>
+#include <functional>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+template <typename T>
+struct Num
+{
+    T val;
+    explicit Num(const T& v) : val(v) {}
+
+    //for "includes" checks
+    template <typename T1>
+    bool
+    operator<(const Num<T1>& v1) const
+    {
+        return val < v1.val;
+    }
+
+    //The types Type1 and Type2 must be such that an object of type InputIt can be dereferenced and then implicitly converted to both of them
+    template <typename T1>
+    operator Num<T1>() const
+    {
+        return Num<T1>((T1)val);
+    }
+};
+
+struct test_one_policy
+{
+    template <typename Policy, typename InputIterator1, typename InputIterator2, typename Compare>
+    typename std::enable_if<!TestUtils::isReverse<InputIterator1>::value, void>::type
+    operator()(Policy&& exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2,
+               Compare comp)
+    {
+
+        auto expect_res = std::includes(first1, last1, first2, last2, comp);
+        auto res = std::includes(exec, first1, last1, first2, last2, comp);
+
+        EXPECT_TRUE(expect_res == res, "wrong result for includes");
+    }
+
+    template <typename Policy, typename InputIterator1, typename InputIterator2, typename Compare>
+    typename std::enable_if<TestUtils::isReverse<InputIterator1>::value, void>::type
+    operator()(Policy&&, InputIterator1, InputIterator1, InputIterator2, InputIterator2, Compare)
+    {
+    }
+};
+
+template <typename T1, typename T2, typename Compare>
+void
+test_includes(Compare compare)
+{
+
+    const std::size_t n_max = 1000000;
+
+    // The rand()%(2*n+1) encourages generation of some duplicates.
+    std::srand(42);
+
+    for (std::size_t n = 0; n < n_max; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
+    {
+        for (std::size_t m = 0; m < n_max; m = m <= 16 ? m + 1 : size_t(2.71828 * m))
+        {
+            //prepare the input ranges
+            Sequence<T1> in1(n, [](std::size_t k) { return rand() % (2 * k + 1); });
+            Sequence<T2> in2(m, [](std::size_t k) { return rand() % (k + 1); });
+
+            std::sort(in1.begin(), in1.end(), compare);
+            std::sort(in2.begin(), in2.end(), compare);
+
+            invoke_on_all_policies(test_one_policy(), in1.begin(), in1.end(), in2.cbegin(), in2.cend(), compare);
+
+            //test w/ non constant predicate
+            if (n < 5 && m < 5)
+                invoke_on_all_policies(test_one_policy(), in1.begin(), in1.end(), in2.cbegin(), in2.cend(),
+                                       non_const(compare));
+        }
+    }
+}
+
+int
+main()
+{
+
+    test_includes<float64_t, float64_t>(std::less<>());
+    test_includes<Num<int64_t>, Num<int32_t>>([](const Num<int64_t>& x, const Num<int32_t>& y) { return x < y; });
+    std::cout << done() << std::endl;
+
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.sorting/alg.set.operations/set.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.sorting/alg.set.operations/set.pass.cpp
new file mode 100644
index 00000000000000..40ae3d92c8a03e
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.sorting/alg.set.operations/set.pass.cpp
@@ -0,0 +1,280 @@
+// -*- C++ -*-
+//===-- set.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+#include "support/pstl_test_config.h"
+
+#include <algorithm>
+#include <chrono>
+#include <cmath>
+#include <execution>
+#include <functional>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+template <typename T>
+struct Num
+{
+    T val;
+
+    Num() : val{} {}
+    Num(const T& v) : val(v) {}
+
+    //for "includes" checks
+    template <typename T1>
+    bool
+    operator<(const Num<T1>& v1) const
+    {
+        return val < v1.val;
+    }
+
+    //The types Type1 and Type2 must be such that an object of type InputIt can be dereferenced and then implicitly converted to both of them
+    template <typename T1>
+    operator Num<T1>() const
+    {
+        return Num<T1>((T1)val);
+    }
+
+    friend bool
+    operator==(const Num& v1, const Num& v2)
+    {
+        return v1.val == v2.val;
+    }
+};
+
+template <typename Type>
+struct test_set_union
+{
+    template <typename Policy, typename InputIterator1, typename InputIterator2, typename Compare>
+    typename std::enable_if<!TestUtils::isReverse<InputIterator1>::value, void>::type
+    operator()(Policy&& exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2,
+               Compare comp)
+    {
+        using T1 = typename std::iterator_traits<InputIterator1>::value_type;
+
+        auto n1 = std::distance(first1, last1);
+        auto n2 = std::distance(first2, last2);
+        auto n = n1 + n2;
+        Sequence<T1> expect(n);
+        Sequence<T1> out(n);
+
+        auto expect_res = std::set_union(first1, last1, first2, last2, expect.begin(), comp);
+        auto res = std::set_union(exec, first1, last1, first2, last2, out.begin(), comp);
+
+        EXPECT_TRUE(expect_res - expect.begin() == res - out.begin(), "wrong result for set_union");
+        EXPECT_EQ_N(expect.begin(), out.begin(), std::distance(out.begin(), res), "wrong set_union effect");
+    }
+
+    template <typename Policy, typename InputIterator1, typename InputIterator2, typename Compare>
+    typename std::enable_if<TestUtils::isReverse<InputIterator1>::value, void>::type
+    operator()(Policy&&, InputIterator1, InputIterator1, InputIterator2, InputIterator2, Compare)
+    {
+    }
+};
+
+template <typename Type>
+struct test_set_intersection
+{
+    template <typename Policy, typename InputIterator1, typename InputIterator2, typename Compare>
+    typename std::enable_if<!TestUtils::isReverse<InputIterator1>::value, void>::type
+    operator()(Policy&& exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2,
+               Compare comp)
+    {
+        using T1 = typename std::iterator_traits<InputIterator1>::value_type;
+
+        auto n1 = std::distance(first1, last1);
+        auto n2 = std::distance(first2, last2);
+        auto n = n1 + n2;
+        Sequence<T1> expect(n);
+        Sequence<T1> out(n);
+
+        auto expect_res = std::set_intersection(first1, last1, first2, last2, expect.begin(), comp);
+        auto res = std::set_intersection(exec, first1, last1, first2, last2, out.begin(), comp);
+
+        EXPECT_TRUE(expect_res - expect.begin() == res - out.begin(), "wrong result for set_intersection");
+        EXPECT_EQ_N(expect.begin(), out.begin(), std::distance(out.begin(), res), "wrong set_intersection effect");
+    }
+
+    template <typename Policy, typename InputIterator1, typename InputIterator2, typename Compare>
+    typename std::enable_if<TestUtils::isReverse<InputIterator1>::value, void>::type
+    operator()(Policy&&, InputIterator1, InputIterator1, InputIterator2, InputIterator2, Compare)
+    {
+    }
+};
+
+template <typename Type>
+struct test_set_difference
+{
+    template <typename Policy, typename InputIterator1, typename InputIterator2, typename Compare>
+    typename std::enable_if<!TestUtils::isReverse<InputIterator1>::value, void>::type
+    operator()(Policy&& exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2,
+               Compare comp)
+    {
+        using T1 = typename std::iterator_traits<InputIterator1>::value_type;
+
+        auto n1 = std::distance(first1, last1);
+        auto n2 = std::distance(first2, last2);
+        auto n = n1 + n2;
+        Sequence<T1> expect(n);
+        Sequence<T1> out(n);
+
+        auto expect_res = std::set_difference(first1, last1, first2, last2, expect.begin(), comp);
+        auto res = std::set_difference(exec, first1, last1, first2, last2, out.begin(), comp);
+
+        EXPECT_TRUE(expect_res - expect.begin() == res - out.begin(), "wrong result for set_difference");
+        EXPECT_EQ_N(expect.begin(), out.begin(), std::distance(out.begin(), res), "wrong set_difference effect");
+    }
+
+    template <typename Policy, typename InputIterator1, typename InputIterator2, typename Compare>
+    typename std::enable_if<TestUtils::isReverse<InputIterator1>::value, void>::type
+    operator()(Policy&&, InputIterator1, InputIterator1, InputIterator2, InputIterator2, Compare)
+    {
+    }
+};
+
+template <typename Type>
+struct test_set_symmetric_difference
+{
+    template <typename Policy, typename InputIterator1, typename InputIterator2, typename Compare>
+    typename std::enable_if<!TestUtils::isReverse<InputIterator1>::value, void>::type
+    operator()(Policy&& exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2,
+               Compare comp)
+    {
+        using T1 = typename std::iterator_traits<InputIterator1>::value_type;
+
+        auto n1 = std::distance(first1, last1);
+        auto n2 = std::distance(first2, last2);
+        auto n = n1 + n2;
+        Sequence<T1> expect(n);
+        Sequence<T1> out(n);
+
+        auto expect_res = std::set_symmetric_difference(first1, last1, first2, last2, expect.begin(), comp);
+        auto res = std::set_symmetric_difference(exec, first1, last1, first2, last2, out.begin(), comp);
+
+        EXPECT_TRUE(expect_res - expect.begin() == res - out.begin(), "wrong result for set_symmetric_difference");
+        EXPECT_EQ_N(expect.begin(), out.begin(), std::distance(out.begin(), res),
+                    "wrong set_symmetric_difference effect");
+    }
+
+    template <typename Policy, typename InputIterator1, typename InputIterator2, typename Compare>
+    typename std::enable_if<TestUtils::isReverse<InputIterator1>::value, void>::type
+    operator()(Policy&&, InputIterator1, InputIterator1, InputIterator2, InputIterator2, Compare)
+    {
+    }
+};
+
+template <typename T1, typename T2, typename Compare>
+void
+test_set(Compare compare)
+{
+
+    const std::size_t n_max = 100000;
+
+    // The rand()%(2*n+1) encourages generation of some duplicates.
+    std::srand(4200);
+
+    for (std::size_t n = 0; n < n_max; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
+    {
+        for (std::size_t m = 0; m < n_max; m = m <= 16 ? m + 1 : size_t(2.71828 * m))
+        {
+            //prepare the input ranges
+            Sequence<T1> in1(n, [](std::size_t k) { return rand() % (2 * k + 1); });
+            Sequence<T2> in2(m, [m](std::size_t k) { return (m % 2) * rand() + rand() % (k + 1); });
+
+            std::sort(in1.begin(), in1.end(), compare);
+            std::sort(in2.begin(), in2.end(), compare);
+
+            invoke_on_all_policies(test_set_union<T1>(), in1.begin(), in1.end(), in2.cbegin(), in2.cend(),
+                                        compare);
+
+            invoke_on_all_policies(test_set_intersection<T1>(), in1.begin(), in1.end(), in2.cbegin(), in2.cend(),
+                                        compare);
+
+            invoke_on_all_policies(test_set_difference<T1>(), in1.begin(), in1.end(), in2.cbegin(), in2.cend(),
+                                        compare);
+
+            invoke_on_all_policies(test_set_symmetric_difference<T1>(), in1.begin(), in1.end(), in2.cbegin(),
+                                        in2.cend(), compare);
+        }
+    }
+}
+
+template <typename T>
+struct test_non_const_set_difference
+{
+    template <typename Policy, typename InputIterator, typename OutputInterator>
+    void
+    operator()(Policy&& exec, InputIterator input_iter, OutputInterator out_iter)
+    {
+        set_difference(exec, input_iter, input_iter, input_iter, input_iter, out_iter, non_const(std::less<T>()));
+    }
+};
+
+template <typename T>
+struct test_non_const_set_intersection
+{
+    template <typename Policy, typename InputIterator, typename OutputInterator>
+    void
+    operator()(Policy&& exec, InputIterator input_iter, OutputInterator out_iter)
+    {
+        set_intersection(exec, input_iter, input_iter, input_iter, input_iter, out_iter, non_const(std::less<T>()));
+    }
+};
+
+template <typename T>
+struct test_non_const_set_symmetric_difference
+{
+    template <typename Policy, typename InputIterator, typename OutputInterator>
+    void
+    operator()(Policy&& exec, InputIterator input_iter, OutputInterator out_iter)
+    {
+        set_symmetric_difference(exec, input_iter, input_iter, input_iter, input_iter, out_iter,
+                                 non_const(std::less<T>()));
+    }
+};
+
+template <typename T>
+struct test_non_const_set_union
+{
+    template <typename Policy, typename InputIterator, typename OutputInterator>
+    void
+    operator()(Policy&& exec, InputIterator input_iter, OutputInterator out_iter)
+    {
+        set_union(exec, input_iter, input_iter, input_iter, input_iter, out_iter, non_const(std::less<T>()));
+    }
+};
+
+int
+main()
+{
+
+    test_set<float64_t, float64_t>(std::less<>());
+    test_set<Num<int64_t>, Num<int32_t>>([](const Num<int64_t>& x, const Num<int32_t>& y) { return x < y; });
+
+    test_set<MemoryChecker, MemoryChecker>([](const MemoryChecker& val1, const MemoryChecker& val2) -> bool {
+        return val1.value() < val2.value();
+    });
+    EXPECT_FALSE(MemoryChecker::alive_objects() < 0, "wrong effect from set algorithms: number of ctors calls < num of dtors calls");
+    EXPECT_FALSE(MemoryChecker::alive_objects() > 0, "wrong effect from set algorithms: number of ctors calls > num of dtors calls");
+
+    test_algo_basic_double<int32_t>(run_for_rnd_fw<test_non_const_set_difference<int32_t>>());
+
+    test_algo_basic_double<int32_t>(run_for_rnd_fw<test_non_const_set_intersection<int32_t>>());
+
+    test_algo_basic_double<int32_t>(run_for_rnd_fw<test_non_const_set_symmetric_difference<int32_t>>());
+
+    test_algo_basic_double<int32_t>(run_for_rnd_fw<test_non_const_set_union<int32_t>>());
+
+    std::cout << done() << std::endl;
+
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.sorting/is_sorted.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.sorting/is_sorted.pass.cpp
new file mode 100644
index 00000000000000..d4c6fe291ed849
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.sorting/is_sorted.pass.cpp
@@ -0,0 +1,100 @@
+// -*- C++ -*-
+//===-- is_sorted.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+#include "support/pstl_test_config.h"
+
+#include <execution>
+#include <algorithm>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+struct test_is_sorted
+{
+    template <typename Policy, typename Iterator>
+    void
+    operator()(Policy&& exec, Iterator first, Iterator last, bool exam)
+    {
+        using namespace std;
+        typedef typename std::iterator_traits<Iterator>::value_type T;
+
+        //try random-access iterator
+        bool res = is_sorted(exec, first, last);
+        EXPECT_TRUE(exam == res, "is_sorted wrong result for random-access iterator");
+        auto iexam = is_sorted_until(first, last);
+        auto ires = is_sorted_until(exec, first, last);
+        EXPECT_TRUE(iexam == ires, "is_sorted_until wrong result for random-access iterator");
+
+        //try random-access iterator with a predicate
+        res = is_sorted(exec, first, last, std::less<T>());
+        EXPECT_TRUE(exam == res, "is_sorted wrong result for random-access iterator");
+        iexam = is_sorted_until(first, last, std::less<T>());
+        ires = is_sorted_until(exec, first, last, std::less<T>());
+        EXPECT_TRUE(iexam == ires, "is_sorted_until wrong result for random-access iterator");
+    }
+};
+
+template <typename T>
+void
+test_is_sorted_by_type()
+{
+
+    Sequence<T> in(99999, [](size_t v) -> T { return T(v); }); //fill 0..n
+
+    invoke_on_all_policies(test_is_sorted(), in.begin(), in.end(), std::is_sorted(in.begin(), in.end()));
+    invoke_on_all_policies(test_is_sorted(), in.cbegin(), in.cend(), std::is_sorted(in.begin(), in.end()));
+
+    in[in.size() / 2] = -1;
+    invoke_on_all_policies(test_is_sorted(), in.begin(), in.end(), std::is_sorted(in.begin(), in.end()));
+    invoke_on_all_policies(test_is_sorted(), in.cbegin(), in.cend(), std::is_sorted(in.begin(), in.end()));
+
+    in[1] = -1;
+    invoke_on_all_policies(test_is_sorted(), in.begin(), in.end(), std::is_sorted(in.begin(), in.end()));
+    invoke_on_all_policies(test_is_sorted(), in.cbegin(), in.cend(), std::is_sorted(in.begin(), in.end()));
+
+    //an empty container
+    Sequence<T> in0(0);
+    invoke_on_all_policies(test_is_sorted(), in0.begin(), in0.end(), std::is_sorted(in0.begin(), in0.end()));
+    invoke_on_all_policies(test_is_sorted(), in0.cbegin(), in0.cend(), std::is_sorted(in0.begin(), in0.end()));
+
+    //non-descending order
+    Sequence<T> in1(9, [](size_t) -> T { return T(0); });
+    invoke_on_all_policies(test_is_sorted(), in1.begin(), in1.end(), std::is_sorted(in1.begin(), in1.end()));
+    invoke_on_all_policies(test_is_sorted(), in1.cbegin(), in1.cend(), std::is_sorted(in1.begin(), in1.end()));
+}
+
+template <typename T>
+struct test_non_const
+{
+    template <typename Policy, typename Iterator>
+    void
+    operator()(Policy&& exec, Iterator iter)
+    {
+        is_sorted(exec, iter, iter, std::less<T>());
+        is_sorted_until(exec, iter, iter, std::less<T>());
+    }
+};
+
+int
+main()
+{
+
+    test_is_sorted_by_type<int32_t>();
+    test_is_sorted_by_type<float64_t>();
+
+    test_is_sorted_by_type<Wrapper<int32_t>>();
+
+    test_algo_basic_single<int32_t>(run_for_rnd_fw<test_non_const<int32_t>>());
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.sorting/partial_sort.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.sorting/partial_sort.pass.cpp
new file mode 100644
index 00000000000000..bf6e68be8c0790
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.sorting/partial_sort.pass.cpp
@@ -0,0 +1,149 @@
+// -*- C++ -*-
+//===-- partial_sort.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+#include "support/pstl_test_config.h"
+
+#include <cmath>
+#include <execution>
+#include <algorithm>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+static std::atomic<int32_t> count_val;
+static std::atomic<int32_t> count_comp;
+
+template <typename T>
+struct Num
+{
+    T val;
+
+    Num() { ++count_val; }
+    Num(T v) : val(v) { ++count_val; }
+    Num(const Num<T>& v) : val(v.val) { ++count_val; }
+    Num(Num<T>&& v) : val(v.val) { ++count_val; }
+    ~Num() { --count_val; }
+    Num<T>&
+    operator=(const Num<T>& v)
+    {
+        val = v.val;
+        return *this;
+    }
+    operator T() const { return val; }
+    bool
+    operator<(const Num<T>& v) const
+    {
+        ++count_comp;
+        return val < v.val;
+    }
+};
+
+struct test_brick_partial_sort
+{
+    template <typename Policy, typename InputIterator, typename Compare>
+    typename std::enable_if<is_same_iterator_category<InputIterator, std::random_access_iterator_tag>::value,
+                            void>::type
+    operator()(Policy&& exec, InputIterator first, InputIterator last, InputIterator exp_first, InputIterator exp_last,
+               Compare compare)
+    {
+
+        typedef typename std::iterator_traits<InputIterator>::value_type T;
+
+        // The rand()%(2*n+1) encourages generation of some duplicates.
+        std::srand(42);
+        const std::size_t n = last - first;
+        for (std::size_t k = 0; k < n; ++k)
+        {
+            first[k] = T(rand() % (2 * n + 1));
+        }
+        std::copy(first, last, exp_first);
+
+        for (std::size_t p = 0; p < n; p = p <= 16 ? p + 1 : std::size_t(31.415 * p))
+        {
+            auto m1 = first + p;
+            auto m2 = exp_first + p;
+
+            std::partial_sort(exp_first, m2, exp_last, compare);
+            count_comp = 0;
+            std::partial_sort(exec, first, m1, last, compare);
+            EXPECT_EQ_N(exp_first, first, p, "wrong effect from partial_sort");
+
+            //checking upper bound number of comparisons; O(p*(last-first)log(middle-first)); where p - number of threads;
+            if (m1 - first > 1)
+            {
+#ifdef _DEBUG
+#    if defined(_PSTL_PAR_BACKEND_TBB)
+                auto p = tbb::this_task_arena::max_concurrency();
+#    else
+                auto p = 1;
+#    endif
+                auto complex = std::ceil(n * std::log(float32_t(m1 - first)));
+                if (count_comp > complex * p)
+                {
+                    std::cout << "complexity exceeded" << std::endl;
+                }
+#endif // _DEBUG
+            }
+        }
+    }
+
+    template <typename Policy, typename InputIterator, typename Compare>
+    typename std::enable_if<!is_same_iterator_category<InputIterator, std::random_access_iterator_tag>::value,
+                            void>::type
+    operator()(Policy&&, InputIterator, InputIterator, InputIterator, InputIterator, Compare)
+    {
+    }
+};
+
+template <typename T, typename Compare>
+void
+test_partial_sort(Compare compare)
+{
+
+    const std::size_t n_max = 100000;
+    Sequence<T> in(n_max);
+    Sequence<T> exp(n_max);
+    for (std::size_t n = 0; n < n_max; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
+    {
+        invoke_on_all_policies(test_brick_partial_sort(), in.begin(), in.begin() + n, exp.begin(), exp.begin() + n,
+                               compare);
+    }
+}
+
+template <typename T>
+struct test_non_const
+{
+    template <typename Policy, typename Iterator>
+    void
+    operator()(Policy&& exec, Iterator iter)
+    {
+        partial_sort(exec, iter, iter, iter, non_const(std::less<T>()));
+    }
+};
+
+int
+main()
+{
+    count_val = 0;
+
+    test_partial_sort<Num<float32_t>>([](Num<float32_t> x, Num<float32_t> y) { return x < y; });
+
+    EXPECT_TRUE(count_val == 0, "cleanup error");
+
+    test_partial_sort<int32_t>(
+        [](int32_t x, int32_t y) { return x > y; }); // Reversed so accidental use of < will be detected.
+
+    test_algo_basic_single<int32_t>(run_for_rnd<test_non_const<int32_t>>());
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.sorting/partial_sort_copy.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.sorting/partial_sort_copy.pass.cpp
new file mode 100644
index 00000000000000..9090f89e43616c
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.sorting/partial_sort_copy.pass.cpp
@@ -0,0 +1,196 @@
+// -*- C++ -*-
+//===-- partial_sort_copy.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+// Tests for partial_sort_copy
+#include "support/pstl_test_config.h"
+
+#include <cmath>
+#include <execution>
+#include <algorithm>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+template <typename T>
+struct Num
+{
+    T val;
+
+    Num() : val(0) {}
+    Num(T v) : val(v) {}
+    Num(const Num<T>& v) : val(v.val) {}
+    Num(Num<T>&& v) : val(v.val) {}
+    Num<T>&
+    operator=(const Num<T>& v)
+    {
+        val = v.val;
+        return *this;
+    }
+    operator T() const { return val; }
+    bool
+    operator<(const Num<T>& v) const
+    {
+        return val < v.val;
+    }
+};
+
+template <typename RandomAccessIterator>
+struct test_one_policy
+{
+    RandomAccessIterator d_first;
+    RandomAccessIterator d_last;
+    RandomAccessIterator exp_first;
+    RandomAccessIterator exp_last;
+    // This ctor is needed because output shouldn't be transformed to any iterator type (only random access iterators are allowed)
+    test_one_policy(RandomAccessIterator b1, RandomAccessIterator e1, RandomAccessIterator b2, RandomAccessIterator e2)
+        : d_first(b1), d_last(e1), exp_first(b2), exp_last(e2)
+    {
+    }
+#if defined(_PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) ||                                                             \
+    defined(_PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) // dummy specialization by policy type, in case of broken configuration
+    template <typename InputIterator, typename Size, typename T, typename Compare>
+    void
+    operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, Size n1, Size n2,
+               const T& trash, Compare compare)
+    {
+    }
+
+    template <typename InputIterator, typename Size, typename T, typename Compare>
+    void
+    operator()(pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last, Size n1, Size n2,
+               const T& trash, Compare compare)
+    {
+    }
+
+    template <typename InputIterator, typename Size, typename T>
+    void
+    operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, Size n1, Size n2,
+               const T& trash)
+    {
+    }
+
+    template <typename InputIterator, typename Size, typename T>
+    void
+    operator()(pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last, Size n1, Size n2,
+               const T& trash)
+    {
+    }
+#endif
+
+    template <typename Policy, typename InputIterator, typename Size, typename T, typename Compare>
+    void
+    operator()(Policy&& exec, InputIterator first, InputIterator last, Size n1, Size n2, const T& trash,
+               Compare compare)
+    {
+        prepare_data(first, last, n1, trash);
+        RandomAccessIterator exp = std::partial_sort_copy(first, last, exp_first, exp_last, compare);
+        RandomAccessIterator res = std::partial_sort_copy(exec, first, last, d_first, d_last, compare);
+
+        EXPECT_TRUE((exp - exp_first) == (res - d_first), "wrong result from partial_sort_copy with predicate");
+        EXPECT_EQ_N(exp_first, d_first, n2, "wrong effect from partial_sort_copy with predicate");
+    }
+
+    template <typename Policy, typename InputIterator, typename Size, typename T>
+    void
+    operator()(Policy&& exec, InputIterator first, InputIterator last, Size n1, Size n2, const T& trash)
+    {
+        prepare_data(first, last, n1, trash);
+        RandomAccessIterator exp = std::partial_sort_copy(first, last, exp_first, exp_last);
+        RandomAccessIterator res = std::partial_sort_copy(exec, first, last, d_first, d_last);
+
+        EXPECT_TRUE((exp - exp_first) == (res - d_first), "wrong result from partial_sort_copy without predicate");
+        EXPECT_EQ_N(exp_first, d_first, n2, "wrong effect from partial_sort_copy without predicate");
+    }
+
+  private:
+    template <typename InputIterator, typename Size, typename T>
+    void
+    prepare_data(InputIterator first, InputIterator last, Size n1, const T& trash)
+    {
+        // The rand()%(2*n+1) encourages generation of some duplicates.
+        std::srand(42);
+        std::generate(first, last, [n1]() { return T(rand() % (2 * n1 + 1)); });
+
+        std::fill(exp_first, exp_last, trash);
+        std::fill(d_first, d_last, trash);
+    }
+};
+
+template <typename T, typename Compare>
+void
+test_partial_sort_copy(Compare compare)
+{
+
+    typedef typename Sequence<T>::iterator iterator_type;
+    const std::size_t n_max = 100000;
+    Sequence<T> in(n_max);
+    Sequence<T> out(2 * n_max);
+    Sequence<T> exp(2 * n_max);
+    std::size_t n1 = 0;
+    std::size_t n2;
+    T trash = T(-666);
+    for (; n1 < n_max; n1 = n1 <= 16 ? n1 + 1 : size_t(3.1415 * n1))
+    {
+        // If both sequences are equal
+        n2 = n1;
+        invoke_on_all_policies(
+            test_one_policy<iterator_type>(out.begin(), out.begin() + n2, exp.begin(), exp.begin() + n2), in.begin(),
+            in.begin() + n1, n1, n2, trash, compare);
+
+        // If first sequence is greater than second
+        n2 = n1 / 3;
+        invoke_on_all_policies(
+            test_one_policy<iterator_type>(out.begin(), out.begin() + n2, exp.begin(), exp.begin() + n2), in.begin(),
+            in.begin() + n1, n1, n2, trash, compare);
+
+        // If first sequence is less than second
+        n2 = 2 * n1;
+        invoke_on_all_policies(
+            test_one_policy<iterator_type>(out.begin(), out.begin() + n2, exp.begin(), exp.begin() + n2), in.begin(),
+            in.begin() + n1, n1, n2, trash, compare);
+    }
+    // Test partial_sort_copy without predicate
+    n1 = n_max;
+    n2 = 2 * n1;
+    invoke_on_all_policies(test_one_policy<iterator_type>(out.begin(), out.begin() + n2, exp.begin(), exp.begin() + n2),
+                           in.begin(), in.begin() + n1, n1, n2, trash);
+}
+
+template <typename T>
+struct test_non_const
+{
+    template <typename Policy, typename InputIterator, typename OutputInterator>
+    void
+    operator()(Policy&& exec, InputIterator input_iter, OutputInterator out_iter)
+    {
+        invoke_if(exec, [&]() {
+            partial_sort_copy(exec, input_iter, input_iter, out_iter, out_iter, non_const(std::less<T>()));
+        });
+    }
+};
+
+int
+main()
+{
+    test_partial_sort_copy<Num<float32_t>>([](Num<float32_t> x, Num<float32_t> y) { return x < y; });
+    test_partial_sort_copy<int32_t>([](int32_t x, int32_t y) { return x > y; });
+
+    test_algo_basic_double<int32_t>(run_for_rnd<test_non_const<int32_t>>());
+
+    test_partial_sort_copy<MemoryChecker>(
+        [](const MemoryChecker& val1, const MemoryChecker& val2){ return val1.value() < val2.value(); });
+    EXPECT_FALSE(MemoryChecker::alive_objects() < 0, "wrong effect from partial_sort_copy: number of ctors calls < num of dtors calls");
+    EXPECT_FALSE(MemoryChecker::alive_objects() > 0, "wrong effect from partial_sort_copy: number of ctors calls > num of dtors calls");
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/algorithms/alg.sorting/sort.pass.cpp b/libcxx/test/std/pstl/algorithms/alg.sorting/sort.pass.cpp
new file mode 100644
index 00000000000000..5617a6019f801f
--- /dev/null
+++ b/libcxx/test/std/pstl/algorithms/alg.sorting/sort.pass.cpp
@@ -0,0 +1,247 @@
+// -*- C++ -*-
+//===-- sort.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+#include "support/pstl_test_config.h"
+
+#include <execution>
+#include <algorithm>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+#define _CRT_SECURE_NO_WARNINGS
+
+#include <atomic>
+
+static bool Stable;
+
+//! Number of extant keys
+static std::atomic<int32_t> KeyCount;
+
+//! One more than highest index in array to be sorted.
+static uint32_t LastIndex;
+
+//! Keeping Equal() static and a friend of ParanoidKey class (C++, paragraphs 3.5/7.1.1)
+class ParanoidKey;
+static bool
+Equal(const ParanoidKey& x, const ParanoidKey& y);
+
+//! A key to be sorted, with lots of checking.
+class ParanoidKey
+{
+    //! Value used by comparator
+    int32_t value;
+    //! Original position or special value (Empty or Dead)
+    int32_t index;
+    //! Special value used to mark object without a comparable value, e.g. after being moved from.
+    static const int32_t Empty = -1;
+    //! Special value used to mark destroyed objects.
+    static const int32_t Dead = -2;
+    // True if key object has comparable value
+    bool
+    isLive() const
+    {
+        return (uint32_t)(index) < LastIndex;
+    }
+    // True if key object has been constructed.
+    bool
+    isConstructed() const
+    {
+        return isLive() || index == Empty;
+    }
+
+  public:
+    ParanoidKey()
+    {
+        ++KeyCount;
+        index = Empty;
+        value = Empty;
+    }
+    ParanoidKey(const ParanoidKey& k) : value(k.value), index(k.index)
+    {
+        EXPECT_TRUE(k.isLive(), "source for copy-constructor is dead");
+        ++KeyCount;
+    }
+    ~ParanoidKey()
+    {
+        EXPECT_TRUE(isConstructed(), "double destruction");
+        index = Dead;
+        --KeyCount;
+    }
+    ParanoidKey&
+    operator=(const ParanoidKey& k)
+    {
+        EXPECT_TRUE(k.isLive(), "source for copy-assignment is dead");
+        EXPECT_TRUE(isConstructed(), "destination for copy-assignment is dead");
+        value = k.value;
+        index = k.index;
+        return *this;
+    }
+    ParanoidKey(int32_t index, int32_t value, OddTag) : value(value), index(index) {}
+    ParanoidKey(ParanoidKey&& k) : value(k.value), index(k.index)
+    {
+        EXPECT_TRUE(k.isConstructed(), "source for move-construction is dead");
+// std::stable_sort() fails in move semantics on paranoid test before VS2015
+#if !defined(_MSC_VER) || _MSC_VER >= 1900
+        k.index = Empty;
+#endif
+        ++KeyCount;
+    }
+    ParanoidKey&
+    operator=(ParanoidKey&& k)
+    {
+        EXPECT_TRUE(k.isConstructed(), "source for move-assignment is dead");
+        EXPECT_TRUE(isConstructed(), "destination for move-assignment is dead");
+        value = k.value;
+        index = k.index;
+// std::stable_sort() fails in move semantics on paranoid test before VS2015
+#if !defined(_MSC_VER) || _MSC_VER >= 1900
+        k.index = Empty;
+#endif
+        return *this;
+    }
+    friend class KeyCompare;
+    friend bool
+    Equal(const ParanoidKey& x, const ParanoidKey& y);
+};
+
+class KeyCompare
+{
+    enum statusType
+    {
+        //! Special value used to mark defined object.
+        Live = 0xabcd,
+        //! Special value used to mark destroyed objects.
+        Dead = -1
+    } status;
+
+  public:
+    KeyCompare(OddTag) : status(Live) {}
+    ~KeyCompare() { status = Dead; }
+    bool
+    operator()(const ParanoidKey& j, const ParanoidKey& k) const
+    {
+        EXPECT_TRUE(status == Live, "key comparison object not defined");
+        EXPECT_TRUE(j.isLive(), "first key to operator() is not live");
+        EXPECT_TRUE(k.isLive(), "second key to operator() is not live");
+        return j.value < k.value;
+    }
+};
+
+// Equal is equality comparison used for checking result of sort against expected result.
+static bool
+Equal(const ParanoidKey& x, const ParanoidKey& y)
+{
+    return (x.value == y.value && !Stable) || (x.index == y.index);
+}
+
+static bool
+Equal(float32_t x, float32_t y)
+{
+    return x == y;
+}
+
+static bool
+Equal(int32_t x, int32_t y)
+{
+    return x == y;
+}
+
+struct test_sort_with_compare
+{
+    template <typename Policy, typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size,
+              typename Compare>
+    typename std::enable_if<is_same_iterator_category<InputIterator, std::random_access_iterator_tag>::value,
+                            void>::type
+    operator()(Policy&& exec, OutputIterator tmp_first, OutputIterator tmp_last, OutputIterator2 expected_first,
+               OutputIterator2 expected_last, InputIterator first, InputIterator, Size n, Compare compare)
+    {
+        using namespace std;
+        copy_n(first, n, expected_first);
+        copy_n(first, n, tmp_first);
+        if (Stable)
+            std::stable_sort(expected_first + 1, expected_last - 1, compare);
+        else
+            std::sort(expected_first + 1, expected_last - 1, compare);
+        int32_t count0 = KeyCount;
+        if (Stable)
+            stable_sort(exec, tmp_first + 1, tmp_last - 1, compare);
+        else
+            sort(exec, tmp_first + 1, tmp_last - 1, compare);
+
+        for (size_t i = 0; i < n; ++i, ++expected_first, ++tmp_first)
+        {
+            // Check that expected[i] is equal to tmp[i]
+            EXPECT_TRUE(Equal(*expected_first, *tmp_first), "bad sort");
+        }
+        int32_t count1 = KeyCount;
+        EXPECT_EQ(count0, count1, "key cleanup error");
+    }
+    template <typename Policy, typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size,
+              typename Compare>
+    typename std::enable_if<!is_same_iterator_category<InputIterator, std::random_access_iterator_tag>::value,
+                            void>::type
+    operator()(Policy&&, OutputIterator, OutputIterator, OutputIterator2, OutputIterator2, InputIterator, InputIterator,
+               Size, Compare)
+    {
+    }
+};
+
+template <typename T, typename Compare, typename Convert>
+void
+test_sort(Compare compare, Convert convert)
+{
+    for (size_t n = 0; n < 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
+    {
+        LastIndex = n + 2;
+        // The rand()%(2*n+1) encourages generation of some duplicates.
+        // Sequence is padded with an extra element at front and back, to detect overwrite bugs.
+        Sequence<T> in(n + 2, [=](size_t k) { return convert(k, rand() % (2 * n + 1)); });
+        Sequence<T> expected(in);
+        Sequence<T> tmp(in);
+        invoke_on_all_policies(test_sort_with_compare(), tmp.begin(), tmp.end(), expected.begin(), expected.end(),
+                               in.begin(), in.end(), in.size(), compare);
+    }
+}
+
+template <typename T>
+struct test_non_const
+{
+    template <typename Policy, typename Iterator>
+    void
+    operator()(Policy&& exec, Iterator iter)
+    {
+        sort(exec, iter, iter, non_const(std::less<T>()));
+        stable_sort(exec, iter, iter, non_const(std::less<T>()));
+    }
+};
+
+int
+main()
+{
+    std::srand(42);
+    for (int32_t kind = 0; kind < 2; ++kind)
+    {
+        Stable = kind != 0;
+        test_sort<ParanoidKey>(KeyCompare(OddTag()),
+                               [](size_t k, size_t val) { return ParanoidKey(k, val, OddTag()); });
+        test_sort<float32_t>([](float32_t x, float32_t y) { return x < y; },
+                             [](size_t, size_t val) { return float32_t(val); });
+        test_sort<int32_t>(
+            [](int32_t x, int32_t y) { return x > y; }, // Reversed so accidental use of < will be detected.
+            [](size_t, size_t val) { return int32_t(val); });
+    }
+
+    test_algo_basic_single<int32_t>(run_for_rnd<test_non_const<int32_t>>());
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/lit.local.cfg b/libcxx/test/std/pstl/lit.local.cfg
new file mode 100644
index 00000000000000..6b1e2c65790626
--- /dev/null
+++ b/libcxx/test/std/pstl/lit.local.cfg
@@ -0,0 +1,2 @@
+if 'parallel-algorithms' not in config.available_features:
+    config.unsupported = True
diff --git a/libcxx/test/std/pstl/numerics/numeric.ops/adjacent_difference.pass.cpp b/libcxx/test/std/pstl/numerics/numeric.ops/adjacent_difference.pass.cpp
new file mode 100644
index 00000000000000..8e56f61c0ccba2
--- /dev/null
+++ b/libcxx/test/std/pstl/numerics/numeric.ops/adjacent_difference.pass.cpp
@@ -0,0 +1,170 @@
+// -*- C++ -*-
+//===-- adjacent_difference.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+#include "support/pstl_test_config.h"
+
+#include <iterator>
+#include <execution>
+#include <numeric>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+template <typename T>
+struct wrapper
+{
+    T t;
+    constexpr explicit wrapper(T t_) : t(t_) {}
+    template <typename T2>
+    constexpr wrapper(const wrapper<T2>& a)
+    {
+        t = a.t;
+    }
+    template <typename T2>
+    constexpr void
+    operator=(const wrapper<T2>& a)
+    {
+        t = a.t;
+    }
+    constexpr wrapper<T>
+    operator-(const wrapper<T>& a) const
+    {
+        return wrapper<T>(t - a.t);
+    }
+};
+
+template <typename T>
+bool
+compare(const T& a, const T& b)
+{
+    return a == b;
+}
+
+template <typename T>
+bool
+compare(const wrapper<T>& a, const wrapper<T>& b)
+{
+    return a.t == b.t;
+}
+
+template <typename Iterator1, typename Iterator2, typename T, typename Function>
+typename std::enable_if<!std::is_floating_point<T>::value, bool>::type
+compute_and_check(Iterator1 first, Iterator1 last, Iterator2 d_first, T, Function f)
+{
+    using T2 = typename std::iterator_traits<Iterator2>::value_type;
+
+    if (first == last)
+        return true;
+
+    {
+        T2 temp(*first);
+        if (!compare(temp, *d_first))
+            return false;
+    }
+    Iterator1 second = std::next(first);
+
+    ++d_first;
+    for (; second != last; ++first, ++second, ++d_first)
+    {
+        T2 temp(f(*second, *first));
+        if (!compare(temp, *d_first))
+            return false;
+    }
+
+    return true;
+}
+
+// we don't want to check equality here
+// because we can't be sure it will be strictly equal for floating point types
+template <typename Iterator1, typename Iterator2, typename T, typename Function>
+typename std::enable_if<std::is_floating_point<T>::value, bool>::type compute_and_check(Iterator1, Iterator1, Iterator2,
+                                                                                        T, Function)
+{
+    return true;
+}
+
+struct test_one_policy
+{
+#if defined(_PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) ||                                                             \
+    defined(_PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) // dummy specialization by policy type, in case of broken configuration
+    template <typename Iterator1, typename Iterator2, typename T, typename Function>
+    typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
+    operator()(pstl::execution::unsequenced_policy, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b,
+               Iterator2 actual_e, T trash, Function f)
+    {
+    }
+    template <typename Iterator1, typename Iterator2, typename T, typename Function>
+    typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
+    operator()(pstl::execution::parallel_unsequenced_policy, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b,
+               Iterator2 actual_e, T trash, Function f)
+    {
+    }
+#endif
+
+    template <typename ExecutionPolicy, typename Iterator1, typename Iterator2, typename T, typename Function>
+    void
+    operator()(ExecutionPolicy&& exec, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b, Iterator2 actual_e,
+               T trash, Function f)
+    {
+        using namespace std;
+        using T2 = typename std::iterator_traits<Iterator1>::value_type;
+
+        fill(actual_b, actual_e, trash);
+
+        Iterator2 actual_return = adjacent_difference(exec, data_b, data_e, actual_b);
+        EXPECT_TRUE(compute_and_check(data_b, data_e, actual_b, T2(0), std::minus<T2>()),
+                    "wrong effect of adjacent_difference");
+        EXPECT_TRUE(actual_return == actual_e, "wrong result of adjacent_difference");
+
+        fill(actual_b, actual_e, trash);
+
+        actual_return = adjacent_difference(exec, data_b, data_e, actual_b, f);
+        EXPECT_TRUE(compute_and_check(data_b, data_e, actual_b, T2(0), f),
+                    "wrong effect of adjacent_difference with functor");
+        EXPECT_TRUE(actual_return == actual_e, "wrong result of adjacent_difference with functor");
+    }
+};
+
+template <typename T1, typename T2, typename Pred>
+void
+test(Pred pred)
+{
+    const std::size_t max_len = 100000;
+
+    static constexpr T2 value = T2(77);
+    static constexpr T1 trash = T1(31);
+
+    Sequence<T1> actual(max_len, [](std::size_t i) { return T1(i); });
+
+    Sequence<T2> data(max_len, [](std::size_t i) { return i % 3 == 2 ? T2(i * i) : value; });
+
+    for (std::size_t len = 0; len < max_len; len = len <= 16 ? len + 1 : std::size_t(3.1415 * len))
+    {
+        invoke_on_all_policies(test_one_policy(), data.begin(), data.begin() + len, actual.begin(),
+                               actual.begin() + len, trash, pred);
+        invoke_on_all_policies(test_one_policy(), data.cbegin(), data.cbegin() + len, actual.begin(),
+                               actual.begin() + len, trash, pred);
+    }
+}
+
+int
+main()
+{
+    test<uint8_t, uint32_t>([](uint32_t a, uint32_t b) { return a - b; });
+    test<int32_t, int64_t>([](int64_t a, int64_t b) { return a / (b + 1); });
+    test<int64_t, float32_t>([](float32_t a, float32_t b) { return (a + b) / 2; });
+    test<wrapper<int32_t>, wrapper<int64_t>>(
+        [](const wrapper<int64_t>& a, const wrapper<int64_t>& b) { return a - b; });
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/numerics/numeric.ops/reduce.pass.cpp b/libcxx/test/std/pstl/numerics/numeric.ops/reduce.pass.cpp
new file mode 100644
index 00000000000000..b2144b96f5ddbb
--- /dev/null
+++ b/libcxx/test/std/pstl/numerics/numeric.ops/reduce.pass.cpp
@@ -0,0 +1,114 @@
+// -*- C++ -*-
+//===-- reduce.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+#include "support/pstl_test_config.h"
+
+#include <execution>
+#include <numeric>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+struct test_long_forms_for_one_policy
+{
+    template <typename Policy, typename Iterator, typename T, typename BinaryOp>
+    void
+    operator()(Policy&& exec, Iterator first, Iterator last, T init, BinaryOp binary, T expected)
+    {
+        T result_r = std::reduce(exec, first, last, init, binary);
+        EXPECT_EQ(expected, result_r, "bad result from reduce(exec, first, last, init, binary_op)");
+    }
+};
+
+template <typename T, typename BinaryOp, typename F>
+void
+test_long_form(T init, BinaryOp binary_op, F f)
+{
+    // Try sequences of various lengths
+    for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
+    {
+        T expected(init);
+        Sequence<T> in(n, [n, f](size_t k) { return f((int32_t(k ^ n) % 1000 - 500)); });
+        for (size_t k = 0; k < n; ++k)
+            expected = binary_op(expected, in[k]);
+
+        using namespace std;
+
+        T result = transform_reduce_serial(in.cfbegin(), in.cfend(), init, binary_op, [](const T& t) { return t; });
+        EXPECT_EQ(expected, result, "bad result from reduce(first, last, init, binary_op_op)");
+
+        invoke_on_all_policies(test_long_forms_for_one_policy(), in.begin(), in.end(), init, binary_op, expected);
+        invoke_on_all_policies(test_long_forms_for_one_policy(), in.cbegin(), in.cend(), init, binary_op, expected);
+    }
+}
+
+struct test_two_short_forms
+{
+
+#if defined(_PSTL_ICC_16_VC14_TEST_PAR_TBB_RT_RELEASE_64_BROKEN) //dummy specialization by policy type, in case of broken configuration
+    template <typename Iterator>
+    void
+    operator()(pstl::execution::parallel_policy, Iterator first, Iterator last, Sum init, Sum expected)
+    {
+    }
+    template <typename Iterator>
+    void
+    operator()(pstl::execution::parallel_unsequenced_policy, Iterator first, Iterator last, Sum init, Sum expected)
+    {
+    }
+#endif
+
+    template <typename Policy, typename Iterator>
+    void
+    operator()(Policy&& exec, Iterator first, Iterator last, Sum init, Sum expected)
+    {
+        using namespace std;
+
+        Sum r0 = init + reduce(exec, first, last);
+        EXPECT_EQ(expected, r0, "bad result from reduce(exec, first, last)");
+
+        Sum r1 = reduce(exec, first, last, init);
+        EXPECT_EQ(expected, r1, "bad result from reduce(exec, first, last, init)");
+    }
+};
+
+// Test forms of reduce(...) that omit the binary_op or init operands.
+void
+test_short_forms()
+{
+    for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
+    {
+        Sum init(42, OddTag());
+        Sum expected(init);
+        Sequence<Sum> in(n, [n](size_t k) { return Sum((int32_t(k ^ n) % 1000 - 500), OddTag()); });
+        for (size_t k = 0; k < n; ++k)
+            expected = expected + in[k];
+        invoke_on_all_policies(test_two_short_forms(), in.begin(), in.end(), init, expected);
+        invoke_on_all_policies(test_two_short_forms(), in.cbegin(), in.cend(), init, expected);
+    }
+}
+
+int
+main()
+{
+    // Test for popular types
+    test_long_form(42, std::plus<int32_t>(), [](int32_t x) { return x; });
+    test_long_form(42.0, std::plus<float64_t>(), [](float64_t x) { return x; });
+
+    // Test for strict types
+    test_long_form<Number>(Number(42, OddTag()), Add(OddTag()), [](int32_t x) { return Number(x, OddTag()); });
+
+    // Short forms are just facade for long forms, so just test with a single type.
+    test_short_forms();
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/numerics/numeric.ops/scan.fail.cpp b/libcxx/test/std/pstl/numerics/numeric.ops/scan.fail.cpp
new file mode 100644
index 00000000000000..b17944ae084644
--- /dev/null
+++ b/libcxx/test/std/pstl/numerics/numeric.ops/scan.fail.cpp
@@ -0,0 +1,28 @@
+// -*- C++ -*-
+//===-- scan.fail.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+#include <execution>
+#include <numeric>
+
+struct CustomPolicy
+{
+} policy;
+
+int32_t
+main()
+{
+    int *first = nullptr, *last = nullptr, *result = nullptr;
+
+    std::exclusive_scan(policy, first, last, result, 0); // expected-error {{no matching function for call to 'exclusive_scan'}}
+    std::exclusive_scan(policy, first, last, result, 0, std::plus<int>()); // expected-error {{no matching function for call to 'exclusive_scan'}}
+
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/numerics/numeric.ops/scan.pass.cpp b/libcxx/test/std/pstl/numerics/numeric.ops/scan.pass.cpp
new file mode 100644
index 00000000000000..e89edc71a2dd0f
--- /dev/null
+++ b/libcxx/test/std/pstl/numerics/numeric.ops/scan.pass.cpp
@@ -0,0 +1,201 @@
+// -*- C++ -*-
+//===-- scan.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+#include "support/pstl_test_config.h"
+
+#include <execution>
+#include <numeric>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+// We provide the no execution policy versions of the exclusive_scan and inclusive_scan due checking correctness result of the versions with execution policies.
+//TODO: to add a macro for availability of ver implementations
+template <class InputIterator, class OutputIterator, class T>
+OutputIterator
+exclusive_scan_serial(InputIterator first, InputIterator last, OutputIterator result, T init)
+{
+    for (; first != last; ++first, ++result)
+    {
+        *result = init;
+        init = init + *first;
+    }
+    return result;
+}
+
+template <class InputIterator, class OutputIterator, class T, class BinaryOperation>
+OutputIterator
+exclusive_scan_serial(InputIterator first, InputIterator last, OutputIterator result, T init, BinaryOperation binary_op)
+{
+    for (; first != last; ++first, ++result)
+    {
+        *result = init;
+        init = binary_op(init, *first);
+    }
+    return result;
+}
+
+// Note: N4582 is missing the ", class T".  Issue was reported 2016-Apr-11 to cxxeditor at gmail.com
+template <class InputIterator, class OutputIterator, class BinaryOperation, class T>
+OutputIterator
+inclusive_scan_serial(InputIterator first, InputIterator last, OutputIterator result, BinaryOperation binary_op, T init)
+{
+    for (; first != last; ++first, ++result)
+    {
+        init = binary_op(init, *first);
+        *result = init;
+    }
+    return result;
+}
+
+template <class InputIterator, class OutputIterator, class BinaryOperation>
+OutputIterator
+inclusive_scan_serial(InputIterator first, InputIterator last, OutputIterator result, BinaryOperation binary_op)
+{
+    if (first != last)
+    {
+        auto tmp = *first;
+        *result = tmp;
+        return inclusive_scan_serial(++first, last, ++result, binary_op, tmp);
+    }
+    else
+    {
+        return result;
+    }
+}
+
+template <class InputIterator, class OutputIterator>
+OutputIterator
+inclusive_scan_serial(InputIterator first, InputIterator last, OutputIterator result)
+{
+    typedef typename std::iterator_traits<InputIterator>::value_type input_type;
+    return inclusive_scan_serial(first, last, result, std::plus<input_type>());
+}
+
+// Most of the framework required for testing inclusive and exclusive scan is identical,
+// so the tests for both are in this file.  Which is being tested is controlled by the global
+// flag inclusive, which is set to each alternative by main().
+static bool inclusive;
+
+template <typename Iterator, typename Size, typename T>
+void
+check_and_reset(Iterator expected_first, Iterator out_first, Size n, T trash)
+{
+    EXPECT_EQ_N(expected_first, out_first, n,
+                inclusive ? "wrong result from inclusive_scan" : "wrong result from exclusive_scan");
+    std::fill_n(out_first, n, trash);
+}
+
+struct test_scan_with_plus
+{
+    template <typename Policy, typename Iterator1, typename Iterator2, typename Iterator3, typename Size, typename T>
+    void
+    operator()(Policy&& exec, Iterator1 in_first, Iterator1 in_last, Iterator2 out_first, Iterator2 out_last,
+               Iterator3 expected_first, Iterator3, Size n, T init, T trash)
+    {
+        using namespace std;
+
+        auto orr1 = inclusive ? inclusive_scan_serial(in_first, in_last, expected_first)
+                              : exclusive_scan_serial(in_first, in_last, expected_first, init);
+        (void)orr1;
+        auto orr = inclusive ? inclusive_scan(exec, in_first, in_last, out_first)
+                             : exclusive_scan(exec, in_first, in_last, out_first, init);
+        EXPECT_TRUE(out_last == orr,
+                    inclusive ? "inclusive_scan returned wrong iterator" : "exclusive_scan returned wrong iterator");
+
+        check_and_reset(expected_first, out_first, n, trash);
+        fill(out_first, out_last, trash);
+    }
+};
+
+template <typename T, typename Convert>
+void
+test_with_plus(T init, T trash, Convert convert)
+{
+    for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
+    {
+        Sequence<T> in(n, convert);
+        Sequence<T> expected(in);
+        Sequence<T> out(n, [&](int32_t) { return trash; });
+
+        invoke_on_all_policies(test_scan_with_plus(), in.begin(), in.end(), out.begin(), out.end(), expected.begin(),
+                               expected.end(), in.size(), init, trash);
+        invoke_on_all_policies(test_scan_with_plus(), in.cbegin(), in.cend(), out.begin(), out.end(), expected.begin(),
+                               expected.end(), in.size(), init, trash);
+    }
+}
+struct test_scan_with_binary_op
+{
+    template <typename Policy, typename Iterator1, typename Iterator2, typename Iterator3, typename Size, typename T,
+              typename BinaryOp>
+    typename std::enable_if<!TestUtils::isReverse<Iterator1>::value, void>::type
+    operator()(Policy&& exec, Iterator1 in_first, Iterator1 in_last, Iterator2 out_first, Iterator2 out_last,
+               Iterator3 expected_first, Iterator3, Size n, T init, BinaryOp binary_op, T trash)
+    {
+        using namespace std;
+
+        auto orr1 = inclusive ? inclusive_scan_serial(in_first, in_last, expected_first, binary_op, init)
+                              : exclusive_scan_serial(in_first, in_last, expected_first, init, binary_op);
+        (void)orr1;
+        auto orr = inclusive ? inclusive_scan(exec, in_first, in_last, out_first, binary_op, init)
+                             : exclusive_scan(exec, in_first, in_last, out_first, init, binary_op);
+
+        EXPECT_TRUE(out_last == orr, "scan returned wrong iterator");
+        check_and_reset(expected_first, out_first, n, trash);
+    }
+
+    template <typename Policy, typename Iterator1, typename Iterator2, typename Iterator3, typename Size, typename T,
+              typename BinaryOp>
+    typename std::enable_if<TestUtils::isReverse<Iterator1>::value, void>::type
+    operator()(Policy&&, Iterator1, Iterator1, Iterator2, Iterator2, Iterator3, Iterator3, Size, T, BinaryOp, T)
+    {
+    }
+};
+
+template <typename In, typename Out, typename BinaryOp>
+void
+test_matrix(Out init, BinaryOp binary_op, Out trash)
+{
+    for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
+    {
+        Sequence<In> in(n, [](size_t k) { return In(k, k + 1); });
+
+        Sequence<Out> out(n, [&](size_t) { return trash; });
+        Sequence<Out> expected(n, [&](size_t) { return trash; });
+
+        invoke_on_all_policies(test_scan_with_binary_op(), in.begin(), in.end(), out.begin(), out.end(),
+                               expected.begin(), expected.end(), in.size(), init, binary_op, trash);
+        invoke_on_all_policies(test_scan_with_binary_op(), in.cbegin(), in.cend(), out.begin(), out.end(),
+                               expected.begin(), expected.end(), in.size(), init, binary_op, trash);
+    }
+}
+
+int
+main()
+{
+    for (int32_t mode = 0; mode < 2; ++mode)
+    {
+        inclusive = mode != 0;
+#if !defined(_PSTL_ICC_19_TEST_SIMD_UDS_WINDOWS_RELEASE_BROKEN)
+        // Test with highly restricted type and associative but not commutative operation
+        test_matrix<Matrix2x2<int32_t>, Matrix2x2<int32_t>>(Matrix2x2<int32_t>(), multiply_matrix<int32_t>,
+                                                            Matrix2x2<int32_t>(-666, 666));
+#endif
+
+        // Since the implict "+" forms of the scan delegate to the generic forms,
+        // there's little point in using a highly restricted type, so just use double.
+        test_with_plus<float64_t>(inclusive ? 0.0 : -1.0, -666.0,
+                                  [](uint32_t k) { return float64_t((k % 991 + 1) ^ (k % 997 + 2)); });
+    }
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/numerics/numeric.ops/transform_reduce.pass.cpp b/libcxx/test/std/pstl/numerics/numeric.ops/transform_reduce.pass.cpp
new file mode 100644
index 00000000000000..f9c4538bf79316
--- /dev/null
+++ b/libcxx/test/std/pstl/numerics/numeric.ops/transform_reduce.pass.cpp
@@ -0,0 +1,129 @@
+// -*- C++ -*-
+//===-- transform_reduce.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+#include "support/pstl_test_config.h"
+
+#include <execution>
+#include <numeric>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+// Functor for xor-operation for modeling binary operations in inner_product
+class XOR
+{
+  public:
+    template <typename T>
+    T
+    operator()(const T& left, const T& right) const
+    {
+        return left ^ right;
+    }
+};
+
+// Model of User-defined class
+class MyClass
+{
+  public:
+    int32_t my_field;
+    MyClass() { my_field = 0; }
+    MyClass(int32_t in) { my_field = in; }
+    MyClass(const MyClass& in) = default;
+
+    friend MyClass
+    operator+(const MyClass& x, const MyClass& y)
+    {
+        return MyClass(x.my_field + y.my_field);
+    }
+    friend MyClass
+    operator-(const MyClass& x)
+    {
+        return MyClass(-x.my_field);
+    }
+    friend MyClass operator*(const MyClass& x, const MyClass& y)
+    {
+        return MyClass(x.my_field * y.my_field);
+    }
+    friend bool operator==(const MyClass& x, const MyClass& y)
+    {
+        return x.my_field == y.my_field;
+    }
+};
+
+template <typename T>
+void
+CheckResults(const T& expected, const T& in)
+{
+    EXPECT_TRUE(expected == in, "wrong result of transform_reduce");
+}
+
+// We need to check correctness only for "int" (for example) except cases
+// if we have "floating-point type"-specialization
+void
+CheckResults(const float32_t&, const float32_t&)
+{
+}
+
+// Test for different types and operations with different iterators
+struct test_transform_reduce
+{
+    template <typename Policy, typename InputIterator1, typename InputIterator2, typename T, typename BinaryOperation1,
+              typename BinaryOperation2, typename UnaryOp>
+    void
+    operator()(Policy&& exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2,
+               T init, BinaryOperation1 opB1, BinaryOperation2 opB2, UnaryOp opU)
+    {
+
+        auto expectedB = std::inner_product(first1, last1, first2, init, opB1, opB2);
+        auto expectedU = transform_reduce_serial(first1, last1, init, opB1, opU);
+        T resRA = std::transform_reduce(exec, first1, last1, first2, init, opB1, opB2);
+        CheckResults(expectedB, resRA);
+        resRA = std::transform_reduce(exec, first1, last1, init, opB1, opU);
+        CheckResults(expectedU, resRA);
+    }
+};
+
+template <typename T, typename BinaryOperation1, typename BinaryOperation2, typename UnaryOp, typename Initializer>
+void
+test_by_type(T init, BinaryOperation1 opB1, BinaryOperation2 opB2, UnaryOp opU, Initializer initObj)
+{
+
+    std::size_t maxSize = 100000;
+    Sequence<T> in1(maxSize, initObj);
+    Sequence<T> in2(maxSize, initObj);
+
+    for (std::size_t n = 0; n < maxSize; n = n < 16 ? n + 1 : size_t(3.1415 * n))
+    {
+        invoke_on_all_policies(test_transform_reduce(), in1.begin(), in1.begin() + n, in2.begin(), in2.begin() + n,
+                               init, opB1, opB2, opU);
+        invoke_on_all_policies(test_transform_reduce(), in1.cbegin(), in1.cbegin() + n, in2.cbegin(), in2.cbegin() + n,
+                               init, opB1, opB2, opU);
+    }
+}
+
+int
+main()
+{
+    test_by_type<int32_t>(42, std::plus<int32_t>(), std::multiplies<int32_t>(), std::negate<int32_t>(),
+                          [](std::size_t) -> int32_t { return int32_t(rand() % 1000); });
+    test_by_type<int64_t>(0, [](const int64_t& a, const int64_t& b) -> int64_t { return a | b; }, XOR(),
+                          [](const int64_t& x) -> int64_t { return x * 2; },
+                          [](std::size_t) -> int64_t { return int64_t(rand() % 1000); });
+    test_by_type<float32_t>(
+        1.0f, std::multiplies<float32_t>(), [](const float32_t& a, const float32_t& b) -> float32_t { return a + b; },
+        [](const float32_t& x) -> float32_t { return x + 2; }, [](std::size_t) -> float32_t { return rand() % 1000; });
+    test_by_type<MyClass>(MyClass(), std::plus<MyClass>(), std::multiplies<MyClass>(), std::negate<MyClass>(),
+                          [](std::size_t) -> MyClass { return MyClass(rand() % 1000); });
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/numerics/numeric.ops/transform_scan.pass.cpp b/libcxx/test/std/pstl/numerics/numeric.ops/transform_scan.pass.cpp
new file mode 100644
index 00000000000000..95294e43c4c1d2
--- /dev/null
+++ b/libcxx/test/std/pstl/numerics/numeric.ops/transform_scan.pass.cpp
@@ -0,0 +1,177 @@
+// -*- C++ -*-
+//===-- transform_scan.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+#include "support/pstl_test_config.h"
+
+#include <execution>
+#include <numeric>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+// Most of the framework required for testing inclusive and exclusive transform-scans is identical,
+// so the tests for both are in this file.  Which is being tested is controlled by the global
+// flag inclusive, which is set to each alternative by main().
+static bool inclusive;
+
+template <typename Iterator, typename Size, typename T>
+void
+check_and_reset(Iterator expected_first, Iterator out_first, Size n, T trash)
+{
+    EXPECT_EQ_N(expected_first, out_first, n,
+                inclusive ? "wrong result from transform_inclusive_scan"
+                          : "wrong result from transform_exclusive_scan");
+    std::fill_n(out_first, n, trash);
+}
+
+struct test_transform_scan
+{
+    template <typename Policy, typename InputIterator, typename OutputIterator, typename Size, typename UnaryOp,
+              typename T, typename BinaryOp>
+    typename std::enable_if<!TestUtils::isReverse<InputIterator>::value, void>::type
+    operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first,
+               OutputIterator out_last, OutputIterator expected_first, OutputIterator, Size n, UnaryOp unary_op, T init,
+               BinaryOp binary_op, T trash)
+    {
+        using namespace std;
+
+        auto orr1 =
+            inclusive
+                ? transform_inclusive_scan(std::execution::seq, first, last, expected_first, binary_op, unary_op, init)
+                : transform_exclusive_scan(std::execution::seq, first, last, expected_first, init, binary_op, unary_op);
+        auto orr2 = inclusive ? transform_inclusive_scan(exec, first, last, out_first, binary_op, unary_op, init)
+                              : transform_exclusive_scan(exec, first, last, out_first, init, binary_op, unary_op);
+        EXPECT_TRUE(out_last == orr2, "transform...scan returned wrong iterator");
+        check_and_reset(expected_first, out_first, n, trash);
+
+        // Checks inclusive scan if init is not provided
+        if (inclusive && n > 0)
+        {
+            orr1 = transform_inclusive_scan(std::execution::seq, first, last, expected_first, binary_op, unary_op);
+            orr2 = transform_inclusive_scan(exec, first, last, out_first, binary_op, unary_op);
+            EXPECT_TRUE(out_last == orr2, "transform...scan returned wrong iterator");
+            check_and_reset(expected_first, out_first, n, trash);
+        }
+    }
+
+    template <typename Policy, typename InputIterator, typename OutputIterator, typename Size, typename UnaryOp,
+              typename T, typename BinaryOp>
+    typename std::enable_if<TestUtils::isReverse<InputIterator>::value, void>::type
+    operator()(Policy&&, InputIterator, InputIterator, OutputIterator, OutputIterator, OutputIterator, OutputIterator,
+               Size, UnaryOp, T, BinaryOp, T)
+    {
+    }
+};
+
+const uint32_t encryption_mask = 0x314;
+
+template <typename InputIterator, typename OutputIterator, typename UnaryOperation, typename T,
+          typename BinaryOperation>
+std::pair<OutputIterator, T>
+transform_inclusive_scan_serial(InputIterator first, InputIterator last, OutputIterator result, UnaryOperation unary_op,
+                                T init, BinaryOperation binary_op) noexcept
+{
+    for (; first != last; ++first, ++result)
+    {
+        init = binary_op(init, unary_op(*first));
+        *result = init;
+    }
+    return std::make_pair(result, init);
+}
+
+template <typename InputIterator, typename OutputIterator, typename UnaryOperation, typename T,
+          typename BinaryOperation>
+std::pair<OutputIterator, T>
+transform_exclusive_scan_serial(InputIterator first, InputIterator last, OutputIterator result, UnaryOperation unary_op,
+                                T init, BinaryOperation binary_op) noexcept
+{
+    for (; first != last; ++first, ++result)
+    {
+        *result = init;
+        init = binary_op(init, unary_op(*first));
+    }
+    return std::make_pair(result, init);
+}
+
+template <typename In, typename Out, typename UnaryOp, typename BinaryOp>
+void
+test(UnaryOp unary_op, Out init, BinaryOp binary_op, Out trash)
+{
+    for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
+    {
+        Sequence<In> in(n, [](size_t k) { return In(k ^ encryption_mask); });
+
+        Out tmp = init;
+        Sequence<Out> expected(n, [&](size_t k) -> Out {
+            if (inclusive)
+            {
+                tmp = binary_op(tmp, unary_op(in[k]));
+                return tmp;
+            }
+            else
+            {
+                Out val = tmp;
+                tmp = binary_op(tmp, unary_op(in[k]));
+                return val;
+            }
+        });
+
+        Sequence<Out> out(n, [&](size_t) { return trash; });
+
+        auto result =
+            inclusive
+                ? transform_inclusive_scan_serial(in.cbegin(), in.cend(), out.fbegin(), unary_op, init, binary_op)
+                : transform_exclusive_scan_serial(in.cbegin(), in.cend(), out.fbegin(), unary_op, init, binary_op);
+        (void)result;
+        check_and_reset(expected.begin(), out.begin(), out.size(), trash);
+
+        invoke_on_all_policies(test_transform_scan(), in.begin(), in.end(), out.begin(), out.end(), expected.begin(),
+                               expected.end(), in.size(), unary_op, init, binary_op, trash);
+        invoke_on_all_policies(test_transform_scan(), in.cbegin(), in.cend(), out.begin(), out.end(), expected.begin(),
+                               expected.end(), in.size(), unary_op, init, binary_op, trash);
+    }
+}
+
+template <typename In, typename Out, typename UnaryOp, typename BinaryOp>
+void
+test_matrix(UnaryOp unary_op, Out init, BinaryOp binary_op, Out trash)
+{
+    for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
+    {
+        Sequence<In> in(n, [](size_t k) { return In(k, k + 1); });
+
+        Sequence<Out> out(n, [&](size_t) { return trash; });
+        Sequence<Out> expected(n, [&](size_t) { return trash; });
+
+        invoke_on_all_policies(test_transform_scan(), in.begin(), in.end(), out.begin(), out.end(), expected.begin(),
+                               expected.end(), in.size(), unary_op, init, binary_op, trash);
+        invoke_on_all_policies(test_transform_scan(), in.cbegin(), in.cend(), out.begin(), out.end(), expected.begin(),
+                               expected.end(), in.size(), unary_op, init, binary_op, trash);
+    }
+}
+
+int
+main()
+{
+    for (int32_t mode = 0; mode < 2; ++mode)
+    {
+        inclusive = mode != 0;
+#if !defined(_PSTL_ICC_19_TEST_SIMD_UDS_WINDOWS_RELEASE_BROKEN)
+        test_matrix<Matrix2x2<int32_t>, Matrix2x2<int32_t>>([](const Matrix2x2<int32_t> x) { return x; },
+                                                            Matrix2x2<int32_t>(), multiply_matrix<int32_t>,
+                                                            Matrix2x2<int32_t>(-666, 666));
+#endif
+        test<int32_t, uint32_t>([](int32_t x) { return x++; }, -123, [](int32_t x, int32_t y) { return x + y; }, 666);
+    }
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/utilities/memory/specialized.algorithms/uninitialized_construct.pass.cpp b/libcxx/test/std/pstl/utilities/memory/specialized.algorithms/uninitialized_construct.pass.cpp
new file mode 100644
index 00000000000000..a5bdbb3a9c7e1a
--- /dev/null
+++ b/libcxx/test/std/pstl/utilities/memory/specialized.algorithms/uninitialized_construct.pass.cpp
@@ -0,0 +1,123 @@
+// -*- C++ -*-
+//===-- uninitialized_construct.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+// Tests for uninitialized_default_construct, uninitialized_default_construct_n,
+//           uninitialized_value_construct,   uninitialized_value_construct_n
+
+#include "support/pstl_test_config.h"
+
+#include <execution>
+#include <memory>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+// function of checking correctness for uninitialized.construct.value
+template <typename T, typename Iterator>
+bool
+IsCheckValueCorrectness(Iterator begin, Iterator end)
+{
+    for (; begin != end; ++begin)
+    {
+        if (*begin != T())
+        {
+            return false;
+        }
+    }
+    return true;
+}
+
+struct test_uninit_construct
+{
+    template <typename Policy, typename Iterator>
+    void
+    operator()(Policy&& exec, Iterator begin, Iterator end, size_t n, /*is_trivial<T>=*/std::false_type)
+    {
+        typedef typename std::iterator_traits<Iterator>::value_type T;
+        // it needs for cleaning memory that was filled by default constructors in unique_ptr<T[]> p(new T[n])
+        // and for cleaning memory after last calling of uninitialized_value_construct_n.
+        // It is important for non-trivial types
+        std::destroy_n(exec, begin, n);
+
+        // reset counter of constructors
+        T::SetCount(0);
+        // run algorithm
+        std::uninitialized_default_construct(exec, begin, end);
+        // compare counter of constructors to length of container
+        EXPECT_TRUE(T::Count() == n, "wrong uninitialized_default_construct");
+        // destroy objects for testing new algorithms on same memory
+        std::destroy(exec, begin, end);
+
+        std::uninitialized_default_construct_n(exec, begin, n);
+        EXPECT_TRUE(T::Count() == n, "wrong uninitialized_default_construct_n");
+        std::destroy_n(exec, begin, n);
+
+        std::uninitialized_value_construct(exec, begin, end);
+        EXPECT_TRUE(T::Count() == n, "wrong uninitialized_value_construct");
+        std::destroy(exec, begin, end);
+
+        std::uninitialized_value_construct_n(exec, begin, n);
+        EXPECT_TRUE(T::Count() == n, "wrong uninitialized_value_construct_n");
+    }
+
+    template <typename Policy, typename Iterator>
+    void
+    operator()(Policy&& exec, Iterator begin, Iterator end, size_t n, /*is_trivial<T>=*/std::true_type)
+    {
+        typedef typename std::iterator_traits<Iterator>::value_type T;
+
+        std::uninitialized_default_construct(exec, begin, end);
+        std::destroy(exec, begin, end);
+
+        std::uninitialized_default_construct_n(exec, begin, n);
+        std::destroy_n(exec, begin, n);
+
+        std::uninitialized_value_construct(exec, begin, end);
+        // check correctness for uninitialized.construct.value
+        EXPECT_TRUE(IsCheckValueCorrectness<T>(begin, end), "wrong uninitialized_value_construct");
+        std::destroy(exec, begin, end);
+
+        std::uninitialized_value_construct_n(exec, begin, n);
+        EXPECT_TRUE(IsCheckValueCorrectness<T>(begin, end), "wrong uninitialized_value_construct_n");
+        std::destroy_n(exec, begin, n);
+    }
+};
+
+template <typename T>
+void
+test_uninit_construct_by_type()
+{
+    std::size_t N = 100000;
+    for (size_t n = 0; n <= N; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
+    {
+        std::unique_ptr<T[]> p(new T[n]);
+        invoke_on_all_policies(test_uninit_construct(), p.get(), std::next(p.get(), n), n, std::is_trivial<T>());
+    }
+}
+
+int
+main()
+{
+
+    // for user-defined types
+#if !defined(_PSTL_ICC_16_VC14_TEST_PAR_TBB_RT_RELEASE_64_BROKEN)
+    test_uninit_construct_by_type<Wrapper<int32_t>>();
+    test_uninit_construct_by_type<Wrapper<std::vector<std::string>>>();
+#endif
+
+    // for trivial types
+    test_uninit_construct_by_type<int8_t>();
+    test_uninit_construct_by_type<float64_t>();
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/utilities/memory/specialized.algorithms/uninitialized_copy_move.pass.cpp b/libcxx/test/std/pstl/utilities/memory/specialized.algorithms/uninitialized_copy_move.pass.cpp
new file mode 100644
index 00000000000000..21186b41ee139b
--- /dev/null
+++ b/libcxx/test/std/pstl/utilities/memory/specialized.algorithms/uninitialized_copy_move.pass.cpp
@@ -0,0 +1,143 @@
+// -*- C++ -*-
+//===-- uninitialized_copy_move.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+// Tests for uninitialized_copy, uninitialized_copy_n, uninitialized_move, uninitialized_move_n
+
+#include "support/pstl_test_config.h"
+
+#include <execution>
+#include <memory>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+// function of checking correctness for uninitialized.construct.value
+template <typename InputIterator, typename OutputIterator, typename Size>
+bool
+IsCheckValueCorrectness(InputIterator first1, OutputIterator first2, Size n)
+{
+    for (Size i = 0; i < n; ++i, ++first1, ++first2)
+    {
+        if (*first1 != *first2)
+        {
+            return false;
+        }
+    }
+    return true;
+}
+
+struct test_uninitialized_copy_move
+{
+    template <typename Policy, typename InputIterator, typename OutputIterator>
+    void
+    operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first, size_t n,
+               /*is_trivial<T>=*/std::false_type)
+    {
+        typedef typename std::iterator_traits<InputIterator>::value_type T;
+        // it needs for cleaning memory that was filled by default constructors in unique_ptr<T[]> p(new T[n])
+        // and for cleaning memory after last calling of uninitialized_value_construct_n.
+        // It is important for non-trivial types
+        std::destroy_n(exec, out_first, n);
+
+        // reset counter of constructors
+        T::SetCount(0);
+        // run algorithm
+        std::uninitialized_copy(exec, first, last, out_first);
+        // compare counter of constructors to length of container
+        EXPECT_TRUE(T::Count() == n, "wrong uninitialized_copy");
+        // destroy objects for testing new algorithms on same memory
+        std::destroy_n(exec, out_first, n);
+
+        std::uninitialized_copy_n(exec, first, n, out_first);
+        EXPECT_TRUE(T::Count() == n, "wrong uninitialized_copy_n");
+        std::destroy_n(exec, out_first, n);
+
+        // For move
+        std::uninitialized_move(exec, first, last, out_first);
+        // compare counter of constructors to length of container
+        EXPECT_TRUE(T::MoveCount() == n, "wrong uninitialized_move");
+        // destroy objects for testing new algorithms on same memory
+        std::destroy_n(exec, out_first, n);
+
+        std::uninitialized_move_n(exec, first, n, out_first);
+        EXPECT_TRUE(T::MoveCount() == n, "wrong uninitialized_move_n");
+        std::destroy_n(exec, out_first, n);
+    }
+
+#if defined(_PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) || defined(_PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN)
+    template <typename InputIterator, typename OutputIterator>
+    void
+    operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first,
+               size_t n, /*is_trivial<T>=*/std::true_type)
+    {
+    }
+    template <typename InputIterator, typename OutputIterator>
+    void
+    operator()(pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last,
+               OutputIterator out_first, size_t n, /*is_trivial<T>=*/std::true_type)
+    {
+    }
+#endif
+
+    template <typename Policy, typename InputIterator, typename OutputIterator>
+    void
+    operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first, size_t n,
+               /*is_trivial<T>=*/std::true_type)
+    {
+        std::uninitialized_copy(exec, first, last, out_first);
+        EXPECT_TRUE(IsCheckValueCorrectness(first, out_first, n), "wrong uninitialized_copy");
+        std::destroy_n(exec, out_first, n);
+
+        std::uninitialized_copy_n(exec, first, n, out_first);
+        EXPECT_TRUE(IsCheckValueCorrectness(first, out_first, n), "wrong uninitialized_copy_n");
+        std::destroy_n(exec, out_first, n);
+
+        std::uninitialized_move(exec, first, last, out_first);
+        EXPECT_TRUE(IsCheckValueCorrectness(first, out_first, n), "wrong uninitialized_move");
+        std::destroy_n(exec, out_first, n);
+
+        std::uninitialized_move_n(exec, first, n, out_first);
+        EXPECT_TRUE(IsCheckValueCorrectness(first, out_first, n), "wrong uninitialized_move_n");
+        std::destroy_n(exec, out_first, n);
+    }
+};
+
+template <typename T>
+void
+test_uninitialized_copy_move_by_type()
+{
+    std::size_t N = 100000;
+    for (size_t n = 0; n <= N; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
+    {
+        Sequence<T> in(n, [=](size_t k) -> T { return T(k); });
+        std::unique_ptr<T[]> p(new T[n]);
+        invoke_on_all_policies(test_uninitialized_copy_move(), in.begin(), in.end(), p.get(), n, std::is_trivial<T>());
+    }
+}
+
+int
+main()
+{
+
+    // for trivial types
+    test_uninitialized_copy_move_by_type<int16_t>();
+    test_uninitialized_copy_move_by_type<float64_t>();
+
+    // for user-defined types
+#if !defined(_PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) && !defined(_PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) &&     \
+    !defined(_PSTL_ICC_16_VC14_TEST_PAR_TBB_RT_RELEASE_64_BROKEN)
+    test_uninitialized_copy_move_by_type<Wrapper<int8_t>>();
+#endif
+
+    std::cout << done() << std::endl;
+    return 0;
+}
diff --git a/libcxx/test/std/pstl/utilities/memory/specialized.algorithms/uninitialized_fill_destroy.pass.cpp b/libcxx/test/std/pstl/utilities/memory/specialized.algorithms/uninitialized_fill_destroy.pass.cpp
new file mode 100644
index 00000000000000..d579ea558839d0
--- /dev/null
+++ b/libcxx/test/std/pstl/utilities/memory/specialized.algorithms/uninitialized_fill_destroy.pass.cpp
@@ -0,0 +1,93 @@
+// -*- C++ -*-
+//===-- uninitialized_fill_destroy.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+#include "support/pstl_test_config.h"
+
+#include <execution>
+#include <memory>
+
+#include "support/utils.h"
+
+using namespace TestUtils;
+
+struct test_uninitialized_fill_destroy
+{
+    template <typename Policy, typename Iterator, typename T>
+    void
+    operator()(Policy&& exec, Iterator first, Iterator last, const T& in, std::size_t n, std::false_type)
+    {
+        using namespace std;
+        {
+            T::SetCount(0);
+            uninitialized_fill(exec, first, last, in);
+            size_t count = count_if(first, last, [&in](T& x) -> bool { return x == in; });
+            EXPECT_TRUE(n == count, "wrong work of uninitialized_fill");
+            destroy(exec, first, last);
+            EXPECT_TRUE(T::Count() == 0, "wrong work of destroy");
+        }
+
+        {
+            auto res = uninitialized_fill_n(exec, first, n, in);
+            EXPECT_TRUE(res == last, "wrong result of uninitialized_fill_n");
+            size_t count = count_if(first, last, [&in](T& x) -> bool { return x == in; });
+            EXPECT_TRUE(n == count, "wrong work of uninitialized_fill_n");
+            destroy_n(exec, first, n);
+            EXPECT_TRUE(T::Count() == 0, "wrong work of destroy_n");
+        }
+    }
+    template <typename Policy, typename Iterator, typename T>
+    void
+    operator()(Policy&& exec, Iterator first, Iterator last, const T& in, std::size_t n, std::true_type)
+    {
+        using namespace std;
+        {
+            destroy(exec, first, last);
+            uninitialized_fill(exec, first, last, in);
+            size_t count = count_if(first, last, [&in](T& x) -> bool { return x == in; });
+            EXPECT_EQ(n, count, "wrong work of uninitialized:_fill");
+        }
+        {
+            destroy_n(exec, first, n);
+            auto res = uninitialized_fill_n(exec, first, n, in);
+            size_t count = count_if(first, last, [&in](T& x) -> bool { return x == in; });
+            EXPECT_EQ(n, count, "wrong work of uninitialized_fill_n");
+            EXPECT_TRUE(res == last, "wrong result of uninitialized_fill_n");
+        }
+    }
+};
+
+template <typename T>
+void
+test_uninitialized_fill_destroy_by_type()
+{
+    std::size_t N = 100000;
+    for (size_t n = 0; n <= N; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
+    {
+        std::unique_ptr<T[]> p(new T[n]);
+        invoke_on_all_policies(test_uninitialized_fill_destroy(), p.get(), std::next(p.get(), n), T(), n,
+                               std::is_trivial<T>());
+    }
+}
+
+int
+main()
+{
+    // for trivial types
+    test_uninitialized_fill_destroy_by_type<int32_t>();
+    test_uninitialized_fill_destroy_by_type<float64_t>();
+
+    // for user-defined types
+    test_uninitialized_fill_destroy_by_type<Wrapper<std::string>>();
+    test_uninitialized_fill_destroy_by_type<Wrapper<int8_t*>>();
+    std::cout << done() << std::endl;
+
+    return 0;
+}
diff --git a/llvm/lib/Target/ARM/ARMEncodeDecode.cpp b/llvm/lib/Target/ARM/ARMEncodeDecode.cpp
new file mode 100755
index 00000000000000..ddf73811254f23
--- /dev/null
+++ b/llvm/lib/Target/ARM/ARMEncodeDecode.cpp
@@ -0,0 +1,628 @@
+//===- ARMRandezvousShadowStack.cpp - ARM Randezvous Shadow Stack ---------===//
+//
+// Copyright (c) 2021-2022, University of Rochester
+//
+// Part of the Randezvous Project, under the Apache License v2.0 with
+// LLVM Exceptions.  See LICENSE.txt in the llvm directory for license
+// information.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains the implementation of a pass that instruments ARM machine
+// code to save/load the return address to/from a randomized compact shadow
+// stack.
+//
+//===----------------------------------------------------------------------===//
+
+#define DEBUG_TYPE "arm-randezvous-shadow-stack"
+
+#include "ARMEncodeDecode.h"
+#include "ARMRandezvousCLR.h"
+#include "ARMRandezvousOptions.h"
+#include "MCTargetDesc/ARMAddressingModes.h"
+#include "llvm/ADT/Statistic.h"
+#include "llvm/CodeGen/MachineFrameInfo.h"
+#include "llvm/CodeGen/MachineModuleInfo.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/Support/RandomNumberGenerator.h"
+#include "llvm/Transforms/Utils/ModuleUtils.h"
+
+using namespace llvm;
+
+STATISTIC(NumPrologues, "Number of prologues transformed to use shadow stack");
+STATISTIC(NumEpilogues, "Number of epilogues transformed to use shadow stack");
+STATISTIC(NumNullified, "Number of return addresses nullified");
+
+char ARMEncodeDecode::ID = 0;
+
+ARMEncodeDecode::ARMEncodeDecode() : ModulePass(ID) {}
+
+StringRef ARMEncodeDecode::getPassName() const {
+  return "ARM Encode and Decode Pass";
+}
+
+void ARMEncodeDecode::getAnalysisUsage(AnalysisUsage &AU) const {
+  // We need this to access MachineFunctions
+  AU.addRequired<MachineModuleInfoWrapperPass>();
+
+  AU.setPreservesCFG();
+  ModulePass::getAnalysisUsage(AU);
+}
+
+// 初始化R9
+
+// 代码插桩,如下
+//  mov r3 [r4]
+//  // Decode the function pointer
+//  xor r3 r9
+//  // Jump or not jump to the other shadow
+//  add r3 #offset (add r3 #0)
+//  // Jump to the target function
+//  blx r3
+
+// push {r4-r8}
+// // Encode the lr before push it to the stack
+// xor lr r9
+// push lr
+
+// pop {r4-r8} lr
+// // Decode the value of lr after fetch it from the stack
+// xor lr r9
+
+// pop {r7,lr}
+// xor pc lr r9
+
+//
+// Method: createInitFunction()
+//
+// Description:
+//   This method creates a function (both Function and MachineFunction) that
+//   initializes the reserved registers for the shadow stack.
+//
+// Inputs:
+//   M  - A reference to the Module in which to create the function.
+//   SS - A reference to the shadow stack global variable.
+//
+// Return value:
+//   A pointer to the created Function.
+//
+Function *ARMEncodeDecode::createInitFunction(Module &M) {
+  // Create types for the init function
+  LLVMContext &Ctx = M.getContext();
+  FunctionType *FuncTy = FunctionType::get(Type::getVoidTy(Ctx), false);
+
+  // Create the init function
+  FunctionCallee FC =
+      M.getOrInsertFunction(ARMEncodeDecode::InitFuncName, FuncTy);
+  Function *F = dyn_cast<Function>(FC.getCallee());
+  assert(F != nullptr && "Init function has wrong type!");
+  MachineModuleInfo &MMI = getAnalysis<MachineModuleInfoWrapperPass>().getMMI();
+  MachineFunction &MF = MMI.getOrCreateMachineFunction(*F);
+
+  // Set necessary attributes and properties
+  F->setLinkage(GlobalVariable::LinkOnceAnyLinkage);
+  if (!F->hasFnAttribute(Attribute::Naked)) {
+    F->addFnAttr(Attribute::Naked);
+  }
+  if (!F->hasFnAttribute(Attribute::NoUnwind)) {
+    F->addFnAttr(Attribute::NoUnwind);
+  }
+  if (!F->hasFnAttribute(Attribute::WillReturn)) {
+    F->addFnAttr(Attribute::WillReturn);
+  }
+  using Property = MachineFunctionProperties::Property;
+  if (!MF.getProperties().hasProperty(Property::NoVRegs)) {
+    MF.getProperties().set(Property::NoVRegs);
+  }
+
+  // Create a basic block if not created
+  if (F->empty()) {
+    assert(MF.empty() && "Machine IR basic block already there!");
+
+    // Build an IR basic block
+    BasicBlock *BB = BasicBlock::Create(Ctx, "", F);
+    IRBuilder<> IRB(BB);
+    IRB.CreateRetVoid(); // At this point, what the IR basic block contains
+                         // doesn't matter so just place a return there
+
+    // Build machine IR basic block(s)
+    const TargetInstrInfo *TII = MF.getSubtarget().getInstrInfo();
+    MachineBasicBlock *MBB = MF.CreateMachineBasicBlock(BB);
+    // MachineBasicBlock * MBB2 = nullptr;
+    // MachineBasicBlock * MBB3 = nullptr;
+    MachineBasicBlock *RetMBB = MBB;
+    MF.push_back(MBB);
+
+    // // Generate a static random stride
+    // uint64_t Stride = (*RNG)();
+    // Stride &= (1ul << (EncodeDecodeNumberLength - 1)) - 1;
+    // Stride &= ~0x3ul;
+
+    uint64_t Stride = 0x00000001;
+
+    if (ARM_AM::getT2SOImmVal(Stride) != -1) {
+      // Use MOVi if the stride can be encoded in Thumb modified constant
+      BuildMI(MBB, DebugLoc(), TII->get(ARM::t2MOVi), XorReg)
+          .addImm(Stride)
+          .add(predOps(ARMCC::AL))
+          .add(condCodeOp()); // No 'S' bit
+    } else {
+      // Otherwise use MOVi16/MOVTi16 to encode lower/upper 16 bits of the
+      // stride
+      BuildMI(MBB, DebugLoc(), TII->get(ARM::t2MOVi16), XorReg)
+          .addImm(Stride & 0xffff)
+          .add(predOps(ARMCC::AL));
+      BuildMI(MBB, DebugLoc(), TII->get(ARM::t2MOVTi16), XorReg)
+          .addReg(XorReg)
+          .addImm((Stride >> 16) & 0xffff)
+          .add(predOps(ARMCC::AL));
+    }
+
+    // BX_RET
+    BuildMI(RetMBB, DebugLoc(), TII->get(ARM::tBX_RET)).add(predOps(ARMCC::AL));
+  }
+  // Add the init function to @llvm.used
+  appendToUsed(M, {F});
+
+  return F;
+}
+
+//
+// Method: EncodeLR()
+//
+// Description:
+//   This method modifies a PUSH instruction to not save LR to the stack and
+//   inserts new instructions that save LR to the shadow stack.
+//
+// Inputs:
+//   MI     - A reference to a PUSH instruction that saves LR to the stack.
+//   LR     - A reference to the LR operand of the PUSH.
+//   Stride - A static stride to use.
+//
+// Return value:
+//   true - The machine code was modified.
+//
+
+// push {r4-r8}
+// // Encode the lr before push it to the stack
+// xor lr r9
+// push lr
+bool ARMEncodeDecode::EncodeLR(MachineInstr &MI, MachineOperand &LR,
+                               uint32_t Stride) {
+  MachineFunction &MF = *MI.getMF();
+  const TargetInstrInfo *TII = MF.getSubtarget().getInstrInfo();
+  const DebugLoc &DL = MI.getDebugLoc();
+
+  Register PredReg;
+  ARMCC::CondCodes Pred = getInstrPredicate(MI, PredReg);
+
+  // 1. replace the old PUSH with a new one that doesn't push LR to the
+  // stack
+  switch (MI.getOpcode()) {
+  case ARM::t2STMDB_UPD:
+    // STMDB_UPD should store at least two registers; if it happens to be two,
+    // we replace it with a STR_PRE
+    assert(MI.getNumExplicitOperands() >= 6 && "Buggy STMDB_UPD!");
+    if (MI.getNumExplicitOperands() > 6) {
+      MI.removeOperand(MI.getOperandNo(&LR));
+    } else {
+      unsigned Idx = MI.getOperandNo(&LR);
+      Idx = Idx == 4 ? 5 : 4;
+      insertInstBefore(MI, BuildMI(MF, DL, TII->get(ARM::t2STR_PRE), ARM::SP)
+                               .add(MI.getOperand(Idx))
+                               .addReg(ARM::SP)
+                               .addImm(-4)
+                               .add(predOps(Pred, PredReg))
+                               .setMIFlags(MI.getFlags()));
+      removeInst(MI);
+    }
+    break;
+
+  case ARM::tPUSH:
+    // PUSH should store at least one register; if it happens to be one, we
+    // just remove it
+    assert(MI.getNumExplicitOperands() >= 3 && "Buggy PUSH!");
+    if (MI.getNumExplicitOperands() > 3) {
+      MI.removeOperand(MI.getOperandNo(&LR));
+    } else {
+      removeInst(MI);
+    }
+    break;
+
+  // ARM::t2STR_PRE
+  default:
+    // STR_PRE only stores one register, so we just remove it
+    removeInst(MI);
+    break;
+  }
+
+  // 2. Build the xor instruction
+  // eor.w lr,lr,r9
+
+  std::vector<MachineInstr *> NewInsts;
+  NewInsts.push_back(BuildMI(MF, DL, TII->get(ARM::t2EORrr), ARM::LR)
+                         .addReg(ARM::LR)
+                         .addReg(XorReg)
+                         .add(predOps(Pred, PredReg))
+                         .add(condCodeOp()));
+
+  // 3. insert a new PUSH with a new one that only push LR to the stack
+  switch (MI.getOpcode()) {
+  case ARM::tPUSH:
+    NewInsts.push_back(BuildMI(MF, DL, TII->get(ARM::tPUSH))
+                           .add(predOps(Pred, PredReg))
+                           .addReg(ARM::LR));
+    break;
+
+  // ARM::t2STR_PRE
+  default:
+    // STR_PRE only stores one register, so we just remove it
+    removeInst(MI);
+    break;
+  }
+
+  MI.addOperand(
+      MachineOperand::CreateReg(storeReg, /*isDef=*/true, /*isImp=*/false));
+
+  // 4. Now insert these new instructions into the basic block
+  insertInstsBefore(MI, NewInsts);
+
+  ++NumPrologues;
+  return true;
+}
+
+bool ARMEncodeDecode::EncodeCallSite(MachineInstr &MI, MachineOperand &MO,
+                                     uint32_t Stride) {
+  MachineFunction &MF = *MI.getMF();
+  const TargetInstrInfo *TII = MF.getSubtarget().getInstrInfo();
+  const DebugLoc &DL = MI.getDebugLoc();
+
+  Register PredReg;
+  ARMCC::CondCodes Pred = getInstrPredicate(MI, PredReg);
+
+  std::vector<MachineInstr *> NewInsts;
+  unsigned Idx = MI.getOperandNo(&MO);
+
+  NewInsts.push_back(BuildMI(MF, DL, TII->get(ARM::t2EORrr), MO.getReg())
+                         .addReg(MO.getReg())
+                         .addReg(XorReg)
+                         .add(predOps(Pred, PredReg))
+                         .add(condCodeOp()));
+
+  // insert the decode instructions before blx
+  insertInstsBefore(MI, NewInsts);
+
+  return true;
+}
+
+//
+// Method: DecodeLR()
+//
+// Description:
+//   This method modifies a POP instruction to not write to PC/LR and inserts
+//   new instructions that load the return address from the shadow stack into
+//   PC/LR.
+//
+// Inputs:
+//   MI     - A reference to a POP instruction that writes to LR or PC.
+//   PCLR   - A reference to the PC or LR operand of the POP.
+//   Stride - A static stride to use.
+//
+// Return value:
+//   true - The machine code was modified.
+//
+
+bool ARMEncodeDecode::DecodeLR(MachineInstr &MI, MachineOperand &PCLR,
+                               uint32_t Stride) {
+  MachineFunction &MF = *MI.getMF();
+  const TargetInstrInfo *TII = MF.getSubtarget().getInstrInfo();
+  const DebugLoc &DL = MI.getDebugLoc();
+
+  Register PredReg;
+  ARMCC::CondCodes Pred = getInstrPredicate(MI, PredReg);
+
+  std::vector<MachineInstr *> NewInsts;
+
+  MachineInstrBuilder MIB =
+      BuildMI(MF, DL, TII->get(ARM::t2LDMIA_UPD), ARM::SP).addReg(ARM::SP);
+  for (MachineOperand &MO : MI.explicit_operands()) {
+    if (MO.isReg() && MO.getReg() == ARM::PC) {
+      MIB.addReg(ARM::LR, RegState::Define);
+    } else {
+      MIB.add(MO);
+    }
+  }
+  NewInsts.push_back(MIB);
+
+  NewInsts.push_back(BuildMI(MF, DL, TII->get(ARM::t2EORrr), ARM::LR)
+                         .addReg(ARM::LR)
+                         .addReg(XorReg)
+                         .add(predOps(Pred, PredReg))
+                         .add(condCodeOp()));
+
+  NewInsts.push_back(
+      BuildMI(MF, DL, TII->get(ARM::tBX_RET)).add(predOps(Pred, PredReg)));
+
+  // Now insert these new instructions after pop.w
+  insertInstsAfter(MI, NewInsts);
+
+  removeInst(MI);
+
+  return true;
+}
+
+//
+// Method: runOnModule()
+//
+// Description:
+//   This method is called when the PassManager wants this pass to transform
+//   the specified Module.  This method
+//
+//   * creates a global variable as the shadow stack,
+//
+//   * creates a function that initializes the reserved registers for the
+//     shadow stack, and
+//
+//   * transforms the Module to utilize the shadow stack for saving/restoring
+//     return addresses and/or to nullify a saved return address on returns.
+//
+// Input:
+//   M - A reference to the Module to transform.
+//
+// Output:
+//   M - The transformed Module.
+//
+// Return value:
+//   true  - The Module was transformed.
+//   false - The Module was not transformed.
+//
+bool ARMEncodeDecode::runOnModule(Module &M) {
+  // if (!EnableEncodeDecode) {
+  //   return false;
+  // }
+
+  // random number stored in r9
+  MachineModuleInfo &MMI = getAnalysis<MachineModuleInfoWrapperPass>().getMMI();
+  Twine RNGName = getPassName() + "-" + Twine(EncodeDecodeSeed);
+  RNG = M.createRNG(RNGName.str());
+
+  if (EnableEncodeDecode) {
+    // Create an init function that:
+    // * loads the address of the shadow stack to the shadow stack pointer
+    //   register, and
+    // * generates a random stride (either dynamic or static) to the shadow
+    //   stack stride register
+    //createInitFunction(M);
+  }
+
+  // Instrument pushes and pops in each function
+  bool changed = false;
+
+  for (Function &F : M) {
+
+    // if (F.getName() == "jzx_Sum" || F.getName() == "jzx_foo" ||
+    //     F.getName() == "getAddr" ||
+    //     F.getName() == "testThread") 
+    //     {
+    if (F.getName() != "Reset_Handler" ) 
+        {
+      MachineFunction *MF = MMI.getMachineFunction(F);
+      if (MF == nullptr) {
+        continue;
+      }
+
+      // Find out all pushes that write LR to the stack and all pops that read a
+      // return address from the stack to LR or PC
+      std::vector<std::pair<MachineInstr *, MachineOperand *>> Pushes;
+      std::vector<std::pair<MachineInstr *, MachineOperand *>> Pops;
+      std::vector<std::pair<MachineInstr *, MachineOperand *>> Blxs;
+      MachineOperand *callRegister = nullptr; // 保存最后一个寄存器操作数的指针
+      Register callRegister1 = ARM::R9; // 对标以下的r0
+      Register callRegister2 = ARM::R9; // 对标以下的r0
+      unsigned SPImm;
+
+      for (MachineBasicBlock &MBB : *MF) {
+        for (MachineBasicBlock::iterator I = MBB.begin(), E = MBB.end();
+             I != E;) {
+          MachineInstr &MI = *I;
+          MachineBasicBlock::iterator I_ = I; // 记录当前位置
+          int state = 1; // 表示当前要找哪一条指令
+          if (MI.getOpcode() == ARM::tBLXr ||
+              MI.getOpcode() == ARM::tBLXr_noip) {
+            for (MachineOperand &MO : MI.explicit_operands()) {
+              if (MO.isReg()) {
+                callRegister = &MO; // 更新最后一个寄存器操作数的指针
+              }
+            }
+            // Blxs.push_back(std::make_pair(&MI, callRegister));
+            while (1) {
+              if (I == MBB.begin()) {
+                break;
+              } else {
+                I--;                    // 往上找
+                MachineInstr &MI1 = *I; // 取当前的MI1
+                if (state == 1) {       // 先找ldr  r2, [sp, #16]
+                  int x = 0;
+                  switch (MI1.getOpcode()) {
+                  case ARM::LDRrs:
+                  case ARM::PICLDR:
+                  case ARM::LDRBrs:
+                  case ARM::t2LDRDi8:
+                  case ARM::LDRi12:
+                  case ARM::t2LDRi12:
+                  case ARM::tLDRi:
+                  case ARM::tLDRspi:
+                    for (MachineOperand &MO : MI1.explicit_operands()) {
+                      if (MO.isReg() && callRegister->getReg() == MO.getReg()) {
+                        unsigned Idx = MI1.getOperandNo(&MO);
+                        callRegister1 = MI1.getOperand(Idx + 1).getReg();
+                        SPImm = MI1.getOperand(Idx + 2).getImm();
+                        state = 2; // 接下来可以找str  r0, [sp, #16] 2
+                      }
+                    }
+                    break;
+                  case ARM::tLDRpci:
+                    x = 1;
+                    break;
+                  default:
+                    break;
+                  }
+                  if (x == 1) {
+                    break;
+                  }
+                } else if (state == 2) {
+                  switch (MI1.getOpcode()) {
+                  case ARM::STRrs:
+                  case ARM::STRBrs:
+                  case ARM::t2STRDi8:
+                  case ARM::STRi12:
+                  case ARM::t2STRi12:
+                  case ARM::tSTRi:
+                  case ARM::tSTRspi:
+                    for (MachineOperand &MO : MI1.explicit_operands()) {
+                      if (MO.isReg() && callRegister1 == MO.getReg()) {
+                        unsigned Idx = MI1.getOperandNo(&MO); //
+                        if (SPImm == MI1.getOperand(Idx + 1).getImm()) {
+                          callRegister1 = MI1.getOperand(Idx - 1).getReg();
+                          state = 3; // 接下来可以找ldr  r0, [r0, #0]
+                        }
+                      }
+                    }
+                    break;
+                  default:
+                    break;
+                  }
+                } else if (state ==
+                           3) { // 找ldr  r0, [r0, #0],一步步迭代到add r0,pc
+                  int f = 0;
+                  switch (MI1.getOpcode()) {
+                  case ARM::tPICADD:
+                  case ARM::PICADD:
+                    for (MachineOperand &MO : MI1.explicit_operands()) {
+                      if (MO.isReg() && callRegister1 == MO.getReg()) {
+                        unsigned Idx = MI1.getOperandNo(&MO);
+                        Blxs.push_back(std::make_pair(&MI, callRegister));
+                        f = 1;
+                        break;
+                      }
+                    }
+                    break;
+                  case ARM::LDRrs:
+                  case ARM::PICLDR:
+                  case ARM::LDRBrs:
+                  case ARM::t2LDRDi8:
+                  case ARM::LDRi12:
+                  case ARM::t2LDRi12:
+                  case ARM::tLDRi:
+                  case ARM::tLDRspi:
+                  case ARM::tLDRpci:
+                    if (MI1.getOperand(0).isReg() &&
+                        callRegister1 == MI1.getOperand(0).getReg() &&
+                        callRegister1 != MI1.getOperand(1).getReg()) {
+                      state = 1; // 转到状态1
+                      callRegister1 = MI1.getOperand(1).getReg();
+                    }
+                    break;
+                  default:
+                    break;
+                  }
+                  if (f == 1) {
+                    break;
+                  }
+                }
+              }
+            }
+            I = I_;
+          }
+          I++;
+        }
+      }
+
+      for (MachineBasicBlock &MBB : *MF) {
+        for (MachineInstr &MI : MBB) {
+          switch (MI.getOpcode()) {
+          // Frame-setup instructions in function prologue
+          case ARM::t2STR_PRE:
+          case ARM::t2STMDB_UPD:
+            // STR_PRE and STMDB_UPD are considered as PUSH if they write to SP!
+            if (MI.getOperand(0).getReg() != ARM::SP) {
+              break;
+            }
+            LLVM_FALLTHROUGH;
+          case ARM::tPUSH:
+            if (MI.getFlag(MachineInstr::FrameSetup)) {
+              for (MachineOperand &MO : MI.explicit_operands()) {
+                if (MO.isReg() && MO.getReg() == ARM::LR) {
+                  Pushes.push_back(std::make_pair(&MI, &MO));
+                  break;
+                }
+              }
+            }
+            break;
+          // Frame-destroy instructions in function epilogue
+          case ARM::t2LDR_POST:
+          case ARM::t2LDMIA_UPD:
+          case ARM::t2LDMIA_RET:
+            // LDR_POST and LDMIA_(UPD|RET) are considered as POP if they read
+            // from SP!
+            if (MI.getOperand(1).getReg() != ARM::SP) {
+              break;
+            }
+            LLVM_FALLTHROUGH;
+          case ARM::tPOP:
+          case ARM::tPOP_RET:
+            if (MI.getFlag(MachineInstr::FrameDestroy)) {
+              // Handle 2 cases:
+              // (1) Pop writing to LR
+              // (2) Pop writing to PC
+              for (MachineOperand &MO : MI.explicit_operands()) {
+                if (MO.isReg()) {
+                  if (MO.getReg() == ARM::LR || MO.getReg() == ARM::PC) {
+                    Pops.push_back(std::make_pair(&MI, &MO));
+                    break;
+                  }
+                }
+              }
+            }
+            break;
+
+          default:
+            break;
+          }
+        }
+      }
+
+      // Instrument each push and pop
+      // if (EnableEncodeDecode) {
+      // Generate a per-function static stride
+      uint32_t Stride = (*RNG)();
+      Stride &= (1ul << (EncodeDecodeNumberLength - 1)) - 1;
+      Stride &= ~0x3ul;
+      // Limit the static stride to be within 8 bits, so that it can fit in
+      // STR_POST and LDR_PRE as an immediate
+      Stride &= 0xfful;
+      // Don't generate an empty stride; either the dynamic stride or the
+      // static stride needs to make sure of it, so just do it on the static to
+      // leave more room for the dynamic
+      if (Stride == 0u) {
+        Stride = 4u;
+      }
+
+      for (auto &MIMO : Pushes) {
+        changed |= EncodeLR(*MIMO.first, *MIMO.second, Stride);
+      }
+
+      for (auto &MIMO : Blxs) {
+        changed |= EncodeCallSite(*MIMO.first, *MIMO.second, Stride);
+      }
+
+      for (auto &MIMO : Pops) {
+        changed |= DecodeLR(*MIMO.first, *MIMO.second, Stride);
+      }
+    }
+  }
+
+  return changed;
+}
+
+ModulePass *llvm::createARMEncodeDecode(void) { return new ARMEncodeDecode(); }
\ No newline at end of file
diff --git a/llvm/lib/Target/ARM/ARMEncodeDecode.h b/llvm/lib/Target/ARM/ARMEncodeDecode.h
new file mode 100755
index 00000000000000..3b00de8bb71d24
--- /dev/null
+++ b/llvm/lib/Target/ARM/ARMEncodeDecode.h
@@ -0,0 +1,38 @@
+#ifndef ARM_ENCODE_DECODE
+#define ARM_ENCODE_DECODE
+
+#include "ARMRandezvousInstrumentor.h"
+#include "llvm/Pass.h"
+#include "llvm/Support/RandomNumberGenerator.h"
+
+namespace llvm {
+  struct ARMEncodeDecode : public ModulePass, ARMRandezvousInstrumentor {
+    // Pass Identifier
+    static char ID;
+
+    // xor number
+    static constexpr Register storeReg = ARM::R8;
+    static constexpr Register XorReg = ARM::R9;
+    static constexpr StringRef InitFuncName = "__xor_register_init";
+
+    ARMEncodeDecode();
+    virtual StringRef getPassName() const override;
+    void getAnalysisUsage(AnalysisUsage & AU) const override;
+    virtual bool runOnModule(Module & M) override;
+
+  private:
+    std::unique_ptr<RandomNumberGenerator> RNG;
+
+    Function * createInitFunction(Module & M);
+    bool EncodeLR(MachineInstr & MI, MachineOperand & LR,
+                           uint32_t Stride);
+    bool EncodeCallSite(MachineInstr & MI, MachineOperand & MO,
+                           uint32_t Stride);
+    bool DecodeLR(MachineInstr & MI, MachineOperand & PCLR,
+                            uint32_t Stride);
+  };
+
+  ModulePass * createARMEncodeDecode(void);
+}
+
+#endif
\ No newline at end of file
diff --git a/llvm/lib/Target/ARM/ARMRandezvousOptions.cpp b/llvm/lib/Target/ARM/ARMRandezvousOptions.cpp
old mode 100644
new mode 100755
index 58dbfca265ad4a..72e3f5dfe9b2ab
--- a/llvm/lib/Target/ARM/ARMRandezvousOptions.cpp
+++ b/llvm/lib/Target/ARM/ARMRandezvousOptions.cpp
@@ -85,6 +85,15 @@ ShadowStack("arm-randezvous-shadow-stack",
             cl::location(EnableRandezvousShadowStack),
             cl::init(false));
 
+//jzx
+bool EnableEncodeDecode;
+static cl::opt<bool, true>
+EncodeDecode("arm-encode-decode",
+            cl::Hidden,
+            cl::desc("Enable ARM Encode and Decode"),
+            cl::location(EnableEncodeDecode),
+            cl::init(true));
+
 bool EnableRandezvousRAN;
 static cl::opt<bool, true>
 RAN("arm-randezvous-ran",
@@ -137,6 +146,15 @@ ShadowStackSeed("arm-randezvous-shadow-stack-seed",
                 cl::location(RandezvousShadowStackSeed),
                 cl::init(0));
 
+//jzx
+uint64_t EncodeDecodeSeed;
+static cl::opt<uint64_t, true>
+XorSeed("encode-decode-seed",
+                cl::Hidden,
+                cl::desc("Seed for the RNG used in ARM Encode and Decode"),
+                cl::location(EncodeDecodeSeed),
+                cl::init(0));
+
 //===----------------------------------------------------------------------===//
 // Size options used by Randezvous passes
 //===----------------------------------------------------------------------===//
@@ -193,6 +211,15 @@ ShadowStackStrideLength("arm-randezvous-shadow-stack-stride-length",
                         cl::location(RandezvousShadowStackStrideLength),
                         cl::init(8));
 
+//jzx
+unsigned EncodeDecodeNumberLength;
+static cl::opt<unsigned, true>
+XorNumLength("arm-xor-number-length",
+                        cl::Hidden,
+                        cl::desc("Number of bits for ARM Xor Number"),
+                        cl::location(EncodeDecodeNumberLength),
+                        cl::init(8));
+
 unsigned RandezvousNumGlobalGuardCandidates;
 static cl::opt<unsigned, true>
 NumGlobalGuardCandidates("arm-randezvous-num-global-guard-candidates",
@@ -207,4 +234,13 @@ RNGAddress("arm-randezvous-rng-addr",
            cl::Hidden,
            cl::desc("Address of a dynamic RNG"),
            cl::location(RandezvousRNGAddress),
+           cl::init(0));
+
+//jzx
+uintptr_t EncodeDecodeRNGAddress;
+static cl::opt<uintptr_t, true>
+XorRNGAddress("arm-encode-and-decode-rng-addr",
+           cl::Hidden,
+           cl::desc("Address of a dynamic RNG"),
+           cl::location(EncodeDecodeRNGAddress),
            cl::init(0));
\ No newline at end of file
diff --git a/llvm/lib/Target/ARM/ARMRandezvousOptions.h b/llvm/lib/Target/ARM/ARMRandezvousOptions.h
old mode 100644
new mode 100755
index 3757fd09e07f42..7e754cdf9e0cf2
--- a/llvm/lib/Target/ARM/ARMRandezvousOptions.h
+++ b/llvm/lib/Target/ARM/ARMRandezvousOptions.h
@@ -30,6 +30,7 @@ extern bool EnableRandezvousGDLR;
 extern bool EnableRandezvousDecoyPointers;
 extern bool EnableRandezvousGlobalGuard;
 extern bool EnableRandezvousShadowStack;
+extern bool EnableEncodeDecode;//jzx
 extern bool EnableRandezvousRAN;
 extern bool EnableRandezvousLGPromote;
 extern bool EnableRandezvousICallLimiter;
@@ -41,6 +42,7 @@ extern bool EnableRandezvousICallLimiter;
 extern uint64_t RandezvousCLRSeed;
 extern uint64_t RandezvousGDLRSeed;
 extern uint64_t RandezvousShadowStackSeed;
+extern uint64_t EncodeDecodeSeed;//jzx
 
 //===----------------------------------------------------------------------===//
 // Size options used by Randezvous passes
@@ -57,7 +59,9 @@ extern size_t RandezvousShadowStackSize;
 //===----------------------------------------------------------------------===//
 
 extern unsigned RandezvousShadowStackStrideLength;
+extern unsigned EncodeDecodeNumberLength;
 extern unsigned RandezvousNumGlobalGuardCandidates;
+extern uintptr_t EncodeDecodeRNGAddress;//jzx
 extern uintptr_t RandezvousRNGAddress;
 
 #endif
\ No newline at end of file
diff --git a/llvm/lib/Target/ARM/ARMTargetMachine.cpp b/llvm/lib/Target/ARM/ARMTargetMachine.cpp
old mode 100644
new mode 100755
index bfd0d0ec4cecda..1f798dc792952e
--- a/llvm/lib/Target/ARM/ARMTargetMachine.cpp
+++ b/llvm/lib/Target/ARM/ARMTargetMachine.cpp
@@ -11,6 +11,8 @@
 
 #include "ARMRandezvousInstrumentor.h"
 #include "ARMRandezvousShadowStack.h"
+//jzx
+#include "ARMEncodeDecode.h"
 #include "ARMTargetMachine.h"
 #include "ARM.h"
 #include "ARMMachineFunctionInfo.h"
@@ -58,6 +60,9 @@
 #include <optional>
 #include <string>
 
+//jzx
+#include "ARMEncodeDecode.h"
+
 using namespace llvm;
 
 static cl::opt<bool>
@@ -618,6 +623,9 @@ void ARMPassConfig::addPreEmitPass2() {
 
   addPass(createARMRandezvousShadowStack());
 
+  //jzx
+  addPass(createARMEncodeDecode());
+
 
   if (TM->getTargetTriple().isOSWindows()) {
     // Identify valid longjmp targets for Windows Control Flow Guard.
diff --git a/llvm/lib/Target/ARM/CMakeLists.txt b/llvm/lib/Target/ARM/CMakeLists.txt
old mode 100644
new mode 100755
index d4dd215b84ab83..df33e216107b52
--- a/llvm/lib/Target/ARM/CMakeLists.txt
+++ b/llvm/lib/Target/ARM/CMakeLists.txt
@@ -19,6 +19,9 @@ tablegen(LLVM ARMGenSystemRegister.inc -gen-searchable-tables)
 
 add_public_tablegen_target(ARMCommonTableGen)
 
+set(ARM_Shadow_Randomization
+  ARMEncodeDecode.cpp
+)
 
 set(ARMRandezvous_SOURCES
   ARMRandezvousInstrumentor.cpp
@@ -77,6 +80,7 @@ add_llvm_target(ARMCodeGen
   Thumb2InstrInfo.cpp
   Thumb2SizeReduction.cpp
   ${ARMRandezvous_SOURCES}
+  ${ARM_Shadow_Randomization}
 
   LINK_COMPONENTS
   ARMDesc
diff --git a/openmp/tools/analyzer/llvm-openmp-analyzer++ b/openmp/tools/analyzer/llvm-openmp-analyzer++
deleted file mode 120000
index b45062ac867626..00000000000000
--- a/openmp/tools/analyzer/llvm-openmp-analyzer++
+++ /dev/null
@@ -1 +0,0 @@
-llvm-openmp-analyzer
\ No newline at end of file
diff --git a/openmp/tools/analyzer/llvm-openmp-analyzer++ b/openmp/tools/analyzer/llvm-openmp-analyzer++
new file mode 100755
index 00000000000000..259809c2dddb29
--- /dev/null
+++ b/openmp/tools/analyzer/llvm-openmp-analyzer++
@@ -0,0 +1,45 @@
+#!/usr/bin/env python
+
+"""
+A wrapper for Clang specialized for gathering information about OpenMP programs.
+Simple replace calls to clang or clang++ with llvm-openmp-analyzer to run the
+analysis passes.
+"""
+
+import argparse
+import subprocess
+import yaml # PyYaml to save and load analysis information
+import sys
+import io
+
+from analyzer import getKernelUsage
+
+desc = '''A wrapper around clang that runs OpenMP Analysis passes and gathers
+information about OpenMP programs.'''
+
+default_args = ["-fopenmp", "-Rpass=openmp-opt", "-Rpass-missed=openmp-opt", "-Rpass-analysis=openmp-opt"]
+
+def main():
+    compiler = ["clang++"] if sys.argv[0].endswith('++') else ["clang"]
+    parser = argparse.ArgumentParser(description=desc)
+    parser.add_argument('--usage-report-file',
+            metavar='filename',
+            default='usage.yaml',
+            help='Filename used for the OpenMP kernel usage reports in YAML format. "usage.yaml" by default.')
+    parser.add_argument('--no-usage-report', 
+            action='store_true',
+            default=False, 
+            help='Do not general a usage report for the OpenMP kernels.')
+    args, clang_args = parser.parse_known_args()
+
+    subprocess.run(compiler + default_args + clang_args, check=True)
+    output = subprocess.run(compiler + default_args + clang_args + ["-v"], stderr=subprocess.PIPE)
+    stderr = output.stderr.decode('utf-8')
+
+    if not args.no_usage_report:
+        usage = getKernelUsage(stderr, fname=args.usage_report_file)
+        with io.open(args.usage_report_file, 'w', encoding = 'utf-8') as f:
+            yaml.dump(usage, f)
+
+if __name__ == '__main__':
+    main()

>From d26a1e94b29fd2cb1abe93302adcb1cfdff7d28a Mon Sep 17 00:00:00 2001
From: jiang-zixian <980485445 at qq.com>
Date: Sun, 31 Mar 2024 23:49:41 +0800
Subject: [PATCH 4/6] edit the reademe.md to add commands for compile

---
 README.md                               | 29 +++++++++++++++++++++++++
 llvm/lib/Target/ARM/ARMEncodeDecode.cpp |  1 +
 2 files changed, 30 insertions(+)

diff --git a/README.md b/README.md
index 1273ba17c2fa0c..631ba44fff154e 100644
--- a/README.md
+++ b/README.md
@@ -1,3 +1,32 @@
+# srtp小组 可用编译命令
+
+1. 设置交换分区
+```bash
+sudo rm /var/cache/swap/swap0
+sudo swapoff -a
+sudo mkdir -p /var/cache/swap/
+sudo dd if=/dev/zero of=/var/cache/swap/swap0 bs=64M count=256
+#(这里的count可以小一点,1024完全ok,更小一些不知道够不够)
+sudo chmod 0600 /var/cache/swap/swap0
+sudo mkswap /var/cache/swap/swap0
+sudo swapon /var/cache/swap/swap0
+sudo swapon -s
+```
+
+2. 进入build文件夹编译
+```bash
+cd llvm-project
+sudo mkdir build
+cd build
+```
+3. 编译
+```bash
+sudo cmake -G "Ninja" -DLLVM_ENABLE_PROJECTS="clang;clang-tools-extra;compiler-rt;" ../llvm -DCMAKE_BUILD_TYPE=release &&sudo ninja -j3
+```
+ninja命令后的-j后跟的数字可根据自己电脑内核数修改,建议比电脑配置内核数少一个,否则电脑其他进程会很卡
+
+
+
 # The LLVM Compiler Infrastructure
 
 This directory and its sub-directories contain the source code for LLVM,
diff --git a/llvm/lib/Target/ARM/ARMEncodeDecode.cpp b/llvm/lib/Target/ARM/ARMEncodeDecode.cpp
index ddf73811254f23..b2bd7fc9401600 100755
--- a/llvm/lib/Target/ARM/ARMEncodeDecode.cpp
+++ b/llvm/lib/Target/ARM/ARMEncodeDecode.cpp
@@ -271,6 +271,7 @@ bool ARMEncodeDecode::EncodeLR(MachineInstr &MI, MachineOperand &LR,
   return true;
 }
 
+//
 bool ARMEncodeDecode::EncodeCallSite(MachineInstr &MI, MachineOperand &MO,
                                      uint32_t Stride) {
   MachineFunction &MF = *MI.getMF();

>From 84b6378ebc1196c159d50be1da847ab64d75c4eb Mon Sep 17 00:00:00 2001
From: jiang-zixian <980485445 at qq.com>
Date: Sun, 31 Mar 2024 23:52:28 +0800
Subject: [PATCH 5/6] add commands for compile

---
 README.md   | 29 -----------------------------
 commands.md | 28 ++++++++++++++++++++++++++++
 2 files changed, 28 insertions(+), 29 deletions(-)
 create mode 100644 commands.md

diff --git a/README.md b/README.md
index 631ba44fff154e..1273ba17c2fa0c 100644
--- a/README.md
+++ b/README.md
@@ -1,32 +1,3 @@
-# srtp小组 可用编译命令
-
-1. 设置交换分区
-```bash
-sudo rm /var/cache/swap/swap0
-sudo swapoff -a
-sudo mkdir -p /var/cache/swap/
-sudo dd if=/dev/zero of=/var/cache/swap/swap0 bs=64M count=256
-#(这里的count可以小一点,1024完全ok,更小一些不知道够不够)
-sudo chmod 0600 /var/cache/swap/swap0
-sudo mkswap /var/cache/swap/swap0
-sudo swapon /var/cache/swap/swap0
-sudo swapon -s
-```
-
-2. 进入build文件夹编译
-```bash
-cd llvm-project
-sudo mkdir build
-cd build
-```
-3. 编译
-```bash
-sudo cmake -G "Ninja" -DLLVM_ENABLE_PROJECTS="clang;clang-tools-extra;compiler-rt;" ../llvm -DCMAKE_BUILD_TYPE=release &&sudo ninja -j3
-```
-ninja命令后的-j后跟的数字可根据自己电脑内核数修改,建议比电脑配置内核数少一个,否则电脑其他进程会很卡
-
-
-
 # The LLVM Compiler Infrastructure
 
 This directory and its sub-directories contain the source code for LLVM,
diff --git a/commands.md b/commands.md
new file mode 100644
index 00000000000000..b989ad0a15a491
--- /dev/null
+++ b/commands.md
@@ -0,0 +1,28 @@
+# srtp小组 可用编译命令
+
+1. 设置交换分区
+```bash
+sudo rm /var/cache/swap/swap0
+sudo swapoff -a
+sudo mkdir -p /var/cache/swap/
+sudo dd if=/dev/zero of=/var/cache/swap/swap0 bs=64M count=256
+#(这里的count可以小一点,1024完全ok,更小一些不知道够不够)
+sudo chmod 0600 /var/cache/swap/swap0
+sudo mkswap /var/cache/swap/swap0
+sudo swapon /var/cache/swap/swap0
+sudo swapon -s
+```
+
+2. 进入build文件夹编译
+```bash
+cd llvm-project
+sudo mkdir build
+cd build
+```
+3. 编译
+```bash
+sudo cmake -G "Ninja" -DLLVM_ENABLE_PROJECTS="clang;clang-tools-extra;compiler-rt;" ../llvm -DCMAKE_BUILD_TYPE=release &&sudo ninja -j3
+```
+ninja命令后的-j后跟的数字可根据自己电脑内核数修改,建议比电脑配置内核数少一个,否则电脑其他进程会很卡
+
+

>From 486da820ff714d5757c3699472ac209b2fb34fcd Mon Sep 17 00:00:00 2001
From: jiang-zixian <980485445 at qq.com>
Date: Sun, 31 Mar 2024 23:54:17 +0800
Subject: [PATCH 6/6] edit the readme.md

---
 README.md   | 30 ++++++++++++++++++++++++++++++
 commands.md | 28 ----------------------------
 2 files changed, 30 insertions(+), 28 deletions(-)
 delete mode 100644 commands.md

diff --git a/README.md b/README.md
index 1273ba17c2fa0c..7f052397e868db 100644
--- a/README.md
+++ b/README.md
@@ -1,3 +1,33 @@
+# srtp小组 可用编译命令
+
+1. 设置交换分区
+```bash
+sudo rm /var/cache/swap/swap0
+sudo swapoff -a
+sudo mkdir -p /var/cache/swap/
+sudo dd if=/dev/zero of=/var/cache/swap/swap0 bs=64M count=256
+#(这里的count可以小一点,1024完全ok,更小一些不知道够不够)
+sudo chmod 0600 /var/cache/swap/swap0
+sudo mkswap /var/cache/swap/swap0
+sudo swapon /var/cache/swap/swap0
+sudo swapon -s
+```
+
+2. 进入build文件夹编译
+```bash
+cd llvm-project
+sudo mkdir build
+cd build
+```
+3. 编译
+```bash
+sudo cmake -G "Ninja" -DLLVM_ENABLE_PROJECTS="clang;clang-tools-extra;compiler-rt;" ../llvm -DCMAKE_BUILD_TYPE=release &&sudo ninja -j3
+```
+ninja命令后的-j后跟的数字可根据自己电脑内核数修改,建议比电脑配置内核数少一个,否则电脑其他进程会很卡
+
+
+
+
 # The LLVM Compiler Infrastructure
 
 This directory and its sub-directories contain the source code for LLVM,
diff --git a/commands.md b/commands.md
deleted file mode 100644
index b989ad0a15a491..00000000000000
--- a/commands.md
+++ /dev/null
@@ -1,28 +0,0 @@
-# srtp小组 可用编译命令
-
-1. 设置交换分区
-```bash
-sudo rm /var/cache/swap/swap0
-sudo swapoff -a
-sudo mkdir -p /var/cache/swap/
-sudo dd if=/dev/zero of=/var/cache/swap/swap0 bs=64M count=256
-#(这里的count可以小一点,1024完全ok,更小一些不知道够不够)
-sudo chmod 0600 /var/cache/swap/swap0
-sudo mkswap /var/cache/swap/swap0
-sudo swapon /var/cache/swap/swap0
-sudo swapon -s
-```
-
-2. 进入build文件夹编译
-```bash
-cd llvm-project
-sudo mkdir build
-cd build
-```
-3. 编译
-```bash
-sudo cmake -G "Ninja" -DLLVM_ENABLE_PROJECTS="clang;clang-tools-extra;compiler-rt;" ../llvm -DCMAKE_BUILD_TYPE=release &&sudo ninja -j3
-```
-ninja命令后的-j后跟的数字可根据自己电脑内核数修改,建议比电脑配置内核数少一个,否则电脑其他进程会很卡
-
-



More information about the Openmp-commits mailing list