[Stack Protection] Add remark for reasons why Stack Protection has been applied

[jhenderson]

Summary

Depends on D29023, which is currently under review. In that change, I am adding diagnostic information to LLVM for why Stack Smash Protection has been applied to each function. This is the second stage, namely adding a new remark to clang, which is emitted when enabled via "-Rstack-protector".

[rsmith]

include/clang/Basic/DiagnosticFrontendKinds.td

229

Can this "unknown reason" case actually happen? It seems like a bug that SSP insertion would not know why it's doing what it's doing.

229

Rather than the potentially-opaque initialism SSP, could you say "stack protector" here? That would match the flag name better.

230

Do we actually know that the cause is a call to alloca rather than a VLA?

232

These two cases seem very easy to tell apart: if -fstack-protector-all is specified, use that diagnostic, otherwise the LLVM attribute must have been from a source-level attribute.

include/clang/Basic/DiagnosticGroups.td

911

The flags to control this are -fstack-protector*, so -Rstack-protector (or something starting -Rstack-protector) should be used here.

[jhenderson]

Thanks for the comments. I have updated the diff accordingly, by removing the unknown case, adding a check to distinguish between the function attribute and command-line switch, and expanded the alloca remark to include VLAs. I also replaced the reference to SSP from the switch and remark text as suggested. To go with that, I changed the DiagGroup name.

[jhenderson]

Ping

[jhenderson]

Ping!

[jhenderson]

Abandoning. Due to changes made in D29023, there is no more need for this patch. The new method followed in that patch means that clang gets support for the new remarks via -Rpass=stack-protector.

include/clang/Basic/DiagnosticFrontendKinds.td

 
 def err_missing_vfs_overlay_file : Error<
   "virtual filesystem overlay file '%0' not found">, DefaultFatal;
 def err_invalid_vfs_overlay : Error<
   "invalid virtual filesystem overlay file '%0'">, DefaultFatal;
 
 def warn_option_invalid_ocl_version : Warning<
   "OpenCL version %0 does not support the option '%1'">, InGroup<Deprecated>;
+
+def remark_ssp_applied_reason
+    : Remark<"SSP applied to function due to %select{an unknown reason|a "
+             "call to alloca|a stack allocated buffer or struct containing a "
+             "buffer|the address of a local variable being taken|a function "
+             "attribute or use of -fstack-protector-all}0">,
+      InGroup<SSPReason>;
 }

include/clang/Basic/DiagnosticGroups.td

 
 def OptionIgnored : DiagGroup<"option-ignored">;
 
 def UnknownArgument : DiagGroup<"unknown-argument">;
 
 // A warning group for warnings about code that clang accepts when
 // compiling OpenCL C/C++ but which is not compatible with the SPIR spec.
 def SpirCompat : DiagGroup<"spir-compat">;
+
+// A remark group for remarks about why stack protection was applied to a
+// function.
+def SSPReason : DiagGroup<"ssp-reason">;

lib/CodeGen/CodeGenAction.cpp

IRGenFinished = true;
     void OptimizationRemarkHandler(const llvm::OptimizationRemarkMissed &D);
     void OptimizationRemarkHandler(const llvm::OptimizationRemarkAnalysis &D);
     void OptimizationRemarkHandler(
         const llvm::OptimizationRemarkAnalysisFPCommute &D);
     void OptimizationRemarkHandler(
         const llvm::OptimizationRemarkAnalysisAliasing &D);
     void OptimizationFailureHandler(
         const llvm::DiagnosticInfoOptimizationFailure &D);
+
+    /// \brief Specialized handler for Stack Protector remark diagnostics.
+    void SSPRemarkHandler(const DiagnosticInfoSSP &D);
   };
   
   void BackendConsumer::anchor() {}
 }
 
 /// ConvertBackendLocation - Convert a location in a temporary llvm::SourceMgr
 /// buffer to be a valid FullSourceLoc.
 static FullSourceLoc ConvertBackendLocation(const llvm::SMDiagnostic &D,
EmitOptimizationMessage(
         D, diag::remark_fe_backend_optimization_remark_analysis_aliasing);
 }
 
 void BackendConsumer::OptimizationFailureHandler(
     const llvm::DiagnosticInfoOptimizationFailure &D) {
   EmitOptimizationMessage(D, diag::warn_fe_backend_optimization_failure);
 }
 
+void BackendConsumer::SSPRemarkHandler(const DiagnosticInfoSSP &D) {
+  StringRef Filename;
+  unsigned Line, Column;
+  bool BadDebugInfo = false;
+  FullSourceLoc Loc = getBestLocationFromDebugLoc(D, BadDebugInfo, Filename,
+      Line, Column);
+  Diags.Report(Loc, diag::remark_ssp_applied_reason) << D.Reason();
+}
+
 /// \brief This function is invoked when the backend needs
 /// to report something to the user.
 void BackendConsumer::DiagnosticHandlerImpl(const DiagnosticInfo &DI) {
   unsigned DiagID = diag::err_fe_inline_asm;
   llvm::DiagnosticSeverity Severity = DI.getSeverity();
   // Get the diagnostic ID based.
   switch (DI.getKind()) {
   case llvm::DK_InlineAsm:
void BackendConsumer::DiagnosticHandlerImpl(const DiagnosticInfo &DI) {
   case llvm::DK_OptimizationFailure:
     // Optimization failures are always handled completely by this
     // handler.
     OptimizationFailureHandler(cast<DiagnosticInfoOptimizationFailure>(DI));
     return;
   case llvm::DK_Unsupported:
     UnsupportedDiagHandler(cast<DiagnosticInfoUnsupported>(DI));
     return;
+  case llvm::DK_SSPReason:
+    SSPRemarkHandler(cast<DiagnosticInfoSSP>(DI));
+    return;
   default:
     // Plugin IDs are not bound to any value as they are set dynamically.
     ComputeDiagRemarkID(Severity, backend_plugin, DiagID);
     break;
   }
   std::string MsgStorage;
   {
     raw_string_ostream Stream(MsgStorage);

test/CodeGen/stack-protector-remarks.c

+// RUN: %clang_cc1 -emit-obj %s -Rssp-reason -stack-protector 2 -o /dev/null 2>&1 | FileCheck %s -check-prefix=CHECK1
+// CHECK1-NOT: no_ssp
+// CHECK1: call to alloca
+// CHECK1-NEXT: alloca_ssp()
+// CHECK1: stack allocated buffer or struct
+// CHECK1-NEXT: buffer_ssp()
+// CHECK1: stack allocated buffer or struct
+// CHECK1-NEXT: struct_ssp()
+// CHECK1: address of a local variable
+// CHECK1-NEXT: address_ssp()
+// CHECK1: stack allocated buffer or struct
+// CHECK1-NEXT: multiple_ssp
+// CHECK1: stack allocated buffer or struct
+// CHECK1: address of a local variable
+// CHECK1: call to alloca
+
+// RUN: %clang_cc1 -emit-obj %s -Rssp-reason -stack-protector 3 -o /dev/null 2>&1 | FileCheck %s -check-prefix=CHECK2
+// CHECK2: function attribute or use of -fstack-protector-all
+// CHECK2-NEXT: no_ssp
+// CHECK2: function attribute or use of -fstack-protector-all
+// CHECK2-NEXT: alloca_ssp()
+// CHECK2: function attribute or use of -fstack-protector-all
+// CHECK2-NEXT: buffer_ssp()
+// CHECK2: function attribute or use of -fstack-protector-all
+// CHECK2-NEXT: struct_ssp()
+// CHECK2: function attribute or use of -fstack-protector-all
+// CHECK2-NEXT: address_ssp()
+// CHECK2: function attribute or use of -fstack-protector-all
+// CHECK2-NEXT: multiple_ssp
+
+void no_ssp() {
+}
+
+void alloca_ssp() {
+  __builtin_alloca(2);
+}
+
+void buffer_ssp() {
+  int x[64];
+}
+
+struct X {
+  int x[64];
+};
+void struct_ssp() {
+  struct X x;
+}
+
+void address_ssp() {
+  int x = 32;
+  int * y = &x;
+}
+
+void multiple_ssp() {
+  struct X x;
+  int y[64];
+  __builtin_alloca(2);
+  int a = 32;
+  int * b = &a;
+}