[llvm] [AggressiveInstCombine] Fold byte-reversed consecutive loads to load+bswap (PR #227517)

Craig Topper via llvm-commits llvm-commits at lists.llvm.org
Fri Oct 2 14:54:59 PDT 2026


https://github.com/topperc updated https://github.com/llvm/llvm-project/pull/227517

>From bcbe264b232519188b8c1a113702bcf8be6f0ee8 Mon Sep 17 00:00:00 2001
From: Craig Topper <craig.topper at sifive.com>
Date: Tue, 29 Sep 2026 16:15:09 -0700
Subject: [PATCH 1/2] [AggressiveInstCombine] Fold byte-reversed consecutive
 loads to load+bswap

Teach foldConsecutiveLoads to recognize chains of i8 loads that are
combined in the opposite byte order of the target, e.g. a big endian
read on a little endian target:

  res |= (u64)y[i] << ((7-i) * 8)

These are now combined into a single wide load followed by a bswap.
The byte order is determined by the first pair in the chain and all
remaining loads must match it. All loads must be i8 since reversing
wider elements is not a bswap. The fold is only done if the target
reports that bswap is cheap.

Co-Authored-By: Claude Opus 5.5 <noreply at anthropic.com>
---
 .../AggressiveInstCombine.cpp                 |  56 +-
 .../AggressiveInstCombine/AArch64/or-load.ll  | 570 ++----------
 .../AggressiveInstCombine/RISCV/or-load.ll    |  88 ++
 .../AggressiveInstCombine/X86/or-load.ll      | 856 +++++++-----------
 4 files changed, 564 insertions(+), 1006 deletions(-)

diff --git a/llvm/lib/Transforms/AggressiveInstCombine/AggressiveInstCombine.cpp b/llvm/lib/Transforms/AggressiveInstCombine/AggressiveInstCombine.cpp
index c5548eb107a11..de6cc3b865251 100644
--- a/llvm/lib/Transforms/AggressiveInstCombine/AggressiveInstCombine.cpp
+++ b/llvm/lib/Transforms/AggressiveInstCombine/AggressiveInstCombine.cpp
@@ -1368,11 +1368,13 @@ static bool tryToRecognizeTableBasedPatterns(Instruction &I,
 
 /// This is used by foldLoadsRecursive() to capture a Root Load node which is
 /// of type or(load, load) and recursively build the wide load. Also capture the
-/// shift amount, zero extend type and loadSize.
+/// shift amount, zero extend type and loadSize. BSwap indicates the loads
+/// are combined in the opposite byte order of the target and need a bswap.
 struct LoadOps {
   LoadInst *Root = nullptr;
   LoadInst *RootInsert = nullptr;
   bool FoundRoot = false;
+  bool BSwap = false;
   uint64_t LoadSize = 0;
   uint64_t Shift = 0;
   Type *ZextType;
@@ -1382,6 +1384,8 @@ struct LoadOps {
 // Identify and Merge consecutive loads recursively which is of the form
 // (ZExt(L1) << shift1) | (ZExt(L2) << shift2) -> ZExt(L3) << shift1
 // (ZExt(L1) << shift1) | ZExt(L2) -> ZExt(L3)
+// If the loads are i8 and in the opposite byte order of the target, L3 is
+// combined with a bswap.
 static bool foldLoadsRecursive(Value *V, LoadOps &LOps, const DataLayout &DL,
                                AliasAnalysis &AA, bool IsRoot = false) {
   uint64_t ShAmt2;
@@ -1477,6 +1481,10 @@ static bool foldLoadsRecursive(Value *V, LoadOps &LOps, const DataLayout &DL,
       return false;
   }
 
+  // LI2 is always a single load. LI1 is only a single load if this is the
+  // first pair in the chain. A bswap is only possible if all loads are i8.
+  bool AllBytes = LoadSize2 == 8 && (LOps.FoundRoot || LoadSize1 == 8);
+
   // Make sure Load with lower Offset is at LI1
   bool Reverse = false;
   if (Offset2.slt(Offset1)) {
@@ -1488,10 +1496,6 @@ static bool foldLoadsRecursive(Value *V, LoadOps &LOps, const DataLayout &DL,
     Reverse = true;
   }
 
-  // Big endian swap the shifts
-  if (IsBigEndian)
-    std::swap(ShAmt1, ShAmt2);
-
   // First load is always LI1. This is where we put the new load.
   // Use the merged load size available from LI1 for forward loads.
   if (LOps.FoundRoot) {
@@ -1503,12 +1507,32 @@ static bool foldLoadsRecursive(Value *V, LoadOps &LOps, const DataLayout &DL,
 
   // Verify if shift amount and load index aligns and verifies that loads
   // are consecutive.
-  uint64_t ShiftDiff = IsBigEndian ? LoadSize2 : LoadSize1;
   uint64_t PrevSize =
       DL.getTypeStoreSize(IntegerType::get(LI1->getContext(), LoadSize1));
-  if ((ShAmt2 - ShAmt1) != ShiftDiff || (Offset2 - Offset1) != PrevSize)
+  if ((Offset2 - Offset1) != PrevSize)
+    return false;
+
+  // Check if the shift amounts match the byte order.
+  auto ShiftsMatch = [&](bool BigEndian) {
+    uint64_t LoShAmt = BigEndian ? ShAmt2 : ShAmt1;
+    uint64_t HiShAmt = BigEndian ? ShAmt1 : ShAmt2;
+    uint64_t ShiftDiff = BigEndian ? LoadSize2 : LoadSize1;
+    return (HiShAmt - LoShAmt) == ShiftDiff;
+  };
+
+  // The byte order of the chain is determined by the first pair. If the
+  // shifts don't match the target byte order, try the opposite byte order.
+  bool BSwap = LOps.FoundRoot ? LOps.BSwap : !ShiftsMatch(IsBigEndian);
+  if (BSwap && !AllBytes)
+    return false;
+  bool EffectiveBigEndian = IsBigEndian != BSwap;
+  if (!ShiftsMatch(EffectiveBigEndian))
     return false;
 
+  // Big endian swap the shifts
+  if (EffectiveBigEndian)
+    std::swap(ShAmt1, ShAmt2);
+
   // Reject if the combined size of the loads exceeds the target type size.
   // This avoids attempting to emit an invalid ZExt (from wider to narrower
   // type) when out-of-bounds shifts lead to matching too many loads.
@@ -1524,6 +1548,7 @@ static bool foldLoadsRecursive(Value *V, LoadOps &LOps, const DataLayout &DL,
   }
   LOps.LoadSize = LoadSize1 + LoadSize2;
   LOps.RootInsert = Start;
+  LOps.BSwap = BSwap;
 
   // Concatenate the AATags of the Merged Loads.
   LOps.AATags = AATags1.concat(AATags2);
@@ -1564,6 +1589,18 @@ static bool foldConsecutiveLoads(Instruction &I, const DataLayout &DL,
   if (!Allowed || !Fast)
     return false;
 
+  IntegerType *WiderType = IntegerType::get(I.getContext(), LOps.LoadSize);
+
+  // Check the target has an efficient bswap if the loads are in the opposite
+  // byte order of the target.
+  if (LOps.BSwap) {
+    IntrinsicCostAttributes Attrs(Intrinsic::bswap, WiderType, {WiderType});
+    InstructionCost Cost = TTI.getIntrinsicInstrCost(
+        Attrs, TargetTransformInfo::TCK_SizeAndLatency);
+    if (Cost > 2 * TargetTransformInfo::TCC_Basic)
+      return false;
+  }
+
   // Get the Index and Ptr for the new GEP.
   Value *Load1Ptr = LI1->getPointerOperand();
   Builder.SetInsertPoint(LOps.RootInsert);
@@ -1574,7 +1611,6 @@ static bool foldConsecutiveLoads(Instruction &I, const DataLayout &DL,
     Load1Ptr = Builder.CreatePtrAdd(Load1Ptr, Builder.getInt(Offset1));
   }
   // Generate wider load.
-  IntegerType *WiderType = IntegerType::get(I.getContext(), LOps.LoadSize);
   NewLoad = Builder.CreateAlignedLoad(WiderType, Load1Ptr, LI1->getAlign(),
                                       LI1->isVolatile(), "");
   NewLoad->takeName(LI1);
@@ -1583,6 +1619,10 @@ static bool foldConsecutiveLoads(Instruction &I, const DataLayout &DL,
     NewLoad->setAAMetadata(LOps.AATags);
 
   Value *NewOp = NewLoad;
+  // Reverse the bytes if needed.
+  if (LOps.BSwap)
+    NewOp = Builder.CreateUnaryIntrinsic(Intrinsic::bswap, NewOp);
+
   // Zero extend if needed.
   NewOp = Builder.CreateZExt(NewOp, LOps.ZextType);
 
diff --git a/llvm/test/Transforms/AggressiveInstCombine/AArch64/or-load.ll b/llvm/test/Transforms/AggressiveInstCombine/AArch64/or-load.ll
index 0a00083c340b9..a68aff13bc875 100644
--- a/llvm/test/Transforms/AggressiveInstCombine/AArch64/or-load.ll
+++ b/llvm/test/Transforms/AggressiveInstCombine/AArch64/or-load.ll
@@ -9,13 +9,8 @@ define i16 @loadCombine_2consecutive(ptr %p) {
 ; LE-NEXT:    ret i16 [[L1]]
 ;
 ; BE-LABEL: @loadCombine_2consecutive(
-; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
-; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i16
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i16
-; BE-NEXT:    [[S2:%.*]] = shl i16 [[E2]], 8
-; BE-NEXT:    [[O1:%.*]] = or i16 [[E1]], [[S2]]
+; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P:%.*]], align 1
+; BE-NEXT:    [[O1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
 ; BE-NEXT:    ret i16 [[O1]]
 ;
   %p1 = getelementptr i8, ptr %p, i32 1
@@ -30,13 +25,8 @@ define i16 @loadCombine_2consecutive(ptr %p) {
 
 define i16 @loadCombine_2consecutive_BE(ptr %p) {
 ; LE-LABEL: @loadCombine_2consecutive_BE(
-; LE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; LE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; LE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
-; LE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i16
-; LE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i16
-; LE-NEXT:    [[S1:%.*]] = shl i16 [[E1]], 8
-; LE-NEXT:    [[O1:%.*]] = or i16 [[S1]], [[E2]]
+; LE-NEXT:    [[L1:%.*]] = load i16, ptr [[P:%.*]], align 1
+; LE-NEXT:    [[O1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
 ; LE-NEXT:    ret i16 [[O1]]
 ;
 ; BE-LABEL: @loadCombine_2consecutive_BE(
@@ -59,23 +49,8 @@ define i32 @loadCombine_4consecutive(ptr %p) {
 ; LE-NEXT:    ret i32 [[L1]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive(
-; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
-; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
-; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
-; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
-; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
-; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
-; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
-; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
-; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
-; BE-NEXT:    [[O1:%.*]] = or i32 [[E1]], [[S2]]
-; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
-; BE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[S4]]
+; BE-NEXT:    [[L1:%.*]] = load i32, ptr [[P:%.*]], align 1
+; BE-NEXT:    [[O3:%.*]] = call i32 @llvm.bswap.i32(i32 [[L1]])
 ; BE-NEXT:    ret i32 [[O3]]
 ;
   %p1 = getelementptr i8, ptr %p, i32 1
@@ -103,23 +78,8 @@ define i32 @loadCombine_4consecutive(ptr %p) {
 
 define i32 @loadCombine_4consecutive_BE(ptr %p) {
 ; LE-LABEL: @loadCombine_4consecutive_BE(
-; LE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; LE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
-; LE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; LE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; LE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
-; LE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
-; LE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
-; LE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
-; LE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
-; LE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
-; LE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; LE-NEXT:    [[S1:%.*]] = shl i32 [[E1]], 24
-; LE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 16
-; LE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 8
-; LE-NEXT:    [[O1:%.*]] = or i32 [[S1]], [[S2]]
-; LE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
-; LE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[E4]]
+; LE-NEXT:    [[L1:%.*]] = load i32, ptr [[P:%.*]], align 1
+; LE-NEXT:    [[O3:%.*]] = call i32 @llvm.bswap.i32(i32 [[L1]])
 ; LE-NEXT:    ret i32 [[O3]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_BE(
@@ -156,24 +116,9 @@ define i32 @loadCombine_4consecutive_alias(ptr %p) {
 ; LE-NEXT:    ret i32 [[L1]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_alias(
-; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
-; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
+; BE-NEXT:    [[L1:%.*]] = load i32, ptr [[P:%.*]], align 1
+; BE-NEXT:    [[O3:%.*]] = call i32 @llvm.bswap.i32(i32 [[L1]])
 ; BE-NEXT:    store i8 10, ptr [[P]], align 1
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
-; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
-; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
-; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
-; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
-; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
-; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
-; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
-; BE-NEXT:    [[O1:%.*]] = or i32 [[E1]], [[S2]]
-; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
-; BE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[S4]]
 ; BE-NEXT:    ret i32 [[O3]]
 ;
   %p1 = getelementptr i8, ptr %p, i32 1
@@ -202,24 +147,9 @@ define i32 @loadCombine_4consecutive_alias(ptr %p) {
 
 define i32 @loadCombine_4consecutive_alias_BE(ptr %p) {
 ; LE-LABEL: @loadCombine_4consecutive_alias_BE(
-; LE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; LE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
-; LE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; LE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
+; LE-NEXT:    [[L1:%.*]] = load i32, ptr [[P:%.*]], align 1
+; LE-NEXT:    [[O3:%.*]] = call i32 @llvm.bswap.i32(i32 [[L1]])
 ; LE-NEXT:    store i8 10, ptr [[P]], align 1
-; LE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
-; LE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
-; LE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
-; LE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
-; LE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
-; LE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
-; LE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; LE-NEXT:    [[S1:%.*]] = shl i32 [[E1]], 24
-; LE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 16
-; LE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 8
-; LE-NEXT:    [[O1:%.*]] = or i32 [[S1]], [[S2]]
-; LE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
-; LE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[E4]]
 ; LE-NEXT:    ret i32 [[O3]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_alias_BE(
@@ -269,22 +199,18 @@ define i32 @loadCombine_4consecutive_alias2(ptr %p, ptr %pstr) {
 ; LE-NEXT:    ret i32 [[O3]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_alias2(
-; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
+; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
 ; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
+; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
+; BE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
+; BE-NEXT:    [[O1:%.*]] = zext i16 [[TMP1]] to i32
 ; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
 ; BE-NEXT:    store i8 10, ptr [[PSTR:%.*]], align 1
 ; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
-; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
 ; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
 ; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
 ; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
 ; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
-; BE-NEXT:    [[O1:%.*]] = or i32 [[E1]], [[S2]]
 ; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
 ; BE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[S4]]
 ; BE-NEXT:    ret i32 [[O3]]
@@ -315,22 +241,18 @@ define i32 @loadCombine_4consecutive_alias2(ptr %p, ptr %pstr) {
 
 define i32 @loadCombine_4consecutive_alias2_BE(ptr %p, ptr %pstr) {
 ; LE-LABEL: @loadCombine_4consecutive_alias2_BE(
-; LE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; LE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
+; LE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
 ; LE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; LE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; LE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
+; LE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
+; LE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
+; LE-NEXT:    [[TMP2:%.*]] = zext i16 [[TMP1]] to i32
+; LE-NEXT:    [[O1:%.*]] = shl i32 [[TMP2]], 16
 ; LE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
 ; LE-NEXT:    store i8 10, ptr [[PSTR:%.*]], align 1
 ; LE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
-; LE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
-; LE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
 ; LE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
 ; LE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; LE-NEXT:    [[S1:%.*]] = shl i32 [[E1]], 24
-; LE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 16
 ; LE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 8
-; LE-NEXT:    [[O1:%.*]] = or i32 [[S1]], [[S2]]
 ; LE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
 ; LE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[E4]]
 ; LE-NEXT:    ret i32 [[O3]]
@@ -394,23 +316,19 @@ define i32 @loadCombine_4consecutive_alias3(ptr %p) {
 ; LE-NEXT:    ret i32 [[O3]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_alias3(
-; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
+; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
 ; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
+; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
+; BE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
+; BE-NEXT:    [[O1:%.*]] = zext i16 [[TMP1]] to i32
 ; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
 ; BE-NEXT:    store i8 10, ptr [[P3]], align 1
 ; BE-NEXT:    store i8 5, ptr [[P]], align 1
 ; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
-; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
 ; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
 ; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
 ; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
 ; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
-; BE-NEXT:    [[O1:%.*]] = or i32 [[E1]], [[S2]]
 ; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
 ; BE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[S4]]
 ; BE-NEXT:    ret i32 [[O3]]
@@ -442,23 +360,19 @@ define i32 @loadCombine_4consecutive_alias3(ptr %p) {
 
 define i32 @loadCombine_4consecutive_alias3_BE(ptr %p) {
 ; LE-LABEL: @loadCombine_4consecutive_alias3_BE(
-; LE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; LE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
+; LE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
 ; LE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; LE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; LE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
+; LE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
+; LE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
+; LE-NEXT:    [[TMP2:%.*]] = zext i16 [[TMP1]] to i32
+; LE-NEXT:    [[O1:%.*]] = shl i32 [[TMP2]], 16
 ; LE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
 ; LE-NEXT:    store i8 10, ptr [[P3]], align 1
 ; LE-NEXT:    store i8 5, ptr [[P]], align 1
 ; LE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
-; LE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
-; LE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
 ; LE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
 ; LE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; LE-NEXT:    [[S1:%.*]] = shl i32 [[E1]], 24
-; LE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 16
 ; LE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 8
-; LE-NEXT:    [[O1:%.*]] = or i32 [[S1]], [[S2]]
 ; LE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
 ; LE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[E4]]
 ; LE-NEXT:    ret i32 [[O3]]
@@ -739,21 +653,17 @@ define i32 @loadCombine_4consecutive_hasOneUse4(ptr %p) {
 ; LE-NEXT:    ret i32 [[O3]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_hasOneUse4(
-; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
+; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
 ; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
+; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
+; BE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
+; BE-NEXT:    [[O1:%.*]] = zext i16 [[TMP1]] to i32
 ; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
 ; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
-; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
 ; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
 ; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
 ; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
 ; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
-; BE-NEXT:    [[O1:%.*]] = or i32 [[E1]], [[S2]]
 ; BE-NEXT:    call void @use(i32 [[O1]])
 ; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
 ; BE-NEXT:    call void @use(i32 [[O2]])
@@ -792,23 +702,8 @@ define i32 @fold_i32_multiple_uses(ptr %input, ptr %output) {
 ; LE-NEXT:    ret i32 [[B0]]
 ;
 ; BE-LABEL: @fold_i32_multiple_uses(
-; BE-NEXT:    [[B0:%.*]] = load i8, ptr [[INPUT:%.*]], align 1
-; BE-NEXT:    [[PTR1:%.*]] = getelementptr inbounds i8, ptr [[INPUT]], i64 1
-; BE-NEXT:    [[B1:%.*]] = load i8, ptr [[PTR1]], align 1
-; BE-NEXT:    [[PTR2:%.*]] = getelementptr inbounds i8, ptr [[INPUT]], i64 2
-; BE-NEXT:    [[B2:%.*]] = load i8, ptr [[PTR2]], align 1
-; BE-NEXT:    [[PTR3:%.*]] = getelementptr inbounds i8, ptr [[INPUT]], i64 3
-; BE-NEXT:    [[B3:%.*]] = load i8, ptr [[PTR3]], align 1
-; BE-NEXT:    [[B0_32:%.*]] = zext i8 [[B0]] to i32
-; BE-NEXT:    [[B1_32:%.*]] = zext i8 [[B1]] to i32
-; BE-NEXT:    [[B1_SHIFT:%.*]] = shl i32 [[B1_32]], 8
-; BE-NEXT:    [[VAL01:%.*]] = or i32 [[B1_SHIFT]], [[B0_32]]
-; BE-NEXT:    [[B2_32:%.*]] = zext i8 [[B2]] to i32
-; BE-NEXT:    [[B2_SHIFT:%.*]] = shl i32 [[B2_32]], 16
-; BE-NEXT:    [[VAL012:%.*]] = or i32 [[VAL01]], [[B2_SHIFT]]
-; BE-NEXT:    [[B3_32:%.*]] = zext i8 [[B3]] to i32
-; BE-NEXT:    [[B3_SHIFT:%.*]] = shl i32 [[B3_32]], 24
-; BE-NEXT:    [[VAL:%.*]] = or i32 [[VAL012]], [[B3_SHIFT]]
+; BE-NEXT:    [[B0:%.*]] = load i32, ptr [[INPUT:%.*]], align 1
+; BE-NEXT:    [[VAL:%.*]] = call i32 @llvm.bswap.i32(i32 [[B0]])
 ; BE-NEXT:    store i32 [[VAL]], ptr [[OUTPUT:%.*]], align 4
 ; BE-NEXT:    ret i32 [[VAL]]
 ;
@@ -851,17 +746,13 @@ define i32 @loadCombine_parLoad1(ptr %p) {
 ; LE-NEXT:    ret i32 [[O2]]
 ;
 ; BE-LABEL: @loadCombine_parLoad1(
-; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
+; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
+; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
+; BE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
+; BE-NEXT:    [[O1:%.*]] = zext i16 [[TMP1]] to i32
 ; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
-; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
 ; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
-; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
 ; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
-; BE-NEXT:    [[O1:%.*]] = or i32 [[E1]], [[S2]]
 ; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
 ; BE-NEXT:    ret i32 [[O2]]
 ;
@@ -1194,43 +1085,8 @@ define i64 @load64_farLoads(ptr %ptr) {
 ;
 ; BE-LABEL: @load64_farLoads(
 ; BE-NEXT:  entry:
-; BE-NEXT:    [[TMP0:%.*]] = load i8, ptr [[PTR:%.*]], align 1
-; BE-NEXT:    [[CONV:%.*]] = zext i8 [[TMP0]] to i64
-; BE-NEXT:    [[ARRAYIDX1:%.*]] = getelementptr inbounds i8, ptr [[PTR]], i64 1
-; BE-NEXT:    [[TMP1:%.*]] = load i8, ptr [[ARRAYIDX1]], align 1
-; BE-NEXT:    [[CONV2:%.*]] = zext i8 [[TMP1]] to i64
-; BE-NEXT:    [[SHL:%.*]] = shl i64 [[CONV2]], 8
-; BE-NEXT:    [[OR:%.*]] = or i64 [[CONV]], [[SHL]]
-; BE-NEXT:    [[ARRAYIDX3:%.*]] = getelementptr inbounds i8, ptr [[PTR]], i64 2
-; BE-NEXT:    [[TMP2:%.*]] = load i8, ptr [[ARRAYIDX3]], align 1
-; BE-NEXT:    [[CONV4:%.*]] = zext i8 [[TMP2]] to i64
-; BE-NEXT:    [[SHL5:%.*]] = shl i64 [[CONV4]], 16
-; BE-NEXT:    [[OR6:%.*]] = or i64 [[OR]], [[SHL5]]
-; BE-NEXT:    [[ARRAYIDX7:%.*]] = getelementptr inbounds i8, ptr [[PTR]], i64 3
-; BE-NEXT:    [[TMP3:%.*]] = load i8, ptr [[ARRAYIDX7]], align 1
-; BE-NEXT:    [[CONV8:%.*]] = zext i8 [[TMP3]] to i64
-; BE-NEXT:    [[SHL9:%.*]] = shl i64 [[CONV8]], 24
-; BE-NEXT:    [[OR10:%.*]] = or i64 [[OR6]], [[SHL9]]
-; BE-NEXT:    [[ARRAYIDX11:%.*]] = getelementptr inbounds i8, ptr [[PTR]], i64 4
-; BE-NEXT:    [[TMP4:%.*]] = load i8, ptr [[ARRAYIDX11]], align 1
-; BE-NEXT:    [[CONV12:%.*]] = zext i8 [[TMP4]] to i64
-; BE-NEXT:    [[SHL13:%.*]] = shl i64 [[CONV12]], 32
-; BE-NEXT:    [[OR14:%.*]] = or i64 [[OR10]], [[SHL13]]
-; BE-NEXT:    [[ARRAYIDX15:%.*]] = getelementptr inbounds i8, ptr [[PTR]], i64 5
-; BE-NEXT:    [[TMP5:%.*]] = load i8, ptr [[ARRAYIDX15]], align 1
-; BE-NEXT:    [[CONV16:%.*]] = zext i8 [[TMP5]] to i64
-; BE-NEXT:    [[SHL17:%.*]] = shl i64 [[CONV16]], 40
-; BE-NEXT:    [[OR18:%.*]] = or i64 [[OR14]], [[SHL17]]
-; BE-NEXT:    [[ARRAYIDX19:%.*]] = getelementptr inbounds i8, ptr [[PTR]], i64 6
-; BE-NEXT:    [[TMP6:%.*]] = load i8, ptr [[ARRAYIDX19]], align 1
-; BE-NEXT:    [[CONV20:%.*]] = zext i8 [[TMP6]] to i64
-; BE-NEXT:    [[SHL21:%.*]] = shl i64 [[CONV20]], 48
-; BE-NEXT:    [[OR22:%.*]] = or i64 [[OR18]], [[SHL21]]
-; BE-NEXT:    [[ARRAYIDX23:%.*]] = getelementptr inbounds i8, ptr [[PTR]], i64 7
-; BE-NEXT:    [[TMP7:%.*]] = load i8, ptr [[ARRAYIDX23]], align 1
-; BE-NEXT:    [[CONV24:%.*]] = zext i8 [[TMP7]] to i64
-; BE-NEXT:    [[SHL25:%.*]] = shl i64 [[CONV24]], 56
-; BE-NEXT:    [[OR26:%.*]] = or i64 [[OR22]], [[SHL25]]
+; BE-NEXT:    [[TMP0:%.*]] = load i64, ptr [[PTR:%.*]], align 1
+; BE-NEXT:    [[OR26:%.*]] = call i64 @llvm.bswap.i64(i64 [[TMP0]])
 ; BE-NEXT:    ret i64 [[OR26]]
 ;
 entry:
@@ -1281,24 +1137,9 @@ define i32 @loadCombine_4consecutive_metadata(ptr %p, ptr %pstr) {
 ; LE-NEXT:    ret i32 [[L1]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_metadata(
-; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
-; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1, !alias.scope [[META0:![0-9]+]]
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1, !alias.scope [[META0]]
-; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1, !alias.scope [[META0]]
-; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1, !alias.scope [[META0]]
+; BE-NEXT:    [[L1:%.*]] = load i32, ptr [[P:%.*]], align 1, !alias.scope [[META0:![0-9]+]]
+; BE-NEXT:    [[O3:%.*]] = call i32 @llvm.bswap.i32(i32 [[L1]])
 ; BE-NEXT:    store i32 25, ptr [[PSTR:%.*]], align 4, !noalias [[META0]]
-; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
-; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
-; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
-; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
-; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
-; BE-NEXT:    [[O1:%.*]] = or i32 [[E1]], [[S2]]
-; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
-; BE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[S4]]
 ; BE-NEXT:    ret i32 [[O3]]
 ;
   %p1 = getelementptr i8, ptr %p, i32 1
@@ -1380,23 +1221,8 @@ define i32 @loadCombine_4consecutive_rev(ptr %p) {
 ; LE-NEXT:    ret i32 [[L1]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_rev(
-; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
-; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
-; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
-; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
-; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
-; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
-; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
-; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
-; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
-; BE-NEXT:    [[O1:%.*]] = or i32 [[S4]], [[S3]]
-; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S2]]
-; BE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[E1]]
+; BE-NEXT:    [[L1:%.*]] = load i32, ptr [[P:%.*]], align 1
+; BE-NEXT:    [[O3:%.*]] = call i32 @llvm.bswap.i32(i32 [[L1]])
 ; BE-NEXT:    ret i32 [[O3]]
 ;
   %p1 = getelementptr i8, ptr %p, i32 1
@@ -1428,43 +1254,8 @@ define i64 @loadCombine_8consecutive_rev(ptr %p) {
 ; LE-NEXT:    ret i64 [[L1]]
 ;
 ; BE-LABEL: @loadCombine_8consecutive_rev(
-; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
-; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; BE-NEXT:    [[P4:%.*]] = getelementptr i8, ptr [[P]], i32 4
-; BE-NEXT:    [[P5:%.*]] = getelementptr i8, ptr [[P]], i32 5
-; BE-NEXT:    [[P6:%.*]] = getelementptr i8, ptr [[P]], i32 6
-; BE-NEXT:    [[P7:%.*]] = getelementptr i8, ptr [[P]], i32 7
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
-; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
-; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
-; BE-NEXT:    [[L5:%.*]] = load i8, ptr [[P4]], align 1
-; BE-NEXT:    [[L6:%.*]] = load i8, ptr [[P5]], align 1
-; BE-NEXT:    [[L7:%.*]] = load i8, ptr [[P6]], align 1
-; BE-NEXT:    [[L8:%.*]] = load i8, ptr [[P7]], align 1
-; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i64
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i64
-; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i64
-; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i64
-; BE-NEXT:    [[E5:%.*]] = zext i8 [[L5]] to i64
-; BE-NEXT:    [[E6:%.*]] = zext i8 [[L6]] to i64
-; BE-NEXT:    [[E7:%.*]] = zext i8 [[L7]] to i64
-; BE-NEXT:    [[E8:%.*]] = zext i8 [[L8]] to i64
-; BE-NEXT:    [[S2:%.*]] = shl i64 [[E2]], 8
-; BE-NEXT:    [[S3:%.*]] = shl i64 [[E3]], 16
-; BE-NEXT:    [[S4:%.*]] = shl i64 [[E4]], 24
-; BE-NEXT:    [[S5:%.*]] = shl i64 [[E5]], 32
-; BE-NEXT:    [[S6:%.*]] = shl i64 [[E6]], 40
-; BE-NEXT:    [[S7:%.*]] = shl i64 [[E7]], 48
-; BE-NEXT:    [[S8:%.*]] = shl i64 [[E8]], 56
-; BE-NEXT:    [[O7:%.*]] = or i64 [[S8]], [[S7]]
-; BE-NEXT:    [[O6:%.*]] = or i64 [[O7]], [[S6]]
-; BE-NEXT:    [[O5:%.*]] = or i64 [[O6]], [[S5]]
-; BE-NEXT:    [[O4:%.*]] = or i64 [[O5]], [[S4]]
-; BE-NEXT:    [[O3:%.*]] = or i64 [[O4]], [[S3]]
-; BE-NEXT:    [[O2:%.*]] = or i64 [[O3]], [[S2]]
-; BE-NEXT:    [[O1:%.*]] = or i64 [[O2]], [[E1]]
+; BE-NEXT:    [[L1:%.*]] = load i64, ptr [[P:%.*]], align 1
+; BE-NEXT:    [[O1:%.*]] = call i64 @llvm.bswap.i64(i64 [[L1]])
 ; BE-NEXT:    ret i64 [[O1]]
 ;
   %p1 = getelementptr i8, ptr %p, i32 1
@@ -1512,43 +1303,8 @@ define i64 @loadCombine_8consecutive_rev(ptr %p) {
 
 define i64 @loadCombine_8consecutive_rev_BE(ptr %p) {
 ; LE-LABEL: @loadCombine_8consecutive_rev_BE(
-; LE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; LE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
-; LE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; LE-NEXT:    [[P4:%.*]] = getelementptr i8, ptr [[P]], i32 4
-; LE-NEXT:    [[P5:%.*]] = getelementptr i8, ptr [[P]], i32 5
-; LE-NEXT:    [[P6:%.*]] = getelementptr i8, ptr [[P]], i32 6
-; LE-NEXT:    [[P7:%.*]] = getelementptr i8, ptr [[P]], i32 7
-; LE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; LE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
-; LE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
-; LE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
-; LE-NEXT:    [[L5:%.*]] = load i8, ptr [[P4]], align 1
-; LE-NEXT:    [[L6:%.*]] = load i8, ptr [[P5]], align 1
-; LE-NEXT:    [[L7:%.*]] = load i8, ptr [[P6]], align 1
-; LE-NEXT:    [[L8:%.*]] = load i8, ptr [[P7]], align 1
-; LE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i64
-; LE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i64
-; LE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i64
-; LE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i64
-; LE-NEXT:    [[E5:%.*]] = zext i8 [[L5]] to i64
-; LE-NEXT:    [[E6:%.*]] = zext i8 [[L6]] to i64
-; LE-NEXT:    [[E7:%.*]] = zext i8 [[L7]] to i64
-; LE-NEXT:    [[E8:%.*]] = zext i8 [[L8]] to i64
-; LE-NEXT:    [[S1:%.*]] = shl i64 [[E1]], 56
-; LE-NEXT:    [[S2:%.*]] = shl i64 [[E2]], 48
-; LE-NEXT:    [[S3:%.*]] = shl i64 [[E3]], 40
-; LE-NEXT:    [[S4:%.*]] = shl i64 [[E4]], 32
-; LE-NEXT:    [[S5:%.*]] = shl i64 [[E5]], 24
-; LE-NEXT:    [[S6:%.*]] = shl i64 [[E6]], 16
-; LE-NEXT:    [[S7:%.*]] = shl i64 [[E7]], 8
-; LE-NEXT:    [[O7:%.*]] = or i64 [[E8]], [[S7]]
-; LE-NEXT:    [[O6:%.*]] = or i64 [[O7]], [[S6]]
-; LE-NEXT:    [[O5:%.*]] = or i64 [[O6]], [[S5]]
-; LE-NEXT:    [[O4:%.*]] = or i64 [[O5]], [[S4]]
-; LE-NEXT:    [[O3:%.*]] = or i64 [[O4]], [[S3]]
-; LE-NEXT:    [[O2:%.*]] = or i64 [[O3]], [[S2]]
-; LE-NEXT:    [[O1:%.*]] = or i64 [[O2]], [[S1]]
+; LE-NEXT:    [[L1:%.*]] = load i64, ptr [[P:%.*]], align 1
+; LE-NEXT:    [[O1:%.*]] = call i64 @llvm.bswap.i64(i64 [[L1]])
 ; LE-NEXT:    ret i64 [[O1]]
 ;
 ; BE-LABEL: @loadCombine_8consecutive_rev_BE(
@@ -1604,43 +1360,8 @@ define i64 @eggs(ptr noundef readonly %arg) {
 ; LE-NEXT:    ret i64 [[TMP3]]
 ;
 ; BE-LABEL: @eggs(
-; BE-NEXT:    [[TMP3:%.*]] = load i8, ptr [[ARG:%.*]], align 1
-; BE-NEXT:    [[TMP4:%.*]] = getelementptr inbounds i8, ptr [[ARG]], i64 1
-; BE-NEXT:    [[TMP5:%.*]] = load i8, ptr [[TMP4]], align 1
-; BE-NEXT:    [[TMP6:%.*]] = getelementptr inbounds i8, ptr [[ARG]], i64 2
-; BE-NEXT:    [[TMP7:%.*]] = load i8, ptr [[TMP6]], align 1
-; BE-NEXT:    [[TMP8:%.*]] = getelementptr inbounds i8, ptr [[ARG]], i64 3
-; BE-NEXT:    [[TMP9:%.*]] = load i8, ptr [[TMP8]], align 1
-; BE-NEXT:    [[TMP10:%.*]] = getelementptr inbounds i8, ptr [[ARG]], i64 4
-; BE-NEXT:    [[TMP11:%.*]] = load i8, ptr [[TMP10]], align 1
-; BE-NEXT:    [[TMP12:%.*]] = getelementptr inbounds i8, ptr [[ARG]], i64 5
-; BE-NEXT:    [[TMP13:%.*]] = load i8, ptr [[TMP12]], align 1
-; BE-NEXT:    [[TMP14:%.*]] = getelementptr inbounds i8, ptr [[ARG]], i64 6
-; BE-NEXT:    [[TMP15:%.*]] = load i8, ptr [[TMP14]], align 1
-; BE-NEXT:    [[TMP16:%.*]] = getelementptr inbounds i8, ptr [[ARG]], i64 7
-; BE-NEXT:    [[TMP17:%.*]] = load i8, ptr [[TMP16]], align 1
-; BE-NEXT:    [[TMP18:%.*]] = zext i8 [[TMP17]] to i64
-; BE-NEXT:    [[TMP19:%.*]] = shl nuw i64 [[TMP18]], 56
-; BE-NEXT:    [[TMP20:%.*]] = zext i8 [[TMP15]] to i64
-; BE-NEXT:    [[TMP21:%.*]] = shl nuw nsw i64 [[TMP20]], 48
-; BE-NEXT:    [[TMP22:%.*]] = or i64 [[TMP19]], [[TMP21]]
-; BE-NEXT:    [[TMP23:%.*]] = zext i8 [[TMP13]] to i64
-; BE-NEXT:    [[TMP24:%.*]] = shl nuw nsw i64 [[TMP23]], 40
-; BE-NEXT:    [[TMP25:%.*]] = or i64 [[TMP22]], [[TMP24]]
-; BE-NEXT:    [[TMP26:%.*]] = zext i8 [[TMP11]] to i64
-; BE-NEXT:    [[TMP27:%.*]] = shl nuw nsw i64 [[TMP26]], 32
-; BE-NEXT:    [[TMP28:%.*]] = or i64 [[TMP25]], [[TMP27]]
-; BE-NEXT:    [[TMP29:%.*]] = zext i8 [[TMP9]] to i64
-; BE-NEXT:    [[TMP30:%.*]] = shl nuw nsw i64 [[TMP29]], 24
-; BE-NEXT:    [[TMP31:%.*]] = or i64 [[TMP28]], [[TMP30]]
-; BE-NEXT:    [[TMP32:%.*]] = zext i8 [[TMP7]] to i64
-; BE-NEXT:    [[TMP33:%.*]] = shl nuw nsw i64 [[TMP32]], 16
-; BE-NEXT:    [[TMP34:%.*]] = zext i8 [[TMP5]] to i64
-; BE-NEXT:    [[TMP35:%.*]] = shl nuw nsw i64 [[TMP34]], 8
-; BE-NEXT:    [[TMP36:%.*]] = or i64 [[TMP31]], [[TMP33]]
-; BE-NEXT:    [[TMP37:%.*]] = zext i8 [[TMP3]] to i64
-; BE-NEXT:    [[TMP38:%.*]] = or i64 [[TMP36]], [[TMP35]]
-; BE-NEXT:    [[TMP39:%.*]] = or i64 [[TMP38]], [[TMP37]]
+; BE-NEXT:    [[TMP3:%.*]] = load i64, ptr [[ARG:%.*]], align 1
+; BE-NEXT:    [[TMP39:%.*]] = call i64 @llvm.bswap.i64(i64 [[TMP3]])
 ; BE-NEXT:    ret i64 [[TMP39]]
 ;
   %tmp3 = load i8, ptr %arg, align 1
@@ -1766,17 +1487,13 @@ define i32 @loadCombine_4consecutive_rev_mixsize1(ptr %p) {
 ;
 ; BE-LABEL: @loadCombine_4consecutive_rev_mixsize1(
 ; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
-; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
 ; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 2
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P2]], align 1
-; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P3]], align 1
-; BE-NEXT:    [[E1:%.*]] = zext i16 [[L1]] to i32
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
-; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
+; BE-NEXT:    [[L2:%.*]] = load i16, ptr [[P2]], align 1
+; BE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L2]])
+; BE-NEXT:    [[E2:%.*]] = zext i16 [[TMP1]] to i32
 ; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 16
-; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 24
-; BE-NEXT:    [[O1:%.*]] = or i32 [[S3]], [[S2]]
-; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[E1]]
+; BE-NEXT:    [[E1:%.*]] = zext i16 [[L1]] to i32
+; BE-NEXT:    [[O2:%.*]] = or i32 [[S2]], [[E1]]
 ; BE-NEXT:    ret i32 [[O2]]
 ;
   %p2 = getelementptr i8, ptr %p, i32 2
@@ -1800,16 +1517,12 @@ define i32 @loadCombine_4consecutive_rev_mixsize1(ptr %p) {
 define i32 @loadCombine_4consecutive_rev_mixsize1_BE(ptr %p) {
 ; LE-LABEL: @loadCombine_4consecutive_rev_mixsize1_BE(
 ; LE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
-; LE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
 ; LE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 2
-; LE-NEXT:    [[L2:%.*]] = load i8, ptr [[P2]], align 1
-; LE-NEXT:    [[L3:%.*]] = load i8, ptr [[P3]], align 1
+; LE-NEXT:    [[L2:%.*]] = load i16, ptr [[P2]], align 1
+; LE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L2]])
+; LE-NEXT:    [[O1:%.*]] = zext i16 [[TMP1]] to i32
 ; LE-NEXT:    [[E1:%.*]] = zext i16 [[L1]] to i32
-; LE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
-; LE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
 ; LE-NEXT:    [[S1:%.*]] = shl i32 [[E1]], 16
-; LE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
-; LE-NEXT:    [[O1:%.*]] = or i32 [[E3]], [[S2]]
 ; LE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S1]]
 ; LE-NEXT:    ret i32 [[O2]]
 ;
@@ -1841,17 +1554,13 @@ define i32 @loadCombine_4consecutive_mixsize2(ptr %p) {
 ; LE-NEXT:    ret i32 [[L1]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_mixsize2(
-; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
+; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
+; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
+; BE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
+; BE-NEXT:    [[O1:%.*]] = zext i16 [[TMP1]] to i32
 ; BE-NEXT:    [[L3:%.*]] = load i16, ptr [[P2]], align 2
-; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
 ; BE-NEXT:    [[E3:%.*]] = zext i16 [[L3]] to i32
-; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
 ; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
-; BE-NEXT:    [[O1:%.*]] = or i32 [[E1]], [[S2]]
 ; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
 ; BE-NEXT:    ret i32 [[O2]]
 ;
@@ -2127,21 +1836,17 @@ define i64 @loadCombine_8consecutive_mixsize(ptr %p) {
 ; LE-NEXT:    ret i64 [[L1]]
 ;
 ; BE-LABEL: @loadCombine_8consecutive_mixsize(
-; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i64 1
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i64 2
+; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i64 2
 ; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i64 4
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
+; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
+; BE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
+; BE-NEXT:    [[O1:%.*]] = zext i16 [[TMP1]] to i64
 ; BE-NEXT:    [[L3:%.*]] = load i16, ptr [[P2]], align 2
 ; BE-NEXT:    [[L4:%.*]] = load i32, ptr [[P3]], align 4
-; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i64
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i64
 ; BE-NEXT:    [[E3:%.*]] = zext i16 [[L3]] to i64
 ; BE-NEXT:    [[E4:%.*]] = zext i32 [[L4]] to i64
-; BE-NEXT:    [[S2:%.*]] = shl i64 [[E2]], 8
 ; BE-NEXT:    [[S3:%.*]] = shl i64 [[E3]], 16
 ; BE-NEXT:    [[S4:%.*]] = shl i64 [[E4]], 32
-; BE-NEXT:    [[O1:%.*]] = or i64 [[E1]], [[S2]]
 ; BE-NEXT:    [[O2:%.*]] = or i64 [[O1]], [[S3]]
 ; BE-NEXT:    [[O3:%.*]] = or i64 [[O2]], [[S4]]
 ; BE-NEXT:    ret i64 [[O3]]
@@ -2175,23 +1880,8 @@ define i32 @loadCombine_4consecutive_lower_index_comes_before(ptr %p) {
 ; LE-NEXT:    ret i32 [[L1]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_lower_index_comes_before(
-; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
-; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
-; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
-; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
-; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
-; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
-; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
-; BE-NEXT:    [[O1:%.*]] = or i32 [[E1]], [[S2]]
-; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
-; BE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[S4]]
+; BE-NEXT:    [[L1:%.*]] = load i32, ptr [[P:%.*]], align 1
+; BE-NEXT:    [[O3:%.*]] = call i32 @llvm.bswap.i32(i32 [[L1]])
 ; BE-NEXT:    ret i32 [[O3]]
 ;
   %p1 = getelementptr i8, ptr %p, i32 1
@@ -2226,13 +1916,9 @@ define i16 @loadCombine_2consecutive_badinsert(ptr %p) {
 ;
 ; BE-LABEL: @loadCombine_2consecutive_badinsert(
 ; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
+; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
+; BE-NEXT:    [[O1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
 ; BE-NEXT:    store i8 0, ptr [[P1]], align 1
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i16
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i16
-; BE-NEXT:    [[S2:%.*]] = shl i16 [[E2]], 8
-; BE-NEXT:    [[O1:%.*]] = or i16 [[E1]], [[S2]]
 ; BE-NEXT:    ret i16 [[O1]]
 ;
   %p1 = getelementptr i8, ptr %p, i32 1
@@ -2255,23 +1941,9 @@ define i32 @loadCombine_4consecutive_badinsert(ptr %p) {
 ;
 ; BE-LABEL: @loadCombine_4consecutive_badinsert(
 ; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
-; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
-; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
+; BE-NEXT:    [[L1:%.*]] = load i32, ptr [[P]], align 1
+; BE-NEXT:    [[O3:%.*]] = call i32 @llvm.bswap.i32(i32 [[L1]])
 ; BE-NEXT:    store i8 0, ptr [[P1]], align 1
-; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
-; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
-; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
-; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
-; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
-; BE-NEXT:    [[O1:%.*]] = or i32 [[E1]], [[S2]]
-; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
-; BE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[S4]]
 ; BE-NEXT:    ret i32 [[O3]]
 ;
   %p1 = getelementptr i8, ptr %p, i32 1
@@ -2316,22 +1988,18 @@ define i32 @loadCombine_4consecutive_badinsert2(ptr %p) {
 ; LE-NEXT:    ret i32 [[O3]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_badinsert2(
-; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
+; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
 ; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
+; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
+; BE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
+; BE-NEXT:    [[O1:%.*]] = zext i16 [[TMP1]] to i32
 ; BE-NEXT:    store i8 0, ptr [[P3]], align 1
 ; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
 ; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
 ; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
 ; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
 ; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
 ; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
-; BE-NEXT:    [[O1:%.*]] = or i32 [[E1]], [[S2]]
 ; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
 ; BE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[S4]]
 ; BE-NEXT:    ret i32 [[O3]]
@@ -2367,24 +2035,9 @@ define i32 @loadCombine_4consecutive_badinsert3(ptr %p) {
 ; LE-NEXT:    ret i32 [[L1]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_badinsert3(
-; BE-NEXT:    [[P4:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 4
-; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P4]], align 1
-; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
-; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P3]], align 1
-; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
-; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P2]], align 1
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
-; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
-; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P]], i32 1
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P1]], align 1
-; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
-; BE-NEXT:    [[O1:%.*]] = or i32 [[E1]], [[S2]]
-; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
-; BE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[S4]]
+; BE-NEXT:    [[TMP1:%.*]] = getelementptr i8, ptr [[P:%.*]], i64 1
+; BE-NEXT:    [[L1:%.*]] = load i32, ptr [[TMP1]], align 1
+; BE-NEXT:    [[O3:%.*]] = call i32 @llvm.bswap.i32(i32 [[L1]])
 ; BE-NEXT:    ret i32 [[O3]]
 ;
   %p4 = getelementptr i8, ptr %p, i32 4
@@ -2434,23 +2087,8 @@ define i32 @loadCombine_4consecutive_badinsert4(ptr %p) {
 ; BE-NEXT:    [[CMP:%.*]] = icmp eq i8 [[C1]], 0
 ; BE-NEXT:    br i1 [[CMP]], label [[END:%.*]], label [[BB2:%.*]]
 ; BE:       bb2:
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P1]], align 1
-; BE-NEXT:    [[C2:%.*]] = zext i8 [[L1]] to i32
-; BE-NEXT:    [[P4:%.*]] = getelementptr i8, ptr [[P]], i64 4
-; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P4]], align 1
-; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; BE-NEXT:    [[S4:%.*]] = shl nuw i32 [[E4]], 24
-; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i64 3
-; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P3]], align 1
-; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
-; BE-NEXT:    [[S3:%.*]] = shl nuw nsw i32 [[E3]], 16
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i64 2
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P2]], align 1
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
-; BE-NEXT:    [[S2:%.*]] = shl nuw nsw i32 [[E2]], 8
-; BE-NEXT:    [[O1:%.*]] = or i32 [[S2]], [[C2]]
-; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
-; BE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[S4]]
+; BE-NEXT:    [[L1:%.*]] = load i32, ptr [[P1]], align 1
+; BE-NEXT:    [[O3:%.*]] = call i32 @llvm.bswap.i32(i32 [[L1]])
 ; BE-NEXT:    br label [[END]]
 ; BE:       end:
 ; BE-NEXT:    [[COND:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[O3]], [[BB2]] ]
@@ -2505,22 +2143,18 @@ define i32 @loadCombine_4consecutive_badinsert5(ptr %p) {
 ; LE-NEXT:    ret i32 [[O3]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_badinsert5(
-; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
+; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
 ; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
 ; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
 ; BE-NEXT:    store i8 0, ptr [[P2]], align 1
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
+; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
+; BE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
+; BE-NEXT:    [[O1:%.*]] = zext i16 [[TMP1]] to i32
 ; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
-; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
 ; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
 ; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
 ; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
 ; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
-; BE-NEXT:    [[O1:%.*]] = or i32 [[E1]], [[S2]]
 ; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
 ; BE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[S4]]
 ; BE-NEXT:    ret i32 [[O3]]
@@ -2574,16 +2208,13 @@ define i32 @loadCombine_4consecutive_badinsert6(ptr %p) {
 ; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
 ; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
 ; BE-NEXT:    store i8 0, ptr [[P3]], align 1
-; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
-; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
+; BE-NEXT:    [[L3:%.*]] = load i16, ptr [[P2]], align 1
+; BE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L3]])
+; BE-NEXT:    [[TMP2:%.*]] = zext i16 [[TMP1]] to i32
+; BE-NEXT:    [[O1:%.*]] = shl i32 [[TMP2]], 16
 ; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
 ; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
-; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
-; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
 ; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
-; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
-; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
-; BE-NEXT:    [[O1:%.*]] = or i32 [[S3]], [[S4]]
 ; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S2]]
 ; BE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[E1]]
 ; BE-NEXT:    ret i32 [[O3]]
@@ -2698,23 +2329,8 @@ define i1 @loadCombine_4consecutive_rev_icmp0(ptr %p) {
 ; LE-NEXT:    ret i1 [[C]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_rev_icmp0(
-; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
-; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
-; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
-; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
-; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
-; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
-; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
-; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
-; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
-; BE-NEXT:    [[O1:%.*]] = or i32 [[S4]], [[S3]]
-; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S2]]
-; BE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[E1]]
+; BE-NEXT:    [[L1:%.*]] = load i32, ptr [[P:%.*]], align 1
+; BE-NEXT:    [[O3:%.*]] = call i32 @llvm.bswap.i32(i32 [[L1]])
 ; BE-NEXT:    [[C:%.*]] = icmp eq i32 [[O3]], 0
 ; BE-NEXT:    ret i1 [[C]]
 ;
diff --git a/llvm/test/Transforms/AggressiveInstCombine/RISCV/or-load.ll b/llvm/test/Transforms/AggressiveInstCombine/RISCV/or-load.ll
index 352abec985e05..767286f0d3e45 100644
--- a/llvm/test/Transforms/AggressiveInstCombine/RISCV/or-load.ll
+++ b/llvm/test/Transforms/AggressiveInstCombine/RISCV/or-load.ll
@@ -3,6 +3,7 @@
 ; RUN: opt < %s -passes=aggressive-instcombine -S -mtriple riscv64be -mattr=+unaligned-scalar-mem | FileCheck %s --check-prefixes=ALL,BE,RV64BE
 ; RUN: opt < %s -passes=aggressive-instcombine -S -mtriple riscv32 -mattr=+unaligned-scalar-mem | FileCheck %s --check-prefixes=ALL,LE,RV32LE
 ; RUN: opt < %s -passes=aggressive-instcombine -S -mtriple riscv32be -mattr=+unaligned-scalar-mem | FileCheck %s --check-prefixes=ALL,BE,RV32BE
+; RUN: opt < %s -passes=aggressive-instcombine -S -mtriple riscv64 -mattr=+unaligned-scalar-mem,+zbb | FileCheck %s --check-prefixes=ALL,ZBB
 
 define i16 @loadCombine_2consecutive(ptr %p) {
 ; LE-LABEL: @loadCombine_2consecutive(
@@ -18,6 +19,10 @@ define i16 @loadCombine_2consecutive(ptr %p) {
 ; BE-NEXT:    [[S2:%.*]] = shl i16 [[E2]], 8
 ; BE-NEXT:    [[O1:%.*]] = or i16 [[E1]], [[S2]]
 ; BE-NEXT:    ret i16 [[O1]]
+;
+; ZBB-LABEL: @loadCombine_2consecutive(
+; ZBB-NEXT:    [[L1:%.*]] = load i16, ptr [[P:%.*]], align 1
+; ZBB-NEXT:    ret i16 [[L1]]
 ;
   %p1 = getelementptr i8, ptr %p, i32 1
   %l1 = load i8, ptr %p
@@ -43,6 +48,11 @@ define i16 @loadCombine_2consecutive_BE(ptr %p) {
 ; BE-LABEL: @loadCombine_2consecutive_BE(
 ; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P:%.*]], align 1
 ; BE-NEXT:    ret i16 [[L1]]
+;
+; ZBB-LABEL: @loadCombine_2consecutive_BE(
+; ZBB-NEXT:    [[L1:%.*]] = load i16, ptr [[P:%.*]], align 1
+; ZBB-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
+; ZBB-NEXT:    ret i16 [[TMP1]]
 ;
   %p1 = getelementptr i8, ptr %p, i32 1
   %l1 = load i8, ptr %p
@@ -78,6 +88,10 @@ define i32 @loadCombine_4consecutive(ptr %p) {
 ; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
 ; BE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[S4]]
 ; BE-NEXT:    ret i32 [[O3]]
+;
+; ZBB-LABEL: @loadCombine_4consecutive(
+; ZBB-NEXT:    [[L1:%.*]] = load i32, ptr [[P:%.*]], align 1
+; ZBB-NEXT:    ret i32 [[L1]]
 ;
   %p1 = getelementptr i8, ptr %p, i32 1
   %p2 = getelementptr i8, ptr %p, i32 2
@@ -126,6 +140,11 @@ define i32 @loadCombine_4consecutive_BE(ptr %p) {
 ; BE-LABEL: @loadCombine_4consecutive_BE(
 ; BE-NEXT:    [[L1:%.*]] = load i32, ptr [[P:%.*]], align 1
 ; BE-NEXT:    ret i32 [[L1]]
+;
+; ZBB-LABEL: @loadCombine_4consecutive_BE(
+; ZBB-NEXT:    [[L1:%.*]] = load i32, ptr [[P:%.*]], align 1
+; ZBB-NEXT:    [[TMP1:%.*]] = call i32 @llvm.bswap.i32(i32 [[L1]])
+; ZBB-NEXT:    ret i32 [[TMP1]]
 ;
   %p1 = getelementptr i8, ptr %p, i32 1
   %p2 = getelementptr i8, ptr %p, i32 2
@@ -205,6 +224,21 @@ define i128 @loadCombine_i128(ptr %p) {
 ; RV32LE-NEXT:    [[O2:%.*]] = or i128 [[O1]], [[S3]]
 ; RV32LE-NEXT:    [[O3:%.*]] = or i128 [[O2]], [[S4]]
 ; RV32LE-NEXT:    ret i128 [[O3]]
+;
+; ZBB-LABEL: @loadCombine_i128(
+; ZBB-NEXT:    [[P2:%.*]] = getelementptr i32, ptr [[P:%.*]], i32 2
+; ZBB-NEXT:    [[P3:%.*]] = getelementptr i32, ptr [[P]], i32 3
+; ZBB-NEXT:    [[L1:%.*]] = load i64, ptr [[P]], align 4
+; ZBB-NEXT:    [[TMP1:%.*]] = zext i64 [[L1]] to i128
+; ZBB-NEXT:    [[L3:%.*]] = load i32, ptr [[P2]], align 4
+; ZBB-NEXT:    [[L4:%.*]] = load i32, ptr [[P3]], align 4
+; ZBB-NEXT:    [[E3:%.*]] = zext i32 [[L3]] to i128
+; ZBB-NEXT:    [[E4:%.*]] = zext i32 [[L4]] to i128
+; ZBB-NEXT:    [[S3:%.*]] = shl i128 [[E3]], 64
+; ZBB-NEXT:    [[S4:%.*]] = shl i128 [[E4]], 96
+; ZBB-NEXT:    [[O2:%.*]] = or i128 [[TMP1]], [[S3]]
+; ZBB-NEXT:    [[O3:%.*]] = or i128 [[O2]], [[S4]]
+; ZBB-NEXT:    ret i128 [[O3]]
 ;
   %p1 = getelementptr i32, ptr %p, i32 1
   %p2 = getelementptr i32, ptr %p, i32 2
@@ -284,6 +318,26 @@ define i128 @loadCombine_i128_BE(ptr %p) {
 ; RV32BE-NEXT:    [[O2:%.*]] = or i128 [[O1]], [[S3]]
 ; RV32BE-NEXT:    [[O3:%.*]] = or i128 [[O2]], [[E4]]
 ; RV32BE-NEXT:    ret i128 [[O3]]
+;
+; ZBB-LABEL: @loadCombine_i128_BE(
+; ZBB-NEXT:    [[P1:%.*]] = getelementptr i32, ptr [[P:%.*]], i32 1
+; ZBB-NEXT:    [[P2:%.*]] = getelementptr i32, ptr [[P]], i32 2
+; ZBB-NEXT:    [[P3:%.*]] = getelementptr i32, ptr [[P]], i32 3
+; ZBB-NEXT:    [[L1:%.*]] = load i32, ptr [[P]], align 4
+; ZBB-NEXT:    [[L2:%.*]] = load i32, ptr [[P1]], align 4
+; ZBB-NEXT:    [[L3:%.*]] = load i32, ptr [[P2]], align 4
+; ZBB-NEXT:    [[L4:%.*]] = load i32, ptr [[P3]], align 4
+; ZBB-NEXT:    [[E1:%.*]] = zext i32 [[L1]] to i128
+; ZBB-NEXT:    [[E2:%.*]] = zext i32 [[L2]] to i128
+; ZBB-NEXT:    [[E3:%.*]] = zext i32 [[L3]] to i128
+; ZBB-NEXT:    [[E4:%.*]] = zext i32 [[L4]] to i128
+; ZBB-NEXT:    [[S1:%.*]] = shl i128 [[E1]], 96
+; ZBB-NEXT:    [[S2:%.*]] = shl i128 [[E2]], 64
+; ZBB-NEXT:    [[S3:%.*]] = shl i128 [[E3]], 32
+; ZBB-NEXT:    [[O1:%.*]] = or i128 [[S1]], [[S2]]
+; ZBB-NEXT:    [[O2:%.*]] = or i128 [[O1]], [[S3]]
+; ZBB-NEXT:    [[O3:%.*]] = or i128 [[O2]], [[E4]]
+; ZBB-NEXT:    ret i128 [[O3]]
 ;
   %p1 = getelementptr i32, ptr %p, i32 1
   %p2 = getelementptr i32, ptr %p, i32 2
@@ -347,6 +401,10 @@ define i64 @loadCombine_i64(ptr %p) {
 ; RV32LE-NEXT:    [[O2:%.*]] = or i64 [[TMP1]], [[S3]]
 ; RV32LE-NEXT:    [[O3:%.*]] = or i64 [[O2]], [[S4]]
 ; RV32LE-NEXT:    ret i64 [[O3]]
+;
+; ZBB-LABEL: @loadCombine_i64(
+; ZBB-NEXT:    [[L1:%.*]] = load i64, ptr [[P:%.*]], align 2
+; ZBB-NEXT:    ret i64 [[L1]]
 ;
   %p1 = getelementptr i16, ptr %p, i32 1
   %p2 = getelementptr i16, ptr %p, i32 2
@@ -410,6 +468,26 @@ define i64 @loadCombine_i64_BE(ptr %p) {
 ; RV32BE-NEXT:    [[O2:%.*]] = or i64 [[TMP2]], [[S3]]
 ; RV32BE-NEXT:    [[O3:%.*]] = or i64 [[O2]], [[E4]]
 ; RV32BE-NEXT:    ret i64 [[O3]]
+;
+; ZBB-LABEL: @loadCombine_i64_BE(
+; ZBB-NEXT:    [[P1:%.*]] = getelementptr i16, ptr [[P:%.*]], i32 1
+; ZBB-NEXT:    [[P2:%.*]] = getelementptr i16, ptr [[P]], i32 2
+; ZBB-NEXT:    [[P3:%.*]] = getelementptr i16, ptr [[P]], i32 3
+; ZBB-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 2
+; ZBB-NEXT:    [[L2:%.*]] = load i16, ptr [[P1]], align 2
+; ZBB-NEXT:    [[L3:%.*]] = load i16, ptr [[P2]], align 2
+; ZBB-NEXT:    [[L4:%.*]] = load i16, ptr [[P3]], align 2
+; ZBB-NEXT:    [[E1:%.*]] = zext i16 [[L1]] to i64
+; ZBB-NEXT:    [[E2:%.*]] = zext i16 [[L2]] to i64
+; ZBB-NEXT:    [[E3:%.*]] = zext i16 [[L3]] to i64
+; ZBB-NEXT:    [[E4:%.*]] = zext i16 [[L4]] to i64
+; ZBB-NEXT:    [[S1:%.*]] = shl i64 [[E1]], 48
+; ZBB-NEXT:    [[S2:%.*]] = shl i64 [[E2]], 32
+; ZBB-NEXT:    [[S3:%.*]] = shl i64 [[E3]], 16
+; ZBB-NEXT:    [[O1:%.*]] = or i64 [[S1]], [[S2]]
+; ZBB-NEXT:    [[O2:%.*]] = or i64 [[O1]], [[S3]]
+; ZBB-NEXT:    [[O3:%.*]] = or i64 [[O2]], [[E4]]
+; ZBB-NEXT:    ret i64 [[O3]]
 ;
   %p1 = getelementptr i16, ptr %p, i32 1
   %p2 = getelementptr i16, ptr %p, i32 2
@@ -460,6 +538,16 @@ define i32 @loadCombine_3consecutive(ptr %p) {
 ; BE-NEXT:    [[O1:%.*]] = or i32 [[E1]], [[S2]]
 ; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
 ; BE-NEXT:    ret i32 [[O2]]
+;
+; ZBB-LABEL: @loadCombine_3consecutive(
+; ZBB-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
+; ZBB-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
+; ZBB-NEXT:    [[TMP1:%.*]] = zext i16 [[L1]] to i32
+; ZBB-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
+; ZBB-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
+; ZBB-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
+; ZBB-NEXT:    [[O2:%.*]] = or i32 [[TMP1]], [[S3]]
+; ZBB-NEXT:    ret i32 [[O2]]
 ;
   %p1 = getelementptr i8, ptr %p, i32 1
   %p2 = getelementptr i8, ptr %p, i32 2
diff --git a/llvm/test/Transforms/AggressiveInstCombine/X86/or-load.ll b/llvm/test/Transforms/AggressiveInstCombine/X86/or-load.ll
index d8ab24c7b7eb1..b22d6e46054b6 100644
--- a/llvm/test/Transforms/AggressiveInstCombine/X86/or-load.ll
+++ b/llvm/test/Transforms/AggressiveInstCombine/X86/or-load.ll
@@ -9,13 +9,8 @@ define i16 @loadCombine_2consecutive(ptr %p) {
 ; LE-NEXT:    ret i16 [[L1]]
 ;
 ; BE-LABEL: @loadCombine_2consecutive(
-; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
-; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i16
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i16
-; BE-NEXT:    [[S2:%.*]] = shl i16 [[E2]], 8
-; BE-NEXT:    [[O1:%.*]] = or i16 [[E1]], [[S2]]
+; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P:%.*]], align 1
+; BE-NEXT:    [[O1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
 ; BE-NEXT:    ret i16 [[O1]]
 ;
   %p1 = getelementptr i8, ptr %p, i32 1
@@ -30,13 +25,8 @@ define i16 @loadCombine_2consecutive(ptr %p) {
 
 define i16 @loadCombine_2consecutive_BE(ptr %p) {
 ; LE-LABEL: @loadCombine_2consecutive_BE(
-; LE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; LE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; LE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
-; LE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i16
-; LE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i16
-; LE-NEXT:    [[S1:%.*]] = shl i16 [[E1]], 8
-; LE-NEXT:    [[O1:%.*]] = or i16 [[S1]], [[E2]]
+; LE-NEXT:    [[L1:%.*]] = load i16, ptr [[P:%.*]], align 1
+; LE-NEXT:    [[O1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
 ; LE-NEXT:    ret i16 [[O1]]
 ;
 ; BE-LABEL: @loadCombine_2consecutive_BE(
@@ -59,23 +49,8 @@ define i32 @loadCombine_4consecutive(ptr %p) {
 ; LE-NEXT:    ret i32 [[L1]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive(
-; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
-; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
-; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
-; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
-; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
-; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
-; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
-; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
-; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
-; BE-NEXT:    [[O1:%.*]] = or i32 [[E1]], [[S2]]
-; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
-; BE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[S4]]
+; BE-NEXT:    [[L1:%.*]] = load i32, ptr [[P:%.*]], align 1
+; BE-NEXT:    [[O3:%.*]] = call i32 @llvm.bswap.i32(i32 [[L1]])
 ; BE-NEXT:    ret i32 [[O3]]
 ;
   %p1 = getelementptr i8, ptr %p, i32 1
@@ -107,23 +82,8 @@ define i32 @loadCombine_4consecutive_commuted(ptr %p) {
 ; LE-NEXT:    ret i32 [[O3]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_commuted(
-; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
-; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
-; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
-; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
-; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
-; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
-; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
-; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
-; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
-; BE-NEXT:    [[O1:%.*]] = or i32 [[S2]], [[S3]]
-; BE-NEXT:    [[O2:%.*]] = or i32 [[S4]], [[O1]]
-; BE-NEXT:    [[O3:%.*]] = or i32 [[E1]], [[O2]]
+; BE-NEXT:    [[L1:%.*]] = load i32, ptr [[P:%.*]], align 1
+; BE-NEXT:    [[O3:%.*]] = call i32 @llvm.bswap.i32(i32 [[L1]])
 ; BE-NEXT:    ret i32 [[O3]]
 ;
   %p1 = getelementptr i8, ptr %p, i32 1
@@ -158,24 +118,11 @@ define i32 @loadCombine_4consecutive_multiuse(ptr %p) {
 ; LE-NEXT:    ret i32 [[O3]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_multiuse(
-; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
-; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
-; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
+; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 3
+; BE-NEXT:    [[L1:%.*]] = load i32, ptr [[P]], align 1
+; BE-NEXT:    [[O3:%.*]] = call i32 @llvm.bswap.i32(i32 [[L1]])
 ; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
 ; BE-NEXT:    call void @use(i8 [[L4]])
-; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
-; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
-; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
-; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
-; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
-; BE-NEXT:    [[O1:%.*]] = or i32 [[E1]], [[S2]]
-; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
-; BE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[S4]]
 ; BE-NEXT:    ret i32 [[O3]]
 ;
   %p1 = getelementptr i8, ptr %p, i32 1
@@ -204,23 +151,8 @@ define i32 @loadCombine_4consecutive_multiuse(ptr %p) {
 
 define i32 @loadCombine_4consecutive_BE(ptr %p) {
 ; LE-LABEL: @loadCombine_4consecutive_BE(
-; LE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; LE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
-; LE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; LE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; LE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
-; LE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
-; LE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
-; LE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
-; LE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
-; LE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
-; LE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; LE-NEXT:    [[S1:%.*]] = shl i32 [[E1]], 24
-; LE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 16
-; LE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 8
-; LE-NEXT:    [[O1:%.*]] = or i32 [[S1]], [[S2]]
-; LE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
-; LE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[E4]]
+; LE-NEXT:    [[L1:%.*]] = load i32, ptr [[P:%.*]], align 1
+; LE-NEXT:    [[O3:%.*]] = call i32 @llvm.bswap.i32(i32 [[L1]])
 ; LE-NEXT:    ret i32 [[O3]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_BE(
@@ -257,24 +189,9 @@ define i32 @loadCombine_4consecutive_alias(ptr %p) {
 ; LE-NEXT:    ret i32 [[L1]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_alias(
-; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
-; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
+; BE-NEXT:    [[L1:%.*]] = load i32, ptr [[P:%.*]], align 1
+; BE-NEXT:    [[O3:%.*]] = call i32 @llvm.bswap.i32(i32 [[L1]])
 ; BE-NEXT:    store i8 10, ptr [[P]], align 1
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
-; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
-; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
-; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
-; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
-; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
-; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
-; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
-; BE-NEXT:    [[O1:%.*]] = or i32 [[E1]], [[S2]]
-; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
-; BE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[S4]]
 ; BE-NEXT:    ret i32 [[O3]]
 ;
   %p1 = getelementptr i8, ptr %p, i32 1
@@ -303,24 +220,9 @@ define i32 @loadCombine_4consecutive_alias(ptr %p) {
 
 define i32 @loadCombine_4consecutive_alias_BE(ptr %p) {
 ; LE-LABEL: @loadCombine_4consecutive_alias_BE(
-; LE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; LE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
-; LE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; LE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
+; LE-NEXT:    [[L1:%.*]] = load i32, ptr [[P:%.*]], align 1
+; LE-NEXT:    [[O3:%.*]] = call i32 @llvm.bswap.i32(i32 [[L1]])
 ; LE-NEXT:    store i8 10, ptr [[P]], align 1
-; LE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
-; LE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
-; LE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
-; LE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
-; LE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
-; LE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
-; LE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; LE-NEXT:    [[S1:%.*]] = shl i32 [[E1]], 24
-; LE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 16
-; LE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 8
-; LE-NEXT:    [[O1:%.*]] = or i32 [[S1]], [[S2]]
-; LE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
-; LE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[E4]]
 ; LE-NEXT:    ret i32 [[O3]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_alias_BE(
@@ -370,22 +272,18 @@ define i32 @loadCombine_4consecutive_alias2(ptr %p, ptr %pstr) {
 ; LE-NEXT:    ret i32 [[O3]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_alias2(
-; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
+; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
 ; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
+; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
+; BE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
+; BE-NEXT:    [[O1:%.*]] = zext i16 [[TMP1]] to i32
 ; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
 ; BE-NEXT:    store i8 10, ptr [[PSTR:%.*]], align 1
 ; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
-; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
 ; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
 ; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
 ; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
 ; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
-; BE-NEXT:    [[O1:%.*]] = or i32 [[E1]], [[S2]]
 ; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
 ; BE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[S4]]
 ; BE-NEXT:    ret i32 [[O3]]
@@ -416,22 +314,18 @@ define i32 @loadCombine_4consecutive_alias2(ptr %p, ptr %pstr) {
 
 define i32 @loadCombine_4consecutive_alias2_BE(ptr %p, ptr %pstr) {
 ; LE-LABEL: @loadCombine_4consecutive_alias2_BE(
-; LE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; LE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
+; LE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
 ; LE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; LE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; LE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
+; LE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
+; LE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
+; LE-NEXT:    [[TMP2:%.*]] = zext i16 [[TMP1]] to i32
+; LE-NEXT:    [[O1:%.*]] = shl i32 [[TMP2]], 16
 ; LE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
 ; LE-NEXT:    store i8 10, ptr [[PSTR:%.*]], align 1
 ; LE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
-; LE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
-; LE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
 ; LE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
 ; LE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; LE-NEXT:    [[S1:%.*]] = shl i32 [[E1]], 24
-; LE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 16
 ; LE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 8
-; LE-NEXT:    [[O1:%.*]] = or i32 [[S1]], [[S2]]
 ; LE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
 ; LE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[E4]]
 ; LE-NEXT:    ret i32 [[O3]]
@@ -495,23 +389,19 @@ define i32 @loadCombine_4consecutive_alias3(ptr %p) {
 ; LE-NEXT:    ret i32 [[O3]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_alias3(
-; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
+; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
 ; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
+; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
+; BE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
+; BE-NEXT:    [[O1:%.*]] = zext i16 [[TMP1]] to i32
 ; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
 ; BE-NEXT:    store i8 10, ptr [[P3]], align 1
 ; BE-NEXT:    store i8 5, ptr [[P]], align 1
 ; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
-; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
 ; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
 ; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
 ; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
 ; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
-; BE-NEXT:    [[O1:%.*]] = or i32 [[E1]], [[S2]]
 ; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
 ; BE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[S4]]
 ; BE-NEXT:    ret i32 [[O3]]
@@ -543,23 +433,19 @@ define i32 @loadCombine_4consecutive_alias3(ptr %p) {
 
 define i32 @loadCombine_4consecutive_alias3_BE(ptr %p) {
 ; LE-LABEL: @loadCombine_4consecutive_alias3_BE(
-; LE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; LE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
+; LE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
 ; LE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; LE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; LE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
+; LE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
+; LE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
+; LE-NEXT:    [[TMP2:%.*]] = zext i16 [[TMP1]] to i32
+; LE-NEXT:    [[O1:%.*]] = shl i32 [[TMP2]], 16
 ; LE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
 ; LE-NEXT:    store i8 10, ptr [[P3]], align 1
 ; LE-NEXT:    store i8 5, ptr [[P]], align 1
 ; LE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
-; LE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
-; LE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
 ; LE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
 ; LE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; LE-NEXT:    [[S1:%.*]] = shl i32 [[E1]], 24
-; LE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 16
 ; LE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 8
-; LE-NEXT:    [[O1:%.*]] = or i32 [[S1]], [[S2]]
 ; LE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
 ; LE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[E4]]
 ; LE-NEXT:    ret i32 [[O3]]
@@ -840,21 +726,17 @@ define i32 @loadCombine_4consecutive_hasOneUse4(ptr %p) {
 ; LE-NEXT:    ret i32 [[O3]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_hasOneUse4(
-; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
+; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
 ; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
+; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
+; BE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
+; BE-NEXT:    [[O1:%.*]] = zext i16 [[TMP1]] to i32
 ; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
 ; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
-; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
 ; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
 ; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
 ; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
 ; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
-; BE-NEXT:    [[O1:%.*]] = or i32 [[E1]], [[S2]]
 ; BE-NEXT:    call void @use(i32 [[O1]])
 ; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
 ; BE-NEXT:    call void @use(i32 [[O2]])
@@ -893,23 +775,8 @@ define i32 @fold_i32_multiple_uses(ptr %input, ptr %output) {
 ; LE-NEXT:    ret i32 [[B0]]
 ;
 ; BE-LABEL: @fold_i32_multiple_uses(
-; BE-NEXT:    [[B0:%.*]] = load i8, ptr [[INPUT:%.*]], align 1
-; BE-NEXT:    [[PTR1:%.*]] = getelementptr inbounds i8, ptr [[INPUT]], i64 1
-; BE-NEXT:    [[B1:%.*]] = load i8, ptr [[PTR1]], align 1
-; BE-NEXT:    [[PTR2:%.*]] = getelementptr inbounds i8, ptr [[INPUT]], i64 2
-; BE-NEXT:    [[B2:%.*]] = load i8, ptr [[PTR2]], align 1
-; BE-NEXT:    [[PTR3:%.*]] = getelementptr inbounds i8, ptr [[INPUT]], i64 3
-; BE-NEXT:    [[B3:%.*]] = load i8, ptr [[PTR3]], align 1
-; BE-NEXT:    [[B0_32:%.*]] = zext i8 [[B0]] to i32
-; BE-NEXT:    [[B1_32:%.*]] = zext i8 [[B1]] to i32
-; BE-NEXT:    [[B1_SHIFT:%.*]] = shl i32 [[B1_32]], 8
-; BE-NEXT:    [[VAL01:%.*]] = or i32 [[B1_SHIFT]], [[B0_32]]
-; BE-NEXT:    [[B2_32:%.*]] = zext i8 [[B2]] to i32
-; BE-NEXT:    [[B2_SHIFT:%.*]] = shl i32 [[B2_32]], 16
-; BE-NEXT:    [[VAL012:%.*]] = or i32 [[VAL01]], [[B2_SHIFT]]
-; BE-NEXT:    [[B3_32:%.*]] = zext i8 [[B3]] to i32
-; BE-NEXT:    [[B3_SHIFT:%.*]] = shl i32 [[B3_32]], 24
-; BE-NEXT:    [[VAL:%.*]] = or i32 [[VAL012]], [[B3_SHIFT]]
+; BE-NEXT:    [[B0:%.*]] = load i32, ptr [[INPUT:%.*]], align 1
+; BE-NEXT:    [[VAL:%.*]] = call i32 @llvm.bswap.i32(i32 [[B0]])
 ; BE-NEXT:    store i32 [[VAL]], ptr [[OUTPUT:%.*]], align 4
 ; BE-NEXT:    ret i32 [[VAL]]
 ;
@@ -952,17 +819,13 @@ define i32 @loadCombine_parLoad1(ptr %p) {
 ; LE-NEXT:    ret i32 [[O2]]
 ;
 ; BE-LABEL: @loadCombine_parLoad1(
-; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
+; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
+; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
+; BE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
+; BE-NEXT:    [[O1:%.*]] = zext i16 [[TMP1]] to i32
 ; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
-; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
 ; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
-; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
 ; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
-; BE-NEXT:    [[O1:%.*]] = or i32 [[E1]], [[S2]]
 ; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
 ; BE-NEXT:    ret i32 [[O2]]
 ;
@@ -1295,43 +1158,8 @@ define i64 @load64_farLoads(ptr %ptr) {
 ;
 ; BE-LABEL: @load64_farLoads(
 ; BE-NEXT:  entry:
-; BE-NEXT:    [[TMP0:%.*]] = load i8, ptr [[PTR:%.*]], align 1
-; BE-NEXT:    [[CONV:%.*]] = zext i8 [[TMP0]] to i64
-; BE-NEXT:    [[ARRAYIDX1:%.*]] = getelementptr inbounds i8, ptr [[PTR]], i64 1
-; BE-NEXT:    [[TMP1:%.*]] = load i8, ptr [[ARRAYIDX1]], align 1
-; BE-NEXT:    [[CONV2:%.*]] = zext i8 [[TMP1]] to i64
-; BE-NEXT:    [[SHL:%.*]] = shl i64 [[CONV2]], 8
-; BE-NEXT:    [[OR:%.*]] = or i64 [[CONV]], [[SHL]]
-; BE-NEXT:    [[ARRAYIDX3:%.*]] = getelementptr inbounds i8, ptr [[PTR]], i64 2
-; BE-NEXT:    [[TMP2:%.*]] = load i8, ptr [[ARRAYIDX3]], align 1
-; BE-NEXT:    [[CONV4:%.*]] = zext i8 [[TMP2]] to i64
-; BE-NEXT:    [[SHL5:%.*]] = shl i64 [[CONV4]], 16
-; BE-NEXT:    [[OR6:%.*]] = or i64 [[OR]], [[SHL5]]
-; BE-NEXT:    [[ARRAYIDX7:%.*]] = getelementptr inbounds i8, ptr [[PTR]], i64 3
-; BE-NEXT:    [[TMP3:%.*]] = load i8, ptr [[ARRAYIDX7]], align 1
-; BE-NEXT:    [[CONV8:%.*]] = zext i8 [[TMP3]] to i64
-; BE-NEXT:    [[SHL9:%.*]] = shl i64 [[CONV8]], 24
-; BE-NEXT:    [[OR10:%.*]] = or i64 [[OR6]], [[SHL9]]
-; BE-NEXT:    [[ARRAYIDX11:%.*]] = getelementptr inbounds i8, ptr [[PTR]], i64 4
-; BE-NEXT:    [[TMP4:%.*]] = load i8, ptr [[ARRAYIDX11]], align 1
-; BE-NEXT:    [[CONV12:%.*]] = zext i8 [[TMP4]] to i64
-; BE-NEXT:    [[SHL13:%.*]] = shl i64 [[CONV12]], 32
-; BE-NEXT:    [[OR14:%.*]] = or i64 [[OR10]], [[SHL13]]
-; BE-NEXT:    [[ARRAYIDX15:%.*]] = getelementptr inbounds i8, ptr [[PTR]], i64 5
-; BE-NEXT:    [[TMP5:%.*]] = load i8, ptr [[ARRAYIDX15]], align 1
-; BE-NEXT:    [[CONV16:%.*]] = zext i8 [[TMP5]] to i64
-; BE-NEXT:    [[SHL17:%.*]] = shl i64 [[CONV16]], 40
-; BE-NEXT:    [[OR18:%.*]] = or i64 [[OR14]], [[SHL17]]
-; BE-NEXT:    [[ARRAYIDX19:%.*]] = getelementptr inbounds i8, ptr [[PTR]], i64 6
-; BE-NEXT:    [[TMP6:%.*]] = load i8, ptr [[ARRAYIDX19]], align 1
-; BE-NEXT:    [[CONV20:%.*]] = zext i8 [[TMP6]] to i64
-; BE-NEXT:    [[SHL21:%.*]] = shl i64 [[CONV20]], 48
-; BE-NEXT:    [[OR22:%.*]] = or i64 [[OR18]], [[SHL21]]
-; BE-NEXT:    [[ARRAYIDX23:%.*]] = getelementptr inbounds i8, ptr [[PTR]], i64 7
-; BE-NEXT:    [[TMP7:%.*]] = load i8, ptr [[ARRAYIDX23]], align 1
-; BE-NEXT:    [[CONV24:%.*]] = zext i8 [[TMP7]] to i64
-; BE-NEXT:    [[SHL25:%.*]] = shl i64 [[CONV24]], 56
-; BE-NEXT:    [[OR26:%.*]] = or i64 [[OR22]], [[SHL25]]
+; BE-NEXT:    [[TMP0:%.*]] = load i64, ptr [[PTR:%.*]], align 1
+; BE-NEXT:    [[OR26:%.*]] = call i64 @llvm.bswap.i64(i64 [[TMP0]])
 ; BE-NEXT:    ret i64 [[OR26]]
 ;
 entry:
@@ -1382,24 +1210,9 @@ define i32 @loadCombine_4consecutive_metadata(ptr %p, ptr %pstr) {
 ; LE-NEXT:    ret i32 [[L1]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_metadata(
-; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
-; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1, !alias.scope [[META0:![0-9]+]]
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1, !alias.scope [[META0]]
-; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1, !alias.scope [[META0]]
-; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1, !alias.scope [[META0]]
+; BE-NEXT:    [[L1:%.*]] = load i32, ptr [[P:%.*]], align 1, !alias.scope [[META0:![0-9]+]]
+; BE-NEXT:    [[O3:%.*]] = call i32 @llvm.bswap.i32(i32 [[L1]])
 ; BE-NEXT:    store i32 25, ptr [[PSTR:%.*]], align 4, !noalias [[META0]]
-; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
-; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
-; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
-; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
-; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
-; BE-NEXT:    [[O1:%.*]] = or i32 [[E1]], [[S2]]
-; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
-; BE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[S4]]
 ; BE-NEXT:    ret i32 [[O3]]
 ;
   %p1 = getelementptr i8, ptr %p, i32 1
@@ -1481,23 +1294,8 @@ define i32 @loadCombine_4consecutive_rev(ptr %p) {
 ; LE-NEXT:    ret i32 [[L1]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_rev(
-; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
-; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
-; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
-; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
-; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
-; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
-; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
-; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
-; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
-; BE-NEXT:    [[O1:%.*]] = or i32 [[S4]], [[S3]]
-; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S2]]
-; BE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[E1]]
+; BE-NEXT:    [[L1:%.*]] = load i32, ptr [[P:%.*]], align 1
+; BE-NEXT:    [[O3:%.*]] = call i32 @llvm.bswap.i32(i32 [[L1]])
 ; BE-NEXT:    ret i32 [[O3]]
 ;
   %p1 = getelementptr i8, ptr %p, i32 1
@@ -1529,43 +1327,8 @@ define i64 @loadCombine_8consecutive_rev(ptr %p) {
 ; LE-NEXT:    ret i64 [[L1]]
 ;
 ; BE-LABEL: @loadCombine_8consecutive_rev(
-; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
-; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; BE-NEXT:    [[P4:%.*]] = getelementptr i8, ptr [[P]], i32 4
-; BE-NEXT:    [[P5:%.*]] = getelementptr i8, ptr [[P]], i32 5
-; BE-NEXT:    [[P6:%.*]] = getelementptr i8, ptr [[P]], i32 6
-; BE-NEXT:    [[P7:%.*]] = getelementptr i8, ptr [[P]], i32 7
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
-; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
-; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
-; BE-NEXT:    [[L5:%.*]] = load i8, ptr [[P4]], align 1
-; BE-NEXT:    [[L6:%.*]] = load i8, ptr [[P5]], align 1
-; BE-NEXT:    [[L7:%.*]] = load i8, ptr [[P6]], align 1
-; BE-NEXT:    [[L8:%.*]] = load i8, ptr [[P7]], align 1
-; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i64
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i64
-; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i64
-; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i64
-; BE-NEXT:    [[E5:%.*]] = zext i8 [[L5]] to i64
-; BE-NEXT:    [[E6:%.*]] = zext i8 [[L6]] to i64
-; BE-NEXT:    [[E7:%.*]] = zext i8 [[L7]] to i64
-; BE-NEXT:    [[E8:%.*]] = zext i8 [[L8]] to i64
-; BE-NEXT:    [[S2:%.*]] = shl i64 [[E2]], 8
-; BE-NEXT:    [[S3:%.*]] = shl i64 [[E3]], 16
-; BE-NEXT:    [[S4:%.*]] = shl i64 [[E4]], 24
-; BE-NEXT:    [[S5:%.*]] = shl i64 [[E5]], 32
-; BE-NEXT:    [[S6:%.*]] = shl i64 [[E6]], 40
-; BE-NEXT:    [[S7:%.*]] = shl i64 [[E7]], 48
-; BE-NEXT:    [[S8:%.*]] = shl i64 [[E8]], 56
-; BE-NEXT:    [[O7:%.*]] = or i64 [[S8]], [[S7]]
-; BE-NEXT:    [[O6:%.*]] = or i64 [[O7]], [[S6]]
-; BE-NEXT:    [[O5:%.*]] = or i64 [[O6]], [[S5]]
-; BE-NEXT:    [[O4:%.*]] = or i64 [[O5]], [[S4]]
-; BE-NEXT:    [[O3:%.*]] = or i64 [[O4]], [[S3]]
-; BE-NEXT:    [[O2:%.*]] = or i64 [[O3]], [[S2]]
-; BE-NEXT:    [[O1:%.*]] = or i64 [[O2]], [[E1]]
+; BE-NEXT:    [[L1:%.*]] = load i64, ptr [[P:%.*]], align 1
+; BE-NEXT:    [[O1:%.*]] = call i64 @llvm.bswap.i64(i64 [[L1]])
 ; BE-NEXT:    ret i64 [[O1]]
 ;
   %p1 = getelementptr i8, ptr %p, i32 1
@@ -1613,43 +1376,8 @@ define i64 @loadCombine_8consecutive_rev(ptr %p) {
 
 define i64 @loadCombine_8consecutive_rev_BE(ptr %p) {
 ; LE-LABEL: @loadCombine_8consecutive_rev_BE(
-; LE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; LE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
-; LE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; LE-NEXT:    [[P4:%.*]] = getelementptr i8, ptr [[P]], i32 4
-; LE-NEXT:    [[P5:%.*]] = getelementptr i8, ptr [[P]], i32 5
-; LE-NEXT:    [[P6:%.*]] = getelementptr i8, ptr [[P]], i32 6
-; LE-NEXT:    [[P7:%.*]] = getelementptr i8, ptr [[P]], i32 7
-; LE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; LE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
-; LE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
-; LE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
-; LE-NEXT:    [[L5:%.*]] = load i8, ptr [[P4]], align 1
-; LE-NEXT:    [[L6:%.*]] = load i8, ptr [[P5]], align 1
-; LE-NEXT:    [[L7:%.*]] = load i8, ptr [[P6]], align 1
-; LE-NEXT:    [[L8:%.*]] = load i8, ptr [[P7]], align 1
-; LE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i64
-; LE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i64
-; LE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i64
-; LE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i64
-; LE-NEXT:    [[E5:%.*]] = zext i8 [[L5]] to i64
-; LE-NEXT:    [[E6:%.*]] = zext i8 [[L6]] to i64
-; LE-NEXT:    [[E7:%.*]] = zext i8 [[L7]] to i64
-; LE-NEXT:    [[E8:%.*]] = zext i8 [[L8]] to i64
-; LE-NEXT:    [[S1:%.*]] = shl i64 [[E1]], 56
-; LE-NEXT:    [[S2:%.*]] = shl i64 [[E2]], 48
-; LE-NEXT:    [[S3:%.*]] = shl i64 [[E3]], 40
-; LE-NEXT:    [[S4:%.*]] = shl i64 [[E4]], 32
-; LE-NEXT:    [[S5:%.*]] = shl i64 [[E5]], 24
-; LE-NEXT:    [[S6:%.*]] = shl i64 [[E6]], 16
-; LE-NEXT:    [[S7:%.*]] = shl i64 [[E7]], 8
-; LE-NEXT:    [[O7:%.*]] = or i64 [[E8]], [[S7]]
-; LE-NEXT:    [[O6:%.*]] = or i64 [[O7]], [[S6]]
-; LE-NEXT:    [[O5:%.*]] = or i64 [[O6]], [[S5]]
-; LE-NEXT:    [[O4:%.*]] = or i64 [[O5]], [[S4]]
-; LE-NEXT:    [[O3:%.*]] = or i64 [[O4]], [[S3]]
-; LE-NEXT:    [[O2:%.*]] = or i64 [[O3]], [[S2]]
-; LE-NEXT:    [[O1:%.*]] = or i64 [[O2]], [[S1]]
+; LE-NEXT:    [[L1:%.*]] = load i64, ptr [[P:%.*]], align 1
+; LE-NEXT:    [[O1:%.*]] = call i64 @llvm.bswap.i64(i64 [[L1]])
 ; LE-NEXT:    ret i64 [[O1]]
 ;
 ; BE-LABEL: @loadCombine_8consecutive_rev_BE(
@@ -1705,43 +1433,8 @@ define i64 @eggs(ptr noundef readonly %arg) {
 ; LE-NEXT:    ret i64 [[TMP3]]
 ;
 ; BE-LABEL: @eggs(
-; BE-NEXT:    [[TMP3:%.*]] = load i8, ptr [[ARG:%.*]], align 1
-; BE-NEXT:    [[TMP4:%.*]] = getelementptr inbounds i8, ptr [[ARG]], i64 1
-; BE-NEXT:    [[TMP5:%.*]] = load i8, ptr [[TMP4]], align 1
-; BE-NEXT:    [[TMP6:%.*]] = getelementptr inbounds i8, ptr [[ARG]], i64 2
-; BE-NEXT:    [[TMP7:%.*]] = load i8, ptr [[TMP6]], align 1
-; BE-NEXT:    [[TMP8:%.*]] = getelementptr inbounds i8, ptr [[ARG]], i64 3
-; BE-NEXT:    [[TMP9:%.*]] = load i8, ptr [[TMP8]], align 1
-; BE-NEXT:    [[TMP10:%.*]] = getelementptr inbounds i8, ptr [[ARG]], i64 4
-; BE-NEXT:    [[TMP11:%.*]] = load i8, ptr [[TMP10]], align 1
-; BE-NEXT:    [[TMP12:%.*]] = getelementptr inbounds i8, ptr [[ARG]], i64 5
-; BE-NEXT:    [[TMP13:%.*]] = load i8, ptr [[TMP12]], align 1
-; BE-NEXT:    [[TMP14:%.*]] = getelementptr inbounds i8, ptr [[ARG]], i64 6
-; BE-NEXT:    [[TMP15:%.*]] = load i8, ptr [[TMP14]], align 1
-; BE-NEXT:    [[TMP16:%.*]] = getelementptr inbounds i8, ptr [[ARG]], i64 7
-; BE-NEXT:    [[TMP17:%.*]] = load i8, ptr [[TMP16]], align 1
-; BE-NEXT:    [[TMP18:%.*]] = zext i8 [[TMP17]] to i64
-; BE-NEXT:    [[TMP19:%.*]] = shl nuw i64 [[TMP18]], 56
-; BE-NEXT:    [[TMP20:%.*]] = zext i8 [[TMP15]] to i64
-; BE-NEXT:    [[TMP21:%.*]] = shl nuw nsw i64 [[TMP20]], 48
-; BE-NEXT:    [[TMP22:%.*]] = or i64 [[TMP19]], [[TMP21]]
-; BE-NEXT:    [[TMP23:%.*]] = zext i8 [[TMP13]] to i64
-; BE-NEXT:    [[TMP24:%.*]] = shl nuw nsw i64 [[TMP23]], 40
-; BE-NEXT:    [[TMP25:%.*]] = or i64 [[TMP22]], [[TMP24]]
-; BE-NEXT:    [[TMP26:%.*]] = zext i8 [[TMP11]] to i64
-; BE-NEXT:    [[TMP27:%.*]] = shl nuw nsw i64 [[TMP26]], 32
-; BE-NEXT:    [[TMP28:%.*]] = or i64 [[TMP25]], [[TMP27]]
-; BE-NEXT:    [[TMP29:%.*]] = zext i8 [[TMP9]] to i64
-; BE-NEXT:    [[TMP30:%.*]] = shl nuw nsw i64 [[TMP29]], 24
-; BE-NEXT:    [[TMP31:%.*]] = or i64 [[TMP28]], [[TMP30]]
-; BE-NEXT:    [[TMP32:%.*]] = zext i8 [[TMP7]] to i64
-; BE-NEXT:    [[TMP33:%.*]] = shl nuw nsw i64 [[TMP32]], 16
-; BE-NEXT:    [[TMP34:%.*]] = zext i8 [[TMP5]] to i64
-; BE-NEXT:    [[TMP35:%.*]] = shl nuw nsw i64 [[TMP34]], 8
-; BE-NEXT:    [[TMP36:%.*]] = or i64 [[TMP31]], [[TMP33]]
-; BE-NEXT:    [[TMP37:%.*]] = zext i8 [[TMP3]] to i64
-; BE-NEXT:    [[TMP38:%.*]] = or i64 [[TMP36]], [[TMP35]]
-; BE-NEXT:    [[TMP39:%.*]] = or i64 [[TMP38]], [[TMP37]]
+; BE-NEXT:    [[TMP3:%.*]] = load i64, ptr [[ARG:%.*]], align 1
+; BE-NEXT:    [[TMP39:%.*]] = call i64 @llvm.bswap.i64(i64 [[TMP3]])
 ; BE-NEXT:    ret i64 [[TMP39]]
 ;
   %tmp3 = load i8, ptr %arg, align 1
@@ -1867,17 +1560,13 @@ define i32 @loadCombine_4consecutive_rev_mixsize1(ptr %p) {
 ;
 ; BE-LABEL: @loadCombine_4consecutive_rev_mixsize1(
 ; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
-; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
 ; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 2
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P2]], align 1
-; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P3]], align 1
-; BE-NEXT:    [[E1:%.*]] = zext i16 [[L1]] to i32
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
-; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
+; BE-NEXT:    [[L2:%.*]] = load i16, ptr [[P2]], align 1
+; BE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L2]])
+; BE-NEXT:    [[E2:%.*]] = zext i16 [[TMP1]] to i32
 ; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 16
-; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 24
-; BE-NEXT:    [[O1:%.*]] = or i32 [[S3]], [[S2]]
-; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[E1]]
+; BE-NEXT:    [[E1:%.*]] = zext i16 [[L1]] to i32
+; BE-NEXT:    [[O2:%.*]] = or i32 [[S2]], [[E1]]
 ; BE-NEXT:    ret i32 [[O2]]
 ;
   %p2 = getelementptr i8, ptr %p, i32 2
@@ -1901,16 +1590,12 @@ define i32 @loadCombine_4consecutive_rev_mixsize1(ptr %p) {
 define i32 @loadCombine_4consecutive_rev_mixsize1_BE(ptr %p) {
 ; LE-LABEL: @loadCombine_4consecutive_rev_mixsize1_BE(
 ; LE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
-; LE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
 ; LE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 2
-; LE-NEXT:    [[L2:%.*]] = load i8, ptr [[P2]], align 1
-; LE-NEXT:    [[L3:%.*]] = load i8, ptr [[P3]], align 1
+; LE-NEXT:    [[L2:%.*]] = load i16, ptr [[P2]], align 1
+; LE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L2]])
+; LE-NEXT:    [[O1:%.*]] = zext i16 [[TMP1]] to i32
 ; LE-NEXT:    [[E1:%.*]] = zext i16 [[L1]] to i32
-; LE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
-; LE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
 ; LE-NEXT:    [[S1:%.*]] = shl i32 [[E1]], 16
-; LE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
-; LE-NEXT:    [[O1:%.*]] = or i32 [[E3]], [[S2]]
 ; LE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S1]]
 ; LE-NEXT:    ret i32 [[O2]]
 ;
@@ -1942,17 +1627,13 @@ define i32 @loadCombine_4consecutive_mixsize2(ptr %p) {
 ; LE-NEXT:    ret i32 [[O2]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_mixsize2(
-; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
+; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
+; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
+; BE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
+; BE-NEXT:    [[O1:%.*]] = zext i16 [[TMP1]] to i32
 ; BE-NEXT:    [[L3:%.*]] = load i16, ptr [[P2]], align 2
-; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
 ; BE-NEXT:    [[E3:%.*]] = zext i16 [[L3]] to i32
-; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
 ; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
-; BE-NEXT:    [[O1:%.*]] = or i32 [[E1]], [[S2]]
 ; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
 ; BE-NEXT:    ret i32 [[O2]]
 ;
@@ -1980,23 +1661,8 @@ define i32 @loadCombine_4consecutive_lower_index_comes_before(ptr %p) {
 ; LE-NEXT:    ret i32 [[L1]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_lower_index_comes_before(
-; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
-; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
-; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
-; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
-; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
-; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
-; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
-; BE-NEXT:    [[O1:%.*]] = or i32 [[E1]], [[S2]]
-; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
-; BE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[S4]]
+; BE-NEXT:    [[L1:%.*]] = load i32, ptr [[P:%.*]], align 1
+; BE-NEXT:    [[O3:%.*]] = call i32 @llvm.bswap.i32(i32 [[L1]])
 ; BE-NEXT:    ret i32 [[O3]]
 ;
   %p1 = getelementptr i8, ptr %p, i32 1
@@ -2031,13 +1697,9 @@ define i16 @loadCombine_2consecutive_badinsert(ptr %p) {
 ;
 ; BE-LABEL: @loadCombine_2consecutive_badinsert(
 ; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
+; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
+; BE-NEXT:    [[O1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
 ; BE-NEXT:    store i8 0, ptr [[P1]], align 1
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i16
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i16
-; BE-NEXT:    [[S2:%.*]] = shl i16 [[E2]], 8
-; BE-NEXT:    [[O1:%.*]] = or i16 [[E1]], [[S2]]
 ; BE-NEXT:    ret i16 [[O1]]
 ;
   %p1 = getelementptr i8, ptr %p, i32 1
@@ -2060,23 +1722,9 @@ define i32 @loadCombine_4consecutive_badinsert(ptr %p) {
 ;
 ; BE-LABEL: @loadCombine_4consecutive_badinsert(
 ; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
-; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
-; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
+; BE-NEXT:    [[L1:%.*]] = load i32, ptr [[P]], align 1
+; BE-NEXT:    [[O3:%.*]] = call i32 @llvm.bswap.i32(i32 [[L1]])
 ; BE-NEXT:    store i8 0, ptr [[P1]], align 1
-; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
-; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
-; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
-; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
-; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
-; BE-NEXT:    [[O1:%.*]] = or i32 [[E1]], [[S2]]
-; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
-; BE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[S4]]
 ; BE-NEXT:    ret i32 [[O3]]
 ;
   %p1 = getelementptr i8, ptr %p, i32 1
@@ -2121,22 +1769,18 @@ define i32 @loadCombine_4consecutive_badinsert2(ptr %p) {
 ; LE-NEXT:    ret i32 [[O3]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_badinsert2(
-; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
+; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
 ; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
+; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
+; BE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
+; BE-NEXT:    [[O1:%.*]] = zext i16 [[TMP1]] to i32
 ; BE-NEXT:    store i8 0, ptr [[P3]], align 1
 ; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
 ; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
 ; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
 ; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
 ; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
 ; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
-; BE-NEXT:    [[O1:%.*]] = or i32 [[E1]], [[S2]]
 ; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
 ; BE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[S4]]
 ; BE-NEXT:    ret i32 [[O3]]
@@ -2172,24 +1816,9 @@ define i32 @loadCombine_4consecutive_badinsert3(ptr %p) {
 ; LE-NEXT:    ret i32 [[L1]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_badinsert3(
-; BE-NEXT:    [[P4:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 4
-; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P4]], align 1
-; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
-; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P3]], align 1
-; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
-; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P2]], align 1
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
-; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
-; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P]], i32 1
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P1]], align 1
-; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
-; BE-NEXT:    [[O1:%.*]] = or i32 [[E1]], [[S2]]
-; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
-; BE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[S4]]
+; BE-NEXT:    [[TMP1:%.*]] = getelementptr i8, ptr [[P:%.*]], i64 1
+; BE-NEXT:    [[L1:%.*]] = load i32, ptr [[TMP1]], align 1
+; BE-NEXT:    [[O3:%.*]] = call i32 @llvm.bswap.i32(i32 [[L1]])
 ; BE-NEXT:    ret i32 [[O3]]
 ;
   %p4 = getelementptr i8, ptr %p, i32 4
@@ -2238,23 +1867,8 @@ define i32 @loadCombine_4consecutive_badinsert4(ptr %p) {
 ; BE-NEXT:    [[CMP:%.*]] = icmp eq i8 [[C1]], 0
 ; BE-NEXT:    br i1 [[CMP]], label [[END:%.*]], label [[BB2:%.*]]
 ; BE:       bb2:
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P1]], align 1
-; BE-NEXT:    [[C2:%.*]] = zext i8 [[L1]] to i32
-; BE-NEXT:    [[P4:%.*]] = getelementptr i8, ptr [[P]], i64 4
-; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P4]], align 1
-; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; BE-NEXT:    [[S4:%.*]] = shl nuw i32 [[E4]], 24
-; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i64 3
-; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P3]], align 1
-; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
-; BE-NEXT:    [[S3:%.*]] = shl nuw nsw i32 [[E3]], 16
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i64 2
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P2]], align 1
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
-; BE-NEXT:    [[S2:%.*]] = shl nuw nsw i32 [[E2]], 8
-; BE-NEXT:    [[O1:%.*]] = or i32 [[S2]], [[C2]]
-; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
-; BE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[S4]]
+; BE-NEXT:    [[L1:%.*]] = load i32, ptr [[P1]], align 1
+; BE-NEXT:    [[O3:%.*]] = call i32 @llvm.bswap.i32(i32 [[L1]])
 ; BE-NEXT:    br label [[END]]
 ; BE:       end:
 ; BE-NEXT:    [[COND:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[O3]], [[BB2]] ]
@@ -2309,22 +1923,18 @@ define i32 @loadCombine_4consecutive_badinsert5(ptr %p) {
 ; LE-NEXT:    ret i32 [[O3]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_badinsert5(
-; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
+; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
 ; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
 ; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
 ; BE-NEXT:    store i8 0, ptr [[P2]], align 1
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
+; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
+; BE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
+; BE-NEXT:    [[O1:%.*]] = zext i16 [[TMP1]] to i32
 ; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
-; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
-; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
 ; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
 ; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
 ; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
 ; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
-; BE-NEXT:    [[O1:%.*]] = or i32 [[E1]], [[S2]]
 ; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
 ; BE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[S4]]
 ; BE-NEXT:    ret i32 [[O3]]
@@ -2378,16 +1988,13 @@ define i32 @loadCombine_4consecutive_badinsert6(ptr %p) {
 ; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
 ; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
 ; BE-NEXT:    store i8 0, ptr [[P3]], align 1
-; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
-; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
+; BE-NEXT:    [[L3:%.*]] = load i16, ptr [[P2]], align 1
+; BE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L3]])
+; BE-NEXT:    [[TMP2:%.*]] = zext i16 [[TMP1]] to i32
+; BE-NEXT:    [[O1:%.*]] = shl i32 [[TMP2]], 16
 ; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
 ; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
-; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
-; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
 ; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
-; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
-; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
-; BE-NEXT:    [[O1:%.*]] = or i32 [[S3]], [[S4]]
 ; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S2]]
 ; BE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[E1]]
 ; BE-NEXT:    ret i32 [[O3]]
@@ -2555,14 +2162,10 @@ define i32 @loadcombine_consecutive_idx_64(ptr %data) {
 ;
 ; BE-LABEL: @loadcombine_consecutive_idx_64(
 ; BE-NEXT:  entry:
-; BE-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds nuw i8, ptr [[DATA:%.*]], i64 2149675577
-; BE-NEXT:    [[VAL:%.*]] = load i8, ptr [[ARRAYIDX]], align 1
-; BE-NEXT:    [[CONV:%.*]] = zext i8 [[VAL]] to i32
-; BE-NEXT:    [[ARRAYIDX_2:%.*]] = getelementptr inbounds nuw i8, ptr [[DATA]], i64 2149675576
-; BE-NEXT:    [[VAL_2:%.*]] = load i8, ptr [[ARRAYIDX_2]], align 1
-; BE-NEXT:    [[CONV_2:%.*]] = zext i8 [[VAL_2]] to i32
-; BE-NEXT:    [[SHL:%.*]] = shl nuw nsw i32 [[CONV]], 8
-; BE-NEXT:    [[OR:%.*]] = or disjoint i32 [[SHL]], [[CONV_2]]
+; BE-NEXT:    [[TMP0:%.*]] = getelementptr i8, ptr [[DATA:%.*]], i64 2149675576
+; BE-NEXT:    [[VAL_2:%.*]] = load i16, ptr [[TMP0]], align 1
+; BE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[VAL_2]])
+; BE-NEXT:    [[OR:%.*]] = zext i16 [[TMP1]] to i32
 ; BE-NEXT:    ret i32 [[OR]]
 ;
 entry:
@@ -2631,34 +2234,14 @@ entry:
 }
 
 define i16 @combine_four_i8_loads_i16_poison(ptr %p) {
-; LE-LABEL: @combine_four_i8_loads_i16_poison(
-; LE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i64 2
-; LE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i64 3
-; LE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
-; LE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
-; LE-NEXT:    [[Z3:%.*]] = zext i8 [[L3]] to i16
-; LE-NEXT:    [[Z4:%.*]] = zext i8 [[L4]] to i16
-; LE-NEXT:    ret i16 poison
-;
-; BE-LABEL: @combine_four_i8_loads_i16_poison(
-; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i64 1
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i64 2
-; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i64 3
-; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
-; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
-; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
-; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
-; BE-NEXT:    [[Z1:%.*]] = zext i8 [[L1]] to i16
-; BE-NEXT:    [[Z2:%.*]] = zext i8 [[L2]] to i16
-; BE-NEXT:    [[Z3:%.*]] = zext i8 [[L3]] to i16
-; BE-NEXT:    [[Z4:%.*]] = zext i8 [[L4]] to i16
-; BE-NEXT:    [[SH2:%.*]] = shl i16 [[Z2]], 8
-; BE-NEXT:    [[OR1:%.*]] = or i16 [[Z1]], [[SH2]]
-; BE-NEXT:    [[SH3:%.*]] = shl i16 [[Z3]], 16
-; BE-NEXT:    [[OR2:%.*]] = or i16 [[OR1]], [[SH3]]
-; BE-NEXT:    [[SH4:%.*]] = shl i16 [[Z4]], 24
-; BE-NEXT:    [[OR3:%.*]] = or i16 [[OR2]], [[SH4]]
-; BE-NEXT:    ret i16 [[OR3]]
+; ALL-LABEL: @combine_four_i8_loads_i16_poison(
+; ALL-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i64 2
+; ALL-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i64 3
+; ALL-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
+; ALL-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
+; ALL-NEXT:    [[Z3:%.*]] = zext i8 [[L3]] to i16
+; ALL-NEXT:    [[Z4:%.*]] = zext i8 [[L4]] to i16
+; ALL-NEXT:    ret i16 poison
 ;
   %p1 = getelementptr i8, ptr %p, i64 1
   %p2 = getelementptr i8, ptr %p, i64 2
@@ -2680,3 +2263,234 @@ define i16 @combine_four_i8_loads_i16_poison(ptr %p) {
   ret i16 %or3
 }
 
+
+define i64 @loadCombine_8consecutive_bswap_disjoint(ptr %p) {
+; LE-LABEL: @loadCombine_8consecutive_bswap_disjoint(
+; LE-NEXT:    [[L0:%.*]] = load i64, ptr [[P:%.*]], align 1
+; LE-NEXT:    [[TMP1:%.*]] = call i64 @llvm.bswap.i64(i64 [[L0]])
+; LE-NEXT:    ret i64 [[TMP1]]
+;
+; BE-LABEL: @loadCombine_8consecutive_bswap_disjoint(
+; BE-NEXT:    [[L0:%.*]] = load i64, ptr [[P:%.*]], align 1
+; BE-NEXT:    ret i64 [[L0]]
+;
+  %l0 = load i8, ptr %p, align 1
+  %e0 = zext i8 %l0 to i64
+  %s0 = shl nuw i64 %e0, 56
+  %p1 = getelementptr inbounds nuw i8, ptr %p, i64 1
+  %l1 = load i8, ptr %p1, align 1
+  %e1 = zext i8 %l1 to i64
+  %s1 = shl nuw nsw i64 %e1, 48
+  %o1 = or disjoint i64 %s1, %s0
+  %p2 = getelementptr inbounds nuw i8, ptr %p, i64 2
+  %l2 = load i8, ptr %p2, align 1
+  %e2 = zext i8 %l2 to i64
+  %s2 = shl nuw nsw i64 %e2, 40
+  %o2 = or disjoint i64 %s2, %o1
+  %p3 = getelementptr inbounds nuw i8, ptr %p, i64 3
+  %l3 = load i8, ptr %p3, align 1
+  %e3 = zext i8 %l3 to i64
+  %s3 = shl nuw nsw i64 %e3, 32
+  %o3 = or disjoint i64 %s3, %o2
+  %p4 = getelementptr inbounds nuw i8, ptr %p, i64 4
+  %l4 = load i8, ptr %p4, align 1
+  %e4 = zext i8 %l4 to i64
+  %s4 = shl nuw nsw i64 %e4, 24
+  %o4 = or disjoint i64 %s4, %o3
+  %p5 = getelementptr inbounds nuw i8, ptr %p, i64 5
+  %l5 = load i8, ptr %p5, align 1
+  %e5 = zext i8 %l5 to i64
+  %s5 = shl nuw nsw i64 %e5, 16
+  %o5 = or disjoint i64 %s5, %o4
+  %p6 = getelementptr inbounds nuw i8, ptr %p, i64 6
+  %l6 = load i8, ptr %p6, align 1
+  %e6 = zext i8 %l6 to i64
+  %s6 = shl nuw nsw i64 %e6, 8
+  %o6 = or i64 %s6, %o5
+  %p7 = getelementptr inbounds nuw i8, ptr %p, i64 7
+  %l7 = load i8, ptr %p7, align 1
+  %e7 = zext i8 %l7 to i64
+  %o7 = or i64 %o6, %e7
+  ret i64 %o7
+}
+
+; Bytes 0-3 in reverse order at bits 32-63 of an i64.
+define i64 @loadCombine_4consecutive_bswap_shifted(ptr %p) {
+; LE-LABEL: @loadCombine_4consecutive_bswap_shifted(
+; LE-NEXT:    [[L0:%.*]] = load i32, ptr [[P:%.*]], align 1
+; LE-NEXT:    [[TMP1:%.*]] = call i32 @llvm.bswap.i32(i32 [[L0]])
+; LE-NEXT:    [[TMP2:%.*]] = zext i32 [[TMP1]] to i64
+; LE-NEXT:    [[TMP3:%.*]] = shl i64 [[TMP2]], 32
+; LE-NEXT:    ret i64 [[TMP3]]
+;
+; BE-LABEL: @loadCombine_4consecutive_bswap_shifted(
+; BE-NEXT:    [[L0:%.*]] = load i32, ptr [[P:%.*]], align 1
+; BE-NEXT:    [[TMP1:%.*]] = zext i32 [[L0]] to i64
+; BE-NEXT:    [[TMP2:%.*]] = shl i64 [[TMP1]], 32
+; BE-NEXT:    ret i64 [[TMP2]]
+;
+  %p1 = getelementptr i8, ptr %p, i64 1
+  %p2 = getelementptr i8, ptr %p, i64 2
+  %p3 = getelementptr i8, ptr %p, i64 3
+  %l0 = load i8, ptr %p
+  %l1 = load i8, ptr %p1
+  %l2 = load i8, ptr %p2
+  %l3 = load i8, ptr %p3
+  %e0 = zext i8 %l0 to i64
+  %e1 = zext i8 %l1 to i64
+  %e2 = zext i8 %l2 to i64
+  %e3 = zext i8 %l3 to i64
+  %s0 = shl i64 %e0, 56
+  %s1 = shl i64 %e1, 48
+  %s2 = shl i64 %e2, 40
+  %s3 = shl i64 %e3, 32
+  %o1 = or i64 %s0, %s1
+  %o2 = or i64 %o1, %s2
+  %o3 = or i64 %o2, %s3
+  ret i64 %o3
+}
+
+define i32 @loadCombine_4consecutive_bswap_multiuse(ptr %p, ptr %q) {
+; LE-LABEL: @loadCombine_4consecutive_bswap_multiuse(
+; LE-NEXT:    [[L0:%.*]] = load i32, ptr [[P:%.*]], align 1
+; LE-NEXT:    [[TMP1:%.*]] = call i32 @llvm.bswap.i32(i32 [[L0]])
+; LE-NEXT:    store i32 [[TMP1]], ptr [[Q:%.*]], align 4
+; LE-NEXT:    ret i32 [[TMP1]]
+;
+; BE-LABEL: @loadCombine_4consecutive_bswap_multiuse(
+; BE-NEXT:    [[L0:%.*]] = load i32, ptr [[P:%.*]], align 1
+; BE-NEXT:    store i32 [[L0]], ptr [[Q:%.*]], align 4
+; BE-NEXT:    ret i32 [[L0]]
+;
+  %p1 = getelementptr i8, ptr %p, i64 1
+  %p2 = getelementptr i8, ptr %p, i64 2
+  %p3 = getelementptr i8, ptr %p, i64 3
+  %l0 = load i8, ptr %p
+  %l1 = load i8, ptr %p1
+  %l2 = load i8, ptr %p2
+  %l3 = load i8, ptr %p3
+  %e0 = zext i8 %l0 to i32
+  %e1 = zext i8 %l1 to i32
+  %e2 = zext i8 %l2 to i32
+  %e3 = zext i8 %l3 to i32
+  %s0 = shl i32 %e0, 24
+  %s1 = shl i32 %e1, 16
+  %s2 = shl i32 %e2, 8
+  %o1 = or i32 %s0, %s1
+  %o2 = or i32 %o1, %s2
+  %o3 = or i32 %o2, %e3
+  store i32 %o3, ptr %q
+  ret i32 %o3
+}
+
+; Negative test: the first pair is in reverse order, but the rest are not.
+define i32 @loadCombine_4consecutive_bswap_mixed_order(ptr %p) {
+; LE-LABEL: @loadCombine_4consecutive_bswap_mixed_order(
+; LE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i64 2
+; LE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i64 3
+; LE-NEXT:    [[L0:%.*]] = load i16, ptr [[P]], align 1
+; LE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L0]])
+; LE-NEXT:    [[TMP2:%.*]] = zext i16 [[TMP1]] to i32
+; LE-NEXT:    [[L2:%.*]] = load i8, ptr [[P2]], align 1
+; LE-NEXT:    [[L3:%.*]] = load i8, ptr [[P3]], align 1
+; LE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
+; LE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
+; LE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 16
+; LE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 24
+; LE-NEXT:    [[O2:%.*]] = or i32 [[TMP2]], [[S2]]
+; LE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[S3]]
+; LE-NEXT:    ret i32 [[O3]]
+;
+; BE-LABEL: @loadCombine_4consecutive_bswap_mixed_order(
+; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i64 2
+; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i64 3
+; BE-NEXT:    [[L0:%.*]] = load i16, ptr [[P]], align 1
+; BE-NEXT:    [[TMP1:%.*]] = zext i16 [[L0]] to i32
+; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P2]], align 1
+; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P3]], align 1
+; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
+; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
+; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 16
+; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 24
+; BE-NEXT:    [[O2:%.*]] = or i32 [[TMP1]], [[S2]]
+; BE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[S3]]
+; BE-NEXT:    ret i32 [[O3]]
+;
+  %p1 = getelementptr i8, ptr %p, i64 1
+  %p2 = getelementptr i8, ptr %p, i64 2
+  %p3 = getelementptr i8, ptr %p, i64 3
+  %l0 = load i8, ptr %p
+  %l1 = load i8, ptr %p1
+  %l2 = load i8, ptr %p2
+  %l3 = load i8, ptr %p3
+  %e0 = zext i8 %l0 to i32
+  %e1 = zext i8 %l1 to i32
+  %e2 = zext i8 %l2 to i32
+  %e3 = zext i8 %l3 to i32
+  %s0 = shl i32 %e0, 8
+  %s2 = shl i32 %e2, 16
+  %s3 = shl i32 %e3, 24
+  %o1 = or i32 %s0, %e1
+  %o2 = or i32 %o1, %s2
+  %o3 = or i32 %o2, %s3
+  ret i32 %o3
+}
+
+; Negative test: i16 elements in reverse order are not a bswap.
+define i32 @loadCombine_2consecutive_i16_reverse(ptr %p) {
+; LE-LABEL: @loadCombine_2consecutive_i16_reverse(
+; LE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i64 2
+; LE-NEXT:    [[L0:%.*]] = load i16, ptr [[P]], align 2
+; LE-NEXT:    [[L1:%.*]] = load i16, ptr [[P1]], align 2
+; LE-NEXT:    [[E0:%.*]] = zext i16 [[L0]] to i32
+; LE-NEXT:    [[E1:%.*]] = zext i16 [[L1]] to i32
+; LE-NEXT:    [[S0:%.*]] = shl i32 [[E0]], 16
+; LE-NEXT:    [[O1:%.*]] = or i32 [[S0]], [[E1]]
+; LE-NEXT:    ret i32 [[O1]]
+;
+; BE-LABEL: @loadCombine_2consecutive_i16_reverse(
+; BE-NEXT:    [[L0:%.*]] = load i32, ptr [[P:%.*]], align 2
+; BE-NEXT:    ret i32 [[L0]]
+;
+  %p1 = getelementptr i8, ptr %p, i64 2
+  %l0 = load i16, ptr %p
+  %l1 = load i16, ptr %p1
+  %e0 = zext i16 %l0 to i32
+  %e1 = zext i16 %l1 to i32
+  %s0 = shl i32 %e0, 16
+  %o1 = or i32 %s0, %e1
+  ret i32 %o1
+}
+
+; Negative test: reversed i8 elements followed by an i16 element in the
+; position that would be reversed if it were two i8 elements.
+define i32 @loadCombine_4consecutive_bswap_mixsize(ptr %p) {
+; LE-LABEL: @loadCombine_4consecutive_bswap_mixsize(
+; LE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i64 2
+; LE-NEXT:    [[L0:%.*]] = load i16, ptr [[P]], align 2
+; LE-NEXT:    [[L2:%.*]] = load i16, ptr [[P2]], align 1
+; LE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L2]])
+; LE-NEXT:    [[TMP2:%.*]] = zext i16 [[TMP1]] to i32
+; LE-NEXT:    [[E0:%.*]] = zext i16 [[L0]] to i32
+; LE-NEXT:    [[S0:%.*]] = shl i32 [[E0]], 16
+; LE-NEXT:    [[O2:%.*]] = or i32 [[TMP2]], [[S0]]
+; LE-NEXT:    ret i32 [[O2]]
+;
+; BE-LABEL: @loadCombine_4consecutive_bswap_mixsize(
+; BE-NEXT:    [[L0:%.*]] = load i32, ptr [[P:%.*]], align 2
+; BE-NEXT:    ret i32 [[L0]]
+;
+  %p2 = getelementptr i8, ptr %p, i64 2
+  %p3 = getelementptr i8, ptr %p, i64 3
+  %l0 = load i16, ptr %p
+  %l2 = load i8, ptr %p2
+  %l3 = load i8, ptr %p3
+  %e0 = zext i16 %l0 to i32
+  %e2 = zext i8 %l2 to i32
+  %e3 = zext i8 %l3 to i32
+  %s0 = shl i32 %e0, 16
+  %s2 = shl i32 %e2, 8
+  %o1 = or i32 %s2, %e3
+  %o2 = or i32 %o1, %s0
+  ret i32 %o2
+}

>From 97b75fc26c845ef0505f46ba0339e78d7d255bab Mon Sep 17 00:00:00 2001
From: Craig Topper <craig.topper at sifive.com>
Date: Fri, 2 Oct 2026 14:54:40 -0700
Subject: [PATCH 2/2] fixup! Prevent forming load+bswap.i16.

---
 .../AggressiveInstCombine.cpp                 |   4 +
 .../AggressiveInstCombine/AArch64/or-load.ll  | 225 ++++++++-----
 .../AggressiveInstCombine/RISCV/or-load.ll    |   9 +-
 .../AggressiveInstCombine/X86/or-load.ll      | 295 ++++++++++++------
 4 files changed, 350 insertions(+), 183 deletions(-)

diff --git a/llvm/lib/Transforms/AggressiveInstCombine/AggressiveInstCombine.cpp b/llvm/lib/Transforms/AggressiveInstCombine/AggressiveInstCombine.cpp
index de6cc3b865251..01f8abb9704e6 100644
--- a/llvm/lib/Transforms/AggressiveInstCombine/AggressiveInstCombine.cpp
+++ b/llvm/lib/Transforms/AggressiveInstCombine/AggressiveInstCombine.cpp
@@ -1582,6 +1582,10 @@ static bool foldConsecutiveLoads(Instruction &I, const DataLayout &DL,
   if (!Allowed)
     return false;
 
+  // Require at least 4 bytes when forming load+bswap to avoid regressions.
+  if (LOps.BSwap && LOps.LoadSize < 32)
+    return false;
+
   unsigned AS = LI1->getPointerAddressSpace();
   unsigned Fast = 0;
   Allowed = TTI.allowsMisalignedMemoryAccesses(I.getContext(), LOps.LoadSize,
diff --git a/llvm/test/Transforms/AggressiveInstCombine/AArch64/or-load.ll b/llvm/test/Transforms/AggressiveInstCombine/AArch64/or-load.ll
index a68aff13bc875..91d5a5e2061cd 100644
--- a/llvm/test/Transforms/AggressiveInstCombine/AArch64/or-load.ll
+++ b/llvm/test/Transforms/AggressiveInstCombine/AArch64/or-load.ll
@@ -9,8 +9,13 @@ define i16 @loadCombine_2consecutive(ptr %p) {
 ; LE-NEXT:    ret i16 [[L1]]
 ;
 ; BE-LABEL: @loadCombine_2consecutive(
-; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P:%.*]], align 1
-; BE-NEXT:    [[O1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
+; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
+; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
+; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
+; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i16
+; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i16
+; BE-NEXT:    [[S2:%.*]] = shl i16 [[E2]], 8
+; BE-NEXT:    [[O1:%.*]] = or i16 [[E1]], [[S2]]
 ; BE-NEXT:    ret i16 [[O1]]
 ;
   %p1 = getelementptr i8, ptr %p, i32 1
@@ -25,8 +30,13 @@ define i16 @loadCombine_2consecutive(ptr %p) {
 
 define i16 @loadCombine_2consecutive_BE(ptr %p) {
 ; LE-LABEL: @loadCombine_2consecutive_BE(
-; LE-NEXT:    [[L1:%.*]] = load i16, ptr [[P:%.*]], align 1
-; LE-NEXT:    [[O1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
+; LE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
+; LE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
+; LE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
+; LE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i16
+; LE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i16
+; LE-NEXT:    [[S1:%.*]] = shl i16 [[E1]], 8
+; LE-NEXT:    [[O1:%.*]] = or i16 [[S1]], [[E2]]
 ; LE-NEXT:    ret i16 [[O1]]
 ;
 ; BE-LABEL: @loadCombine_2consecutive_BE(
@@ -199,18 +209,22 @@ define i32 @loadCombine_4consecutive_alias2(ptr %p, ptr %pstr) {
 ; LE-NEXT:    ret i32 [[O3]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_alias2(
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
+; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
+; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
 ; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
-; BE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
-; BE-NEXT:    [[O1:%.*]] = zext i16 [[TMP1]] to i32
-; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
+; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P]], align 1
+; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
+; BE-NEXT:    [[L5:%.*]] = load i8, ptr [[P2]], align 1
 ; BE-NEXT:    store i8 10, ptr [[PSTR:%.*]], align 1
 ; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
 ; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
+; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
+; BE-NEXT:    [[E5:%.*]] = zext i8 [[L5]] to i32
 ; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
+; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
+; BE-NEXT:    [[S3:%.*]] = shl i32 [[E5]], 16
 ; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
+; BE-NEXT:    [[O1:%.*]] = or i32 [[E3]], [[S2]]
 ; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
 ; BE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[S4]]
 ; BE-NEXT:    ret i32 [[O3]]
@@ -241,21 +255,25 @@ define i32 @loadCombine_4consecutive_alias2(ptr %p, ptr %pstr) {
 
 define i32 @loadCombine_4consecutive_alias2_BE(ptr %p, ptr %pstr) {
 ; LE-LABEL: @loadCombine_4consecutive_alias2_BE(
-; LE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
+; LE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
+; LE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
 ; LE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; LE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
-; LE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
-; LE-NEXT:    [[TMP2:%.*]] = zext i16 [[TMP1]] to i32
-; LE-NEXT:    [[O1:%.*]] = shl i32 [[TMP2]], 16
-; LE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
+; LE-NEXT:    [[L3:%.*]] = load i8, ptr [[P]], align 1
+; LE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
+; LE-NEXT:    [[L5:%.*]] = load i8, ptr [[P2]], align 1
 ; LE-NEXT:    store i8 10, ptr [[PSTR:%.*]], align 1
 ; LE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
 ; LE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
-; LE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; LE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 8
+; LE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
+; LE-NEXT:    [[E5:%.*]] = zext i8 [[L5]] to i32
+; LE-NEXT:    [[E6:%.*]] = zext i8 [[L4]] to i32
+; LE-NEXT:    [[O1:%.*]] = shl i32 [[E3]], 24
+; LE-NEXT:    [[S3:%.*]] = shl i32 [[E2]], 16
+; LE-NEXT:    [[E4:%.*]] = shl i32 [[E5]], 8
 ; LE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
 ; LE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[E4]]
-; LE-NEXT:    ret i32 [[O3]]
+; LE-NEXT:    [[O4:%.*]] = or i32 [[O3]], [[E6]]
+; LE-NEXT:    ret i32 [[O4]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_alias2_BE(
 ; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
@@ -316,19 +334,23 @@ define i32 @loadCombine_4consecutive_alias3(ptr %p) {
 ; LE-NEXT:    ret i32 [[O3]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_alias3(
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
+; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
+; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
 ; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
-; BE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
-; BE-NEXT:    [[O1:%.*]] = zext i16 [[TMP1]] to i32
-; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
+; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P]], align 1
+; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
+; BE-NEXT:    [[L5:%.*]] = load i8, ptr [[P2]], align 1
 ; BE-NEXT:    store i8 10, ptr [[P3]], align 1
 ; BE-NEXT:    store i8 5, ptr [[P]], align 1
 ; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
 ; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
+; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
+; BE-NEXT:    [[E5:%.*]] = zext i8 [[L5]] to i32
 ; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
+; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
+; BE-NEXT:    [[S3:%.*]] = shl i32 [[E5]], 16
 ; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
+; BE-NEXT:    [[O1:%.*]] = or i32 [[E3]], [[S2]]
 ; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
 ; BE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[S4]]
 ; BE-NEXT:    ret i32 [[O3]]
@@ -360,22 +382,26 @@ define i32 @loadCombine_4consecutive_alias3(ptr %p) {
 
 define i32 @loadCombine_4consecutive_alias3_BE(ptr %p) {
 ; LE-LABEL: @loadCombine_4consecutive_alias3_BE(
-; LE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
+; LE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
+; LE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
 ; LE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; LE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
-; LE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
-; LE-NEXT:    [[TMP2:%.*]] = zext i16 [[TMP1]] to i32
-; LE-NEXT:    [[O1:%.*]] = shl i32 [[TMP2]], 16
-; LE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
+; LE-NEXT:    [[L3:%.*]] = load i8, ptr [[P]], align 1
+; LE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
+; LE-NEXT:    [[L5:%.*]] = load i8, ptr [[P2]], align 1
 ; LE-NEXT:    store i8 10, ptr [[P3]], align 1
 ; LE-NEXT:    store i8 5, ptr [[P]], align 1
 ; LE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
 ; LE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
-; LE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; LE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 8
+; LE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
+; LE-NEXT:    [[E5:%.*]] = zext i8 [[L5]] to i32
+; LE-NEXT:    [[E6:%.*]] = zext i8 [[L4]] to i32
+; LE-NEXT:    [[O1:%.*]] = shl i32 [[E3]], 24
+; LE-NEXT:    [[S3:%.*]] = shl i32 [[E2]], 16
+; LE-NEXT:    [[E4:%.*]] = shl i32 [[E5]], 8
 ; LE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
 ; LE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[E4]]
-; LE-NEXT:    ret i32 [[O3]]
+; LE-NEXT:    [[O4:%.*]] = or i32 [[O3]], [[E6]]
+; LE-NEXT:    ret i32 [[O4]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_alias3_BE(
 ; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
@@ -653,17 +679,21 @@ define i32 @loadCombine_4consecutive_hasOneUse4(ptr %p) {
 ; LE-NEXT:    ret i32 [[O3]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_hasOneUse4(
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
+; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
+; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
 ; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
-; BE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
-; BE-NEXT:    [[O1:%.*]] = zext i16 [[TMP1]] to i32
-; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
-; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
+; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P]], align 1
+; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P1]], align 1
+; BE-NEXT:    [[L5:%.*]] = load i8, ptr [[P2]], align 1
+; BE-NEXT:    [[L6:%.*]] = load i8, ptr [[P3]], align 1
 ; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
 ; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
-; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
+; BE-NEXT:    [[E5:%.*]] = zext i8 [[L5]] to i32
+; BE-NEXT:    [[E6:%.*]] = zext i8 [[L6]] to i32
+; BE-NEXT:    [[S2:%.*]] = shl i32 [[E4]], 8
+; BE-NEXT:    [[S3:%.*]] = shl i32 [[E5]], 16
+; BE-NEXT:    [[S4:%.*]] = shl i32 [[E6]], 24
+; BE-NEXT:    [[O1:%.*]] = or i32 [[E3]], [[S2]]
 ; BE-NEXT:    call void @use(i32 [[O1]])
 ; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
 ; BE-NEXT:    call void @use(i32 [[O2]])
@@ -746,13 +776,17 @@ define i32 @loadCombine_parLoad1(ptr %p) {
 ; LE-NEXT:    ret i32 [[O2]]
 ;
 ; BE-LABEL: @loadCombine_parLoad1(
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
-; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
-; BE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
-; BE-NEXT:    [[O1:%.*]] = zext i16 [[TMP1]] to i32
-; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
+; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
+; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
+; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P]], align 1
+; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
+; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P2]], align 1
 ; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
-; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
+; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
+; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
+; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
+; BE-NEXT:    [[S3:%.*]] = shl i32 [[E4]], 16
+; BE-NEXT:    [[O1:%.*]] = or i32 [[E3]], [[S2]]
 ; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
 ; BE-NEXT:    ret i32 [[O2]]
 ;
@@ -1487,13 +1521,17 @@ define i32 @loadCombine_4consecutive_rev_mixsize1(ptr %p) {
 ;
 ; BE-LABEL: @loadCombine_4consecutive_rev_mixsize1(
 ; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
+; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
 ; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 2
-; BE-NEXT:    [[L2:%.*]] = load i16, ptr [[P2]], align 1
-; BE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L2]])
-; BE-NEXT:    [[E2:%.*]] = zext i16 [[TMP1]] to i32
-; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 16
+; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P2]], align 1
+; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P3]], align 1
 ; BE-NEXT:    [[E1:%.*]] = zext i16 [[L1]] to i32
-; BE-NEXT:    [[O2:%.*]] = or i32 [[S2]], [[E1]]
+; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
+; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
+; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 16
+; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 24
+; BE-NEXT:    [[O1:%.*]] = or i32 [[S3]], [[S2]]
+; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[E1]]
 ; BE-NEXT:    ret i32 [[O2]]
 ;
   %p2 = getelementptr i8, ptr %p, i32 2
@@ -1517,12 +1555,16 @@ define i32 @loadCombine_4consecutive_rev_mixsize1(ptr %p) {
 define i32 @loadCombine_4consecutive_rev_mixsize1_BE(ptr %p) {
 ; LE-LABEL: @loadCombine_4consecutive_rev_mixsize1_BE(
 ; LE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
+; LE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
 ; LE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 2
-; LE-NEXT:    [[L2:%.*]] = load i16, ptr [[P2]], align 1
-; LE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L2]])
-; LE-NEXT:    [[O1:%.*]] = zext i16 [[TMP1]] to i32
+; LE-NEXT:    [[L2:%.*]] = load i8, ptr [[P2]], align 1
+; LE-NEXT:    [[L3:%.*]] = load i8, ptr [[P3]], align 1
 ; LE-NEXT:    [[E1:%.*]] = zext i16 [[L1]] to i32
+; LE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
+; LE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
 ; LE-NEXT:    [[S1:%.*]] = shl i32 [[E1]], 16
+; LE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
+; LE-NEXT:    [[O1:%.*]] = or i32 [[E3]], [[S2]]
 ; LE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S1]]
 ; LE-NEXT:    ret i32 [[O2]]
 ;
@@ -1554,13 +1596,17 @@ define i32 @loadCombine_4consecutive_mixsize2(ptr %p) {
 ; LE-NEXT:    ret i32 [[L1]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_mixsize2(
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
-; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
-; BE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
-; BE-NEXT:    [[O1:%.*]] = zext i16 [[TMP1]] to i32
+; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
+; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
+; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
+; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
 ; BE-NEXT:    [[L3:%.*]] = load i16, ptr [[P2]], align 2
+; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
+; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
 ; BE-NEXT:    [[E3:%.*]] = zext i16 [[L3]] to i32
+; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
 ; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
+; BE-NEXT:    [[O1:%.*]] = or i32 [[E1]], [[S2]]
 ; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
 ; BE-NEXT:    ret i32 [[O2]]
 ;
@@ -1836,17 +1882,21 @@ define i64 @loadCombine_8consecutive_mixsize(ptr %p) {
 ; LE-NEXT:    ret i64 [[L1]]
 ;
 ; BE-LABEL: @loadCombine_8consecutive_mixsize(
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i64 2
+; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i64 1
+; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i64 2
 ; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i64 4
-; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
-; BE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
-; BE-NEXT:    [[O1:%.*]] = zext i16 [[TMP1]] to i64
+; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
+; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
 ; BE-NEXT:    [[L3:%.*]] = load i16, ptr [[P2]], align 2
 ; BE-NEXT:    [[L4:%.*]] = load i32, ptr [[P3]], align 4
+; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i64
+; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i64
 ; BE-NEXT:    [[E3:%.*]] = zext i16 [[L3]] to i64
 ; BE-NEXT:    [[E4:%.*]] = zext i32 [[L4]] to i64
+; BE-NEXT:    [[S2:%.*]] = shl i64 [[E2]], 8
 ; BE-NEXT:    [[S3:%.*]] = shl i64 [[E3]], 16
 ; BE-NEXT:    [[S4:%.*]] = shl i64 [[E4]], 32
+; BE-NEXT:    [[O1:%.*]] = or i64 [[E1]], [[S2]]
 ; BE-NEXT:    [[O2:%.*]] = or i64 [[O1]], [[S3]]
 ; BE-NEXT:    [[O3:%.*]] = or i64 [[O2]], [[S4]]
 ; BE-NEXT:    ret i64 [[O3]]
@@ -1916,9 +1966,13 @@ define i16 @loadCombine_2consecutive_badinsert(ptr %p) {
 ;
 ; BE-LABEL: @loadCombine_2consecutive_badinsert(
 ; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
-; BE-NEXT:    [[O1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
+; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
 ; BE-NEXT:    store i8 0, ptr [[P1]], align 1
+; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
+; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i16
+; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i16
+; BE-NEXT:    [[S2:%.*]] = shl i16 [[E2]], 8
+; BE-NEXT:    [[O1:%.*]] = or i16 [[E1]], [[S2]]
 ; BE-NEXT:    ret i16 [[O1]]
 ;
   %p1 = getelementptr i8, ptr %p, i32 1
@@ -1988,18 +2042,22 @@ define i32 @loadCombine_4consecutive_badinsert2(ptr %p) {
 ; LE-NEXT:    ret i32 [[O3]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_badinsert2(
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
+; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
+; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
 ; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
-; BE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
-; BE-NEXT:    [[O1:%.*]] = zext i16 [[TMP1]] to i32
+; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
 ; BE-NEXT:    store i8 0, ptr [[P3]], align 1
 ; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
 ; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
+; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
+; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
+; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
 ; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
 ; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
+; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
 ; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
 ; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
+; BE-NEXT:    [[O1:%.*]] = or i32 [[E1]], [[S2]]
 ; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
 ; BE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[S4]]
 ; BE-NEXT:    ret i32 [[O3]]
@@ -2143,18 +2201,22 @@ define i32 @loadCombine_4consecutive_badinsert5(ptr %p) {
 ; LE-NEXT:    ret i32 [[O3]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_badinsert5(
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
+; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
+; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
 ; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
 ; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
 ; BE-NEXT:    store i8 0, ptr [[P2]], align 1
-; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
-; BE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
-; BE-NEXT:    [[O1:%.*]] = zext i16 [[TMP1]] to i32
-; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
+; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P]], align 1
+; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
+; BE-NEXT:    [[L5:%.*]] = load i8, ptr [[P2]], align 1
 ; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
+; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
+; BE-NEXT:    [[E5:%.*]] = zext i8 [[L5]] to i32
 ; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
+; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
+; BE-NEXT:    [[S3:%.*]] = shl i32 [[E5]], 16
 ; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
+; BE-NEXT:    [[O1:%.*]] = or i32 [[E3]], [[S2]]
 ; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
 ; BE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[S4]]
 ; BE-NEXT:    ret i32 [[O3]]
@@ -2208,13 +2270,16 @@ define i32 @loadCombine_4consecutive_badinsert6(ptr %p) {
 ; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
 ; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
 ; BE-NEXT:    store i8 0, ptr [[P3]], align 1
-; BE-NEXT:    [[L3:%.*]] = load i16, ptr [[P2]], align 1
-; BE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L3]])
-; BE-NEXT:    [[TMP2:%.*]] = zext i16 [[TMP1]] to i32
-; BE-NEXT:    [[O1:%.*]] = shl i32 [[TMP2]], 16
+; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
+; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
 ; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
 ; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
+; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
+; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
 ; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
+; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
+; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
+; BE-NEXT:    [[O1:%.*]] = or i32 [[S3]], [[S4]]
 ; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S2]]
 ; BE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[E1]]
 ; BE-NEXT:    ret i32 [[O3]]
diff --git a/llvm/test/Transforms/AggressiveInstCombine/RISCV/or-load.ll b/llvm/test/Transforms/AggressiveInstCombine/RISCV/or-load.ll
index 767286f0d3e45..17633c64c9254 100644
--- a/llvm/test/Transforms/AggressiveInstCombine/RISCV/or-load.ll
+++ b/llvm/test/Transforms/AggressiveInstCombine/RISCV/or-load.ll
@@ -50,8 +50,13 @@ define i16 @loadCombine_2consecutive_BE(ptr %p) {
 ; BE-NEXT:    ret i16 [[L1]]
 ;
 ; ZBB-LABEL: @loadCombine_2consecutive_BE(
-; ZBB-NEXT:    [[L1:%.*]] = load i16, ptr [[P:%.*]], align 1
-; ZBB-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
+; ZBB-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
+; ZBB-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
+; ZBB-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
+; ZBB-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i16
+; ZBB-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i16
+; ZBB-NEXT:    [[S1:%.*]] = shl i16 [[E1]], 8
+; ZBB-NEXT:    [[TMP1:%.*]] = or i16 [[S1]], [[E2]]
 ; ZBB-NEXT:    ret i16 [[TMP1]]
 ;
   %p1 = getelementptr i8, ptr %p, i32 1
diff --git a/llvm/test/Transforms/AggressiveInstCombine/X86/or-load.ll b/llvm/test/Transforms/AggressiveInstCombine/X86/or-load.ll
index b22d6e46054b6..08846607ba384 100644
--- a/llvm/test/Transforms/AggressiveInstCombine/X86/or-load.ll
+++ b/llvm/test/Transforms/AggressiveInstCombine/X86/or-load.ll
@@ -9,8 +9,13 @@ define i16 @loadCombine_2consecutive(ptr %p) {
 ; LE-NEXT:    ret i16 [[L1]]
 ;
 ; BE-LABEL: @loadCombine_2consecutive(
-; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P:%.*]], align 1
-; BE-NEXT:    [[O1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
+; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
+; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
+; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
+; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i16
+; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i16
+; BE-NEXT:    [[S2:%.*]] = shl i16 [[E2]], 8
+; BE-NEXT:    [[O1:%.*]] = or i16 [[E1]], [[S2]]
 ; BE-NEXT:    ret i16 [[O1]]
 ;
   %p1 = getelementptr i8, ptr %p, i32 1
@@ -25,8 +30,13 @@ define i16 @loadCombine_2consecutive(ptr %p) {
 
 define i16 @loadCombine_2consecutive_BE(ptr %p) {
 ; LE-LABEL: @loadCombine_2consecutive_BE(
-; LE-NEXT:    [[L1:%.*]] = load i16, ptr [[P:%.*]], align 1
-; LE-NEXT:    [[O1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
+; LE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
+; LE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
+; LE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
+; LE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i16
+; LE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i16
+; LE-NEXT:    [[S1:%.*]] = shl i16 [[E1]], 8
+; LE-NEXT:    [[O1:%.*]] = or i16 [[S1]], [[E2]]
 ; LE-NEXT:    ret i16 [[O1]]
 ;
 ; BE-LABEL: @loadCombine_2consecutive_BE(
@@ -272,18 +282,22 @@ define i32 @loadCombine_4consecutive_alias2(ptr %p, ptr %pstr) {
 ; LE-NEXT:    ret i32 [[O3]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_alias2(
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
+; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
+; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
 ; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
-; BE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
-; BE-NEXT:    [[O1:%.*]] = zext i16 [[TMP1]] to i32
-; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
+; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P]], align 1
+; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
+; BE-NEXT:    [[L5:%.*]] = load i8, ptr [[P2]], align 1
 ; BE-NEXT:    store i8 10, ptr [[PSTR:%.*]], align 1
 ; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
 ; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
+; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
+; BE-NEXT:    [[E5:%.*]] = zext i8 [[L5]] to i32
 ; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
+; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
+; BE-NEXT:    [[S3:%.*]] = shl i32 [[E5]], 16
 ; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
+; BE-NEXT:    [[O1:%.*]] = or i32 [[E3]], [[S2]]
 ; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
 ; BE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[S4]]
 ; BE-NEXT:    ret i32 [[O3]]
@@ -314,21 +328,25 @@ define i32 @loadCombine_4consecutive_alias2(ptr %p, ptr %pstr) {
 
 define i32 @loadCombine_4consecutive_alias2_BE(ptr %p, ptr %pstr) {
 ; LE-LABEL: @loadCombine_4consecutive_alias2_BE(
-; LE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
+; LE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
+; LE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
 ; LE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; LE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
-; LE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
-; LE-NEXT:    [[TMP2:%.*]] = zext i16 [[TMP1]] to i32
-; LE-NEXT:    [[O1:%.*]] = shl i32 [[TMP2]], 16
-; LE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
+; LE-NEXT:    [[L3:%.*]] = load i8, ptr [[P]], align 1
+; LE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
+; LE-NEXT:    [[L5:%.*]] = load i8, ptr [[P2]], align 1
 ; LE-NEXT:    store i8 10, ptr [[PSTR:%.*]], align 1
 ; LE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
 ; LE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
-; LE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; LE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 8
+; LE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
+; LE-NEXT:    [[E5:%.*]] = zext i8 [[L5]] to i32
+; LE-NEXT:    [[E6:%.*]] = zext i8 [[L4]] to i32
+; LE-NEXT:    [[O1:%.*]] = shl i32 [[E3]], 24
+; LE-NEXT:    [[S3:%.*]] = shl i32 [[E2]], 16
+; LE-NEXT:    [[E4:%.*]] = shl i32 [[E5]], 8
 ; LE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
 ; LE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[E4]]
-; LE-NEXT:    ret i32 [[O3]]
+; LE-NEXT:    [[O4:%.*]] = or i32 [[O3]], [[E6]]
+; LE-NEXT:    ret i32 [[O4]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_alias2_BE(
 ; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
@@ -389,19 +407,23 @@ define i32 @loadCombine_4consecutive_alias3(ptr %p) {
 ; LE-NEXT:    ret i32 [[O3]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_alias3(
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
+; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
+; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
 ; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
-; BE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
-; BE-NEXT:    [[O1:%.*]] = zext i16 [[TMP1]] to i32
-; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
+; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P]], align 1
+; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
+; BE-NEXT:    [[L5:%.*]] = load i8, ptr [[P2]], align 1
 ; BE-NEXT:    store i8 10, ptr [[P3]], align 1
 ; BE-NEXT:    store i8 5, ptr [[P]], align 1
 ; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
 ; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
+; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
+; BE-NEXT:    [[E5:%.*]] = zext i8 [[L5]] to i32
 ; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
+; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
+; BE-NEXT:    [[S3:%.*]] = shl i32 [[E5]], 16
 ; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
+; BE-NEXT:    [[O1:%.*]] = or i32 [[E3]], [[S2]]
 ; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
 ; BE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[S4]]
 ; BE-NEXT:    ret i32 [[O3]]
@@ -433,22 +455,26 @@ define i32 @loadCombine_4consecutive_alias3(ptr %p) {
 
 define i32 @loadCombine_4consecutive_alias3_BE(ptr %p) {
 ; LE-LABEL: @loadCombine_4consecutive_alias3_BE(
-; LE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
+; LE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
+; LE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
 ; LE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; LE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
-; LE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
-; LE-NEXT:    [[TMP2:%.*]] = zext i16 [[TMP1]] to i32
-; LE-NEXT:    [[O1:%.*]] = shl i32 [[TMP2]], 16
-; LE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
+; LE-NEXT:    [[L3:%.*]] = load i8, ptr [[P]], align 1
+; LE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
+; LE-NEXT:    [[L5:%.*]] = load i8, ptr [[P2]], align 1
 ; LE-NEXT:    store i8 10, ptr [[P3]], align 1
 ; LE-NEXT:    store i8 5, ptr [[P]], align 1
 ; LE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
 ; LE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
-; LE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; LE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 8
+; LE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
+; LE-NEXT:    [[E5:%.*]] = zext i8 [[L5]] to i32
+; LE-NEXT:    [[E6:%.*]] = zext i8 [[L4]] to i32
+; LE-NEXT:    [[O1:%.*]] = shl i32 [[E3]], 24
+; LE-NEXT:    [[S3:%.*]] = shl i32 [[E2]], 16
+; LE-NEXT:    [[E4:%.*]] = shl i32 [[E5]], 8
 ; LE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
 ; LE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[E4]]
-; LE-NEXT:    ret i32 [[O3]]
+; LE-NEXT:    [[O4:%.*]] = or i32 [[O3]], [[E6]]
+; LE-NEXT:    ret i32 [[O4]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_alias3_BE(
 ; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
@@ -726,17 +752,21 @@ define i32 @loadCombine_4consecutive_hasOneUse4(ptr %p) {
 ; LE-NEXT:    ret i32 [[O3]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_hasOneUse4(
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
+; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
+; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
 ; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
-; BE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
-; BE-NEXT:    [[O1:%.*]] = zext i16 [[TMP1]] to i32
-; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
-; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
+; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P]], align 1
+; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P1]], align 1
+; BE-NEXT:    [[L5:%.*]] = load i8, ptr [[P2]], align 1
+; BE-NEXT:    [[L6:%.*]] = load i8, ptr [[P3]], align 1
 ; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
 ; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
-; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
+; BE-NEXT:    [[E5:%.*]] = zext i8 [[L5]] to i32
+; BE-NEXT:    [[E6:%.*]] = zext i8 [[L6]] to i32
+; BE-NEXT:    [[S2:%.*]] = shl i32 [[E4]], 8
+; BE-NEXT:    [[S3:%.*]] = shl i32 [[E5]], 16
+; BE-NEXT:    [[S4:%.*]] = shl i32 [[E6]], 24
+; BE-NEXT:    [[O1:%.*]] = or i32 [[E3]], [[S2]]
 ; BE-NEXT:    call void @use(i32 [[O1]])
 ; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
 ; BE-NEXT:    call void @use(i32 [[O2]])
@@ -819,13 +849,17 @@ define i32 @loadCombine_parLoad1(ptr %p) {
 ; LE-NEXT:    ret i32 [[O2]]
 ;
 ; BE-LABEL: @loadCombine_parLoad1(
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
-; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
-; BE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
-; BE-NEXT:    [[O1:%.*]] = zext i16 [[TMP1]] to i32
-; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
+; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
+; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
+; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P]], align 1
+; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
+; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P2]], align 1
 ; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
-; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
+; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
+; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
+; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
+; BE-NEXT:    [[S3:%.*]] = shl i32 [[E4]], 16
+; BE-NEXT:    [[O1:%.*]] = or i32 [[E3]], [[S2]]
 ; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
 ; BE-NEXT:    ret i32 [[O2]]
 ;
@@ -1560,13 +1594,17 @@ define i32 @loadCombine_4consecutive_rev_mixsize1(ptr %p) {
 ;
 ; BE-LABEL: @loadCombine_4consecutive_rev_mixsize1(
 ; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
+; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
 ; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 2
-; BE-NEXT:    [[L2:%.*]] = load i16, ptr [[P2]], align 1
-; BE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L2]])
-; BE-NEXT:    [[E2:%.*]] = zext i16 [[TMP1]] to i32
-; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 16
+; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P2]], align 1
+; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P3]], align 1
 ; BE-NEXT:    [[E1:%.*]] = zext i16 [[L1]] to i32
-; BE-NEXT:    [[O2:%.*]] = or i32 [[S2]], [[E1]]
+; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
+; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
+; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 16
+; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 24
+; BE-NEXT:    [[O1:%.*]] = or i32 [[S3]], [[S2]]
+; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[E1]]
 ; BE-NEXT:    ret i32 [[O2]]
 ;
   %p2 = getelementptr i8, ptr %p, i32 2
@@ -1590,12 +1628,16 @@ define i32 @loadCombine_4consecutive_rev_mixsize1(ptr %p) {
 define i32 @loadCombine_4consecutive_rev_mixsize1_BE(ptr %p) {
 ; LE-LABEL: @loadCombine_4consecutive_rev_mixsize1_BE(
 ; LE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
+; LE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
 ; LE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 2
-; LE-NEXT:    [[L2:%.*]] = load i16, ptr [[P2]], align 1
-; LE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L2]])
-; LE-NEXT:    [[O1:%.*]] = zext i16 [[TMP1]] to i32
+; LE-NEXT:    [[L2:%.*]] = load i8, ptr [[P2]], align 1
+; LE-NEXT:    [[L3:%.*]] = load i8, ptr [[P3]], align 1
 ; LE-NEXT:    [[E1:%.*]] = zext i16 [[L1]] to i32
+; LE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
+; LE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
 ; LE-NEXT:    [[S1:%.*]] = shl i32 [[E1]], 16
+; LE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
+; LE-NEXT:    [[O1:%.*]] = or i32 [[E3]], [[S2]]
 ; LE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S1]]
 ; LE-NEXT:    ret i32 [[O2]]
 ;
@@ -1627,13 +1669,17 @@ define i32 @loadCombine_4consecutive_mixsize2(ptr %p) {
 ; LE-NEXT:    ret i32 [[O2]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_mixsize2(
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
-; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
-; BE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
-; BE-NEXT:    [[O1:%.*]] = zext i16 [[TMP1]] to i32
+; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
+; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
+; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
+; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
 ; BE-NEXT:    [[L3:%.*]] = load i16, ptr [[P2]], align 2
+; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
+; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
 ; BE-NEXT:    [[E3:%.*]] = zext i16 [[L3]] to i32
+; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
 ; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
+; BE-NEXT:    [[O1:%.*]] = or i32 [[E1]], [[S2]]
 ; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
 ; BE-NEXT:    ret i32 [[O2]]
 ;
@@ -1697,9 +1743,13 @@ define i16 @loadCombine_2consecutive_badinsert(ptr %p) {
 ;
 ; BE-LABEL: @loadCombine_2consecutive_badinsert(
 ; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
-; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
-; BE-NEXT:    [[O1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
+; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
 ; BE-NEXT:    store i8 0, ptr [[P1]], align 1
+; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
+; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i16
+; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i16
+; BE-NEXT:    [[S2:%.*]] = shl i16 [[E2]], 8
+; BE-NEXT:    [[O1:%.*]] = or i16 [[E1]], [[S2]]
 ; BE-NEXT:    ret i16 [[O1]]
 ;
   %p1 = getelementptr i8, ptr %p, i32 1
@@ -1769,18 +1819,22 @@ define i32 @loadCombine_4consecutive_badinsert2(ptr %p) {
 ; LE-NEXT:    ret i32 [[O3]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_badinsert2(
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
+; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
+; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
 ; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
-; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
-; BE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
-; BE-NEXT:    [[O1:%.*]] = zext i16 [[TMP1]] to i32
+; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
 ; BE-NEXT:    store i8 0, ptr [[P3]], align 1
 ; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
 ; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
+; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
+; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
+; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
 ; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
 ; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
+; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
 ; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
 ; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
+; BE-NEXT:    [[O1:%.*]] = or i32 [[E1]], [[S2]]
 ; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
 ; BE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[S4]]
 ; BE-NEXT:    ret i32 [[O3]]
@@ -1923,18 +1977,22 @@ define i32 @loadCombine_4consecutive_badinsert5(ptr %p) {
 ; LE-NEXT:    ret i32 [[O3]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_badinsert5(
-; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 2
+; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 1
+; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i32 2
 ; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 3
 ; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
 ; BE-NEXT:    store i8 0, ptr [[P2]], align 1
-; BE-NEXT:    [[L1:%.*]] = load i16, ptr [[P]], align 1
-; BE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L1]])
-; BE-NEXT:    [[O1:%.*]] = zext i16 [[TMP1]] to i32
-; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
+; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P]], align 1
+; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
+; BE-NEXT:    [[L5:%.*]] = load i8, ptr [[P2]], align 1
 ; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
+; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
+; BE-NEXT:    [[E5:%.*]] = zext i8 [[L5]] to i32
 ; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
-; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
+; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
+; BE-NEXT:    [[S3:%.*]] = shl i32 [[E5]], 16
 ; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
+; BE-NEXT:    [[O1:%.*]] = or i32 [[E3]], [[S2]]
 ; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S3]]
 ; BE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[S4]]
 ; BE-NEXT:    ret i32 [[O3]]
@@ -1988,13 +2046,16 @@ define i32 @loadCombine_4consecutive_badinsert6(ptr %p) {
 ; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
 ; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
 ; BE-NEXT:    store i8 0, ptr [[P3]], align 1
-; BE-NEXT:    [[L3:%.*]] = load i16, ptr [[P2]], align 1
-; BE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L3]])
-; BE-NEXT:    [[TMP2:%.*]] = zext i16 [[TMP1]] to i32
-; BE-NEXT:    [[O1:%.*]] = shl i32 [[TMP2]], 16
+; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
+; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
 ; BE-NEXT:    [[E1:%.*]] = zext i8 [[L1]] to i32
 ; BE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
+; BE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
+; BE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
 ; BE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
+; BE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 16
+; BE-NEXT:    [[S4:%.*]] = shl i32 [[E4]], 24
+; BE-NEXT:    [[O1:%.*]] = or i32 [[S3]], [[S4]]
 ; BE-NEXT:    [[O2:%.*]] = or i32 [[O1]], [[S2]]
 ; BE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[E1]]
 ; BE-NEXT:    ret i32 [[O3]]
@@ -2162,10 +2223,14 @@ define i32 @loadcombine_consecutive_idx_64(ptr %data) {
 ;
 ; BE-LABEL: @loadcombine_consecutive_idx_64(
 ; BE-NEXT:  entry:
-; BE-NEXT:    [[TMP0:%.*]] = getelementptr i8, ptr [[DATA:%.*]], i64 2149675576
-; BE-NEXT:    [[VAL_2:%.*]] = load i16, ptr [[TMP0]], align 1
-; BE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[VAL_2]])
-; BE-NEXT:    [[OR:%.*]] = zext i16 [[TMP1]] to i32
+; BE-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds nuw i8, ptr [[DATA:%.*]], i64 2149675577
+; BE-NEXT:    [[VAL:%.*]] = load i8, ptr [[ARRAYIDX]], align 1
+; BE-NEXT:    [[CONV:%.*]] = zext i8 [[VAL]] to i32
+; BE-NEXT:    [[ARRAYIDX_2:%.*]] = getelementptr inbounds nuw i8, ptr [[DATA]], i64 2149675576
+; BE-NEXT:    [[VAL_2:%.*]] = load i8, ptr [[ARRAYIDX_2]], align 1
+; BE-NEXT:    [[CONV_2:%.*]] = zext i8 [[VAL_2]] to i32
+; BE-NEXT:    [[SHL:%.*]] = shl nuw nsw i32 [[CONV]], 8
+; BE-NEXT:    [[OR:%.*]] = or disjoint i32 [[SHL]], [[CONV_2]]
 ; BE-NEXT:    ret i32 [[OR]]
 ;
 entry:
@@ -2234,14 +2299,34 @@ entry:
 }
 
 define i16 @combine_four_i8_loads_i16_poison(ptr %p) {
-; ALL-LABEL: @combine_four_i8_loads_i16_poison(
-; ALL-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i64 2
-; ALL-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i64 3
-; ALL-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
-; ALL-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
-; ALL-NEXT:    [[Z3:%.*]] = zext i8 [[L3]] to i16
-; ALL-NEXT:    [[Z4:%.*]] = zext i8 [[L4]] to i16
-; ALL-NEXT:    ret i16 poison
+; LE-LABEL: @combine_four_i8_loads_i16_poison(
+; LE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i64 2
+; LE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i64 3
+; LE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
+; LE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
+; LE-NEXT:    [[Z3:%.*]] = zext i8 [[L3]] to i16
+; LE-NEXT:    [[Z4:%.*]] = zext i8 [[L4]] to i16
+; LE-NEXT:    ret i16 poison
+;
+; BE-LABEL: @combine_four_i8_loads_i16_poison(
+; BE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i64 1
+; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i64 2
+; BE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i64 3
+; BE-NEXT:    [[L1:%.*]] = load i8, ptr [[P]], align 1
+; BE-NEXT:    [[L2:%.*]] = load i8, ptr [[P1]], align 1
+; BE-NEXT:    [[L3:%.*]] = load i8, ptr [[P2]], align 1
+; BE-NEXT:    [[L4:%.*]] = load i8, ptr [[P3]], align 1
+; BE-NEXT:    [[Z1:%.*]] = zext i8 [[L1]] to i16
+; BE-NEXT:    [[Z2:%.*]] = zext i8 [[L2]] to i16
+; BE-NEXT:    [[Z3:%.*]] = zext i8 [[L3]] to i16
+; BE-NEXT:    [[Z4:%.*]] = zext i8 [[L4]] to i16
+; BE-NEXT:    [[SH2:%.*]] = shl i16 [[Z2]], 8
+; BE-NEXT:    [[OR1:%.*]] = or i16 [[Z1]], [[SH2]]
+; BE-NEXT:    [[SH3:%.*]] = shl i16 [[Z3]], 16
+; BE-NEXT:    [[OR2:%.*]] = or i16 [[OR1]], [[SH3]]
+; BE-NEXT:    [[SH4:%.*]] = shl i16 [[Z4]], 24
+; BE-NEXT:    [[OR3:%.*]] = or i16 [[OR2]], [[SH4]]
+; BE-NEXT:    ret i16 [[OR3]]
 ;
   %p1 = getelementptr i8, ptr %p, i64 1
   %p2 = getelementptr i8, ptr %p, i64 2
@@ -2386,20 +2471,24 @@ define i32 @loadCombine_4consecutive_bswap_multiuse(ptr %p, ptr %q) {
 ; Negative test: the first pair is in reverse order, but the rest are not.
 define i32 @loadCombine_4consecutive_bswap_mixed_order(ptr %p) {
 ; LE-LABEL: @loadCombine_4consecutive_bswap_mixed_order(
-; LE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i64 2
+; LE-NEXT:    [[P1:%.*]] = getelementptr i8, ptr [[P:%.*]], i64 1
+; LE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i64 2
 ; LE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i64 3
-; LE-NEXT:    [[L0:%.*]] = load i16, ptr [[P]], align 1
-; LE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L0]])
-; LE-NEXT:    [[TMP2:%.*]] = zext i16 [[TMP1]] to i32
-; LE-NEXT:    [[L2:%.*]] = load i8, ptr [[P2]], align 1
-; LE-NEXT:    [[L3:%.*]] = load i8, ptr [[P3]], align 1
+; LE-NEXT:    [[L2:%.*]] = load i8, ptr [[P]], align 1
+; LE-NEXT:    [[L3:%.*]] = load i8, ptr [[P1]], align 1
+; LE-NEXT:    [[L4:%.*]] = load i8, ptr [[P2]], align 1
+; LE-NEXT:    [[L5:%.*]] = load i8, ptr [[P3]], align 1
 ; LE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
 ; LE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
-; LE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 16
-; LE-NEXT:    [[S3:%.*]] = shl i32 [[E3]], 24
-; LE-NEXT:    [[O2:%.*]] = or i32 [[TMP2]], [[S2]]
+; LE-NEXT:    [[E4:%.*]] = zext i8 [[L4]] to i32
+; LE-NEXT:    [[E5:%.*]] = zext i8 [[L5]] to i32
+; LE-NEXT:    [[S0:%.*]] = shl i32 [[E2]], 8
+; LE-NEXT:    [[S3:%.*]] = shl i32 [[E4]], 16
+; LE-NEXT:    [[S4:%.*]] = shl i32 [[E5]], 24
+; LE-NEXT:    [[O2:%.*]] = or i32 [[S0]], [[E3]]
 ; LE-NEXT:    [[O3:%.*]] = or i32 [[O2]], [[S3]]
-; LE-NEXT:    ret i32 [[O3]]
+; LE-NEXT:    [[O4:%.*]] = or i32 [[O3]], [[S4]]
+; LE-NEXT:    ret i32 [[O4]]
 ;
 ; BE-LABEL: @loadCombine_4consecutive_bswap_mixed_order(
 ; BE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i64 2
@@ -2467,12 +2556,16 @@ define i32 @loadCombine_2consecutive_i16_reverse(ptr %p) {
 define i32 @loadCombine_4consecutive_bswap_mixsize(ptr %p) {
 ; LE-LABEL: @loadCombine_4consecutive_bswap_mixsize(
 ; LE-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P:%.*]], i64 2
+; LE-NEXT:    [[P3:%.*]] = getelementptr i8, ptr [[P]], i64 3
 ; LE-NEXT:    [[L0:%.*]] = load i16, ptr [[P]], align 2
-; LE-NEXT:    [[L2:%.*]] = load i16, ptr [[P2]], align 1
-; LE-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[L2]])
-; LE-NEXT:    [[TMP2:%.*]] = zext i16 [[TMP1]] to i32
+; LE-NEXT:    [[L2:%.*]] = load i8, ptr [[P2]], align 1
+; LE-NEXT:    [[L3:%.*]] = load i8, ptr [[P3]], align 1
 ; LE-NEXT:    [[E0:%.*]] = zext i16 [[L0]] to i32
+; LE-NEXT:    [[E2:%.*]] = zext i8 [[L2]] to i32
+; LE-NEXT:    [[E3:%.*]] = zext i8 [[L3]] to i32
 ; LE-NEXT:    [[S0:%.*]] = shl i32 [[E0]], 16
+; LE-NEXT:    [[S2:%.*]] = shl i32 [[E2]], 8
+; LE-NEXT:    [[TMP2:%.*]] = or i32 [[S2]], [[E3]]
 ; LE-NEXT:    [[O2:%.*]] = or i32 [[TMP2]], [[S0]]
 ; LE-NEXT:    ret i32 [[O2]]
 ;



More information about the llvm-commits mailing list