[PPC64] Add split-stack support.

[sfertile]

Summary

This support is slightly different then the X86_64 implementation in that calls to __morestack don't need to get rewritten to calls to __moresatck_non_split when a split-stack caller calls a non-split-stack callee. Instead the size of the stack frame requested by the caller is adjusted prior to the call to __morestack. The size the stack-frame will be adjusted by is tune-able through a new --split-stack-adjust-size option.

[ruiu]

ELF/Arch/PPC64.cpp

663 ↗

(On Diff #165494)

It perhaps needs a high-level comment describing what instruction sequence is rewritten to what instruction sequence.

665 ↗

(On Diff #165494)

It's not clear to me what this code does -- is this PPC-specific thing?

676 ↗

(On Diff #165494)

nit: remove {}

681 ↗

(On Diff #165494)

Ditto

685 ↗

(On Diff #165494)

nit: I'd name HiImm and LoImm

We usually define one variable per line, so

int16_t HiImm = 0;
int16_t LoImm = 0;

694 ↗

(On Diff #165494)

Can this happen?

703 ↗

(On Diff #165494)

Is this an ABI violation, or legitimate code has such code sequence in which an instruction other than addi or nop follows the first instruction?

ELF/Driver.cpp

284–285 ↗

(On Diff #165494)

This may be a silly question, but why we have --split-stack-adjust-size only for PPC64 and not for x86-64? If we can live without that option with x86-64, why do we need it for PPC64?

ELF/Target.h

80 ↗

(On Diff #165494)

This should be a boolean public member variable instead of a virtual function call for the sake of simplicity.

[sfertile]

ELF/Arch/PPC64.cpp

665 ↗

(On Diff #165494)

Yes, its V2 abi specific. A function can have 2 entry points:

1. A global entry point which will setup the TOC pointer if the function needs it.
2. A local entry point, which will be the entry if the caller shares the same value for the TOC pointer, this skips over the TOC pointer initialization.

The 3 most significant bits of the functions st_other flags are used to encode the offset from the global entry to the local entry.

This is something we are already doing in getRelocTargetVA for R_PPC_CALL RelExpr and I believe it comes up in the position-dependent long branch thunks patch I posted. I'll move the calculation into its own function and try to explain the how and why more clearly there so its not so opaque to people not familiar with PowerPC64 abi.

694 ↗

(On Diff #165494)

I believe so, but I'm not 100% sure. I'm extrapolating from the x86-64-split-stack-prologue-adjust-silent.s test which implies that having a .note.GNU-no-split-stack section tells the linker there may be unrecognizable prologues. I wouldn't expect a compiler to generate such a prologue but was guessing it should be valid to write a custom prologue that called __morestack_non_split directly and the program would still be valid.

703 ↗

(On Diff #165494)

Like the above answer I'm not really sure. I believe a compliant compiler is expected to always emit this sequence but I don't think its necessarily disallowed to emit a different sequence. The behavior with the GNU-no-split-stack note indicates to me that different sequences are allowed but the handshake with the linker is broken and its up to the user to have implemented something that makes sense, but I can't find this documented anywhere,

ELF/Driver.cpp

284–285 ↗

(On Diff #165494)

I'm not very familiar with the x86-64 implementation, but from my understanding on x86-64 you don't have the room to rewrite the instructions to test with the adjusted stack size for all of the supported prologues types (and/or arbitrary stack frame adjustment sizes). So instead of adjusting the check in the function prologue you have to always jump to __morestack_non_split and rely on it doing the adjusted check. On PowerPC we will always emit 2 instructions for adjusting the stack, which is enough to rewrite the adjustment for any supported stack frame size, so we don't need to call __more_stack_non_split.

[ruiu]

ELF/Arch/PPC64.cpp

665 ↗

(On Diff #165494)

A documentation about that kind of ABI-specific stuff is sometimes extremely useful to understand code. Can you write a file comment describing what you just wrote? If there are other PPC-specific things, it's worth to be written as well.

[sfertile]

ELF/Arch/PPC64.cpp

665 ↗

(On Diff #165494)

I've posted https://reviews.llvm.org/D52231 which is an nfc patch adding a helper function to calculate the offset as well as document the differences between global entry and local entry. I'll update this patch to be dependent on that one.

[sfertile]

• Added an explanation of the expected prologue instructions and how the linker is supposed to modify them.
• Add check for overflow on the adjusted stack size
• Add check that the register operands are the expected ones.
• Changed global-entry to local-entry offset calculation to use new helper function.

[ruiu]

ELF/Arch/PPC64.cpp

717 ↗

(On Diff #166062)

there's an extra space after "prologue"

761 ↗

(On Diff #166062)

I think this can be triggered by feeding an object file that doesn't comply with the ABI standard, so this shouldn't be an assert. I'd just omit this check.

794 ↗

(On Diff #166062)

Do you need a cast?

[sfertile]

Removed extra space in comment, and incorrect assert.

[sfertile]

ELF/Arch/PPC64.cpp

761 ↗

(On Diff #166062)

Good point. I've updated to ensure that if LoImm is set and the second instruction is not a nop or we don't adjust the stack.

794 ↗

(On Diff #166062)

Since LoImm and HiImm can be negative I added the casts so that we zero extend in the conversion from 16 bits to 32 bits. I could instead add a mask for the lower 16bits if that is clearer eg write32(Loc + 4, 0x3D810000 | (0x0000FFFF & HiImm));

[ruiu]

LGTM

ELF/Config.h

220 ↗

(On Diff #168313)

Replace two spaces with one space.

lld/trunk/ELF/Arch/PPC64.cpp

public:
   bool needsThunk(RelExpr Expr, RelType Type, const InputFile *File,
                   uint64_t BranchAddr, const Symbol &S) const override;
   RelExpr adjustRelaxExpr(RelType Type, const uint8_t *Data,
                           RelExpr Expr) const override;
   void relaxTlsGdToIe(uint8_t *Loc, RelType Type, uint64_t Val) const override;
   void relaxTlsGdToLe(uint8_t *Loc, RelType Type, uint64_t Val) const override;
   void relaxTlsLdToLe(uint8_t *Loc, RelType Type, uint64_t Val) const override;
   void relaxTlsIeToLe(uint8_t *Loc, RelType Type, uint64_t Val) const override;
+
+  bool adjustPrologueForCrossSplitStack(uint8_t *Loc, uint8_t *End,
+                                        uint8_t StOther) const override;
 };
 } // namespace
 
 // Relocation masks following the #lo(value), #hi(value), #ha(value),
 // #higher(value), #highera(value), #highest(value), and #highesta(value)
 // macros defined in section 4.5.1. Relocation Types of the PPC-elf64abi
 // document.
 static uint16_t lo(uint64_t V) { return V; }
PPC64::PPC64() {
   TcbSize = 8;
   TlsTpOffset = 0x7000;
 
   TlsModuleIndexRel = R_PPC64_DTPMOD64;
   TlsOffsetRel = R_PPC64_DTPREL64;
 
   TlsGotRel = R_PPC64_TPREL64;
 
+  NeedsMoreStackNonSplit = false;
+
   // We need 64K pages (at least under glibc/Linux, the loader won't
   // set different permissions on a finer granularity than that).
   DefaultMaxPageSize = 65536;
 
   // The PPC64 ELF ABI v1 spec, says:
   //
   //   It is normally desirable to put segments with different characteristics
   //   in separate 256 Mbyte portions of the address space, to give the
case R_PPC64_TLSGD:
     write32(Loc, 0x60000000);     // bl __tls_get_addr(sym@tlsgd) --> nop
     write32(Loc + 4, 0x7c636A14); // nop --> add r3, r3, r13
     return;
   default:
     llvm_unreachable("unsupported relocation for TLS GD to IE relaxation");
   }
 }
 
+// The prologue for a split-stack function is expected to look roughly
+// like this:
+//    .Lglobal_entry_point:
+//      # TOC pointer initalization.
+//      ...
+//    .Llocal_entry_point:
+//      # load the __private_ss member of the threads tcbhead.
+//      ld r0,-0x7000-64(r13)
+//      # subtract the functions stack size from the stack pointer.
+//      addis r12, r1, ha(-stack-frame size)
+//      addi  r12, r12, l(-stack-frame size)
+//      # compare needed to actual and branch to allocate_more_stack if more
+//      # space is needed, otherwise fallthrough to 'normal' function body.
+//      cmpld cr7,r12,r0
+//      blt- .Lallocate_more_stack
+//
+// -) The allocate_more_stack block might be placed after the split-stack
+//    prologue and the `blt-` replaced with a `bge+ .Lnormal_func_body`
+//    instead.
+// -) If either the addis or addi is not needed due to the stack size being
+//    smaller then 32K or a multiple of 64K they will be replaced with a nop,
+//    but there will always be 2 instructions the linker can overwrite for the
+//    adjusted stack size.
+//
+// The linkers job here is to increase the stack size used in the addis/addi
+// pair by split-stack-size-adjust.
+// addis r12, r1, ha(-stack-frame size - split-stack-adjust-size)
+// addi  r12, r12, l(-stack-frame size - split-stack-adjust-size)
+bool PPC64::adjustPrologueForCrossSplitStack(uint8_t *Loc, uint8_t *End,
+                                             uint8_t StOther) const {
+  // If the caller has a global entry point adjust the buffer past it. The start
+  // of the split-stack prologue will be at the local entry point.
+  Loc += getPPC64GlobalEntryToLocalEntryOffset(StOther);
+
+  // At the very least we expect to see a load of some split-stack data from the
+  // tcb, and 2 instructions that calculate the ending stack address this
+  // function will require. If there is not enough room for at least 3
+  // instructions it can't be a split-stack prologue.
+  if (Loc + 12 >= End)
+    return false;
+
+  // First instruction must be `ld r0, -0x7000-64(r13)`
+  if (read32(Loc) != 0xe80d8fc0)
+    return false;
+
+  int16_t HiImm = 0;
+  int16_t LoImm = 0;
+  // First instruction can be either an addis if the frame size is larger then
+  // 32K, or an addi if the size is less then 32K.
+  int32_t FirstInstr = read32(Loc + 4);
+  if (getPrimaryOpCode(FirstInstr) == 15) {
+    HiImm = FirstInstr & 0xFFFF;
+  } else if (getPrimaryOpCode(FirstInstr) == 14) {
+    LoImm = FirstInstr & 0xFFFF;
+  } else {
+    return false;
+  }
+
+  // Second instruction is either an addi or a nop. If the first instruction was
+  // an addi then LoImm is set and the second instruction must be a nop.
+  uint32_t SecondInstr = read32(Loc + 8);
+  if (!LoImm && getPrimaryOpCode(SecondInstr) == 14) {
+    LoImm = SecondInstr & 0xFFFF;
+  } else if (SecondInstr != 0x60000000) {
+    return false;
+  }
+
+  // The register operands of the first instruction should be the stack-pointer
+  // (r1) as the input (RA) and r12 as the output (RT). If the second
+  // instruction is not a nop, then it should use r12 as both input and output.
+  auto CheckRegOperands =
+      [](uint32_t Instr, uint8_t ExpectedRT, uint8_t ExpectedRA) {
+        return ((Instr & 0x3E00000) >> 21 == ExpectedRT) &&
+               ((Instr & 0x1F0000) >> 16  == ExpectedRA);
+      };
+  if (!CheckRegOperands(FirstInstr, 12, 1))
+    return false;
+  if (SecondInstr != 0x60000000 && !CheckRegOperands(SecondInstr, 12, 12))
+    return false;
+
+  int32_t StackFrameSize = (HiImm << 16) + LoImm;
+  // Check that the adjusted size doesn't overflow what we can represent with 2
+  // instructions.
+  if (StackFrameSize < -2147483648 + Config->SplitStackAdjustSize) {
+    error(getErrorLocation(Loc) + "split-stack prologue adjustment overflows");
+    return false;
+  }
+
+  int32_t AdjustedStackFrameSize =
+      StackFrameSize - Config->SplitStackAdjustSize;
+
+  LoImm = AdjustedStackFrameSize & 0xFFFF;
+  HiImm = (AdjustedStackFrameSize + 0x8000) >> 16;
+  if (HiImm) {
+    write32(Loc + 4, 0x3D810000 | (uint16_t)HiImm);
+    // If the low immediate is zero the second instruction will be a nop.
+    SecondInstr =
+        LoImm ? 0x398C0000 | (uint16_t)LoImm : 0x60000000;
+    write32(Loc + 8, SecondInstr);
+  } else {
+    // addi r12, r1, imm
+    write32(Loc + 4, (0x39810000) | (uint16_t)LoImm);
+    write32(Loc + 8, 0x60000000);
+  }
+
+  return true;
+}
+
 TargetInfo *elf::getPPC64TargetInfo() {
   static PPC64 Target;
   return &Target;
   }

lld/trunk/ELF/Arch/X86_64.cpp

public:
 
   RelExpr adjustRelaxExpr(RelType Type, const uint8_t *Data,
                           RelExpr Expr) const override;
   void relaxGot(uint8_t *Loc, uint64_t Val) const override;
   void relaxTlsGdToIe(uint8_t *Loc, RelType Type, uint64_t Val) const override;
   void relaxTlsGdToLe(uint8_t *Loc, RelType Type, uint64_t Val) const override;
   void relaxTlsIeToLe(uint8_t *Loc, RelType Type, uint64_t Val) const override;
   void relaxTlsLdToLe(uint8_t *Loc, RelType Type, uint64_t Val) const override;
-  bool adjustPrologueForCrossSplitStack(uint8_t *Loc,
-                                        uint8_t *End) const override;
+  bool adjustPrologueForCrossSplitStack(uint8_t *Loc, uint8_t *End,
+                                        uint8_t StOther) const override;
 
 private:
   void relaxGotNoPic(uint8_t *Loc, uint64_t Val, uint8_t Op,
                      uint8_t ModRm) const;
 };
 } // namespace
 
 template <class ELFT> X86_64<ELFT>::X86_64() {

 namespace {
 
 // A split-stack prologue starts by checking the amount of stack remaining
 // in one of two ways:
 // A) Comparing of the stack pointer to a field in the tcb.
 // B) Or a load of a stack pointer offset with an lea to r10 or r11.
 template <>
 bool X86_64<ELF64LE>::adjustPrologueForCrossSplitStack(uint8_t *Loc,
-                                                       uint8_t *End) const {
+                                                       uint8_t *End,
+                                                       uint8_t StOther) const {
   if (Loc + 8 >= End)
     return false;
 
   // Replace "cmp %fs:0x70,%rsp" and subsequent branch
   // with "stc, nopl 0x0(%rax,%rax,1)"
   if (memcmp(Loc, "\x64\x48\x3b\x24\x25", 5) == 0) {
     memcpy(Loc, "\xf9\x0f\x1f\x84\x00\x00\x00\x00", 8);
     return true;
if (memcmp(Loc, "\x4c\x8d\x94\x24", 4) == 0 ||
     write32le(Loc + 4, read32le(Loc + 4) - 0x4000);
     return true;
   }
   return false;
 }
 
 template <>
 bool X86_64<ELF32LE>::adjustPrologueForCrossSplitStack(uint8_t *Loc,
-                                                       uint8_t *End) const {
+                                                       uint8_t *End,
+                                                       uint8_t StOther) const {
   llvm_unreachable("Target doesn't support split stacks.");
 }
 
 } // namespace
 
 // These nonstandard PLT entries are to migtigate Spectre v2 security
 // vulnerability. In order to mitigate Spectre v2, we want to avoid indirect
 // branch instructions such as `jmp *GOTPLT(%rip)`. So, in the following PLT

lld/trunk/ELF/Config.h

struct Configuration {
   llvm::Optional<uint64_t> ImageBase;
   uint64_t MaxPageSize;
   uint64_t MipsGotSize;
   uint64_t ZStackSize;
   unsigned LTOPartitions;
   unsigned LTOO;
   unsigned Optimize;
   unsigned ThinLTOJobs;
+  int32_t SplitStackAdjustSize;
 
   // The following config options do not directly correspond to any
   // particualr command line options.
 
   // True if we need to pass through relocations in input files to the
   // output file. Usually false because we consume relocations.
   bool CopyRelocs;
 

lld/trunk/ELF/Driver.cpp

void LinkerDriver::readConfigs(opt::InputArgList &Args) {
   Config->Relocatable = Args.hasArg(OPT_relocatable);
   Config->SaveTemps = Args.hasArg(OPT_save_temps);
   Config->SearchPaths = args::getStrings(Args, OPT_library_path);
   Config->SectionStartMap = getSectionStartMap(Args);
   Config->Shared = Args.hasArg(OPT_shared);
   Config->SingleRoRx = Args.hasArg(OPT_no_rosegment);
   Config->SoName = Args.getLastArgValue(OPT_soname);
   Config->SortSection = getSortSection(Args);
+  Config->SplitStackAdjustSize = args::getInteger(Args, OPT_split_stack_adjust_size, 16384);
   Config->Strip = getStrip(Args);
   Config->Sysroot = Args.getLastArgValue(OPT_sysroot);
   Config->Target1Rel = Args.hasFlag(OPT_target1_rel, OPT_target1_abs, false);
   Config->Target2 = getTarget2(Args);
   Config->ThinLTOCacheDir = Args.getLastArgValue(OPT_thinlto_cache_dir);
   Config->ThinLTOCachePolicy = CHECK(
       parseCachePruningPolicy(Args.getLastArgValue(OPT_thinlto_cache_policy)),
       "--thinlto-cache-policy: invalid cache policy");
void LinkerDriver::readConfigs(opt::InputArgList &Args) {
 
   if (Config->LTOO > 3)
     error("invalid optimization level for LTO: " + Twine(Config->LTOO));
   if (Config->LTOPartitions == 0)
     error("--lto-partitions: number of threads must be > 0");
   if (Config->ThinLTOJobs == 0)
     error("--thinlto-jobs: number of threads must be > 0");
 
+  if (Config->SplitStackAdjustSize < 0)
+    error("--split-stack-adjust-size: size must be >= 0");
+
   // Parse ELF{32,64}{LE,BE} and CPU type.
   if (auto *Arg = Args.getLastArg(OPT_m)) {
     StringRef S = Arg->getValue();
     std::tie(Config->EKind, Config->EMachine, Config->OSABI) =
         parseEmulation(S);
     Config->MipsN32Abi = (S == "elf32btsmipn32" || S == "elf32ltsmipn32");
     Config->Emulation = S;
   }

lld/trunk/ELF/InputSection.cpp

if (Defined *D = dyn_cast<Defined>(Rel.Sym))
           continue;
 
     if (enclosingPrologueAttempted(Rel.Offset, Prologues))
       continue;
 
     if (Defined *F = getEnclosingFunction<ELFT>(Rel.Offset)) {
       Prologues.insert(F);
       if (Target->adjustPrologueForCrossSplitStack(Buf + getOffset(F->Value),
-                                                   End))
+                                                   End, F->StOther))
         continue;
       if (!getFile<ELFT>()->SomeNoSplitStack)
         error(lld::toString(this) + ": " + F->getName() +
               " (with -fsplit-stack) calls " + Rel.Sym->getName() +
               " (without -fsplit-stack), but couldn't adjust its prologue");
     }
   }
+
+  if (Target->NeedsMoreStackNonSplit)
     switchMorestackCallsToMorestackNonSplit(Prologues, MorestackCalls);
 }
 
 template <class ELFT> void InputSection::writeTo(uint8_t *Buf) {
   if (Type == SHT_NOBITS)
     return;
 
   if (auto *S = dyn_cast<SyntheticSection>(this)) {
     S->writeTo(Buf + OutSecOff);

lld/trunk/ELF/Options.td

defm check_sections: B<"check-sections",
     "Do not check section addresses for overlaps">;
 
 defm compress_debug_sections:
   Eq<"compress-debug-sections", "Compress DWARF debug sections">,
   MetaVarName<"[none,zlib]">;
 
 defm defsym: Eq<"defsym", "Define a symbol alias">, MetaVarName<"<symbol>=<value>">;
 
+defm split_stack_adjust_size
+    : Eq<"split-stack-adjust-size",
+         "Specify adjustment to stack size when a split-stack function calls a "
+         "non-split-stack function">,
+      MetaVarName<"<value>">;
+
 defm library_path:
   Eq<"library-path", "Add a directory to the library search path">, MetaVarName<"<dir>">;
 
 def O: JoinedOrSeparate<["-"], "O">, HelpText<"Optimize output file size">;
 
 defm Tbss: Eq<"Tbss", "Same as --section-start with .bss as the sectionname">;
 
 defm Tdata: Eq<"Tdata", "Same as --section-start with .data as the sectionname">;

lld/trunk/ELF/Target.h

public:
   // On systems with range extensions we place collections of Thunks at
   // regular spacings that enable the majority of branches reach the Thunks.
   // a value of 0 means range extension thunks are not supported.
   virtual uint32_t getThunkSectionSpacing() const { return 0; }
 
   // The function with a prologue starting at Loc was compiled with
   // -fsplit-stack and it calls a function compiled without. Adjust the prologue
   // to do the right thing. See https://gcc.gnu.org/wiki/SplitStacks.
-  virtual bool adjustPrologueForCrossSplitStack(uint8_t *Loc,
-                                                uint8_t *End) const;
+  // The symbols st_other flags are needed on PowerPC64 for determining the
+  // offset to the split-stack prologue.
+  virtual bool adjustPrologueForCrossSplitStack(uint8_t *Loc, uint8_t *End,
+                                                uint8_t StOther) const;
 
   // Return true if we can reach Dst from Src with Relocation RelocType
   virtual bool inBranchRange(RelType Type, uint64_t Src,
                              uint64_t Dst) const;
   virtual RelExpr getRelExpr(RelType Type, const Symbol &S,
                              const uint8_t *Loc) const = 0;
 
   virtual void relocateOne(uint8_t *Loc, RelType Type, uint64_t Val) const = 0;
public:
   unsigned TlsTpOffset = 0;
 
   bool NeedsThunks = false;
 
   // A 4-byte field corresponding to one or more trap instructions, used to pad
   // executable OutputSections.
   uint32_t TrapInstr = 0;
 
+  // If a target needs to rewrite calls to __morestack to instead call
+  // __morestack_non_split when a split-stack enabled caller calls a
+  // non-split-stack callee this will return true. Otherwise returns false.
+  bool NeedsMoreStackNonSplit = true;
+
   virtual RelExpr adjustRelaxExpr(RelType Type, const uint8_t *Data,
                                   RelExpr Expr) const;
   virtual void relaxGot(uint8_t *Loc, uint64_t Val) const;
   virtual void relaxTlsGdToIe(uint8_t *Loc, RelType Type, uint64_t Val) const;
   virtual void relaxTlsGdToLe(uint8_t *Loc, RelType Type, uint64_t Val) const;
   virtual void relaxTlsIeToLe(uint8_t *Loc, RelType Type, uint64_t Val) const;
   virtual void relaxTlsLdToLe(uint8_t *Loc, RelType Type, uint64_t Val) const;
 

lld/trunk/ELF/Target.cpp

 
 bool TargetInfo::usesOnlyLowPageBits(RelType Type) const { return false; }
 
 bool TargetInfo::needsThunk(RelExpr Expr, RelType Type, const InputFile *File,
                             uint64_t BranchAddr, const Symbol &S) const {
   return false;
 }
 
-bool TargetInfo::adjustPrologueForCrossSplitStack(uint8_t *Loc,
-                                                  uint8_t *End) const {
+bool TargetInfo::adjustPrologueForCrossSplitStack(uint8_t *Loc, uint8_t *End,
+                                                  uint8_t StOther) const {
   llvm_unreachable("Target doesn't support split stacks.");
 }
 
-
 bool TargetInfo::inBranchRange(RelType Type, uint64_t Src, uint64_t Dst) const {
   return true;
 }
 
 void TargetInfo::writeIgotPlt(uint8_t *Buf, const Symbol &S) const {
   writeGotPlt(Buf, S);
 }
 

lld/trunk/test/ELF/Inputs/ppc64-no-split-stack.s

+  .abiversion 2
+        .p2align    2
+        .global     nss_callee
+        .type nss_callee, @function
+nss_callee:
+    li 3, 1
+    blr
+

lld/trunk/test/ELF/ppc64-split-stack-adjust-fail.s

+# REQUIRES: ppc
+
+# RUN: llvm-mc -filetype=obj -triple=powerpc64le-unknown-linux %s -o %t1.o
+# RUN: llvm-mc -filetype=obj -triple=powerpc64le-unknown-linux %p/Inputs/ppc64-no-split-stack.s -o %t2.o
+
+# RUN: not ld.lld --defsym __morestack=0x10010000 %t1.o %t2.o -o %t 2>&1 | FileCheck %s
+
+# RUN: llvm-mc -filetype=obj -triple=powerpc64-unknown-linux %s -o %t1.o
+# RUN: llvm-mc -filetype=obj -triple=powerpc64-unknown-linux %p/Inputs/ppc64-no-split-stack.s -o %t2.o
+
+# RUN: not ld.lld --defsym __morestack=0x10010000 %t1.o %t2.o -o %t 2>&1 | FileCheck %s
+
+# CHECK: error: {{.*}}.o:(.text): wrong_regs (with -fsplit-stack) calls nss_callee (without -fsplit-stack), but couldn't adjust its prologue
+
+        .abiversion 2
+        .section    ".text"
+
+        .p2align 2
+        .global wrong_regs
+        .type wrong_regs, @function
+
+wrong_regs:
+.Lwr_gep:
+    addis 2, 12, .TOC.-.Lwr_gep@ha
+    addi 2, 2, .TOC.-.Lwr_gep@l
+    .localentry wrong_regs, .-wrong_regs
+    ld 0, -0x7040(13)
+    addis 5, 2, -1
+    addi  5, 5, -32
+    addi 12, 1, -32
+    nop
+    cmpld 7, 12, 0
+    blt- 7, .Lwr_alloc_more
+.Lwr_body:
+    mflr 0
+    std 0, 16(1)
+    stdu 1, -32(1)
+    bl nss_callee
+    addi 1, 1, 32
+    ld 0, 16(1)
+    mtlr 0
+    blr
+.Lwr_alloc_more:
+    mflr 0
+    std 0, 16(1)
+    bl __morestack
+    ld 0, 16(1)
+    mtlr 0
+    blr
+    b .Lwr_body
+        .size wrong_regs, .-wrong_regs
+
+        .section        .note.GNU-split-stack,"",@progbits

lld/trunk/test/ELF/ppc64-split-stack-adjust-overflow.s

+# REQUIRES: ppc
+
+# RUN: llvm-mc -filetype=obj -triple=powerpc64le-unknown-linux %s -o %t1.o
+# RUN: llvm-mc -filetype=obj -triple=powerpc64le-unknown-linux %p/Inputs/ppc64-no-split-stack.s -o %t2.o
+
+# RUN: not ld.lld %t1.o %t2.o -o %t --defsym __morestack=0x10010000 2>&1 | \
+# RUN: FileCheck -check-prefix=OVERFLOW %s
+# RUN: not ld.lld %t1.o %t2.o -o %t --defsym __morestack=0x10010000 \
+# RUN: -split-stack-adjust-size 4097 2>&1 | FileCheck -check-prefix=OVERFLOW %s
+# RUN: ld.lld %t1.o %t2.o -o %t --defsym __morestack=0x10010000 -split-stack-adjust-size 4096
+# RUN: llvm-objdump -d %t | FileCheck %s
+
+# RUN: llvm-mc -filetype=obj -triple=powerpc64-unknown-linux %s -o %t1.o
+# RUN: llvm-mc -filetype=obj -triple=powerpc64-unknown-linux %p/Inputs/ppc64-no-split-stack.s -o %t2.o
+
+# RUN: not ld.lld %t1.o %t2.o -o %t --defsym __morestack=0x10010000 2>&1 | \
+# RUN: FileCheck -check-prefix=OVERFLOW %s
+# RUN: not ld.lld %t1.o %t2.o -o %t --defsym __morestack=0x10010000 \
+# RUN: -split-stack-adjust-size 4097 2>&1 | FileCheck -check-prefix=OVERFLOW %s
+# RUN: ld.lld %t1.o %t2.o -o %t --defsym __morestack=0x10010000 -split-stack-adjust-size 4096
+# RUN: llvm-objdump -d %t | FileCheck %s
+
+# OVERFLOW: error: {{.*}}.o:(function caller): split-stack prologue adjustment overflows
+
+        .p2align    2
+        .global caller
+        .type caller, @function
+caller:
+.Lcaller_gep:
+    addis 2, 12, .TOC.-.Lcaller_gep@ha
+    addi 2, 2, .TOC.-.Lcaller_gep@l
+    .localentry caller, .-caller
+    ld 0, -0x7040(13)
+    addis 12, 1, -32768
+    addi  12, 12, 4096
+    cmpld 7, 12, 0
+    blt- 7, .Lcaller_alloc_more
+.Lcaller_body:
+    mflr 0
+    std 0, 16(1)
+    stdu 1, -32(1)
+    bl nss_callee
+    addi 1, 1, 32
+    ld 0, 16(1)
+    mtlr 0
+    blr
+.Lcaller_alloc_more:
+    mflr 0
+    std 0, 16(1)
+    bl __morestack
+    ld 0, 16(1)
+    mtlr 0
+    blr
+    b .Lcaller_body
+        .size caller, .-caller
+
+# CHECK-LABEL: caller
+# CHECK:      ld 0, -28736(13)
+# CHECK-NEXT: addis 12, 1, -32768
+# CHECK-NEXT: nop
+# CHECK-NEXT: cmpld 7, 12, 0
+# CHECK-NEXT: bt- 28, .+36
+
+.section        .note.GNU-split-stack,"",@progbits

lld/trunk/test/ELF/ppc64-split-stack-adjust-size-success.s

+# REQUIRES: ppc
+
+# RUN: llvm-mc -filetype=obj -triple=powerpc64le-unknown-linux %s -o %t1.o
+# RUN: llvm-mc -filetype=obj -triple=powerpc64le-unknown-linux %p/Inputs/ppc64-no-split-stack.s -o %t2.o
+
+# RUN: ld.lld %t1.o %t2.o -o %t --defsym __morestack=0x10010000 -split-stack-adjust-size 32768
+# RUN: llvm-objdump -d %t | FileCheck %s
+# RUN: ld.lld %t1.o %t2.o -o %t --defsym __morestack=0x10010000 -split-stack-adjust-size 4096
+# RUN: llvm-objdump -d %t | FileCheck %s -check-prefix=SMALL
+# RUN: ld.lld %t1.o %t2.o -o %t --defsym __morestack=0x10010000 -split-stack-adjust-size 0
+# RUN: llvm-objdump -d %t | FileCheck %s -check-prefix=ZERO
+
+# RUN: llvm-mc -filetype=obj -triple=powerpc64-unknown-linux %s -o %t1.o
+# RUN: llvm-mc -filetype=obj -triple=powerpc64-unknown-linux %p/Inputs/ppc64-no-split-stack.s -o %t2.o
+
+# RUN: ld.lld %t1.o %t2.o -o %t --defsym __morestack=0x10010000 -split-stack-adjust-size 32768
+# RUN: llvm-objdump -d %t | FileCheck %s
+# RUN: ld.lld %t1.o %t2.o -o %t --defsym __morestack=0x10010000 -split-stack-adjust-size 4096
+# RUN: llvm-objdump -d %t | FileCheck %s -check-prefix=SMALL
+# RUN: ld.lld %t1.o %t2.o -o %t --defsym __morestack=0x10010000 -split-stack-adjust-size 0
+# RUN: llvm-objdump -d %t | FileCheck %s -check-prefix=ZERO
+        .p2align    2
+        .global caller
+        .type caller, @function
+caller:
+.Lcaller_gep:
+    addis 2, 12, .TOC.-.Lcaller_gep@ha
+    addi 2, 2, .TOC.-.Lcaller_gep@l
+    .localentry caller, .-caller
+    ld 0, -0x7040(13)
+    addi 12, 1, -32
+    nop
+    cmpld 7, 12, 0
+    blt- 7, .Lcaller_alloc_more
+.Lcaller_body:
+    mflr 0
+    std 0, 16(1)
+    stdu 1, -32(1)
+    bl nss_callee
+    addi 1, 1, 32
+    ld 0, 16(1)
+    mtlr 0
+    blr
+.Lcaller_alloc_more:
+    mflr 0
+    std 0, 16(1)
+    bl __morestack
+    ld 0, 16(1)
+    mtlr 0
+    blr
+    b .Lcaller_body
+        .size caller, .-caller
+
+# CHECK-LABEL: caller
+# CHECK:      ld 0, -28736(13)
+# CHECK-NEXT: addis 12, 1, -1
+# CHECK-NEXT: addi 12, 12, 32736
+# CHECK-NEXT: cmpld 7, 12, 0
+# CHECK-NEXT: bt- 28, .+36
+
+# SMALL-LABEL: caller
+# SMALL:      ld 0, -28736(13)
+# SMALL-NEXT: addi 12, 1, -4128
+# SMALL-NEXT: nop
+# SMALL-NEXT: cmpld 7, 12, 0
+# SMALL-NEXT: bt- 28, .+36
+
+# ZERO-LABEL: caller
+# ZERO:      ld 0, -28736(13)
+# ZERO-NEXT: addi 12, 1, -32
+# ZERO-NEXT: nop
+# ZERO-NEXT: cmpld 7, 12, 0
+# ZERO-NEXT: bt- 28, .+36
+        .p2align    2
+        .global main
+  .type  main, @function
+main:
+.Lmain_gep:
+    addis 2,12,.TOC.-.Lmain_gep@ha
+    addi 2,2,.TOC.-.Lmain_gep@l
+    .localentry main,.-main
+    ld 0,-0x7040(13)
+    addi 12,1,-32
+    nop
+    cmpld 7,12,0
+    blt- 7, .Lmain_morestack
+.Lmain_body:
+    mflr 0
+    std 0, 16(1)
+    stdu 1, -32(1)
+    bl caller
+    addi 1, 1, 32
+    ld 0, 16(1)
+    mtlr 0
+    blr
+.Lmain_morestack:
+    mflr 0
+    std 0, 16(1)
+    bl __morestack
+    ld 0, 16(1)
+    mtlr 0
+    blr
+    b .Lmain_body
+    .size main,.-main
+
+        .section        .note.GNU-split-stack,"",@progbits

lld/trunk/test/ELF/ppc64-split-stack-prologue-adjust-success.s

+# REQUIRES: ppc
+
+# RUN: llvm-mc -filetype=obj -triple=powerpc64le-unknown-linux %s -o %t1.o
+# RUN: llvm-mc -filetype=obj -triple=powerpc64le-unknown-linux %p/Inputs/ppc64-no-split-stack.s -o %t2.o
+# RUN: ld.lld --defsym __morestack=0x10010000 %t1.o %t2.o -o %t
+# RUN: llvm-objdump -d %t | FileCheck %s
+
+# RUN: llvm-mc -filetype=obj -triple=powerpc64-unknown-linux %s -o %t1.o
+# RUN: llvm-mc -filetype=obj -triple=powerpc64-unknown-linux %p/Inputs/ppc64-no-split-stack.s -o %t2.o
+# RUN: ld.lld --defsym __morestack=0x10010000 %t1.o %t2.o -o %t
+# RUN: llvm-objdump -d %t | FileCheck %s
+
+        .abiversion 2
+        .section    ".text"
+
+
+# A caller with a stack that is small enough that the addis instruction
+# from the split-stack prologue is unneeded, and after the prologue adjustment
+# the stack size still fits whithin 16 bits.
+        .p2align    2
+        .global caller_small_stack
+        .type caller_small_stack, @function
+caller_small_stack:
+.Lcss_gep:
+    addis 2, 12, .TOC.-.Lcss_gep@ha
+    addi 2, 2, .TOC.-.Lcss_gep@l
+    .localentry caller_small_stack, .-caller_small_stack
+    ld 0, -0x7040(13)
+    addi 12, 1, -32
+    nop
+    cmpld 7, 12, 0
+    blt- 7, .Lcss_alloc_more
+.Lcss_body:
+    mflr 0
+    std 0, 16(1)
+    stdu 1, -32(1)
+    bl nss_callee
+    addi 1, 1, 32
+    ld 0, 16(1)
+    mtlr 0
+    blr
+.Lcss_alloc_more:
+    mflr 0
+    std 0, 16(1)
+    bl __morestack
+    ld 0, 16(1)
+    mtlr 0
+    blr
+    b .Lcss_body
+        .size caller_small_stack, .-caller_small_stack
+
+# CHECK-LABEL: caller_small_stack
+# CHECK:       ld 0, -28736(13)
+# CHECK-NEXT:  addi 12, 1, -16416
+# CHECK-NEXT:  nop
+# CHECK-NEXT:  cmpld 7, 12, 0
+# CHECK-NEXT:  bt-  28, .+36
+
+# A caller that has a stack size that fits whithin 16 bits, but the adjusted
+# stack size after prologue adjustment now overflows 16 bits needing both addis
+# and addi instructions.
+        .p2align    2
+        .global caller_med_stack
+        .type caller_med_stack, @function
+caller_med_stack:
+.Lcms_gep:
+    addis 2, 12, .TOC.-.Lcms_gep@ha
+    addi 12, 12, .TOC.-.Lcms_gep@l
+    .localentry caller_med_stack, .-caller_med_stack
+    ld 0, -0x7040(13)
+    addi 12, 1, -32764
+    nop
+    cmpld 7, 12, 0
+    blt- 7, .Lcms_alloc_more
+.Lcms_body:
+    mflr 0
+    std 0, 16(1)
+    stdu 1, -32764(1)
+    bl nss_callee
+    addi 1, 1, 32764
+    ld 0, 16(1)
+    mtlr 0
+    blr
+.Lcms_alloc_more:
+    mflr 0
+    std 0, 16(1)
+    bl __morestack
+    ld 0, 16(1)
+    mtlr 0
+    blr
+    b .Lcms_body
+        .size caller_med_stack, .-caller_med_stack
+
+# A caller with a large enough stack frame that both the addis and
+# addi instructions are used in the split-stack prologue.
+        .p2align    2
+        .global caller_large_stack
+        .type caller_large_stack, @function
+caller_large_stack:
+.Lcls_gep:
+    addis 2, 12, .TOC.-.Lcls_gep@ha
+    addi 12, 12, .TOC.-.Lcls_gep@l
+    .localentry caller_large_stack, .-caller_large_stack
+    ld 0, -0x7040(13)
+    addis 12, 1, -1
+    addi  12, 12, -32
+    cmpld 7, 12, 0
+    blt- 7, .Lcls_alloc_more
+.Lcls_body:
+    mflr 0
+    std 0, 16(1)
+    lis 0, -1
+    addi 0, 0, -32
+    stdux 1, 0, 1
+    bl nss_callee
+    ld 1, 0(1)
+    ld 0, 16(1)
+    mtlr 0
+    blr
+.Lcls_alloc_more:
+    mflr 0
+    std 0, 16(1)
+    bl __morestack
+    ld 0, 16(1)
+    mtlr 0
+    blr
+    b .Lcls_body
+        .size caller_large_stack, .-caller_large_stack
+
+# CHECK-LABEL: caller_large_stack
+# CHECK:       ld 0, -28736(13)
+# CHECK-NEXT:  addis 12, 1, -1
+# CHECK-NEXT:  addi 12, 12, -16416
+# CHECK-NEXT:  cmpld 7, 12, 0
+# CHECK-NEXT:  bt-  28, .+44
+
+# A caller with a stack size that is larger then 16 bits, but aligned such that
+# the addi instruction is unneeded.
+        .p2align    2
+        .global caller_large_aligned_stack
+        .type caller_large_aligned_stack, @function
+caller_large_aligned_stack:
+.Lclas_gep:
+    addis 2, 12, .TOC.-.Lclas_gep@ha
+    addi 12, 12, .TOC.-.Lclas_gep@l
+    .localentry caller_large_aligned_stack, .-caller_large_aligned_stack
+    ld 0, -0x7040(13)
+    addis 12, 1, -2
+    nop
+    cmpld 7, 12, 0
+    blt- 7, .Lclas_alloc_more
+.Lclas_body:
+    mflr 0
+    std 0, 16(1)
+    lis 0, -2
+    stdux 1, 0, 1
+    bl nss_callee
+    ld 1, 0(1)
+    ld 0, 16(1)
+    mtlr 0
+    blr
+.Lclas_alloc_more:
+    mflr 0
+    std 0, 16(1)
+    bl __morestack
+    ld 0, 16(1)
+    mtlr 0
+    blr
+    b .Lclas_body
+        .size caller_large_aligned_stack, .-caller_large_aligned_stack
+
+# CHECK-LABEL: caller_large_aligned_stack
+# CHECK:       ld 0, -28736(13)
+# CHECK-NEXT:  addis 12, 1, -2
+# CHECK-NEXT:  addi 12, 12, -16384
+# CHECK-NEXT:  cmpld 7, 12, 0
+# CHECK-NEXT:  bt-  28, .+40
+
+# main only calls split-stack functions or __morestack so
+# there should be no adjustment of its split-stack prologue.
+        .p2align    2
+        .global main
+  .type  main, @function
+main:
+.Lmain_gep:
+    addis 2, 12,.TOC.-.Lmain_gep@ha
+    addi 2, 2,.TOC.-.Lmain_gep@l
+    .localentry main,.-main
+    ld 0, -0x7040(13)
+    addi 12,1,-32
+    nop
+    cmpld 7, 12,0
+    blt- 7, .Lmain_morestack
+.Lmain_body:
+    mflr 0
+    std 0, 16(1)
+    stdu 1, -32(1)
+    bl caller_small_stack
+    nop
+    bl caller_med_stack
+    nop
+    bl caller_large_stack
+    nop
+    bl caller_large_aligned_stack
+    addi 1, 1, 32
+    ld 0, 16(1)
+    mtlr 0
+    blr
+.Lmain_morestack:
+    mflr 0
+    std 0, 16(1)
+    bl __morestack
+    ld 0, 16(1)
+    mtlr 0
+    blr
+    b .Lmain_body
+    .size main,.-main
+# CHECK-LABEL: main
+# CHECK:       ld 0, -28736(13)
+# CHECK-NEXT:  addi 12, 1, -32
+# CHECK-NEXT:  nop
+# CHECK-NEXT:  cmpld 7, 12, 0
+
+    .section        .note.GNU-split-stack,"",@progbits