X86_64 target now obeys llc -disable-red-zone option

[srking]

Summary

X86_64 enables red zone optimization regardless of llc -disable-red-zone command line flag. This patch corrects this with a target option flag checked in X86FrameLowering::emitPrologue(). The existing x86_64 red-zone regression test is extended to check for this case.

[• rafael]

I think this is OK. Grosbach, what do you think?

include/llvm/Target/TargetOptions.h

195

Don't duplicate name in comment.

[grosbach]

Does this mean the clang -m[no-]red-zone option wasn't hooked up either? Does this fix that if so?

[srking]

This patch is abandoned. See D6046.

include/llvm/CodeGen/CommandFlags.h

static inline TargetOptions InitTargetOptionsFromCodeGenFlags() {
   Options.UseInitArray = !UseCtors;
   Options.DataSections = DataSections;
   Options.FunctionSections = FunctionSections;
 
   Options.MCOptions = InitMCTargetOptionsFromFlags();
   Options.JTType = JTableType;
 
   Options.ThreadModel = TMModel;
+  Options.NoRedZone = DisableRedZone;
 
   return Options;
 }
 
 #endif

include/llvm/Target/TargetOptions.h

TargetOptions()
           NoInfsFPMath(false), NoNaNsFPMath(false),
           HonorSignDependentRoundingFPMathOption(false), UseSoftFloat(false),
           NoZerosInBSS(false), JITEmitDebugInfo(false),
           JITEmitDebugInfoToDisk(false), GuaranteedTailCallOpt(false),
           DisableTailCalls(false), StackAlignmentOverride(0),
           EnableFastISel(false), PositionIndependentExecutable(false),
           UseInitArray(false), DisableIntegratedAS(false),
           CompressDebugSections(false), FunctionSections(false),
-          DataSections(false), TrapUnreachable(false), TrapFuncName(""),
-          FloatABIType(FloatABI::Default),
+          DataSections(false), TrapUnreachable(false), NoRedZone(false),
+          TrapFuncName(""), FloatABIType(FloatABI::Default),
           AllowFPOpFusion(FPOpFusion::Standard), JTType(JumpTable::Single),
           ThreadModel(ThreadModel::POSIX) {}
 
     /// PrintMachineCode - This flag is enabled when the -print-machineinstrs
     /// option is specified on the command line, and should enable debugging
     /// output from the code generator.
     unsigned PrintMachineCode : 1;
 
public:
     unsigned FunctionSections : 1;
 
     /// Emit data into separate sections.
     unsigned DataSections : 1;
 
     /// Emit target-specific trap instruction for 'unreachable' IR instructions.
     unsigned TrapUnreachable : 1;
 
+    /// NoRedZone - This flag is enabled when the -disable-red-zone flag is
+    /// specified on the command line.  When this flag is off (the default),
+    /// leaf functions may use unallocated stack space.  This optimization
+    /// eliminates stack adjustment instructions. For example, in
+    /// x86_64 targets, red zone use results in insructions with negative
+    /// stack offsets, as in -8(%rsp).  Red Zone optimization is unsafe
+    /// where hardware preemption such as interrupt handling may overwrite
+    /// unallocated stack space.
+    unsigned NoRedZone : 1;
+
     /// getTrapFunctionName - If this returns a non-empty string, this means
     /// isel should lower Intrinsic::trap to a call to the specified function
     /// name instead of an ISD::TRAP node.
     std::string TrapFuncName;
     StringRef getTrapFunctionName() const;
 
     /// FloatABIType - This setting is set by -float-abi=xxx option is specfied
     /// on the command line. This setting may either be Default, Soft, or Hard.
return
     ARE_EQUAL(JITEmitDebugInfoToDisk) &&
     ARE_EQUAL(GuaranteedTailCallOpt) &&
     ARE_EQUAL(DisableTailCalls) &&
     ARE_EQUAL(StackAlignmentOverride) &&
     ARE_EQUAL(EnableFastISel) &&
     ARE_EQUAL(PositionIndependentExecutable) &&
     ARE_EQUAL(UseInitArray) &&
     ARE_EQUAL(TrapUnreachable) &&
+    ARE_EQUAL(NoRedZone) &&
     ARE_EQUAL(TrapFuncName) &&
     ARE_EQUAL(FloatABIType) &&
     ARE_EQUAL(AllowFPOpFusion) &&
     ARE_EQUAL(MCOptions);
 #undef ARE_EQUAL
 }
 
 inline bool operator!=(const TargetOptions &LHS,
                        const TargetOptions &RHS) {
   return !(LHS == RHS);
 }
 
 } // End llvm namespace
 
 #endif

lib/Target/X86/X86FrameLowering.cpp

void X86FrameLowering::emitPrologue(MachineFunction &MF) const {
   // push and pop from the stack.
   if (Is64Bit && !Fn->getAttributes().hasAttribute(AttributeSet::FunctionIndex,
                                                    Attribute::NoRedZone) &&
       !RegInfo->needsStackRealignment(MF) &&
       !MFI->hasVarSizedObjects() &&                     // No dynamic alloca.
       !MFI->adjustsStack() &&                           // No calls.
       !IsWin64 &&                                       // Win64 has no Red Zone
       !usesTheStack(MF) &&                              // Don't push and pop.
+      !MF.getTarget().Options.NoRedZone &&              // command line
       !MF.shouldSplitStack()) {                         // Regular stack
     uint64_t MinSize = X86FI->getCalleeSavedFrameSize();
     if (HasFP) MinSize += SlotSize;
     StackSize = std::max(MinSize, StackSize > 128 ? StackSize - 128 : 0);
     MFI->setStackSize(StackSize);
   }
 
   // Insert stack pointer adjustment for later moving of return addr.  Only

test/CodeGen/X86/red-zone.ll

 ; RUN: llc < %s -mcpu=generic -mtriple=x86_64-linux | FileCheck %s
+; RUN: llc < %s -mcpu=generic -disable-red-zone -mtriple=x86_64-linux | FileCheck %s --check-prefix=CMDLINE
 
 ; First without noredzone.
 ; CHECK-LABEL: f0:
 ; CHECK: -4(%rsp)
 ; CHECK: -4(%rsp)
 ; CHECK: ret
 define x86_fp80 @f0(float %f) nounwind readnone {
 entry:
   %0 = fpext float %f to x86_fp80    ; <x86_fp80> [#uses=1]
   ret x86_fp80 %0
 }
 
-; Then with noredzone.
+; Then with noredzone function attribute.
 ; CHECK-LABEL: f1:
 ; CHECK: subq $4, %rsp
 ; CHECK: (%rsp)
 ; CHECK: (%rsp)
 ; CHECK: addq $4, %rsp
 ; CHECK: ret
 define x86_fp80 @f1(float %f) nounwind readnone noredzone {
 entry:
   %0 = fpext float %f to x86_fp80    ; <x86_fp80> [#uses=1]
   ret x86_fp80 %0
 }
+
+; Then with -disable-red-zone on command line
+; CMDLINE-LABEL: f0:
+; CMDLINE: subq $4, %rsp
+; CMDLINE: (%rsp)
+; CMDLINE: (%rsp)
+; CMDLINE: addq $4, %rsp
+; CMDLINE: ret