(void) syscall(__NR_futex, &cblk->mFutex, mClientInServer ? FUTEX_WAKE_PRIVATE : FUTEX_WAKE, 1); } } void ClientProxy::interrupt() { audio_track_cblk_t* cblk = mCblk; if (!(android_atomic_or(CBLK_INTERRUPT, &cblk->mFlags) & CBLK_INTERRUPT)) { android_atomic_or(CBLK_FUTEX_WAKE, &cblk->mFutex); (void) syscall(__NR_futex, &cblk->mFutex, mClientInServer ? FUTEX_WAKE_PRIVATE : FUTEX_WAKE, 1); } } __attribute__((no_sanitize("integer"))) size_t ClientProxy::getMisalignment() { audio_track_cblk_t* cblk = mCblk; return (mFrameCountP2 - (mIsOut ? cblk->u.mStreaming.mRear : cblk->u.mStreaming.mFront)) & (mFrameCountP2 - 1); } size_t ClientProxy::getFramesFilled() { audio_track_cblk_t* cblk = mCblk; int32_t front; int32_t rear; if (mIsOut) { front = android_atomic_acquire_load(&cblk->u.mStreaming.mFront); rear = cblk->u.mStreaming.mRear;
return scanner; } bool scanner_has_next(scanner_t *scanner) { return scanner->index < scanner->size; } uint8_t scanner_next(scanner_t *scanner) { return scanner->mem[scanner->index++]; } void scanner_read(void * address, uintptr_t size, scanner_t *scanner) { memcpy(address, &scanner->mem[scanner->index], size); scanner->index += size; } __attribute__((no_sanitize("address"))) owl_term owl_load_module(vm_t *vm, uint8_t *bytecode, size_t size) { uint8_t ch; scanner_t *scanner = scanner_new(size, bytecode); owl_term function_list = owl_list_init(); unsigned char *code_ptr = vm->code + vm->code_size; while (scanner_has_next(scanner)) { ch = scanner_next(scanner); switch(ch) { default: printf("Unknown opcode: 0x%02x\n", ch); exit(1); case OP_RETURN:
#include <hw/serial.hpp> static const uint16_t port = 0x3F8; // Serial 1 static char initialized = 0xFF; extern "C" __attribute__((no_sanitize("all"))) void __init_serial1() { initialized = false; } static inline void init_if_needed() { if (initialized) return; initialized = true; // properly initialize serial port hw::outb(port + 1, 0x00); // Disable all interrupts hw::outb(port + 3, 0x80); // Enable DLAB (set baud rate divisor) hw::outb(port + 0, 0x03); // Set divisor to 3 (lo byte) 38400 baud hw::outb(port + 1, 0x00); // (hi byte) hw::outb(port + 3, 0x03); // 8 bits, no parity, one stop bit hw::outb(port + 2, 0xC7); // Enable FIFO, clear them, with 14-byte threshold } extern "C" __attribute__((no_sanitize("all"))) void __serial_print1(const char* cstr) { init_if_needed(); while (*cstr) {
// ITANIUM: {{%[^ ]*}} = call i1 @llvm.bitset.test(i8* {{%[^ ]*}}, metadata !"_ZTS1B") // MS: {{%[^ ]*}} = call i1 @llvm.bitset.test(i8* {{%[^ ]*}}, metadata !"?AUB@@") d->g(); } // ITANIUM: define internal void @_Z3dh1PN12_GLOBAL__N_11DE // MS: define internal void @"\01?dh1@@YAXPEAUD@?A@@@Z" void dh1(D *d) { // ITANIUM: {{%[^ ]*}} = call i1 @llvm.bitset.test(i8* {{%[^ ]*}}, metadata ![[DTYPE]]) // MS: {{%[^ ]*}} = call i1 @llvm.bitset.test(i8* {{%[^ ]*}}, metadata ![[DTYPE:[0-9]+]]) d->h(); } // ITANIUM: define internal void @_Z3df2PN12_GLOBAL__N_11DE // MS: define internal void @"\01?df2@@YAXPEAUD@?A@@@Z" __attribute__((no_sanitize("cfi"))) void df2(D *d) { // CFI-NOT: call i1 @llvm.bitset.test d->f(); } // ITANIUM: define internal void @_Z3df3PN12_GLOBAL__N_11DE // MS: define internal void @"\01?df3@@YAXPEAUD@?A@@@Z" __attribute__((no_sanitize("address"))) __attribute__((no_sanitize("cfi-vcall"))) void df3(D *d) { // CFI-NOT: call i1 @llvm.bitset.test d->f(); } D d;
// RUN: echo "int extra_global;" > %t.extra-source.cpp // RUN: echo "global:*blacklisted_global*" > %t.blacklist // RUN: %clang_cc1 -include %t.extra-source.cpp -fsanitize=address -fsanitize-blacklist=%t.blacklist -emit-llvm -o - %s | FileCheck %s // The blacklist file uses regexps, so Windows path backslashes. // RUN: echo "src:%s" | sed -e 's/\\/\\\\/g' > %t.blacklist-src // RUN: %clang_cc1 -include %t.extra-source.cpp -fsanitize=address -fsanitize-blacklist=%t.blacklist-src -emit-llvm -o - %s | FileCheck %s --check-prefix=BLACKLIST-SRC int global; int dyn_init_global = global; int __attribute__((no_sanitize("address"))) attributed_global; int blacklisted_global; void func() { static int static_var = 0; const char *literal = "Hello, world!"; } // CHECK: !llvm.asan.globals = !{![[EXTRA_GLOBAL:[0-9]+]], ![[GLOBAL:[0-9]+]], ![[DYN_INIT_GLOBAL:[0-9]+]], ![[ATTR_GLOBAL:[0-9]+]], ![[BLACKLISTED_GLOBAL:[0-9]+]], ![[STATIC_VAR:[0-9]+]], ![[LITERAL:[0-9]+]]} // CHECK: ![[EXTRA_GLOBAL]] = !{{{.*}} ![[EXTRA_GLOBAL_LOC:[0-9]+]], !"extra_global", i1 false, i1 false} // CHECK: ![[EXTRA_GLOBAL_LOC]] = !{!"{{.*}}extra-source.cpp", i32 1, i32 5} // CHECK: ![[GLOBAL]] = !{{{.*}} ![[GLOBAL_LOC:[0-9]+]], !"global", i1 false, i1 false} // CHECK: ![[GLOBAL_LOC]] = !{!"{{.*}}asan-globals.cpp", i32 8, i32 5} // CHECK: ![[DYN_INIT_GLOBAL]] = !{{{.*}} ![[DYN_INIT_LOC:[0-9]+]], !"dyn_init_global", i1 true, i1 false} // CHECK: ![[DYN_INIT_LOC]] = !{!"{{.*}}asan-globals.cpp", i32 9, i32 5} // CHECK: ![[ATTR_GLOBAL]] = !{{{.*}}, null, null, i1 false, i1 true} // CHECK: ![[BLACKLISTED_GLOBAL]] = !{{{.*}}, null, null, i1 false, i1 true} // CHECK: ![[STATIC_VAR]] = !{{{.*}} ![[STATIC_LOC:[0-9]+]], !"static_var", i1 false, i1 false} // CHECK: ![[STATIC_LOC]] = !{!"{{.*}}asan-globals.cpp", i32 14, i32 14} // CHECK: ![[LITERAL]] = !{{{.*}} ![[LITERAL_LOC:[0-9]+]], !"<string literal>", i1 false, i1 false} // CHECK: ![[LITERAL_LOC]] = !{!"{{.*}}asan-globals.cpp", i32 15, i32 25}
*/ #include <assert.h> #include <stdint.h> #include <stdlib.h> #include "libs_utils.h" // This library is built for all targets, including host tests, so __cfi_slowpath may not be // present. But it is only used in the bionic loader tests. extern "C" __attribute__((weak)) void __cfi_slowpath(uint64_t, void*); static int g_count; // Mock a CFI-enabled library without relying on the compiler. extern "C" __attribute__((no_sanitize("hwaddress"))) __attribute__((aligned(4096))) void __cfi_check(uint64_t /*CallSiteTypeId*/, void* /*TargetAddr*/, void* /*Diag*/) { ++g_count; } // This code runs before hwasan is initialized. __attribute__((no_sanitize("hwaddress"))) void preinit_ctor() { CHECK(g_count == 0); __cfi_slowpath(42, reinterpret_cast<void*>(&preinit_ctor)); CHECK(g_count == 1); } __attribute__((section(".preinit_array"), used)) void (*preinit_ctor_p)(void) = preinit_ctor; __attribute__((constructor, used)) void ctor() {
* * ===----------------------------------------------------------------------=== * * This file implements __muloti4, and is stolen from the compiler_rt library. * * FIXME: we steal and re-compile it into filesystem, which uses __int128_t, * and requires this builtin when sanitized. See llvm.org/PR30643 * * ===----------------------------------------------------------------------=== */ #include "__config" #include "climits" #if !defined(_LIBCPP_HAS_NO_INT128) extern "C" __attribute__((no_sanitize("undefined"))) __int128_t __muloti4(__int128_t a, __int128_t b, int* overflow) { const int N = (int)(sizeof(__int128_t) * CHAR_BIT); const __int128_t MIN = (__int128_t)1 << (N - 1); const __int128_t MAX = ~MIN; *overflow = 0; __int128_t result = a * b; if (a == MIN) { if (b != 0 && b != 1) *overflow = 1; return result; } if (b == MIN) { if (a != 0 && a != 1) *overflow = 1; return result;
// RUN: %clang_cc1 -fsanitize=implicit-unsigned-integer-truncation -fsanitize-recover=implicit-unsigned-integer-truncation -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_implicit_conversion" --check-prefixes=CHECK // CHECK-DAG: @[[LINE_100_UNSIGNED_TRUNCATION:.*]] = {{.*}}, i32 100, i32 10 }, {{.*}}, {{.*}}, i8 1 } // CHECK-DAG: @[[LINE_200_UNSIGNED_TRUNCATION:.*]] = {{.*}}, i32 200, i32 10 }, {{.*}}, {{.*}}, i8 1 } // CHECK-LABEL: @blacklist_0_convert_unsigned_int_to_unsigned_char __attribute__((no_sanitize("undefined"))) unsigned char blacklist_0_convert_unsigned_int_to_unsigned_char(unsigned int x) { // We are not in "undefined" group, so that doesn't work. // CHECK: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_100_UNSIGNED_TRUNCATION]] to i8*) #line 100 return x; } // CHECK-LABEL: @blacklist_1_convert_unsigned_int_to_unsigned_char __attribute__((no_sanitize("integer"))) unsigned char blacklist_1_convert_unsigned_int_to_unsigned_char(unsigned int x) { return x; } // CHECK-LABEL: @blacklist_2_convert_unsigned_int_to_unsigned_char __attribute__((no_sanitize("implicit-conversion"))) unsigned char blacklist_2_convert_unsigned_int_to_unsigned_char(unsigned int x) { return x; } // CHECK-LABEL: @blacklist_3_convert_unsigned_int_to_unsigned_char __attribute__((no_sanitize("implicit-integer-truncation"))) unsigned char blacklist_3_convert_unsigned_int_to_unsigned_char(unsigned int x) { return x; } // CHECK-LABEL: @blacklist_4_convert_unsigned_int_to_unsigned_char __attribute__((no_sanitize("implicit-unsigned-integer-truncation"))) unsigned char blacklist_4_convert_unsigned_int_to_unsigned_char(unsigned int x) { return x;
// CHECK-SANITIZE: %[[ANYEXT:.*]] = zext i16 %[[DST:.*]] to i32, !nosanitize // CHECK-SANITIZE: call // CHECK: } unsigned short b; return (unsigned char)(b = c); } // ========================================================================== // // The expected true-negatives. // ========================================================================== // // Sanitization is explicitly disabled. // ========================================================================== // // CHECK-LABEL: @blacklist_0 __attribute__((no_sanitize("undefined"))) unsigned char blacklist_0(unsigned int src) { // We are not in "undefined" group, so that doesn't work. // CHECK-SANITIZE: call // CHECK: } return src; } // CHECK-LABEL: @blacklist_1 __attribute__((no_sanitize("integer"))) unsigned char blacklist_1(unsigned int src) { // CHECK: } return src; } // CHECK-LABEL: @blacklist_2 __attribute__((no_sanitize("implicit-conversion"))) unsigned char blacklist_2(unsigned int src) { // CHECK: }
* target of an assignment to appear on its right-hand side (contrary * to the Fortran 77 Standard, but in accordance with Fortran 90), * as in a(2:5) = a(4:7) . */ #include "f2c.h" #ifdef __cplusplus extern "C" { #endif /* assign strings: a = b */ // command to get sanitizer error: // ya make -tAr --sanitize=address cv/imgclassifiers/danet/tests/minimize_memory_ut/ -F TMinimizeMemoryTest::TestMinimizeMemoryUsageModeTrain #if defined(__has_feature) # if __has_feature(address_sanitizer) __attribute__((no_sanitize("address"))) # endif #endif #if defined(__has_feature) # if __has_feature(memory_sanitizer) __attribute__((no_sanitize("memory"))) # endif #endif #ifdef KR_headers VOID s_copy(a, b, la, lb) register char *a, *b; ftnlen la, lb; #else void s_copy(register char *a, register char *b, ftnlen la, ftnlen lb) #endif { register char *aend, *bend;
return regex->re_match[number * 2 + 1] - regex->re_match[number * 2]; #elif ENABLE_PCRE2 PCRE2_SIZE len; int rc = pcre2_substring_length_bynumber(regex->re_match, number, &len); return (!rc) ? len : -1; #endif } #endif } /* * Sanitizer helpers to avoid false positives */ #if ENABLE_CCLANG_THREADSAN void *blacklisted_memcpy(void *dest, const void *src, size_t n) __attribute__((no_sanitize("thread"))) { uint8_t *d = dest; const uint8_t *s = src; while (n-- > 0) *d++ = *s++; return dest; } void *dlsym(void *handle, const char *symbol); int blacklisted_close(int fd) __attribute__((no_sanitize("thread"))) { // close(fd); // sanitizer reports errors in close() return 0; }