-fsanitize=noreturn sanitization

[jakubjelinek]

Summary

While both compilers have warnings when noreturn functions return or fall through to the end of function, the actual UB happens only if that actually happens at runtime,
so I think it makes sense to sanitize that (though, it is even worse UB than -fsanitize=return and it doesn't make any sense to try to recover from that, after all the compilers
won't do anything meaningful in the caller usually, it can end up in a different function or unrelated code etc.

No tests included, as this is just the library side, somebody from the LLVM camp would need to add (very simple) compiler changes.

[kcc]

• please CC llvm-dev for any sanitizer changes
• please CC cfe-dev for any changes that need to be done in clang
• we can't accepts a patch like this w/o tests and w/o clang part.

somebody from the LLVM camp would need to add (very simple) compiler changes.

Agree, but we'll need to find that somebody :)

[jakubjelinek]

I have no idea how to CC those mailing lists (Change Subscribers doesn't seem to allow those) in this tool (or shall I just mail them normally)?
As for tests, the ones I have for GCC are:

/* { dg-do run } */
/* { dg-shouldfail "ubsan" } */
/* { dg-options "-fsanitize=undefined" } */

#if __cplusplus >= 201103L
[[noreturn]]
#elif __STDC_VERSION__ >= 201112L
_Noreturn
#else
__attribute__((noreturn))
#endif
void
foo (int x)
{
}       /* { dg-warning "function does return" } */

int
main ()
{
  foo (2);
}

/* { dg-output "\.c:15:\[0-9]*:\[^\n\r]*return from function declared to never return" } */

and

/* { dg-do run } */
/* { dg-shouldfail "ubsan" } */
/* { dg-options "-fsanitize=noreturn" } */

#if __cplusplus >= 201103L
[[noreturn]]
#elif __STDC_VERSION__ >= 201112L
_Noreturn
#else
__attribute__((noreturn))
#endif
void
foo (int x)
{
  if (x < 2)
    __builtin_exit (0);
  return;	/* { dg-warning "function does return" } */
}		/* { dg-warning "function declared 'noreturn' has a 'return' statement" "" { target *-*-* } 17 } */

int
main ()
{
  foo (2);
}

/* { dg-output "\.c:17:\[0-9]*:\[^\n\r]*return from function declared to never return" } */

./ubsan_checks.inc

 UBSAN_CHECK(NonPositiveVLAIndex, "non-positive-vla-index", "vla-bound")
 UBSAN_CHECK(FloatCastOverflow, "float-cast-overflow", "float-cast-overflow")
 UBSAN_CHECK(InvalidBoolLoad, "invalid-bool-load", "bool")
 UBSAN_CHECK(InvalidEnumLoad, "invalid-enum-load", "enum")
 UBSAN_CHECK(FunctionTypeMismatch, "function-type-mismatch", "function")
 UBSAN_CHECK(InvalidNullReturn, "invalid-null-return",
             "returns-nonnull-attribute")
 UBSAN_CHECK(InvalidNullArgument, "invalid-null-argument", "nonnull-attribute")
+UBSAN_CHECK(InvalidNoreturn, "invalid-noreturn", "noreturn")
 UBSAN_CHECK(DynamicTypeMismatch, "dynamic-type-mismatch", "vptr")
 UBSAN_CHECK(CFIBadType, "cfi-bad-type", "cfi")

./ubsan_handlers.h

struct NonNullArgData {
   int ArgIndex;
 };
 
 /// \brief Handle passing null pointer to a function parameter with the nonnull
 /// attribute, or a _Nonnull type annotation.
 RECOVERABLE(nonnull_arg, NonNullArgData *Data)
 RECOVERABLE(nullability_arg, NonNullArgData *Data)
 
+struct NoreturnData {
+  SourceLocation AttrLoc;
+};
+
+/// \brief Handle returning from function with the noreturn
+/// attribute.
+UNRECOVERABLE(noreturn, NoreturnData *Data, SourceLocation *Loc)
+
 struct PointerOverflowData {
   SourceLocation Loc;
 };
 
 RECOVERABLE(pointer_overflow, PointerOverflowData *Data, ValueHandle Base,
             ValueHandle Result)
 
 /// \brief Known CFI check kinds.

./ubsan_handlers.cc

 }
 
 void __ubsan::__ubsan_handle_nullability_arg_abort(NonNullArgData *Data) {
   GET_REPORT_OPTIONS(true);
   handleNonNullArg(Data, Opts, false);
   Die();
 }
 
+static void handleNoreturn(NoreturnData *Data, SourceLocation *LocPtr,
+         ReportOptions Opts) {
+  if (!LocPtr)
+    UNREACHABLE("source location pointer is null!");
+
+  SourceLocation Loc = LocPtr->acquire();
+  ErrorType ET = ErrorType::InvalidNoreturn;
+
+  if (ignoreReport(Loc, Opts, ET))
+    return;
+
+  ScopedReport R(Opts, Loc, ET);
+
+  Diag(Loc, DL_Error, "return from function declared to never "
+                      "return");
+  if (!Data->AttrLoc.isInvalid())
+    Diag(Data->AttrLoc, DL_Note, "noreturn attribute specified here");
+}
+
+void __ubsan::__ubsan_handle_noreturn(NoreturnData *Data,
+                                      SourceLocation *LocPtr) {
+  GET_REPORT_OPTIONS(true);
+  handleNoreturn(Data, LocPtr, Opts);
+  Die();
+}
+
 static void handlePointerOverflowImpl(PointerOverflowData *Data,
                                       ValueHandle Base,
                                       ValueHandle Result,
                                       ReportOptions Opts) {
   SourceLocation Loc = Data->Loc.acquire();
   ErrorType ET = ErrorType::PointerOverflow;
 
   if (ignoreReport(Loc, Opts, ET))