LadybirdBrowser/ladybird
1
1
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-01-06 19:19:44 +03:00
Code Issues Packages Projects Releases Wiki Activity
1716105e73
ladybird/Userland/Libraries/LibSanitizer/UBSanitizer.cpp

307 lines
12 KiB
C++
Raw Normal View History

Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
/*
* Copyright (c) 2021, Andreas Kling <kling@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <AK/Format.h>
#include <AK/UBSanitizer.h>
using namespace AK::UBSanitizer;
LibSantizer: Read $UBSAN_OPTIONS to set deadliness on first print The first time we want to print a UBSAN violation, the UBSAN runtime in userspace will get the UBSAN_OPTIONS environment variable to check if it contains the string "halt_on_error=1". This is clearly not robust to invalid options or adding more options, but it gets the job done at the moment. :^)
2021-06-28 08:35:58 +03:00
bool AK::UBSanitizer::g_ubsan_is_deadly { false };
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
#define WARNLN_AND_DBGLN(fmt, ...) \
warnln(fmt, ##__VA_ARGS__); \
LibSanitizer: Log UBSAN errors in red text to the debug console This makes them harder to miss for spammy apps when UBSAN is not deadly. Don't commit to making the warnln red at the momment, because that would probably be a nuisance if stderr is not a tty.
2021-12-12 20:16:51 +03:00
dbgln("\x1B[31m" fmt "\x1B[0m", ##__VA_ARGS__);
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
extern "C" {
static void print_location(const SourceLocation& location)
{
if (!location.filename()) {
WARNLN_AND_DBGLN("UBSAN: in unknown file");
} else {
WARNLN_AND_DBGLN("UBSAN: at {}, line {}, column: {}", location.filename(), location.line(), location.column());
}
// FIXME: Dump backtrace of this process (with symbols? without symbols?) in case the user wants non-deadly UBSAN
// Should probably go through the kernel for SC_dump_backtrace, then access the loader's symbol tables rather than
// going through the symbolizer service?
LibSantizer: Read $UBSAN_OPTIONS to set deadliness on first print The first time we want to print a UBSAN violation, the UBSAN runtime in userspace will get the UBSAN_OPTIONS environment variable to check if it contains the string "halt_on_error=1". This is clearly not robust to invalid options or adding more options, but it gets the job done at the moment. :^)
2021-06-28 08:35:58 +03:00
static bool checked_env_for_deadly = false;
if (!checked_env_for_deadly) {
checked_env_for_deadly = true;
StringView options = getenv("UBSAN_OPTIONS");
// FIXME: Parse more options and complain about invalid options
LibSanitizer: Check for halt_on_error=0 in $UBSAN_OPTIONS This allows a developer to set the g_ubsan_is_deadly flag to true by default and still disable UBSAN for certain applications.
2021-11-23 08:56:09 +03:00
if (!options.is_null()) {
if (options.contains("halt_on_error=1"))
g_ubsan_is_deadly = true;
else if (options.contains("halt_on_error=0"))
g_ubsan_is_deadly = false;
}
LibSantizer: Read $UBSAN_OPTIONS to set deadliness on first print The first time we want to print a UBSAN violation, the UBSAN runtime in userspace will get the UBSAN_OPTIONS environment variable to check if it contains the string "halt_on_error=1". This is clearly not robust to invalid options or adding more options, but it gets the job done at the moment. :^)
2021-06-28 08:35:58 +03:00
}
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
if (g_ubsan_is_deadly) {
WARNLN_AND_DBGLN("UB is configured to be deadly");
VERIFY_NOT_REACHED();
}
}
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
void __ubsan_handle_load_invalid_value(InvalidValueData&, ValueHandle) __attribute__((used));
void __ubsan_handle_load_invalid_value(InvalidValueData& data, ValueHandle)
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
{
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
auto location = data.location.permanently_clear();
if (!location.needs_logging())
return;
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
WARNLN_AND_DBGLN("UBSAN: load-invalid-value: {} ({}-bit)", data.type.name(), data.type.bit_width());
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
print_location(location);
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
}
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
void __ubsan_handle_nonnull_arg(NonnullArgData&) __attribute__((used));
void __ubsan_handle_nonnull_arg(NonnullArgData& data)
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
{
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
auto location = data.location.permanently_clear();
if (!location.needs_logging())
return;
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
WARNLN_AND_DBGLN("UBSAN: null pointer passed as argument {}, which is declared to never be null", data.argument_index);
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
print_location(location);
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
}
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
void __ubsan_handle_nullability_arg(NonnullArgData&) __attribute__((used));
void __ubsan_handle_nullability_arg(NonnullArgData& data)
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
{
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
auto location = data.location.permanently_clear();
if (!location.needs_logging())
return;
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
WARNLN_AND_DBGLN("UBSAN: null pointer passed as argument {}, which is declared to never be null", data.argument_index);
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
print_location(location);
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
}
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
void __ubsan_handle_nonnull_return_v1(const NonnullReturnData&, SourceLocation&) __attribute__((used));
void __ubsan_handle_nonnull_return_v1(const NonnullReturnData&, SourceLocation& location)
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
{
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
auto loc = location.permanently_clear();
if (!loc.needs_logging())
return;
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
WARNLN_AND_DBGLN("UBSAN: null pointer return from function declared to never return null");
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
print_location(loc);
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
}
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
void __ubsan_handle_nullability_return_v1(const NonnullReturnData& data, SourceLocation& location) __attribute__((used));
void __ubsan_handle_nullability_return_v1(const NonnullReturnData&, SourceLocation& location)
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
{
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
auto loc = location.permanently_clear();
if (!loc.needs_logging())
return;
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
WARNLN_AND_DBGLN("UBSAN: null pointer return from function declared to never return null");
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
print_location(loc);
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
}
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
void __ubsan_handle_vla_bound_not_positive(VLABoundData&, ValueHandle) __attribute__((used));
void __ubsan_handle_vla_bound_not_positive(VLABoundData& data, ValueHandle)
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
{
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
auto location = data.location.permanently_clear();
if (!location.needs_logging())
return;
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
WARNLN_AND_DBGLN("UBSAN: VLA bound not positive {} ({}-bit)", data.type.name(), data.type.bit_width());
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
print_location(location);
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
}
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
void __ubsan_handle_add_overflow(OverflowData&, ValueHandle lhs, ValueHandle rhs) __attribute__((used));
void __ubsan_handle_add_overflow(OverflowData& data, ValueHandle, ValueHandle)
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
{
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
auto location = data.location.permanently_clear();
if (!location.needs_logging())
return;
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
WARNLN_AND_DBGLN("UBSAN: addition overflow, {} ({}-bit)", data.type.name(), data.type.bit_width());
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
print_location(location);
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
}
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
void __ubsan_handle_sub_overflow(OverflowData&, ValueHandle lhs, ValueHandle rhs) __attribute__((used));
void __ubsan_handle_sub_overflow(OverflowData& data, ValueHandle, ValueHandle)
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
{
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
auto location = data.location.permanently_clear();
if (!location.needs_logging())
return;
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
WARNLN_AND_DBGLN("UBSAN: subtraction overflow, {} ({}-bit)", data.type.name(), data.type.bit_width());
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
print_location(location);
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
}
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
void __ubsan_handle_negate_overflow(OverflowData&, ValueHandle) __attribute__((used));
void __ubsan_handle_negate_overflow(OverflowData& data, ValueHandle)
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
{
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
auto location = data.location.permanently_clear();
if (!location.needs_logging())
return;
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
WARNLN_AND_DBGLN("UBSAN: negation overflow, {} ({}-bit)", data.type.name(), data.type.bit_width());
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
print_location(location);
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
}
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
void __ubsan_handle_mul_overflow(OverflowData&, ValueHandle lhs, ValueHandle rhs) __attribute__((used));
void __ubsan_handle_mul_overflow(OverflowData& data, ValueHandle, ValueHandle)
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
{
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
auto location = data.location.permanently_clear();
if (!location.needs_logging())
return;
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
WARNLN_AND_DBGLN("UBSAN: multiplication overflow, {} ({}-bit)", data.type.name(), data.type.bit_width());
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
print_location(location);
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
}
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
void __ubsan_handle_shift_out_of_bounds(ShiftOutOfBoundsData&, ValueHandle lhs, ValueHandle rhs) __attribute__((used));
void __ubsan_handle_shift_out_of_bounds(ShiftOutOfBoundsData& data, ValueHandle, ValueHandle)
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
{
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
auto location = data.location.permanently_clear();
if (!location.needs_logging())
return;
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
WARNLN_AND_DBGLN("UBSAN: shift out of bounds, {} ({}-bit) shifted by {} ({}-bit)", data.lhs_type.name(), data.lhs_type.bit_width(), data.rhs_type.name(), data.rhs_type.bit_width());
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
print_location(location);
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
}
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
void __ubsan_handle_divrem_overflow(OverflowData&, ValueHandle lhs, ValueHandle rhs) __attribute__((used));
void __ubsan_handle_divrem_overflow(OverflowData& data, ValueHandle, ValueHandle)
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
{
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
auto location = data.location.permanently_clear();
if (!location.needs_logging())
return;
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
WARNLN_AND_DBGLN("UBSAN: divrem overflow, {} ({}-bit)", data.type.name(), data.type.bit_width());
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
print_location(location);
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
}
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
void __ubsan_handle_out_of_bounds(OutOfBoundsData&, ValueHandle) __attribute__((used));
void __ubsan_handle_out_of_bounds(OutOfBoundsData& data, ValueHandle)
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
{
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
auto location = data.location.permanently_clear();
if (!location.needs_logging())
return;
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
WARNLN_AND_DBGLN("UBSAN: out of bounds access into array of {} ({}-bit), index type {} ({}-bit)", data.array_type.name(), data.array_type.bit_width(), data.index_type.name(), data.index_type.bit_width());
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
print_location(location);
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
}
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
void __ubsan_handle_type_mismatch_v1(TypeMismatchData&, ValueHandle) __attribute__((used));
void __ubsan_handle_type_mismatch_v1(TypeMismatchData& data, ValueHandle ptr)
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
{
constexpr StringView kinds[] = {
"load of",
"store to",
"reference binding to",
"member access within",
"member call on",
"constructor call on",
"downcast of",
"downcast of",
"upcast of",
"cast to virtual base of",
"_Nonnull binding to",
"dynamic operation on"
};
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
auto location = data.location.permanently_clear();
if (!location.needs_logging())
return;
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
FlatPtr alignment = (FlatPtr)1 << data.log_alignment;
auto kind = kinds[data.type_check_kind];
if (!ptr) {
WARNLN_AND_DBGLN("UBSAN: {} null pointer of type {}", kind, data.type.name());
} else if ((FlatPtr)ptr & (alignment - 1)) {
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
WARNLN_AND_DBGLN("UBSAN: {} misaligned address {:p} of type {} which requires {} byte alignment", kind, ptr, data.type.name(), alignment);
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
} else {
WARNLN_AND_DBGLN("UBSAN: {} address {:p} with insufficient space for type {}", kind, ptr, data.type.name());
}
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
print_location(location);
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
}
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
void __ubsan_handle_alignment_assumption(AlignmentAssumptionData&, ValueHandle, ValueHandle, ValueHandle) __attribute__((used));
void __ubsan_handle_alignment_assumption(AlignmentAssumptionData& data, ValueHandle pointer, ValueHandle alignment, ValueHandle offset)
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
{
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
auto location = data.location.permanently_clear();
if (!location.needs_logging())
return;
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
if (offset) {
WARNLN_AND_DBGLN(
"UBSAN: assumption of {:p} byte alignment (with offset of {:p} byte) for pointer {:p}"
"of type {} failed",
alignment, offset, pointer, data.type.name());
} else {
WARNLN_AND_DBGLN("UBSAN: assumption of {:p} byte alignment for pointer {:p}"
"of type {} failed",
alignment, pointer, data.type.name());
}
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
print_location(location);
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
}
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
void __ubsan_handle_builtin_unreachable(UnreachableData&) __attribute__((used));
void __ubsan_handle_builtin_unreachable(UnreachableData& data)
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
{
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
auto location = data.location.permanently_clear();
if (!location.needs_logging())
return;
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
WARNLN_AND_DBGLN("UBSAN: execution reached an unreachable program point");
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
print_location(location);
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
}
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
void __ubsan_handle_missing_return(UnreachableData&) __attribute__((used));
void __ubsan_handle_missing_return(UnreachableData& data)
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
{
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
auto location = data.location.permanently_clear();
if (!location.needs_logging())
return;
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
WARNLN_AND_DBGLN("UBSAN: execution reached the end of a value-returning function without returning a value");
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
print_location(location);
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
}
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
void __ubsan_handle_implicit_conversion(ImplicitConversionData&, ValueHandle, ValueHandle) __attribute__((used));
void __ubsan_handle_implicit_conversion(ImplicitConversionData& data, ValueHandle, ValueHandle)
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
{
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
auto location = data.location.permanently_clear();
if (!location.needs_logging())
return;
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
const char* src_signed = data.from_type.is_signed() ? "" : "un";
const char* dst_signed = data.to_type.is_signed() ? "" : "un";
WARNLN_AND_DBGLN("UBSAN: implicit conversion from type {} ({}-bit, {}signed) to type {} ({}-bit, {}signed)",
data.from_type.name(), data.from_type.bit_width(), src_signed, data.to_type.name(), data.to_type.bit_width(), dst_signed);
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
print_location(location);
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
}
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
void __ubsan_handle_invalid_builtin(InvalidBuiltinData&) __attribute__((used));
void __ubsan_handle_invalid_builtin(InvalidBuiltinData& data)
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
{
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
auto location = data.location.permanently_clear();
if (!location.needs_logging())
return;
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
WARNLN_AND_DBGLN("UBSAN: passing invalid argument");
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
print_location(location);
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
}
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
void __ubsan_handle_pointer_overflow(PointerOverflowData&, ValueHandle, ValueHandle) __attribute__((used));
void __ubsan_handle_pointer_overflow(PointerOverflowData& data, ValueHandle base, ValueHandle result)
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
{
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
auto location = data.location.permanently_clear();
if (!location.needs_logging())
return;
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
if (base == 0 && result == 0) {
WARNLN_AND_DBGLN("UBSAN: applied zero offset to nullptr");
} else if (base == 0 && result != 0) {
WARNLN_AND_DBGLN("UBSAN: applied non-zero offset {:p} to nullptr", result);
} else if (base != 0 && result == 0) {
WARNLN_AND_DBGLN("UBSAN: applying non-zero offset to non-null pointer {:p} produced null pointer", base);
} else {
WARNLN_AND_DBGLN("UBSAN: addition of unsigned offset to {:p} overflowed to {:p}", base, result);
}
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
print_location(location);
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
}
LibSanitizer+AK: Add float cast overflow handler This is not enabled by default in GCC, but is in Clang.
2021-08-06 09:26:21 +03:00
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
void __ubsan_handle_float_cast_overflow(FloatCastOverflowData&, ValueHandle) __attribute__((used));
void __ubsan_handle_float_cast_overflow(FloatCastOverflowData& data, ValueHandle)
LibSanitizer+AK: Add float cast overflow handler This is not enabled by default in GCC, but is in Clang.
2021-08-06 09:26:21 +03:00
{
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
auto location = data.location.permanently_clear();
if (!location.needs_logging())
return;
LibSanitizer+AK: Add float cast overflow handler This is not enabled by default in GCC, but is in Clang.
2021-08-06 09:26:21 +03:00
WARNLN_AND_DBGLN("UBSAN: overflow when casting from {} to {}", data.from_type.name(), data.to_type.name());
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
print_location(location);
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
}
AK+LibSanitizer: Add method to zero out a UBSAN SourceLocation This is the same strategy that LLVM's compiler-rt uses to make sure that each UBSAN error is only reported once, when UBSAN is *not* deadly. Otherwise, each time we head through a UB codepath, we will log the same error over and over. That behavior just adds noise to the logs and makes it nearly impossible to run binaires that have some common code path with flagged UB in them. compiler-rt goes the extra step to make sure the "clear" action is atomic, but we don't really have that many multi-threaded apps gettting tested with UBSAN yet, so we can add that later.
2021-11-23 08:59:16 +03:00
} // extern "C"
Reference in New Issue Copy Permalink