Added Support for Warning Flag -Wstack-usage=

[rsanthir.quic]

Summary

The -Wstack-usage flag has been added, which provides a
warning message when size of stack exceeds user provided value.

[rsanthir.quic]

Another approach is explored here:
https://reviews.llvm.org/D101964

[rsanthir.quic]

Moving forward with simpler approach here:
https://reviews.llvm.org/D102782

clang/include/clang/Basic/DiagnosticFrontendKinds.td

 def note_fe_inline_asm : Note<"%0">, CatInlineAsm;
 def note_fe_inline_asm_here : Note<"instantiated into assembly here">;
 def err_fe_source_mgr : Error<"%0">, CatSourceMgr;
 def warn_fe_source_mgr : Warning<"%0">, CatSourceMgr, InGroup<BackendSourceMgr>;
 def note_fe_source_mgr : Note<"%0">, CatSourceMgr;
 def err_fe_cannot_link_module : Error<"cannot link module '%0': %1">,
   DefaultFatal;
 
+def warn_fe_stack_usage : Warning<"stack usage is %0 bytes in %1">,
+    BackendInfo, InGroup<BackendStackUsageEQ>;
+def warn_fe_stack_usage_dynam : Warning<"stack usage might be %0 bytes in %1">,
+    BackendInfo, InGroup<BackendStackUsageEQ>;
+def warn_fe_backend_stack_usage: Warning<"%0">,
+    BackendInfo, InGroup<BackendStackUsageEQ>;
+def err_fe_backend_stack_usage: Error<"%0">, BackendInfo;
+def note_fe_backend_stack_usage: Note<"%0">, BackendInfo;
+
 def warn_fe_frame_larger_than : Warning<"stack frame size of %0 bytes in %q1">,
     BackendInfo, InGroup<BackendFrameLargerThanEQ>;
 def warn_fe_backend_frame_larger_than: Warning<"%0">,
     BackendInfo, InGroup<BackendFrameLargerThanEQ>;
 def err_fe_backend_frame_larger_than: Error<"%0">, BackendInfo;
 def note_fe_backend_frame_larger_than: Note<"%0">, BackendInfo;
 
 def warn_fe_backend_plugin: Warning<"%0">, BackendInfo, InGroup<BackendPlugin>;

clang/include/clang/Basic/DiagnosticGroups.td

 def OpenMP : DiagGroup<"openmp", [
     SourceUsesOpenMP, OpenMPClauses, OpenMPLoopForm, OpenMPTarget, OpenMPMapping
   ]>;
 
 // Backend warnings.
 def BackendInlineAsm : DiagGroup<"inline-asm">;
 def BackendSourceMgr : DiagGroup<"source-mgr">;
 def BackendFrameLargerThanEQ : DiagGroup<"frame-larger-than=">;
+def BackendStackUsageEQ : DiagGroup<"stack-usage=">;
 def BackendPlugin : DiagGroup<"backend-plugin">;
 def RemarkBackendPlugin : DiagGroup<"remark-backend-plugin">;
 def BackendOptimizationRemark : DiagGroup<"pass">;
 def BackendOptimizationRemarkMissed : DiagGroup<"pass-missed">;
 def BackendOptimizationRemarkAnalysis : DiagGroup<"pass-analysis">;
 def BackendOptimizationFailure : DiagGroup<"pass-failed">;
 
 // Instrumentation based profiling warnings.

clang/include/clang/Driver/Options.td

def Wlarge_by_value_copy_EQ : Joined<["-"], "Wlarge-by-value-copy=">, Flags<[CC1Option]>,
   MarshallingInfoInt<LangOpts<"NumLargeByValueCopy">>;
 
 // These "special" warning flags are effectively processed as f_Group flags by the driver:
 // Just silence warnings about -Wlarger-than for now.
 def Wlarger_than_EQ : Joined<["-"], "Wlarger-than=">, Group<clang_ignored_f_Group>;
 def Wlarger_than_ : Joined<["-"], "Wlarger-than-">, Alias<Wlarger_than_EQ>;
 def Wframe_larger_than_EQ : Joined<["-"], "Wframe-larger-than=">, Group<f_Group>, Flags<[NoXarchOption]>;
 
+def Wstack_usage_EQ : Joined<["-"], "Wstack-usage=">, Group<f_Group>, Flags<[NoXarchOption]>;
+
 def : Flag<["-"], "fterminated-vtables">, Alias<fapple_kext>;
 defm threadsafe_statics : BoolFOption<"threadsafe-statics",
   LangOpts<"ThreadsafeStatics">, DefaultTrue,
   NegFlag<SetFalse, [CC1Option], "Do not emit code to make initialization of local statics thread safe">,
   PosFlag<SetTrue>>;
 def ftime_report : Flag<["-"], "ftime-report">, Group<f_Group>, Flags<[CC1Option]>,
   MarshallingInfoFlag<CodeGenOpts<"TimePasses">>;
 def ftime_report_EQ: Joined<["-"], "ftime-report=">, Group<f_Group>,

clang/lib/CodeGen/CodeGenAction.cpp

 
 bool
 BackendConsumer::StackSizeDiagHandler(const llvm::DiagnosticInfoStackSize &D) {
   if (D.getSeverity() != llvm::DS_Warning)
     // For now, the only support we have for StackSize diagnostic is warning.
     // We do not know how to format other severities.
     return false;
 
-  if (const Decl *ND = Gen->GetDeclForMangledName(D.getFunction().getName())) {
-    // FIXME: Shouldn't need to truncate to uint32_t
-    Diags.Report(ND->getASTContext().getFullLoc(ND->getLocation()),
-                 diag::warn_fe_frame_larger_than)
+  const Decl *ND = Gen->GetDeclForMangledName(D.getFunction().getName());
+  if (!ND)
+    return false;
+
+  unsigned DiagID = diag::warn_fe_frame_larger_than;
+  if (D.printStackUsageInfo())
+    DiagID = D.hasVarSizedObjects() ? diag::warn_fe_stack_usage_dynam
+                                    : diag::warn_fe_stack_usage;
+  Diags.Report(ND->getASTContext().getFullLoc(ND->getLocation()), DiagID)
       << static_cast<uint32_t>(D.getStackSize()) << Decl::castToDeclContext(ND);
-    return true;
-  }
 
-  return false;
+  return true;
 }
 
 const FullSourceLoc BackendConsumer::getBestLocationFromDebugLoc(
     const llvm::DiagnosticInfoWithLocationBase &D, bool &BadDebugInfo,
     StringRef &Filename, unsigned &Line, unsigned &Column) const {
   SourceManager &SourceMgr = Context->getSourceManager();
   FileManager &FileMgr = SourceMgr.getFileManager();
   SourceLocation DILoc;
case llvm::DK_InlineAsm:
     ComputeDiagID(Severity, inline_asm, DiagID);
     break;
   case llvm::DK_SrcMgr:
     SrcMgrDiagHandler(cast<DiagnosticInfoSrcMgr>(DI));
     return;
   case llvm::DK_StackSize:
     if (StackSizeDiagHandler(cast<DiagnosticInfoStackSize>(DI)))
       return;
+    if (cast<DiagnosticInfoStackSize>(DI).printStackUsageInfo())
+      ComputeDiagID(Severity, backend_stack_usage, DiagID);
+    else
       ComputeDiagID(Severity, backend_frame_larger_than, DiagID);
     break;
   case DK_Linker:
     assert(CurLinkModule);
     // FIXME: stop eating the warnings and notes.
     if (Severity != DS_Error)
       return;
     DiagID = diag::err_fe_cannot_link_module;
     break;

clang/lib/Driver/ToolChains/Clang.cpp

#endif
 
   if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
     StringRef v = A->getValue();
     CmdArgs.push_back("-mllvm");
     CmdArgs.push_back(Args.MakeArgString("-warn-stack-size=" + v));
     A->claim();
   }
 
+  if (Arg *A = Args.getLastArg(options::OPT_Wstack_usage_EQ)) {
+    StringRef bytes = A->getValue();
+    CmdArgs.push_back("-mllvm");
+    CmdArgs.push_back(Args.MakeArgString("-warn-stack-usage=" + bytes));
+  }
+
   if (!Args.hasFlag(options::OPT_fjump_tables, options::OPT_fno_jump_tables,
                     true))
     CmdArgs.push_back("-fno-jump-tables");
 
   if (Args.hasFlag(options::OPT_fprofile_sample_accurate,
                    options::OPT_fno_profile_sample_accurate, false))
     CmdArgs.push_back("-fprofile-sample-accurate");
 

clang/test/Frontend/backend-stack-usage-diagnostic.c

+
+// RUN: %clang -Wstack-usage=0 -o /dev/null -c %s 2> %t.err
+// RUN: FileCheck < %t.err %s --check-prefix=WARN
+// RUN: %clang -Wstack-usage=0 -Wno-stack-usage= -o /dev/null -c %s 2> %t.err
+// RUN: FileCheck < %t.err %s --check-prefix=IGNORE --allow-empty
+// RUN: %clang -Wstack-usage=0 -w -o /dev/null -c %s 2> %t.err
+// RUN: FileCheck < %t.err %s --check-prefix=IGNORE --allow-empty
+// RUN: %clang -Wstack-usage=3 -o /dev/null -c %s 2> %t.err
+// RUN: FileCheck < %t.err %s --check-prefix=WARN
+// RUN: %clang -Wstack-usage=100 -o /dev/null -c %s 2> %t.err
+// RUN: FileCheck < %t.err %s --check-prefix=IGNORE --allow-empty
+
+// WARN: warning: stack usage is {{[0-9]+}} bytes in function 'test_square'
+// IGNORE-NOT:  stack usage is {{[0-9]+}} bytes in function 'test_square'
+int test_square(int num) {
+  return num * num;
+}
+
+// WARN: warning: stack usage might be {{[0-9]+}} bytes in function 'test_unbounded'
+// IGNORE-NOT:  stack usage might be {{[0-9]+}} bytes in function 'test_unbounded'
+int test_unbounded(int len) {
+  char a[len];
+  return 1;
+}

llvm/include/llvm/IR/DiagnosticInfo.h

public:
 
   static bool classof(const DiagnosticInfo *DI) {
     return DI->getKind() == DK_ResourceLimit || DI->getKind() == DK_StackSize;
   }
 };
 
 class DiagnosticInfoStackSize : public DiagnosticInfoResourceLimit {
   void anchor() override;
+  bool HasVarSizedObjects;
+  bool PrintStackUsageInfo;
+
 public:
   DiagnosticInfoStackSize(const Function &Fn, uint64_t StackSize,
+                          bool HasVarSizedObjects = false,
+                          bool PrintStackUsageInfo = false,
                           DiagnosticSeverity Severity = DS_Warning,
                           uint64_t StackLimit = 0)
       : DiagnosticInfoResourceLimit(Fn, "stack size", StackSize, Severity,
-                                    DK_StackSize, StackLimit) {}
+                                    DK_StackSize, StackLimit),
+        HasVarSizedObjects(HasVarSizedObjects),
+        PrintStackUsageInfo(PrintStackUsageInfo) {}
 
   uint64_t getStackSize() const { return getResourceSize(); }
   uint64_t getStackLimit() const { return getResourceLimit(); }
+  bool hasVarSizedObjects() const { return HasVarSizedObjects; }
+  bool printStackUsageInfo() const { return PrintStackUsageInfo; }
 
   static bool classof(const DiagnosticInfo *DI) {
     return DI->getKind() == DK_StackSize;
   }
 };
 
 /// Diagnostic information for debug metadata version reporting.
 /// This is basically a module and a version.

llvm/lib/CodeGen/PrologEpilogInserter.cpp

 
 char &llvm::PrologEpilogCodeInserterID = PEI::ID;
 
 static cl::opt<unsigned>
 WarnStackSize("warn-stack-size", cl::Hidden, cl::init((unsigned)-1),
               cl::desc("Warn for stack size bigger than the given"
                        " number"));
 
+static cl::opt<unsigned>
+    WarnStackUsage("warn-stack-usage", cl::Hidden, cl::init((unsigned)-1),
+                   cl::desc("Warn for stack size bigger than the given"
+                            " number"));
+
 INITIALIZE_PASS_BEGIN(PEI, DEBUG_TYPE, "Prologue/Epilogue Insertion", false,
                       false)
 INITIALIZE_PASS_DEPENDENCY(MachineLoopInfo)
 INITIALIZE_PASS_DEPENDENCY(MachineDominatorTree)
 INITIALIZE_PASS_DEPENDENCY(MachineOptimizationRemarkEmitterPass)
 INITIALIZE_PASS_END(PEI, DEBUG_TYPE,
                     "Prologue/Epilogue Insertion & Frame Finalization", false,
                     false)
bool PEI::runOnMachineFunction(MachineFunction &MF) {
   replaceFrameIndices(MF);
 
   // If register scavenging is needed, as we've enabled doing it as a
   // post-pass, scavenge the virtual registers that frame index elimination
   // inserted.
   if (TRI->requiresRegisterScavenging(MF) && FrameIndexVirtualScavenging)
     scavengeFrameVirtualRegs(MF, *RS);
 
-  // Warn on stack size when we exceeds the given limit.
+  // Warn on stack usage size when we exceed the given limit
   MachineFrameInfo &MFI = MF.getFrameInfo();
   uint64_t StackSize = MFI.getStackSize();
+  if (WarnStackUsage.getNumOccurrences() > 0 && WarnStackUsage <= StackSize) {
+    DiagnosticInfoStackSize DiagStackUsage(
+        F, StackSize, MFI.hasVarSizedObjects(), true /*Stack Usage*/);
+    F.getContext().diagnose(DiagStackUsage);
+  }
+
+  // Warn on stack size when we exceeds the given limit.
   if (WarnStackSize.getNumOccurrences() > 0 && WarnStackSize < StackSize) {
     DiagnosticInfoStackSize DiagStackSize(F, StackSize);
     F.getContext().diagnose(DiagStackSize);
   }
   ORE->emit([&]() {
     return MachineOptimizationRemarkAnalysis(DEBUG_TYPE, "StackSize",
                                              MF.getFunction().getSubprogram(),
                                              &MF.front())