[PowerPC] Add a pass to merge all of the constant global arrays into one pool.

[stefanp]

Summary

On PowerPC the number of TOC entries must be kept low for large
applications. In order to reduce the number of constant global arrays
we can pool them into one structure and then access them as the base
address of that structure plus some offset. The constant global arrays
may be arrays of i8 which are constant strings but they may also be
arrays of i32, i64, etc....

[stefanp]

Did a clang-format on one file where I had missed the formatting.

[amyk]

llvm/lib/Target/PowerPC/PPCMergeStringPool.cpp

61

Silly question - Does this need to be an else if? Just wondering since the alignments are an else if so maybe I am missing something.

91

Question: I think we discussed this before when talking about constant merging, but how do we determine which passes to preserve again? And how does this different from the constant pool merge patch?

112

Is there a reason why this is declared outside, rather than inside the class?

280

298

Do we mean user here?

llvm/lib/Target/PowerPC/PPCTargetMachine.cpp

105

[amyk]

llvm/lib/Target/PowerPC/PPCMergeStringPool.cpp

164

This might be just me and is a minor nit, but I think it may read better of it was something like "Constant data of Global:" or something like that.

This is minor though, so you can feel free to go with whichever one you like.

llvm/test/CodeGen/PowerPC/stringpool.ll

2

Can we add -ppc-asm-full-reg-names to this?

[amyk]

Also can we add in the title of the review that this is for strings specifically?

[amyk]

More group code review comments.

Also, actually, is it more accurate to call this "array pooling" rather than "string pooling"?

llvm/lib/Target/PowerPC/PPCMergeStringPool.cpp

50

Do we need to check size and alignment together?

58

Can this be slightly more elaborated upon?

114

Can we get the context later on when we need it?

120

Can we document this function (and why instruction and non-GlobalValue constant users are valid)?

127

Question:

• Can we elaborate why we can't have GlobalValues here?
• Can we add a test case where we have a constant using constant?
• Can we add a test where a constant is a global value and where it is not?

128

• Can we do CurrentUser here instead of UserConstant since we are casting twice?
• And can we pull this statement out after after 122-123 since we're reducing nesting?

137

Can we document this function?

145

Is the hasInitializer() check necessary?

Also, is it possible to have a constant that is undef?

148

• Can we document why the global cannot have a section and metadata?
• Can we combine these into ||?

llvm/test/CodeGen/PowerPC/stringpool.ll

32

Can we add a test where we do addis->addi?

[amyk]

llvm/lib/Target/PowerPC/PPCMergeStringPool.cpp

79

New group code review questions:

• Have we considered alignment based string pool struct?
• Have we considered making this target independent and making a Discourse discussion regarding this?

193

Could we update the name of this SmallVector to better indicate it's purpose?

211

Is our element index big enough?
Should it be size_t, or at least a size large enough for what we are targeting? It should support any platform's size_t.

243

Could we please add some documentation to this function?

[stefanp]

Addressed most of the comments in the review. There is only one more test case that I want to look at.
Turned the pass on by default on PowerPC.

[stefanp]

llvm/lib/Target/PowerPC/PPCMergeStringPool.cpp

50

At this point I've added a limitation where where the alignment cannot be larger than the size of the element in order to be included in the pool. This means that at this point it is sufficient to just check the alignment here.

79

I think that both of these are good suggestions.

I think that one struct per alignment may be a good idea but I think it should be controlled by an option and added as a later patch.

This pass does not rely on anything that is PowerPC specific and so it could be turned into a target independent pass. However, I would prefer to try this for PowerPC first because I go ahead and try to make it target independent for a number of targets.

91

When I look at passes to preserve I generally add this pass and then look to see which analysis passes are added after this one in the pipeline. After that I check the passes that are added to see if it makes sense to preserve them. It's not really a hard science and it is a bit of a judgement call because I have to have an understanding of what each pass does.

This pass is in a very different place in the pipeline compared to the constant pool patch. This pass is before instruction selection and so it is an IR pass and not a machine IR pass.

112

Moved inside the class.

114

Moved this out.

148

I'm not going to merge these two into one if statement. They have nothing to do with each other and I think it's more clear if they are separate.

[lei]

nit: can we rename the new test files tobe mergeable-string-pool.ll mergeable-string-pool-large.ll?

[amyk]

Group review comments.
Also, can we update the patch description to elaborate on what we mean by "strings"?

llvm/lib/Target/PowerPC/PPCMergeStringPool.cpp

103

nit: Maybe renaming this is more clear? MergeableStrings, or something similar?

119

Can we rename this function so it is more clear?

122

(For here and below) Instead of dyn_cast<>, maybe isa<> is better?

133

156

169

Check to see if line 168 can be inlined.

224

Can we add a TODO to split the struct if the offsets get too big?

llvm/test/CodeGen/PowerPC/stringpool.ll

6

If this is on by default, I think -ppc-merge-string-pool=true can be removed for here and other places.

[stefanp]

Addressed the remainder of the review comments.
Added a couple of TODOs.
Removed the option from the test cases as it is on by default now.

[amyk]

More group review comments.

It would be good add an IR to IR test for this patch, as well.

llvm/lib/Target/PowerPC/PPCMergeStringPool.cpp

112

Please check that this is where the namespace should end.

222

Can we reword the comment (to describe the intention behind the code and to elaborate on why we're doing it)?

Also, update the TODO below to reflect that we're calling it "pool" rather than "struct".

227

Can we also update the naming for AnonStruct?
Maybe just ConstantPool?

231

Rename this maybe so we know what the global is for?

248–252

This whole part can probably be put into the function that inserts the GEP before the users.

254

• This function name update might be more clear.
• Add a comment as to why we need to insert the GEPs.

257

• Maybe it would be safer to limit the globals only to private linkage (move the check to collectCandidateConstants)?
• Can this either be either private or internal linkage?

[stefanp]

Added better variable naming.
Moved the linkage check to the place where the candidates are collected.
Moved the array copy into the function that adds the GEP.

[amyk]

Submitting group code review.

llvm/lib/Target/PowerPC/PPCMergeStringPool.cpp

95

Can adding the constant GEP in PHI affect SCEV (line 93/94)?

236

Use PooledStructType in this line.

276

Rewording of the function for clarity.

279–280

Can these variables be inlined?

286

288

Maybe just:

289

Instead of G, use the full word (Global) for all G* variables.

297

Expand on this a bit more (that the GEP is added into the PHI itself).

304

Indicate that for regular instructions we add the GEP before hand.

322

• Add a comment here to describe the situation (adding the GEP inline).
• Also, move this before line 338 (where it is first used).

326–327

• Clarify the comment a bit?
• Can we move all of the casts/checks/asserts (also on 331, 335) on top rather than at the bottom (so we check everything that is valid, then we go about the replacing)?
• Add an IR test for this case.

llvm/test/CodeGen/PowerPC/O3-pipeline.ll

76 ↗

(On Diff #553460)

Can we check if the Dominator Tree Construction is expected, or if it's just there because it's a module pass.

[stefanp]

Added another test case that is IR to IR for this pass.
Addressed remaining comments.

llvm/lib/Target/PowerPC/PPCMergeStringPool.cpp

112

I've moved this down. None of the functions needs to be accessed from outside of the class so there is no reason to take them outside of the namespace.

llvm/test/CodeGen/PowerPC/O3-pipeline.ll

76 ↗

(On Diff #553460)

I did check and this seems to be related to the fact that this is a module pass. I did try to add setPreservesAll and I still got the extra passes so I'm not sure there is much that can be done about this.

[lei]

For new passes, maybe we can commit it as off first and then subsequent patch to turn it on by default? That way if it causes any issues we can just revert the default on patch.

llvm/lib/Target/PowerPC/PPCMergeStringPool.cpp

214

Wondering if maybe we need to do more investigation into this, as in is there any negative benefits to merging strings if they are < N.

223

nit: Do we need the braces for the for-loop?

306–336

Was thinking maybe we can split this nested if into an early exit of the loop.
Basically:

if (!UserInstruction) {
  // User is a constant type.
  ....
  continue;
}

// User is a valid instruction.

if (PHINode *UserPHI = dyn_cast<PHINode>(UserInstruction)) {
  // User is a PHI node instruction.
  .....
  continue;

}

// The user is a valid instruction that is not a PHINode.

314

nit: indent

[stefanp]

In D155730#4628279, @lei wrote:

For new passes, maybe we can commit it as off first and then subsequent patch to turn it on by default? That way if it causes any issues we can just revert the default on patch.

I'm going to split this patch as you suggested. This patch will have the pass off by default and then I will add another quick patch to github where it is turned on.

llvm/lib/Target/PowerPC/PPCMergeStringPool.cpp

214

I've added an option that we can use to do this investigation in the future.

[stefanp]

Addressed a couple of review comments. Split this patch into two.
This patch now has the pass off by default. A second patch will turn it on by default.

[lei]

LGTM
Thx

llvm/lib/Target/PowerPC/PPCMergeStringPool.cpp

318

nit: extra empty line

[amyk]

Also LGTM and thanks for answering the questions and addressing comments.

[stefanp]

Rebased to top of main. Fixed last nit.

llvm/lib/Target/PowerPC/CMakeLists.txt

add_llvm_target(PowerPCCodeGen
   PPCEarlyReturn.cpp
   PPCFastISel.cpp
   PPCFrameLowering.cpp
   PPCLoopInstrFormPrep.cpp
   PPCMCInstLower.cpp
   PPCMachineFunctionInfo.cpp
   PPCMachineScheduler.cpp
   PPCMacroFusion.cpp
+  PPCMergeStringPool.cpp
   PPCMIPeephole.cpp
   PPCRegisterInfo.cpp
   PPCSubtarget.cpp
   PPCTargetMachine.cpp
   PPCTargetObjectFile.cpp
   PPCTargetTransformInfo.cpp
   PPCTOCRegDeps.cpp
   PPCTLSDynamicCall.cpp

llvm/lib/Target/PowerPC/PPC.h

#endif
   FunctionPass *createPPCBranchCoalescingPass();
   FunctionPass *createPPCISelDag(PPCTargetMachine &TM, CodeGenOpt::Level OL);
   FunctionPass *createPPCTLSDynamicCallPass();
   FunctionPass *createPPCBoolRetToIntPass();
   FunctionPass *createPPCExpandISELPass();
   FunctionPass *createPPCPreEmitPeepholePass();
   FunctionPass *createPPCExpandAtomicPseudoPass();
   FunctionPass *createPPCCTRLoopsPass();
+  ModulePass *createPPCMergeStringPoolPass();
   void LowerPPCMachineInstrToMCInst(const MachineInstr *MI, MCInst &OutMI,
                                     AsmPrinter &AP);
   bool LowerPPCMachineOperandToMCOperand(const MachineOperand &MO,
                                          MCOperand &OutMO, AsmPrinter &AP);
 
 #ifndef NDEBUG
   void initializePPCCTRLoopsVerifyPass(PassRegistry&);
 #endif
#endif
   void initializePPCBoolRetToIntPass(PassRegistry&);
   void initializePPCExpandISELPass(PassRegistry &);
   void initializePPCPreEmitPeepholePass(PassRegistry &);
   void initializePPCTLSDynamicCallPass(PassRegistry &);
   void initializePPCMIPeepholePass(PassRegistry&);
   void initializePPCExpandAtomicPseudoPass(PassRegistry &);
   void initializePPCCTRLoopsPass(PassRegistry &);
   void initializePPCDAGToDAGISelPass(PassRegistry &);
+  void initializePPCMergeStringPoolPass(PassRegistry &);
 
   extern char &PPCVSXFMAMutateID;
 
   ModulePass *createPPCLowerMASSVEntriesPass();
   void initializePPCLowerMASSVEntriesPass(PassRegistry &);
   extern char &PPCLowerMASSVEntriesID;
 
   ModulePass *createPPCGenScalarMASSEntriesPass();

llvm/lib/Target/PowerPC/PPCMergeStringPool.cpp

+//===-- PPCMergeStringPool.cpp -------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This transformation tries to merge the strings in the module into one pool
+// of strings. The idea is to reduce the number of TOC entries in the module so
+// that instead of having one TOC entry for each string there is only one global
+// TOC entry and all of the strings are referenced off of that one entry plus
+// an offset.
+//
+//===----------------------------------------------------------------------===//
+
+#include "PPC.h"
+#include "llvm/ADT/SetVector.h"
+#include "llvm/ADT/SmallSet.h"
+#include "llvm/ADT/Statistic.h"
+#include "llvm/Analysis/DomTreeUpdater.h"
+#include "llvm/Analysis/LoopInfo.h"
+#include "llvm/Analysis/LoopIterator.h"
+#include "llvm/Analysis/ScalarEvolution.h"
+#include "llvm/Analysis/ScalarEvolutionAliasAnalysis.h"
+#include "llvm/IR/Constants.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/IR/Module.h"
+#include "llvm/IR/ValueSymbolTable.h"
+#include "llvm/Pass.h"
+#include "llvm/Support/CommandLine.h"
+
+#define DEBUG_TYPE "ppc-merge-strings"
+
+STATISTIC(NumPooledStrings, "Number of Strings Pooled");
+
+using namespace llvm;
+
+static cl::opt<unsigned>
+    MaxStringsPooled("ppc-max-strings-pooled", cl::Hidden, cl::init(-1),
+                     cl::desc("Maximum Number of Strings to Pool."));
+
+namespace {
+struct {
+  bool operator()(const GlobalVariable *LHS, const GlobalVariable *RHS) const {
+    // First priority is alignment.
+    // If elements are sorted in terms of alignment then there won't be an
+    // issue with incorrect alignent that would require padding.
+    Align LHSAlign = LHS->getAlign().valueOrOne();
+    Align RHSAlign = RHS->getAlign().valueOrOne();
+    if (LHSAlign > RHSAlign)
+      return true;
+    else if (LHSAlign < RHSAlign)
+      return false;
+
+    // Next priority is the number of uses.
+    // Theoretically smaller offsets are easier to materialize.
+    if (LHS->getNumUses() > RHS->getNumUses())
+      return true;
+    if (LHS->getNumUses() < RHS->getNumUses())
+      return false;
+
+    const Constant *ConstLHS = LHS->getInitializer();
+    const ConstantDataSequential *ConstDataLHS =
+        dyn_cast<ConstantDataSequential>(ConstLHS);
+    unsigned LHSSize =
+        ConstDataLHS->getNumElements() * ConstDataLHS->getElementByteSize();
+    const Constant *ConstRHS = RHS->getInitializer();
+    const ConstantDataSequential *ConstDataRHS =
+        dyn_cast<ConstantDataSequential>(ConstRHS);
+    unsigned RHSSize =
+        ConstDataRHS->getNumElements() * ConstDataRHS->getElementByteSize();
+
+    // Finally smaller constants should go first. This is, again, trying to
+    // minimize the offsets into the final struct.
+    return LHSSize < RHSSize;
+  }
+} CompareConstants;
+
+class PPCMergeStringPool : public ModulePass {
+public:
+  static char ID;
+  PPCMergeStringPool() : ModulePass(ID) {}
+
+  bool runOnModule(Module &M) override;
+
+  StringRef getPassName() const override { return "PPC Merge String Pool"; }
+
+  void getAnalysisUsage(AnalysisUsage &AU) const override {
+    AU.addPreserved<DominatorTreeWrapperPass>();
+    AU.addPreserved<LoopInfoWrapperPass>();
+    AU.addPreserved<ScalarEvolutionWrapperPass>();
+    AU.addPreserved<SCEVAAWrapperPass>();
+  }
+
+private:
+  // Globals in a Module are already unique so a set is not required and a
+  // vector will do.
+  std::vector<GlobalVariable *> ConstsToMerge;
+  Type *PooledStructType;
+  LLVMContext *Context;
+  void collectCandidateConstants(Module &M);
+  bool mergeModuleStringPool(Module &M);
+  void insertGEPBeforeUser(SmallVector<User *> &UsersList,
+                           GlobalVariable *GToReplace, GlobalVariable *GPool,
+                           unsigned ElementIndex);
+};
+
+} // namespace
+
+bool PPCMergeStringPool::runOnModule(Module &M) {
+  bool Changed = false;
+  Context = &M.getContext();
+
+  Changed = mergeModuleStringPool(M);
+  return Changed;
+}
+
+static bool hasValidUsers(GlobalVariable &GV) {
+  for (User *CurrentUser : GV.users()) {
+    // Instruction users are always valid.
+    if (dyn_cast<Instruction>(CurrentUser))
+      continue;
+
+    if (Constant *UserConstant = dyn_cast<Constant>(CurrentUser)) {
+      // We can replace all Constant users except GlobalValues.
+      if (dyn_cast<GlobalValue>(UserConstant))
+        return false;
+    } else
+      return false;
+  }
+
+  return true;
+}
+
+void PPCMergeStringPool::collectCandidateConstants(Module &M) {
+  for (GlobalVariable &Global : M.globals()) {
+    LLVM_DEBUG(dbgs() << "Looking at global:");
+    LLVM_DEBUG(Global.dump());
+    LLVM_DEBUG(dbgs() << "isConstant() " << Global.isConstant() << "\n");
+    LLVM_DEBUG(dbgs() << "hasInitializer() " << Global.hasInitializer()
+                      << "\n");
+
+    // We can only pool constants.
+    if (!Global.isConstant() || !Global.hasInitializer())
+      continue;
+
+    if (Global.hasSection())
+      continue;
+
+    if (Global.hasMetadata())
+      continue;
+
+    Constant *Const = Global.getInitializer();
+    ConstantDataSequential *ConstData = dyn_cast<ConstantDataSequential>(Const);
+
+    if (!ConstData)
+      continue;
+
+    if (!hasValidUsers(Global))
+      continue;
+
+    LLVM_DEBUG(dbgs() << "Have constant data: ");
+    LLVM_DEBUG(ConstData->dump());
+    LLVM_DEBUG(dbgs() << "\n\n");
+
+    ConstsToMerge.push_back(&Global);
+
+    // If we have already reached the maximum number of pooled strings then
+    // there is no point in looking for more.
+    if (ConstsToMerge.size() >= MaxStringsPooled)
+      break;
+  }
+}
+
+bool PPCMergeStringPool::mergeModuleStringPool(Module &M) {
+
+  LLVM_DEBUG(dbgs() << "Merging string pool for module: " << M.getName()
+                    << "\n");
+  LLVM_DEBUG(dbgs() << "Number of globals is: " << M.global_size() << "\n");
+
+  collectCandidateConstants(M);
+
+  // If we only have one (or fewer) constants in the module that are merge
+  // candidates we can skip doing the merging.
+  if (ConstsToMerge.size() <= 1)
+    return false;
+
+  // Sort the global constants to make access more efficient.
+  std::sort(ConstsToMerge.begin(), ConstsToMerge.end(), CompareConstants);
+
+  SmallVector<Constant *> OrderedVector;
+  for (GlobalVariable *GV : ConstsToMerge) {
+    OrderedVector.push_back(GV->getInitializer());
+  }
+
+  // Use an anonymous struct to pool the strings.
+  Constant *AnonStruct = ConstantStruct::getAnon(OrderedVector);
+  PooledStructType = AnonStruct->getType();
+
+  // The GlobalVariable constructor calls MM->insertGlobalVariable(G).
+  GlobalVariable *G =
+      new GlobalVariable(M, AnonStruct->getType(),
+                         /* isConstant */ true, GlobalValue::PrivateLinkage,
+                         AnonStruct, "__ModuleStringPool");
+
+  LLVM_DEBUG(dbgs() << "Constructing global variable for string pool: ");
+  LLVM_DEBUG(G->dump());
+
+  unsigned ElementIndex = 0;
+  for (GlobalVariable *GV : ConstsToMerge) {
+
+    LLVM_DEBUG(dbgs() << "The global:\n");
+    LLVM_DEBUG(GV->dump());
+    LLVM_DEBUG(dbgs() << "Has " << GV->getNumUses() << " uses.\n");
+
+    // Need to save a temporary copy of each use list because we remove uses
+    // as we replace them.
+    SmallVector<User *> UserList;
+    for (User *CurrentUser : GV->users())
+      UserList.push_back(CurrentUser);
+
+    insertGEPBeforeUser(UserList, GV, G, ElementIndex);
+
+    // This GV has no more uses and is privately linked so we can erase it.
+    if (GV->use_empty() && GV->getLinkage() == GlobalValue::PrivateLinkage)
+      GV->eraseFromParent();
+
+    NumPooledStrings++;
+    ElementIndex++;
+  }
+  return true;
+}
+
+static bool userHasOperand(User *TheUser, GlobalVariable *GVOperand) {
+  for (Value *Op : TheUser->operands())
+    if (Op == GVOperand)
+      return true;
+
+  return false;
+}
+
+void PPCMergeStringPool::insertGEPBeforeUser(SmallVector<User *> &UsersList,
+                                             GlobalVariable *GToReplace,
+                                             GlobalVariable *GPool,
+                                             unsigned ElementIndex) {
+  ConstantInt *Zero = ConstantInt::get(Type::getInt32Ty(*Context), 0);
+  ConstantInt *Index =
+      ConstantInt::get(Type::getInt32Ty(*Context), ElementIndex);
+  SmallVector<Value *, 2> Indices;
+  Indices.push_back(Zero);
+  Indices.push_back(Index);
+
+  for (User *CurrentUser : UsersList) {
+    Instruction *UseInstruction = dyn_cast<Instruction>(CurrentUser);
+
+    // The user is a valid instruction.
+    if (UseInstruction) {
+      // GEP instructions cannot be added before PHI nodes.
+      if (PHINode *UsePHI = dyn_cast<PHINode>(UseInstruction)) {
+        Constant *ConstGEP = ConstantExpr::getInBoundsGetElementPtr(
+            PooledStructType, GPool, Indices);
+        UsePHI->replaceUsesOfWith(GToReplace, ConstGEP);
+        continue;
+      }
+
+      GetElementPtrInst *GEPInst =
+          GetElementPtrInst::Create(PooledStructType, GPool, Indices);
+      GEPInst->insertBefore(UseInstruction);
+
+      LLVM_DEBUG(dbgs() << "Inserting GEP before:\n");
+      LLVM_DEBUG(UseInstruction->dump());
+
+      LLVM_DEBUG(dbgs() << "Replacing this global:\n");
+      LLVM_DEBUG(GToReplace->dump());
+      LLVM_DEBUG(dbgs() << "with this:\n");
+      LLVM_DEBUG(GEPInst->dump());
+
+      // After the GEP is insterted the GV can be replaced.
+      CurrentUser->replaceUsesOfWith(GToReplace, GEPInst);
+      continue;
+    }
+
+    Constant *ConstGEP = ConstantExpr::getInBoundsGetElementPtr(
+        PooledStructType, GPool, Indices);
+    Constant *UserConstant = dyn_cast<Constant>(CurrentUser);
+
+    // At this point we expect that the user is either an instruction or a
+    // constant.
+    assert(UserConstant &&
+           "Expected the user to be an instruction or a constant.");
+
+    // We cannot replace operands in globals so we ignore those.
+    if (dyn_cast<GlobalValue>(UserConstant))
+      continue;
+
+    // The use was not found so it must have been replaced earlier.
+    if (!userHasOperand(UserConstant, GToReplace))
+      continue;
+
+    UserConstant->handleOperandChange(GToReplace, ConstGEP);
+  }
+}
+
+char PPCMergeStringPool::ID = 0;
+
+INITIALIZE_PASS(PPCMergeStringPool, DEBUG_TYPE, "PPC Merge String Pool", false,
+                false)
+
+ModulePass *llvm::createPPCMergeStringPoolPass() {
+  return new PPCMergeStringPool();
+}

llvm/lib/Target/PowerPC/PPCTargetMachine.cpp

EnableMachineCombinerPass("ppc-machine-combiner",
                           cl::desc("Enable the machine combiner pass"),
                           cl::init(true), cl::Hidden);
 
 static cl::opt<bool>
   ReduceCRLogical("ppc-reduce-cr-logicals",
                   cl::desc("Expand eligible cr-logical binary ops to branches"),
                   cl::init(true), cl::Hidden);
 
+static cl::opt<bool>
+  MergeStringPool("ppc-merge-string-pool",
+                  cl::desc("Merge all of strings in a module into one pool"),
+                  cl::init(false), cl::Hidden);
+
+
 static cl::opt<bool> EnablePPCGenScalarMASSEntries(
     "enable-ppc-gen-scalar-mass", cl::init(false),
     cl::desc("Enable lowering math functions to their corresponding MASS "
              "(scalar) entries"),
     cl::Hidden);
 
 extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializePowerPCTarget() {
   // Register the targets
#endif
   initializePPCTLSDynamicCallPass(PR);
   initializePPCMIPeepholePass(PR);
   initializePPCLowerMASSVEntriesPass(PR);
   initializePPCGenScalarMASSEntriesPass(PR);
   initializePPCExpandAtomicPseudoPass(PR);
   initializeGlobalISel(PR);
   initializePPCCTRLoopsPass(PR);
   initializePPCDAGToDAGISelPass(PR);
+  initializePPCMergeStringPoolPass(PR);
 }
 
 static bool isLittleEndianTriple(const Triple &T) {
   return T.getArch() == Triple::ppc64le || T.getArch() == Triple::ppcle;
 }
 
 /// Return the datalayout string of a subtarget.
 static std::string getDataLayoutString(const Triple &T) {
if (TM->getOptLevel() >= CodeGenOpt::Default && EnableGEPOpt) {
     // invariant.
     addPass(createLICMPass());
   }
 
   TargetPassConfig::addIRPasses();
 }
 
 bool PPCPassConfig::addPreISel() {
+  if (MergeStringPool && getOptLevel() != CodeGenOpt::None)
+    addPass(createPPCMergeStringPoolPass());
+
   if (!DisableInstrFormPrep && getOptLevel() != CodeGenOpt::None)
     addPass(createPPCLoopInstrFormPrepPass(getPPCTargetMachine()));
 
   if (!DisableCTRLoops && getOptLevel() != CodeGenOpt::None)
     addPass(createHardwareLoopsLegacyPass());
 
   return false;
 }

llvm/test/CodeGen/PowerPC/stringpool.ll

+; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr8 \
+; RUN:   -ppc-merge-string-pool=true < %s | FileCheck %s --check-prefixes=AIX32,AIXDATA
+; RUN: llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff -mcpu=pwr8 \
+; RUN:   -ppc-merge-string-pool=true < %s | FileCheck %s --check-prefixes=AIX64,AIXDATA
+; RUN: llc -verify-machineinstrs -mtriple powerpc64-unknown-linux -mcpu=pwr8 \
+; RUN:   -ppc-merge-string-pool=true < %s | FileCheck %s --check-prefixes=LINUX64BE,LINUXDATA
+; RUN: llc -verify-machineinstrs -mtriple powerpc64le-unknown-linux -mcpu=pwr8 \
+; RUN:   -ppc-merge-string-pool=true < %s | FileCheck %s --check-prefixes=LINUX64LE,LINUXDATA
+
+@.str = private unnamed_addr constant [47 x i8] c"This is the global string that is at the top.\0A\00", align 1
+@GLOBALSTRING = dso_local local_unnamed_addr global ptr @.str, align 8
+@IntArray2 = dso_local global [7 x i32] [i32 5, i32 7, i32 9, i32 11, i32 17, i32 1235, i32 32], align 4
+@.str.1 = private unnamed_addr constant [12 x i8] c"str1_STRING\00", align 1
+@.str.2 = private unnamed_addr constant [12 x i8] c"str2_STRING\00", align 1
+@.str.3 = private unnamed_addr constant [12 x i8] c"str3_STRING\00", align 1
+@.str.4 = private unnamed_addr constant [12 x i8] c"str4_STRING\00", align 1
+@.str.5 = private unnamed_addr constant [183 x i8] c"longerstr5_longerstr5_longerstr5_longerstr5_longerstr5_longerstr5_longerstr5_longerstr5_longerstr5_longerstr5_longerstr5_longerstr5_longerstr5_longerstr5_longerstr5_longerstr5_STRING\00", align 1
+@__const.str6.TheString = private unnamed_addr constant [10 x i8] c"ABCABCABC\00", align 1
+@.str.6 = private unnamed_addr constant [12 x i8] c"MixedString\00", align 1
+@__const.mixed2.IntArray = private unnamed_addr constant [7 x i32] [i32 5, i32 7, i32 9, i32 11, i32 17, i32 1235, i32 32], align 4
+@.str.7 = private unnamed_addr constant [20 x i8] c"Different String 01\00", align 1
+@.str.8 = private unnamed_addr constant [15 x i8] c"Static Global\0A\00", align 1
+
+define dso_local signext i32 @str1() local_unnamed_addr #0 {
+; AIX32-LABEL: str1:
+; AIX32:       # %bb.0: # %entry
+; AIX32-NEXT:    mflr 0
+; AIX32-NEXT:    stwu 1, -64(1)
+; AIX32-NEXT:    lwz 3, L..C0(2) # @__ModuleStringPool
+; AIX32-NEXT:    stw 0, 72(1)
+; AIX32-NEXT:    addi 3, 3, 62
+; AIX32-NEXT:    bl .callee[PR]
+; AIX32-NEXT:    nop
+; AIX32-NEXT:    addi 1, 1, 64
+; AIX32-NEXT:    lwz 0, 8(1)
+; AIX32-NEXT:    mtlr 0
+; AIX32-NEXT:    blr
+;
+; AIX64-LABEL: str1:
+; AIX64:       # %bb.0: # %entry
+; AIX64-NEXT:    mflr 0
+; AIX64-NEXT:    stdu 1, -112(1)
+; AIX64-NEXT:    ld 3, L..C0(2) # @__ModuleStringPool
+; AIX64-NEXT:    std 0, 128(1)
+; AIX64-NEXT:    addi 3, 3, 62
+; AIX64-NEXT:    bl .callee[PR]
+; AIX64-NEXT:    nop
+; AIX64-NEXT:    addi 1, 1, 112
+; AIX64-NEXT:    ld 0, 16(1)
+; AIX64-NEXT:    mtlr 0
+; AIX64-NEXT:    blr
+;
+; LINUX64BE-LABEL: str1:
+; LINUX64BE:       # %bb.0: # %entry
+; LINUX64BE-NEXT:    mflr 0
+; LINUX64BE-NEXT:    stdu 1, -112(1)
+; LINUX64BE-NEXT:    addis 3, 2, .L__ModuleStringPool@toc@ha
+; LINUX64BE-NEXT:    std 0, 128(1)
+; LINUX64BE-NEXT:    addi 3, 3, .L__ModuleStringPool@toc@l
+; LINUX64BE-NEXT:    addi 3, 3, 62
+; LINUX64BE-NEXT:    bl callee
+; LINUX64BE-NEXT:    nop
+; LINUX64BE-NEXT:    addi 1, 1, 112
+; LINUX64BE-NEXT:    ld 0, 16(1)
+; LINUX64BE-NEXT:    mtlr 0
+; LINUX64BE-NEXT:    blr
+;
+; LINUX64LE-LABEL: str1:
+; LINUX64LE:       # %bb.0: # %entry
+; LINUX64LE-NEXT:    mflr 0
+; LINUX64LE-NEXT:    stdu 1, -32(1)
+; LINUX64LE-NEXT:    addis 3, 2, .L__ModuleStringPool@toc@ha
+; LINUX64LE-NEXT:    std 0, 48(1)
+; LINUX64LE-NEXT:    addi 3, 3, .L__ModuleStringPool@toc@l
+; LINUX64LE-NEXT:    addi 3, 3, 62
+; LINUX64LE-NEXT:    bl callee
+; LINUX64LE-NEXT:    nop
+; LINUX64LE-NEXT:    addi 1, 1, 32
+; LINUX64LE-NEXT:    ld 0, 16(1)
+; LINUX64LE-NEXT:    mtlr 0
+; LINUX64LE-NEXT:    blr
+entry:
+  %call = tail call signext i32 @callee(ptr noundef nonnull @.str.1)
+  ret i32 %call
+}
+
+declare signext i32 @callee(ptr noundef) local_unnamed_addr
+
+define dso_local signext i32 @str2() local_unnamed_addr #0 {
+; AIX32-LABEL: str2:
+; AIX32:       # %bb.0: # %entry
+; AIX32-NEXT:    mflr 0
+; AIX32-NEXT:    stwu 1, -64(1)
+; AIX32-NEXT:    lwz 3, L..C0(2) # @__ModuleStringPool
+; AIX32-NEXT:    stw 0, 72(1)
+; AIX32-NEXT:    addi 3, 3, 28
+; AIX32-NEXT:    bl .callee[PR]
+; AIX32-NEXT:    nop
+; AIX32-NEXT:    addi 1, 1, 64
+; AIX32-NEXT:    lwz 0, 8(1)
+; AIX32-NEXT:    mtlr 0
+; AIX32-NEXT:    blr
+;
+; AIX64-LABEL: str2:
+; AIX64:       # %bb.0: # %entry
+; AIX64-NEXT:    mflr 0
+; AIX64-NEXT:    stdu 1, -112(1)
+; AIX64-NEXT:    ld 3, L..C0(2) # @__ModuleStringPool
+; AIX64-NEXT:    std 0, 128(1)
+; AIX64-NEXT:    addi 3, 3, 28
+; AIX64-NEXT:    bl .callee[PR]
+; AIX64-NEXT:    nop
+; AIX64-NEXT:    addi 1, 1, 112
+; AIX64-NEXT:    ld 0, 16(1)
+; AIX64-NEXT:    mtlr 0
+; AIX64-NEXT:    blr
+;
+; LINUX64BE-LABEL: str2:
+; LINUX64BE:       # %bb.0: # %entry
+; LINUX64BE-NEXT:    mflr 0
+; LINUX64BE-NEXT:    stdu 1, -112(1)
+; LINUX64BE-NEXT:    addis 3, 2, .L__ModuleStringPool@toc@ha
+; LINUX64BE-NEXT:    std 0, 128(1)
+; LINUX64BE-NEXT:    addi 3, 3, .L__ModuleStringPool@toc@l
+; LINUX64BE-NEXT:    addi 3, 3, 28
+; LINUX64BE-NEXT:    bl callee
+; LINUX64BE-NEXT:    nop
+; LINUX64BE-NEXT:    addi 1, 1, 112
+; LINUX64BE-NEXT:    ld 0, 16(1)
+; LINUX64BE-NEXT:    mtlr 0
+; LINUX64BE-NEXT:    blr
+;
+; LINUX64LE-LABEL: str2:
+; LINUX64LE:       # %bb.0: # %entry
+; LINUX64LE-NEXT:    mflr 0
+; LINUX64LE-NEXT:    stdu 1, -32(1)
+; LINUX64LE-NEXT:    addis 3, 2, .L__ModuleStringPool@toc@ha
+; LINUX64LE-NEXT:    std 0, 48(1)
+; LINUX64LE-NEXT:    addi 3, 3, .L__ModuleStringPool@toc@l
+; LINUX64LE-NEXT:    addi 3, 3, 28
+; LINUX64LE-NEXT:    bl callee
+; LINUX64LE-NEXT:    nop
+; LINUX64LE-NEXT:    addi 1, 1, 32
+; LINUX64LE-NEXT:    ld 0, 16(1)
+; LINUX64LE-NEXT:    mtlr 0
+; LINUX64LE-NEXT:    blr
+entry:
+  %call = tail call signext i32 @callee(ptr noundef nonnull @.str.2)
+  ret i32 %call
+}
+
+define dso_local signext i32 @str3() local_unnamed_addr #0 {
+; AIX32-LABEL: str3:
+; AIX32:       # %bb.0: # %entry
+; AIX32-NEXT:    mflr 0
+; AIX32-NEXT:    stwu 1, -64(1)
+; AIX32-NEXT:    stw 0, 72(1)
+; AIX32-NEXT:    stw 31, 60(1) # 4-byte Folded Spill
+; AIX32-NEXT:    lwz 31, L..C0(2) # @__ModuleStringPool
+; AIX32-NEXT:    addi 3, 31, 74
+; AIX32-NEXT:    bl .callee[PR]
+; AIX32-NEXT:    nop
+; AIX32-NEXT:    addi 4, 31, 28
+; AIX32-NEXT:    mr 31, 3
+; AIX32-NEXT:    mr 3, 4
+; AIX32-NEXT:    bl .callee[PR]
+; AIX32-NEXT:    nop
+; AIX32-NEXT:    add 3, 3, 31
+; AIX32-NEXT:    lwz 31, 60(1) # 4-byte Folded Reload
+; AIX32-NEXT:    addi 1, 1, 64
+; AIX32-NEXT:    lwz 0, 8(1)
+; AIX32-NEXT:    mtlr 0
+; AIX32-NEXT:    blr
+;
+; AIX64-LABEL: str3:
+; AIX64:       # %bb.0: # %entry
+; AIX64-NEXT:    mflr 0
+; AIX64-NEXT:    stdu 1, -128(1)
+; AIX64-NEXT:    std 0, 144(1)
+; AIX64-NEXT:    std 30, 112(1) # 8-byte Folded Spill
+; AIX64-NEXT:    ld 30, L..C0(2) # @__ModuleStringPool
+; AIX64-NEXT:    std 31, 120(1) # 8-byte Folded Spill
+; AIX64-NEXT:    addi 3, 30, 74
+; AIX64-NEXT:    bl .callee[PR]
+; AIX64-NEXT:    nop
+; AIX64-NEXT:    mr 31, 3
+; AIX64-NEXT:    addi 3, 30, 28
+; AIX64-NEXT:    bl .callee[PR]
+; AIX64-NEXT:    nop
+; AIX64-NEXT:    add 3, 3, 31
+; AIX64-NEXT:    ld 31, 120(1) # 8-byte Folded Reload
+; AIX64-NEXT:    ld 30, 112(1) # 8-byte Folded Reload
+; AIX64-NEXT:    extsw 3, 3
+; AIX64-NEXT:    addi 1, 1, 128
+; AIX64-NEXT:    ld 0, 16(1)
+; AIX64-NEXT:    mtlr 0
+; AIX64-NEXT:    blr
+;
+; LINUX64BE-LABEL: str3:
+; LINUX64BE:       # %bb.0: # %entry
+; LINUX64BE-NEXT:    mflr 0
+; LINUX64BE-NEXT:    stdu 1, -144(1)
+; LINUX64BE-NEXT:    addis 3, 2, .L__ModuleStringPool@toc@ha
+; LINUX64BE-NEXT:    std 0, 160(1)
+; LINUX64BE-NEXT:    std 29, 120(1) # 8-byte Folded Spill
+; LINUX64BE-NEXT:    std 30, 128(1) # 8-byte Folded Spill
+; LINUX64BE-NEXT:    addi 29, 3, .L__ModuleStringPool@toc@l
+; LINUX64BE-NEXT:    addi 3, 29, 74
+; LINUX64BE-NEXT:    bl callee
+; LINUX64BE-NEXT:    nop
+; LINUX64BE-NEXT:    mr 30, 3
+; LINUX64BE-NEXT:    addi 3, 29, 28
+; LINUX64BE-NEXT:    bl callee
+; LINUX64BE-NEXT:    nop
+; LINUX64BE-NEXT:    add 3, 3, 30
+; LINUX64BE-NEXT:    ld 30, 128(1) # 8-byte Folded Reload
+; LINUX64BE-NEXT:    ld 29, 120(1) # 8-byte Folded Reload
+; LINUX64BE-NEXT:    extsw 3, 3
+; LINUX64BE-NEXT:    addi 1, 1, 144
+; LINUX64BE-NEXT:    ld 0, 16(1)
+; LINUX64BE-NEXT:    mtlr 0
+; LINUX64BE-NEXT:    blr
+;
+; LINUX64LE-LABEL: str3:
+; LINUX64LE:       # %bb.0: # %entry
+; LINUX64LE-NEXT:    mflr 0
+; LINUX64LE-NEXT:    std 29, -24(1) # 8-byte Folded Spill
+; LINUX64LE-NEXT:    std 30, -16(1) # 8-byte Folded Spill
+; LINUX64LE-NEXT:    stdu 1, -64(1)
+; LINUX64LE-NEXT:    addis 3, 2, .L__ModuleStringPool@toc@ha
+; LINUX64LE-NEXT:    std 0, 80(1)
+; LINUX64LE-NEXT:    addi 29, 3, .L__ModuleStringPool@toc@l
+; LINUX64LE-NEXT:    addi 3, 29, 74
+; LINUX64LE-NEXT:    bl callee
+; LINUX64LE-NEXT:    nop
+; LINUX64LE-NEXT:    mr 30, 3
+; LINUX64LE-NEXT:    addi 3, 29, 28
+; LINUX64LE-NEXT:    bl callee
+; LINUX64LE-NEXT:    nop
+; LINUX64LE-NEXT:    add 3, 3, 30
+; LINUX64LE-NEXT:    extsw 3, 3
+; LINUX64LE-NEXT:    addi 1, 1, 64
+; LINUX64LE-NEXT:    ld 0, 16(1)
+; LINUX64LE-NEXT:    ld 30, -16(1) # 8-byte Folded Reload
+; LINUX64LE-NEXT:    ld 29, -24(1) # 8-byte Folded Reload
+; LINUX64LE-NEXT:    mtlr 0
+; LINUX64LE-NEXT:    blr
+entry:
+  %call = tail call signext i32 @callee(ptr noundef nonnull @.str.3)
+  %call1 = tail call signext i32 @callee(ptr noundef nonnull @.str.2)
+  %add = add nsw i32 %call1, %call
+  ret i32 %add
+}
+
+define dso_local signext i32 @str4() local_unnamed_addr #0 {
+; AIX32-LABEL: str4:
+; AIX32:       # %bb.0: # %entry
+; AIX32-NEXT:    mflr 0
+; AIX32-NEXT:    stwu 1, -64(1)
+; AIX32-NEXT:    lwz 3, L..C0(2) # @__ModuleStringPool
+; AIX32-NEXT:    stw 0, 72(1)
+; AIX32-NEXT:    addi 3, 3, 86
+; AIX32-NEXT:    bl .callee[PR]
+; AIX32-NEXT:    nop
+; AIX32-NEXT:    addi 1, 1, 64
+; AIX32-NEXT:    lwz 0, 8(1)
+; AIX32-NEXT:    mtlr 0
+; AIX32-NEXT:    blr
+;
+; AIX64-LABEL: str4:
+; AIX64:       # %bb.0: # %entry
+; AIX64-NEXT:    mflr 0
+; AIX64-NEXT:    stdu 1, -112(1)
+; AIX64-NEXT:    ld 3, L..C0(2) # @__ModuleStringPool
+; AIX64-NEXT:    std 0, 128(1)
+; AIX64-NEXT:    addi 3, 3, 86
+; AIX64-NEXT:    bl .callee[PR]
+; AIX64-NEXT:    nop
+; AIX64-NEXT:    addi 1, 1, 112
+; AIX64-NEXT:    ld 0, 16(1)
+; AIX64-NEXT:    mtlr 0
+; AIX64-NEXT:    blr
+;
+; LINUX64BE-LABEL: str4:
+; LINUX64BE:       # %bb.0: # %entry
+; LINUX64BE-NEXT:    mflr 0
+; LINUX64BE-NEXT:    stdu 1, -112(1)
+; LINUX64BE-NEXT:    addis 3, 2, .L__ModuleStringPool@toc@ha
+; LINUX64BE-NEXT:    std 0, 128(1)
+; LINUX64BE-NEXT:    addi 3, 3, .L__ModuleStringPool@toc@l
+; LINUX64BE-NEXT:    addi 3, 3, 86
+; LINUX64BE-NEXT:    bl callee
+; LINUX64BE-NEXT:    nop
+; LINUX64BE-NEXT:    addi 1, 1, 112
+; LINUX64BE-NEXT:    ld 0, 16(1)
+; LINUX64BE-NEXT:    mtlr 0
+; LINUX64BE-NEXT:    blr
+;
+; LINUX64LE-LABEL: str4:
+; LINUX64LE:       # %bb.0: # %entry
+; LINUX64LE-NEXT:    mflr 0
+; LINUX64LE-NEXT:    stdu 1, -32(1)
+; LINUX64LE-NEXT:    addis 3, 2, .L__ModuleStringPool@toc@ha
+; LINUX64LE-NEXT:    std 0, 48(1)
+; LINUX64LE-NEXT:    addi 3, 3, .L__ModuleStringPool@toc@l
+; LINUX64LE-NEXT:    addi 3, 3, 86
+; LINUX64LE-NEXT:    bl callee
+; LINUX64LE-NEXT:    nop
+; LINUX64LE-NEXT:    addi 1, 1, 32
+; LINUX64LE-NEXT:    ld 0, 16(1)
+; LINUX64LE-NEXT:    mtlr 0
+; LINUX64LE-NEXT:    blr
+entry:
+  %call = tail call signext i32 @callee(ptr noundef nonnull @.str.4)
+  ret i32 %call
+}
+
+define dso_local signext i32 @str5() local_unnamed_addr #0 {
+; AIX32-LABEL: str5:
+; AIX32:       # %bb.0: # %entry
+; AIX32-NEXT:    mflr 0
+; AIX32-NEXT:    stwu 1, -64(1)
+; AIX32-NEXT:    lwz 3, L..C0(2) # @__ModuleStringPool
+; AIX32-NEXT:    stw 0, 72(1)
+; AIX32-NEXT:    addi 3, 3, 133
+; AIX32-NEXT:    bl .callee[PR]
+; AIX32-NEXT:    nop
+; AIX32-NEXT:    addi 1, 1, 64
+; AIX32-NEXT:    lwz 0, 8(1)
+; AIX32-NEXT:    mtlr 0
+; AIX32-NEXT:    blr
+;
+; AIX64-LABEL: str5:
+; AIX64:       # %bb.0: # %entry
+; AIX64-NEXT:    mflr 0
+; AIX64-NEXT:    stdu 1, -112(1)
+; AIX64-NEXT:    ld 3, L..C0(2) # @__ModuleStringPool
+; AIX64-NEXT:    std 0, 128(1)
+; AIX64-NEXT:    addi 3, 3, 133
+; AIX64-NEXT:    bl .callee[PR]
+; AIX64-NEXT:    nop
+; AIX64-NEXT:    addi 1, 1, 112
+; AIX64-NEXT:    ld 0, 16(1)
+; AIX64-NEXT:    mtlr 0
+; AIX64-NEXT:    blr
+;
+; LINUX64BE-LABEL: str5:
+; LINUX64BE:       # %bb.0: # %entry
+; LINUX64BE-NEXT:    mflr 0
+; LINUX64BE-NEXT:    stdu 1, -112(1)
+; LINUX64BE-NEXT:    addis 3, 2, .L__ModuleStringPool@toc@ha
+; LINUX64BE-NEXT:    std 0, 128(1)
+; LINUX64BE-NEXT:    addi 3, 3, .L__ModuleStringPool@toc@l
+; LINUX64BE-NEXT:    addi 3, 3, 133
+; LINUX64BE-NEXT:    bl callee
+; LINUX64BE-NEXT:    nop
+; LINUX64BE-NEXT:    addi 1, 1, 112
+; LINUX64BE-NEXT:    ld 0, 16(1)
+; LINUX64BE-NEXT:    mtlr 0
+; LINUX64BE-NEXT:    blr
+;
+; LINUX64LE-LABEL: str5:
+; LINUX64LE:       # %bb.0: # %entry
+; LINUX64LE-NEXT:    mflr 0
+; LINUX64LE-NEXT:    stdu 1, -32(1)
+; LINUX64LE-NEXT:    addis 3, 2, .L__ModuleStringPool@toc@ha
+; LINUX64LE-NEXT:    std 0, 48(1)
+; LINUX64LE-NEXT:    addi 3, 3, .L__ModuleStringPool@toc@l
+; LINUX64LE-NEXT:    addi 3, 3, 133
+; LINUX64LE-NEXT:    bl callee
+; LINUX64LE-NEXT:    nop
+; LINUX64LE-NEXT:    addi 1, 1, 32
+; LINUX64LE-NEXT:    ld 0, 16(1)
+; LINUX64LE-NEXT:    mtlr 0
+; LINUX64LE-NEXT:    blr
+entry:
+  %call = tail call signext i32 @callee(ptr noundef nonnull @.str.5)
+  ret i32 %call
+}
+
+define dso_local signext i32 @array1() local_unnamed_addr #0 {
+; AIX32-LABEL: array1:
+; AIX32:       # %bb.0: # %entry
+; AIX32-NEXT:    mflr 0
+; AIX32-NEXT:    stwu 1, -96(1)
+; AIX32-NEXT:    lwz 4, L..C0(2) # @__ModuleStringPool
+; AIX32-NEXT:    li 5, 12
+; AIX32-NEXT:    addi 3, 1, 64
+; AIX32-NEXT:    stw 0, 104(1)
+; AIX32-NEXT:    lxvw4x 0, 4, 5
+; AIX32-NEXT:    lxvw4x 1, 0, 4
+; AIX32-NEXT:    mr 4, 3
+; AIX32-NEXT:    rlwimi 4, 5, 0, 28, 29
+; AIX32-NEXT:    stxvw4x 0, 0, 4
+; AIX32-NEXT:    stxvw4x 1, 0, 3
+; AIX32-NEXT:    bl .calleeInt[PR]
+; AIX32-NEXT:    nop
+; AIX32-NEXT:    addi 1, 1, 96
+; AIX32-NEXT:    lwz 0, 8(1)
+; AIX32-NEXT:    mtlr 0
+; AIX32-NEXT:    blr
+;
+; AIX64-LABEL: array1:
+; AIX64:       # %bb.0: # %entry
+; AIX64-NEXT:    mflr 0
+; AIX64-NEXT:    stdu 1, -144(1)
+; AIX64-NEXT:    ld 3, L..C0(2) # @__ModuleStringPool
+; AIX64-NEXT:    li 4, 12
+; AIX64-NEXT:    std 0, 160(1)
+; AIX64-NEXT:    lxvw4x 0, 3, 4
+; AIX64-NEXT:    lxvw4x 1, 0, 3
+; AIX64-NEXT:    addi 4, 1, 124
+; AIX64-NEXT:    addi 3, 1, 112
+; AIX64-NEXT:    stxvw4x 0, 0, 4
+; AIX64-NEXT:    stxvw4x 1, 0, 3
+; AIX64-NEXT:    bl .calleeInt[PR]
+; AIX64-NEXT:    nop
+; AIX64-NEXT:    addi 1, 1, 144
+; AIX64-NEXT:    ld 0, 16(1)
+; AIX64-NEXT:    mtlr 0
+; AIX64-NEXT:    blr
+;
+; LINUX64BE-LABEL: array1:
+; LINUX64BE:       # %bb.0: # %entry
+; LINUX64BE-NEXT:    mflr 0
+; LINUX64BE-NEXT:    stdu 1, -144(1)
+; LINUX64BE-NEXT:    addis 3, 2, .L__ModuleStringPool@toc@ha
+; LINUX64BE-NEXT:    li 4, 12
+; LINUX64BE-NEXT:    std 0, 160(1)
+; LINUX64BE-NEXT:    addi 3, 3, .L__ModuleStringPool@toc@l
+; LINUX64BE-NEXT:    lxvw4x 0, 3, 4
+; LINUX64BE-NEXT:    lxvw4x 1, 0, 3
+; LINUX64BE-NEXT:    addi 4, 1, 124
+; LINUX64BE-NEXT:    addi 3, 1, 112
+; LINUX64BE-NEXT:    stxvw4x 0, 0, 4
+; LINUX64BE-NEXT:    stxvw4x 1, 0, 3
+; LINUX64BE-NEXT:    bl calleeInt
+; LINUX64BE-NEXT:    nop
+; LINUX64BE-NEXT:    addi 1, 1, 144
+; LINUX64BE-NEXT:    ld 0, 16(1)
+; LINUX64BE-NEXT:    mtlr 0
+; LINUX64BE-NEXT:    blr
+;
+; LINUX64LE-LABEL: array1:
+; LINUX64LE:       # %bb.0: # %entry
+; LINUX64LE-NEXT:    mflr 0
+; LINUX64LE-NEXT:    stdu 1, -64(1)
+; LINUX64LE-NEXT:    addis 3, 2, .L__ModuleStringPool@toc@ha
+; LINUX64LE-NEXT:    li 4, 12
+; LINUX64LE-NEXT:    std 0, 80(1)
+; LINUX64LE-NEXT:    addi 3, 3, .L__ModuleStringPool@toc@l
+; LINUX64LE-NEXT:    lxvd2x 0, 3, 4
+; LINUX64LE-NEXT:    lxvd2x 1, 0, 3
+; LINUX64LE-NEXT:    addi 4, 1, 44
+; LINUX64LE-NEXT:    addi 3, 1, 32
+; LINUX64LE-NEXT:    stxvd2x 0, 0, 4
+; LINUX64LE-NEXT:    stxvd2x 1, 0, 3
+; LINUX64LE-NEXT:    bl calleeInt
+; LINUX64LE-NEXT:    nop
+; LINUX64LE-NEXT:    addi 1, 1, 64
+; LINUX64LE-NEXT:    ld 0, 16(1)
+; LINUX64LE-NEXT:    mtlr 0
+; LINUX64LE-NEXT:    blr
+entry:
+  %IntArray = alloca [7 x i32], align 4
+  call void @llvm.lifetime.start.p0(i64 28, ptr nonnull %IntArray)
+  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 4 dereferenceable(28) %IntArray, ptr noundef nonnull align 4 dereferenceable(28) @__const.mixed2.IntArray, i64 28, i1 false)
+  %call = call signext i32 @calleeInt(ptr noundef nonnull %IntArray)
+  call void @llvm.lifetime.end.p0(i64 28, ptr nonnull %IntArray)
+  ret i32 %call
+}
+
+declare void @llvm.lifetime.start.p0(i64 immarg, ptr nocapture)
+declare void @llvm.memcpy.p0.p0.i64(ptr noalias nocapture writeonly, ptr noalias nocapture readonly, i64, i1 immarg)
+declare signext i32 @calleeInt(ptr noundef) local_unnamed_addr
+declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture)
+
+define dso_local double @DValue1() local_unnamed_addr #0 {
+; LINUX-LABEL: DValue1:
+; LINUX:       # %bb.0: # %entry
+; LINUX-NEXT:    addis 3, 2, .LCPI6_0@toc@ha
+; LINUX-NEXT:    lfd 1, .LCPI6_0@toc@l(3)
+; LINUX-NEXT:    blr
+; AIX32-LABEL: DValue1:
+; AIX32:       # %bb.0: # %entry
+; AIX32-NEXT:    lwz 3, L..C1(2) # %const.0
+; AIX32-NEXT:    lfd 1, 0(3)
+; AIX32-NEXT:    blr
+;
+; AIX64-LABEL: DValue1:
+; AIX64:       # %bb.0: # %entry
+; AIX64-NEXT:    ld 3, L..C1(2) # %const.0
+; AIX64-NEXT:    lfd 1, 0(3)
+; AIX64-NEXT:    blr
+;
+; LINUX64BE-LABEL: DValue1:
+; LINUX64BE:       # %bb.0: # %entry
+; LINUX64BE-NEXT:    addis 3, 2, .LCPI6_0@toc@ha
+; LINUX64BE-NEXT:    lfd 1, .LCPI6_0@toc@l(3)
+; LINUX64BE-NEXT:    blr
+;
+; LINUX64LE-LABEL: DValue1:
+; LINUX64LE:       # %bb.0: # %entry
+; LINUX64LE-NEXT:    addis 3, 2, .LCPI6_0@toc@ha
+; LINUX64LE-NEXT:    lfd 1, .LCPI6_0@toc@l(3)
+; LINUX64LE-NEXT:    blr
+entry:
+  ret double 3.141590e+00
+}
+
+define dso_local signext i32 @str6() local_unnamed_addr #0 {
+; AIX32-LABEL: str6:
+; AIX32:       # %bb.0: # %entry
+; AIX32-NEXT:    mflr 0
+; AIX32-NEXT:    stwu 1, -80(1)
+; AIX32-NEXT:    li 3, 17152
+; AIX32-NEXT:    lis 4, 16963
+; AIX32-NEXT:    stw 0, 88(1)
+; AIX32-NEXT:    lis 5, 16706
+; AIX32-NEXT:    sth 3, 72(1)
+; AIX32-NEXT:    ori 3, 4, 16706
+; AIX32-NEXT:    ori 4, 5, 17217
+; AIX32-NEXT:    stw 31, 76(1) # 4-byte Folded Spill
+; AIX32-NEXT:    stw 3, 68(1)
+; AIX32-NEXT:    addi 3, 1, 64
+; AIX32-NEXT:    stw 4, 64(1)
+; AIX32-NEXT:    bl .callee[PR]
+; AIX32-NEXT:    nop
+; AIX32-NEXT:    addi 4, 1, 69
+; AIX32-NEXT:    mr 31, 3
+; AIX32-NEXT:    mr 3, 4
+; AIX32-NEXT:    bl .callee[PR]
+; AIX32-NEXT:    nop
+; AIX32-NEXT:    add 3, 3, 31
+; AIX32-NEXT:    lwz 31, 76(1) # 4-byte Folded Reload
+; AIX32-NEXT:    addi 1, 1, 80
+; AIX32-NEXT:    lwz 0, 8(1)
+; AIX32-NEXT:    mtlr 0
+; AIX32-NEXT:    blr
+;
+; AIX64-LABEL: str6:
+; AIX64:       # %bb.0: # %entry
+; AIX64-NEXT:    mflr 0
+; AIX64-NEXT:    stdu 1, -144(1)
+; AIX64-NEXT:    lis 3, 16706
+; AIX64-NEXT:    std 0, 160(1)
+; AIX64-NEXT:    li 4, 17152
+; AIX64-NEXT:    std 31, 136(1) # 8-byte Folded Spill
+; AIX64-NEXT:    ori 3, 3, 17217
+; AIX64-NEXT:    rldic 3, 3, 32, 1
+; AIX64-NEXT:    oris 3, 3, 16963
+; AIX64-NEXT:    sth 4, 128(1)
+; AIX64-NEXT:    ori 3, 3, 16706
+; AIX64-NEXT:    std 3, 120(1)
+; AIX64-NEXT:    addi 3, 1, 120
+; AIX64-NEXT:    bl .callee[PR]
+; AIX64-NEXT:    nop
+; AIX64-NEXT:    mr 31, 3
+; AIX64-NEXT:    addi 3, 1, 125
+; AIX64-NEXT:    bl .callee[PR]
+; AIX64-NEXT:    nop
+; AIX64-NEXT:    add 3, 3, 31
+; AIX64-NEXT:    ld 31, 136(1) # 8-byte Folded Reload
+; AIX64-NEXT:    extsw 3, 3
+; AIX64-NEXT:    addi 1, 1, 144
+; AIX64-NEXT:    ld 0, 16(1)
+; AIX64-NEXT:    mtlr 0
+; AIX64-NEXT:    blr
+;
+; LINUX64BE-LABEL: str6:
+; LINUX64BE:       # %bb.0: # %entry
+; LINUX64BE-NEXT:    mflr 0
+; LINUX64BE-NEXT:    stdu 1, -144(1)
+; LINUX64BE-NEXT:    lis 3, 16706
+; LINUX64BE-NEXT:    std 0, 160(1)
+; LINUX64BE-NEXT:    li 4, 17152
+; LINUX64BE-NEXT:    std 30, 128(1) # 8-byte Folded Spill
+; LINUX64BE-NEXT:    ori 3, 3, 17217
+; LINUX64BE-NEXT:    rldic 3, 3, 32, 1
+; LINUX64BE-NEXT:    oris 3, 3, 16963
+; LINUX64BE-NEXT:    sth 4, 120(1)
+; LINUX64BE-NEXT:    ori 3, 3, 16706
+; LINUX64BE-NEXT:    std 3, 112(1)
+; LINUX64BE-NEXT:    addi 3, 1, 112
+; LINUX64BE-NEXT:    bl callee
+; LINUX64BE-NEXT:    nop
+; LINUX64BE-NEXT:    mr 30, 3
+; LINUX64BE-NEXT:    addi 3, 1, 117
+; LINUX64BE-NEXT:    bl callee
+; LINUX64BE-NEXT:    nop
+; LINUX64BE-NEXT:    add 3, 3, 30
+; LINUX64BE-NEXT:    ld 30, 128(1) # 8-byte Folded Reload
+; LINUX64BE-NEXT:    extsw 3, 3
+; LINUX64BE-NEXT:    addi 1, 1, 144
+; LINUX64BE-NEXT:    ld 0, 16(1)
+; LINUX64BE-NEXT:    mtlr 0
+; LINUX64BE-NEXT:    blr
+;
+; LINUX64LE-LABEL: str6:
+; LINUX64LE:       # %bb.0: # %entry
+; LINUX64LE-NEXT:    mflr 0
+; LINUX64LE-NEXT:    std 30, -16(1) # 8-byte Folded Spill
+; LINUX64LE-NEXT:    stdu 1, -64(1)
+; LINUX64LE-NEXT:    lis 3, 8480
+; LINUX64LE-NEXT:    std 0, 80(1)
+; LINUX64LE-NEXT:    li 4, 67
+; LINUX64LE-NEXT:    ori 3, 3, 41377
+; LINUX64LE-NEXT:    sth 4, 40(1)
+; LINUX64LE-NEXT:    rldic 3, 3, 33, 1
+; LINUX64LE-NEXT:    oris 3, 3, 16707
+; LINUX64LE-NEXT:    ori 3, 3, 16961
+; LINUX64LE-NEXT:    std 3, 32(1)
+; LINUX64LE-NEXT:    addi 3, 1, 32
+; LINUX64LE-NEXT:    bl callee
+; LINUX64LE-NEXT:    nop
+; LINUX64LE-NEXT:    mr 30, 3
+; LINUX64LE-NEXT:    addi 3, 1, 37
+; LINUX64LE-NEXT:    bl callee
+; LINUX64LE-NEXT:    nop
+; LINUX64LE-NEXT:    add 3, 3, 30
+; LINUX64LE-NEXT:    extsw 3, 3
+; LINUX64LE-NEXT:    addi 1, 1, 64
+; LINUX64LE-NEXT:    ld 0, 16(1)
+; LINUX64LE-NEXT:    ld 30, -16(1) # 8-byte Folded Reload
+; LINUX64LE-NEXT:    mtlr 0
+; LINUX64LE-NEXT:    blr
+entry:
+  %TheString = alloca [10 x i8], align 1
+  call void @llvm.lifetime.start.p0(i64 10, ptr nonnull %TheString)
+  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(10) %TheString, ptr noundef nonnull align 1 dereferenceable(10) @__const.str6.TheString, i64 10, i1 false)
+  %call = call signext i32 @callee(ptr noundef nonnull %TheString)
+  %add.ptr = getelementptr inbounds i8, ptr %TheString, i64 5
+  %call2 = call signext i32 @callee(ptr noundef nonnull %add.ptr)
+  %add = add nsw i32 %call2, %call
+  call void @llvm.lifetime.end.p0(i64 10, ptr nonnull %TheString)
+  ret i32 %add
+}
+
+define dso_local signext i32 @str7() local_unnamed_addr #0 {
+; AIX32-LABEL: str7:
+; AIX32:       # %bb.0: # %entry
+; AIX32-NEXT:    mflr 0
+; AIX32-NEXT:    stwu 1, -64(1)
+; AIX32-NEXT:    lwz 3, L..C2(2) # @GLOBALSTRING
+; AIX32-NEXT:    stw 0, 72(1)
+; AIX32-NEXT:    stw 31, 60(1) # 4-byte Folded Spill
+; AIX32-NEXT:    lwz 3, 0(3)
+; AIX32-NEXT:    bl .callee[PR]
+; AIX32-NEXT:    nop
+; AIX32-NEXT:    lwz 4, L..C0(2) # @__ModuleStringPool
+; AIX32-NEXT:    mr 31, 3
+; AIX32-NEXT:    addi 4, 4, 98
+; AIX32-NEXT:    mr 3, 4
+; AIX32-NEXT:    bl .callee[PR]
+; AIX32-NEXT:    nop
+; AIX32-NEXT:    add 3, 3, 31
+; AIX32-NEXT:    lwz 31, 60(1) # 4-byte Folded Reload
+; AIX32-NEXT:    addi 1, 1, 64
+; AIX32-NEXT:    lwz 0, 8(1)
+; AIX32-NEXT:    mtlr 0
+; AIX32-NEXT:    blr
+;
+; AIX64-LABEL: str7:
+; AIX64:       # %bb.0: # %entry
+; AIX64-NEXT:    mflr 0
+; AIX64-NEXT:    stdu 1, -128(1)
+; AIX64-NEXT:    ld 3, L..C2(2) # @GLOBALSTRING
+; AIX64-NEXT:    std 0, 144(1)
+; AIX64-NEXT:    std 31, 120(1) # 8-byte Folded Spill
+; AIX64-NEXT:    ld 3, 0(3)
+; AIX64-NEXT:    bl .callee[PR]
+; AIX64-NEXT:    nop
+; AIX64-NEXT:    mr 31, 3
+; AIX64-NEXT:    ld 3, L..C0(2) # @__ModuleStringPool
+; AIX64-NEXT:    addi 3, 3, 98
+; AIX64-NEXT:    bl .callee[PR]
+; AIX64-NEXT:    nop
+; AIX64-NEXT:    add 3, 3, 31
+; AIX64-NEXT:    ld 31, 120(1) # 8-byte Folded Reload
+; AIX64-NEXT:    extsw 3, 3
+; AIX64-NEXT:    addi 1, 1, 128
+; AIX64-NEXT:    ld 0, 16(1)
+; AIX64-NEXT:    mtlr 0
+; AIX64-NEXT:    blr
+;
+; LINUX64BE-LABEL: str7:
+; LINUX64BE:       # %bb.0: # %entry
+; LINUX64BE-NEXT:    mflr 0
+; LINUX64BE-NEXT:    stdu 1, -128(1)
+; LINUX64BE-NEXT:    std 0, 144(1)
+; LINUX64BE-NEXT:    addis 3, 2, GLOBALSTRING@toc@ha
+; LINUX64BE-NEXT:    std 30, 112(1) # 8-byte Folded Spill
+; LINUX64BE-NEXT:    ld 3, GLOBALSTRING@toc@l(3)
+; LINUX64BE-NEXT:    bl callee
+; LINUX64BE-NEXT:    nop
+; LINUX64BE-NEXT:    mr 30, 3
+; LINUX64BE-NEXT:    addis 3, 2, .L__ModuleStringPool@toc@ha
+; LINUX64BE-NEXT:    addi 3, 3, .L__ModuleStringPool@toc@l
+; LINUX64BE-NEXT:    addi 3, 3, 98
+; LINUX64BE-NEXT:    bl callee
+; LINUX64BE-NEXT:    nop
+; LINUX64BE-NEXT:    add 3, 3, 30
+; LINUX64BE-NEXT:    ld 30, 112(1) # 8-byte Folded Reload
+; LINUX64BE-NEXT:    extsw 3, 3
+; LINUX64BE-NEXT:    addi 1, 1, 128
+; LINUX64BE-NEXT:    ld 0, 16(1)
+; LINUX64BE-NEXT:    mtlr 0
+; LINUX64BE-NEXT:    blr
+;
+; LINUX64LE-LABEL: str7:
+; LINUX64LE:       # %bb.0: # %entry
+; LINUX64LE-NEXT:    mflr 0
+; LINUX64LE-NEXT:    std 30, -16(1) # 8-byte Folded Spill
+; LINUX64LE-NEXT:    stdu 1, -48(1)
+; LINUX64LE-NEXT:    std 0, 64(1)
+; LINUX64LE-NEXT:    addis 3, 2, GLOBALSTRING@toc@ha
+; LINUX64LE-NEXT:    ld 3, GLOBALSTRING@toc@l(3)
+; LINUX64LE-NEXT:    bl callee
+; LINUX64LE-NEXT:    nop
+; LINUX64LE-NEXT:    mr 30, 3
+; LINUX64LE-NEXT:    addis 3, 2, .L__ModuleStringPool@toc@ha
+; LINUX64LE-NEXT:    addi 3, 3, .L__ModuleStringPool@toc@l
+; LINUX64LE-NEXT:    addi 3, 3, 98
+; LINUX64LE-NEXT:    bl callee
+; LINUX64LE-NEXT:    nop
+; LINUX64LE-NEXT:    add 3, 3, 30
+; LINUX64LE-NEXT:    extsw 3, 3
+; LINUX64LE-NEXT:    addi 1, 1, 48
+; LINUX64LE-NEXT:    ld 0, 16(1)
+; LINUX64LE-NEXT:    ld 30, -16(1) # 8-byte Folded Reload
+; LINUX64LE-NEXT:    mtlr 0
+; LINUX64LE-NEXT:    blr
+entry:
+  %0 = load ptr, ptr @GLOBALSTRING, align 8
+  %call = tail call signext i32 @callee(ptr noundef %0)
+  %call1 = tail call signext i32 @callee(ptr noundef nonnull @.str.8)
+  %add = add nsw i32 %call1, %call
+  ret i32 %add
+}
+
+define dso_local signext i32 @mixed1() local_unnamed_addr #0 {
+; AIX32-LABEL: mixed1:
+; AIX32:       # %bb.0: # %entry
+; AIX32-NEXT:    mflr 0
+; AIX32-NEXT:    stwu 1, -64(1)
+; AIX32-NEXT:    lwz 3, L..C3(2) # @IntArray2
+; AIX32-NEXT:    stw 0, 72(1)
+; AIX32-NEXT:    stw 31, 60(1) # 4-byte Folded Spill
+; AIX32-NEXT:    bl .calleeInt[PR]
+; AIX32-NEXT:    nop
+; AIX32-NEXT:    lwz 4, L..C0(2) # @__ModuleStringPool
+; AIX32-NEXT:    mr 31, 3
+; AIX32-NEXT:    addi 4, 4, 40
+; AIX32-NEXT:    mr 3, 4
+; AIX32-NEXT:    bl .callee[PR]
+; AIX32-NEXT:    nop
+; AIX32-NEXT:    add 3, 3, 31
+; AIX32-NEXT:    lwz 31, 60(1) # 4-byte Folded Reload
+; AIX32-NEXT:    addi 1, 1, 64
+; AIX32-NEXT:    lwz 0, 8(1)
+; AIX32-NEXT:    mtlr 0
+; AIX32-NEXT:    blr
+;
+; AIX64-LABEL: mixed1:
+; AIX64:       # %bb.0: # %entry
+; AIX64-NEXT:    mflr 0
+; AIX64-NEXT:    stdu 1, -128(1)
+; AIX64-NEXT:    ld 3, L..C3(2) # @IntArray2
+; AIX64-NEXT:    std 0, 144(1)
+; AIX64-NEXT:    std 31, 120(1) # 8-byte Folded Spill
+; AIX64-NEXT:    bl .calleeInt[PR]
+; AIX64-NEXT:    nop
+; AIX64-NEXT:    mr 31, 3
+; AIX64-NEXT:    ld 3, L..C0(2) # @__ModuleStringPool
+; AIX64-NEXT:    addi 3, 3, 40
+; AIX64-NEXT:    bl .callee[PR]
+; AIX64-NEXT:    nop
+; AIX64-NEXT:    add 3, 3, 31
+; AIX64-NEXT:    ld 31, 120(1) # 8-byte Folded Reload
+; AIX64-NEXT:    extsw 3, 3
+; AIX64-NEXT:    addi 1, 1, 128
+; AIX64-NEXT:    ld 0, 16(1)
+; AIX64-NEXT:    mtlr 0
+; AIX64-NEXT:    blr
+;
+; LINUX64BE-LABEL: mixed1:
+; LINUX64BE:       # %bb.0: # %entry
+; LINUX64BE-NEXT:    mflr 0
+; LINUX64BE-NEXT:    stdu 1, -128(1)
+; LINUX64BE-NEXT:    addis 3, 2, IntArray2@toc@ha
+; LINUX64BE-NEXT:    std 0, 144(1)
+; LINUX64BE-NEXT:    std 30, 112(1) # 8-byte Folded Spill
+; LINUX64BE-NEXT:    addi 3, 3, IntArray2@toc@l
+; LINUX64BE-NEXT:    bl calleeInt
+; LINUX64BE-NEXT:    nop
+; LINUX64BE-NEXT:    mr 30, 3
+; LINUX64BE-NEXT:    addis 3, 2, .L__ModuleStringPool@toc@ha
+; LINUX64BE-NEXT:    addi 3, 3, .L__ModuleStringPool@toc@l
+; LINUX64BE-NEXT:    addi 3, 3, 40
+; LINUX64BE-NEXT:    bl callee
+; LINUX64BE-NEXT:    nop
+; LINUX64BE-NEXT:    add 3, 3, 30
+; LINUX64BE-NEXT:    ld 30, 112(1) # 8-byte Folded Reload
+; LINUX64BE-NEXT:    extsw 3, 3
+; LINUX64BE-NEXT:    addi 1, 1, 128
+; LINUX64BE-NEXT:    ld 0, 16(1)
+; LINUX64BE-NEXT:    mtlr 0
+; LINUX64BE-NEXT:    blr
+;
+; LINUX64LE-LABEL: mixed1:
+; LINUX64LE:       # %bb.0: # %entry
+; LINUX64LE-NEXT:    mflr 0
+; LINUX64LE-NEXT:    std 30, -16(1) # 8-byte Folded Spill
+; LINUX64LE-NEXT:    stdu 1, -48(1)
+; LINUX64LE-NEXT:    addis 3, 2, IntArray2@toc@ha
+; LINUX64LE-NEXT:    std 0, 64(1)
+; LINUX64LE-NEXT:    addi 3, 3, IntArray2@toc@l
+; LINUX64LE-NEXT:    bl calleeInt
+; LINUX64LE-NEXT:    nop
+; LINUX64LE-NEXT:    mr 30, 3
+; LINUX64LE-NEXT:    addis 3, 2, .L__ModuleStringPool@toc@ha
+; LINUX64LE-NEXT:    addi 3, 3, .L__ModuleStringPool@toc@l
+; LINUX64LE-NEXT:    addi 3, 3, 40
+; LINUX64LE-NEXT:    bl callee
+; LINUX64LE-NEXT:    nop
+; LINUX64LE-NEXT:    add 3, 3, 30
+; LINUX64LE-NEXT:    extsw 3, 3
+; LINUX64LE-NEXT:    addi 1, 1, 48
+; LINUX64LE-NEXT:    ld 0, 16(1)
+; LINUX64LE-NEXT:    ld 30, -16(1) # 8-byte Folded Reload
+; LINUX64LE-NEXT:    mtlr 0
+; LINUX64LE-NEXT:    blr
+entry:
+  %call = tail call signext i32 @calleeInt(ptr noundef nonnull @IntArray2)
+  %call1 = tail call signext i32 @callee(ptr noundef nonnull @.str.6)
+  %add = add nsw i32 %call1, %call
+  ret i32 %add
+}
+
+define dso_local signext i32 @mixed2() local_unnamed_addr #0 {
+; AIX32-LABEL: mixed2:
+; AIX32:       # %bb.0: # %entry
+; AIX32-NEXT:    mflr 0
+; AIX32-NEXT:    stwu 1, -112(1)
+; AIX32-NEXT:    stw 0, 120(1)
+; AIX32-NEXT:    stw 30, 104(1) # 4-byte Folded Spill
+; AIX32-NEXT:    lwz 30, L..C0(2) # @__ModuleStringPool
+; AIX32-NEXT:    li 4, 12
+; AIX32-NEXT:    addi 3, 1, 64
+; AIX32-NEXT:    mr 5, 3
+; AIX32-NEXT:    stw 31, 108(1) # 4-byte Folded Spill
+; AIX32-NEXT:    rlwimi 5, 4, 0, 28, 29
+; AIX32-NEXT:    lxvw4x 0, 30, 4
+; AIX32-NEXT:    lxvw4x 1, 0, 30
+; AIX32-NEXT:    stxvw4x 0, 0, 5
+; AIX32-NEXT:    stxvw4x 1, 0, 3
+; AIX32-NEXT:    bl .calleeInt[PR]
+; AIX32-NEXT:    nop
+; AIX32-NEXT:    lwz 4, L..C3(2) # @IntArray2
+; AIX32-NEXT:    mr 31, 3
+; AIX32-NEXT:    mr 3, 4
+; AIX32-NEXT:    bl .calleeInt[PR]
+; AIX32-NEXT:    nop
+; AIX32-NEXT:    addi 4, 30, 40
+; AIX32-NEXT:    mr 5, 3
+; AIX32-NEXT:    mr 3, 4
+; AIX32-NEXT:    add 31, 5, 31
+; AIX32-NEXT:    bl .callee[PR]
+; AIX32-NEXT:    nop
+; AIX32-NEXT:    addi 4, 30, 113
+; AIX32-NEXT:    mr 5, 3
+; AIX32-NEXT:    mr 3, 4
+; AIX32-NEXT:    add 31, 31, 5
+; AIX32-NEXT:    bl .callee[PR]
+; AIX32-NEXT:    nop
+; AIX32-NEXT:    add 3, 31, 3
+; AIX32-NEXT:    lwz 31, 108(1) # 4-byte Folded Reload
+; AIX32-NEXT:    lwz 30, 104(1) # 4-byte Folded Reload
+; AIX32-NEXT:    addi 1, 1, 112
+; AIX32-NEXT:    lwz 0, 8(1)
+; AIX32-NEXT:    mtlr 0
+; AIX32-NEXT:    blr
+;
+; AIX64-LABEL: mixed2:
+; AIX64:       # %bb.0: # %entry
+; AIX64-NEXT:    mflr 0
+; AIX64-NEXT:    stdu 1, -160(1)
+; AIX64-NEXT:    std 0, 176(1)
+; AIX64-NEXT:    std 30, 144(1) # 8-byte Folded Spill
+; AIX64-NEXT:    ld 30, L..C0(2) # @__ModuleStringPool
+; AIX64-NEXT:    li 3, 12
+; AIX64-NEXT:    addi 4, 1, 124
+; AIX64-NEXT:    std 31, 152(1) # 8-byte Folded Spill
+; AIX64-NEXT:    lxvw4x 0, 30, 3
+; AIX64-NEXT:    lxvw4x 1, 0, 30
+; AIX64-NEXT:    addi 3, 1, 112
+; AIX64-NEXT:    stxvw4x 0, 0, 4
+; AIX64-NEXT:    stxvw4x 1, 0, 3
+; AIX64-NEXT:    bl .calleeInt[PR]
+; AIX64-NEXT:    nop
+; AIX64-NEXT:    mr 31, 3
+; AIX64-NEXT:    ld 3, L..C3(2) # @IntArray2
+; AIX64-NEXT:    bl .calleeInt[PR]
+; AIX64-NEXT:    nop
+; AIX64-NEXT:    addi 4, 30, 40
+; AIX64-NEXT:    add 31, 3, 31
+; AIX64-NEXT:    mr 3, 4
+; AIX64-NEXT:    bl .callee[PR]
+; AIX64-NEXT:    nop
+; AIX64-NEXT:    addi 4, 30, 113
+; AIX64-NEXT:    add 31, 31, 3
+; AIX64-NEXT:    mr 3, 4
+; AIX64-NEXT:    bl .callee[PR]
+; AIX64-NEXT:    nop
+; AIX64-NEXT:    add 3, 31, 3
+; AIX64-NEXT:    ld 31, 152(1) # 8-byte Folded Reload
+; AIX64-NEXT:    ld 30, 144(1) # 8-byte Folded Reload
+; AIX64-NEXT:    extsw 3, 3
+; AIX64-NEXT:    addi 1, 1, 160
+; AIX64-NEXT:    ld 0, 16(1)
+; AIX64-NEXT:    mtlr 0
+; AIX64-NEXT:    blr
+;
+; LINUX64BE-LABEL: mixed2:
+; LINUX64BE:       # %bb.0: # %entry
+; LINUX64BE-NEXT:    mflr 0
+; LINUX64BE-NEXT:    stdu 1, -176(1)
+; LINUX64BE-NEXT:    addis 3, 2, .L__ModuleStringPool@toc@ha
+; LINUX64BE-NEXT:    std 0, 192(1)
+; LINUX64BE-NEXT:    std 29, 152(1) # 8-byte Folded Spill
+; LINUX64BE-NEXT:    addi 4, 1, 124
+; LINUX64BE-NEXT:    std 30, 160(1) # 8-byte Folded Spill
+; LINUX64BE-NEXT:    addi 29, 3, .L__ModuleStringPool@toc@l
+; LINUX64BE-NEXT:    li 3, 12
+; LINUX64BE-NEXT:    lxvw4x 0, 29, 3
+; LINUX64BE-NEXT:    addi 3, 1, 112
+; LINUX64BE-NEXT:    lxvw4x 1, 0, 29
+; LINUX64BE-NEXT:    stxvw4x 0, 0, 4
+; LINUX64BE-NEXT:    stxvw4x 1, 0, 3
+; LINUX64BE-NEXT:    bl calleeInt
+; LINUX64BE-NEXT:    nop
+; LINUX64BE-NEXT:    mr 30, 3
+; LINUX64BE-NEXT:    addis 3, 2, IntArray2@toc@ha
+; LINUX64BE-NEXT:    addi 3, 3, IntArray2@toc@l
+; LINUX64BE-NEXT:    bl calleeInt
+; LINUX64BE-NEXT:    nop
+; LINUX64BE-NEXT:    addi 4, 29, 40
+; LINUX64BE-NEXT:    add 30, 3, 30
+; LINUX64BE-NEXT:    mr 3, 4
+; LINUX64BE-NEXT:    bl callee
+; LINUX64BE-NEXT:    nop
+; LINUX64BE-NEXT:    addi 4, 29, 113
+; LINUX64BE-NEXT:    add 30, 30, 3
+; LINUX64BE-NEXT:    mr 3, 4
+; LINUX64BE-NEXT:    bl callee
+; LINUX64BE-NEXT:    nop
+; LINUX64BE-NEXT:    add 3, 30, 3
+; LINUX64BE-NEXT:    ld 30, 160(1) # 8-byte Folded Reload
+; LINUX64BE-NEXT:    ld 29, 152(1) # 8-byte Folded Reload
+; LINUX64BE-NEXT:    extsw 3, 3
+; LINUX64BE-NEXT:    addi 1, 1, 176
+; LINUX64BE-NEXT:    ld 0, 16(1)
+; LINUX64BE-NEXT:    mtlr 0
+; LINUX64BE-NEXT:    blr
+;
+; LINUX64LE-LABEL: mixed2:
+; LINUX64LE:       # %bb.0: # %entry
+; LINUX64LE-NEXT:    mflr 0
+; LINUX64LE-NEXT:    std 29, -24(1) # 8-byte Folded Spill
+; LINUX64LE-NEXT:    std 30, -16(1) # 8-byte Folded Spill
+; LINUX64LE-NEXT:    stdu 1, -96(1)
+; LINUX64LE-NEXT:    addis 3, 2, .L__ModuleStringPool@toc@ha
+; LINUX64LE-NEXT:    addi 4, 1, 44
+; LINUX64LE-NEXT:    std 0, 112(1)
+; LINUX64LE-NEXT:    addi 29, 3, .L__ModuleStringPool@toc@l
+; LINUX64LE-NEXT:    li 3, 12
+; LINUX64LE-NEXT:    lxvd2x 0, 29, 3
+; LINUX64LE-NEXT:    lxvd2x 1, 0, 29
+; LINUX64LE-NEXT:    addi 3, 1, 32
+; LINUX64LE-NEXT:    stxvd2x 0, 0, 4
+; LINUX64LE-NEXT:    stxvd2x 1, 0, 3
+; LINUX64LE-NEXT:    bl calleeInt
+; LINUX64LE-NEXT:    nop
+; LINUX64LE-NEXT:    mr 30, 3
+; LINUX64LE-NEXT:    addis 3, 2, IntArray2@toc@ha
+; LINUX64LE-NEXT:    addi 3, 3, IntArray2@toc@l
+; LINUX64LE-NEXT:    bl calleeInt
+; LINUX64LE-NEXT:    nop
+; LINUX64LE-NEXT:    addi 4, 29, 40
+; LINUX64LE-NEXT:    add 30, 3, 30
+; LINUX64LE-NEXT:    mr 3, 4
+; LINUX64LE-NEXT:    bl callee
+; LINUX64LE-NEXT:    nop
+; LINUX64LE-NEXT:    addi 4, 29, 113
+; LINUX64LE-NEXT:    add 30, 30, 3
+; LINUX64LE-NEXT:    mr 3, 4
+; LINUX64LE-NEXT:    bl callee
+; LINUX64LE-NEXT:    nop
+; LINUX64LE-NEXT:    add 3, 30, 3
+; LINUX64LE-NEXT:    extsw 3, 3
+; LINUX64LE-NEXT:    addi 1, 1, 96
+; LINUX64LE-NEXT:    ld 0, 16(1)
+; LINUX64LE-NEXT:    ld 30, -16(1) # 8-byte Folded Reload
+; LINUX64LE-NEXT:    ld 29, -24(1) # 8-byte Folded Reload
+; LINUX64LE-NEXT:    mtlr 0
+; LINUX64LE-NEXT:    blr
+entry:
+  %IntArray = alloca [7 x i32], align 4
+  call void @llvm.lifetime.start.p0(i64 28, ptr nonnull %IntArray)
+  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 4 dereferenceable(28) %IntArray, ptr noundef nonnull align 4 dereferenceable(28) @__const.mixed2.IntArray, i64 28, i1 false)
+  %call = call signext i32 @calleeInt(ptr noundef nonnull %IntArray)
+  %call1 = call signext i32 @calleeInt(ptr noundef nonnull @IntArray2)
+  %add = add nsw i32 %call1, %call
+  %call2 = call signext i32 @callee(ptr noundef nonnull @.str.6)
+  %add3 = add nsw i32 %add, %call2
+  %call4 = call signext i32 @callee(ptr noundef nonnull @.str.7)
+  %add5 = add nsw i32 %add3, %call4
+  call void @llvm.lifetime.end.p0(i64 28, ptr nonnull %IntArray)
+  ret i32 %add5
+}
+
+attributes #0 = { nounwind }
+
+; AIXDATA: .csect L..__ModuleStringPool[RO],2
+; AIXDATA:       .align  4                               # @__ModuleStringPool
+; AIXDATA:       .vbyte  4, 5                            # 0x5
+; AIXDATA:       .vbyte  4, 7                            # 0x7
+; AIXDATA:       .vbyte  4, 9                            # 0x9
+; AIXDATA:       .vbyte  4, 11                           # 0xb
+; AIXDATA:       .vbyte  4, 17                           # 0x11
+; AIXDATA:       .vbyte  4, 1235                         # 0x4d3
+; AIXDATA:       .vbyte  4, 32                           # 0x20
+; AIXDATA:       .string "str2_STRING"
+; AIXDATA:       .string "MixedString"
+; AIXDATA:       .string "ABCABCABC"
+; AIXDATA:       .string "str1_STRING"
+; AIXDATA:       .string "str3_STRING"
+; AIXDATA:       .string "str4_STRING"
+; AIXDATA:       .byte   'S,'t,'a,'t,'i,'c,' ,'G,'l,'o,'b,'a,'l,0012,0000
+; AIXDATA:       .string "Different String 01"
+; AIXDATA:       .string "longerstr5_longerstr5_longerstr5_longerstr5_longerstr5_longerstr5_longerstr5_longerstr5_longerstr5_longerstr5_longerstr5_longerstr5_longerstr5_longerstr5_longerstr5_longerstr5_STRING"
+
+; LINUXDATA: .L__ModuleStringPool:
+; LINUXDATA:    .long 5                               # 0x5
+; LINUXDATA:    .long 7                               # 0x7
+; LINUXDATA:    .long 9                               # 0x9
+; LINUXDATA:    .long 11                              # 0xb
+; LINUXDATA:    .long 17                              # 0x11
+; LINUXDATA:    .long 1235                            # 0x4d3
+; LINUXDATA:    .long 32                              # 0x20
+; LINUXDATA:    .asciz  "str2_STRING"
+; LINUXDATA:    .asciz  "MixedString"
+; LINUXDATA:    .asciz  "ABCABCABC"
+; LINUXDATA:    .asciz  "str1_STRING"
+; LINUXDATA:    .asciz  "str3_STRING"
+; LINUXDATA:    .asciz  "str4_STRING"
+; LINUXDATA:    .asciz  "Static Global\n"
+; LINUXDATA:    .asciz  "Different String 01"
+; LINUXDATA:    .asciz  "longerstr5_longerstr5_longerstr5_longerstr5_longerstr5_longerstr5_longerstr5_longerstr5_longerstr5_longerstr5_longerstr5_longerstr5_longerstr5_longerstr5_longerstr5_longerstr5_STRING"