[compiler-rt] r267293 - [esan] EfficiencySanitizer libc interceptors
Derek Bruening via llvm-commits
llvm-commits at lists.llvm.org
Sun Apr 24 21:03:10 PDT 2016
ctx is not used, but the compiler has a hard time telling and it is best to
set it to something. Fixed in r267376.
On Sun, Apr 24, 2016 at 11:15 AM, Teresa Johnson <tejohnson at google.com>
wrote:
> Hi Derek,
>
> I am getting many uninitialized variable errors in my builds (which enable
> -Werror) after this change. They all look like:
>
> In file included from
> /usr/local/google/home/tejohnson/llvm/llvm_13/projects/compiler-rt/lib/esan/esan_interceptors.cpp:89:
> /usr/local/google/home/tejohnson/llvm/llvm_13/projects/compiler-rt/lib/esan/../sanitizer_common/sanitizer_common_interceptors.inc:377:17:
> error: variable 'ctx' is uninitialized when used here
> [-Werror,-Wuninitialized]
> StrstrCheck(ctx, r, s1, s2);
> ^~~
> /usr/local/google/home/tejohnson/llvm/llvm_13/projects/compiler-rt/lib/esan/../sanitizer_common/sanitizer_common_interceptors.inc:373:12:
> note: initialize the variable 'ctx' to silence this warning
> void *ctx;
> ^
> = nullptr
>
>
> I took a quick look to see if it was a spurious warning, but it does seem
> in fact that ctx is uninitialized when it is passed to StrstrCheck, so I am
> not sure what was intended.
>
> Thanks,
> Teresa
>
> On Sat, Apr 23, 2016 at 9:41 AM, Derek Bruening via llvm-commits <
> llvm-commits at lists.llvm.org> wrote:
>
>> Author: bruening
>> Date: Sat Apr 23 11:41:24 2016
>> New Revision: 267293
>>
>> URL: http://llvm.org/viewvc/llvm-project?rev=267293&view=rev
>> Log:
>> [esan] EfficiencySanitizer libc interceptors
>>
>> Summary:
>> Adds libc interceptors to the runtime library for the new
>> EfficiencySanitizer ("esan") family of tools. The interceptors cover
>> the memory operations in most common library calls and will be shared
>> among all esan tools.
>>
>> Reviewers: aizatsky
>>
>> Subscribers: zhaoqin, tberghammer, danalbert, srhines, llvm-commits,
>> vitalybuka, eugenis, kcc
>>
>> Differential Revision: http://reviews.llvm.org/D19411
>>
>> Added:
>> compiler-rt/trunk/lib/esan/esan_interceptors.cpp
>> compiler-rt/trunk/test/esan/TestCases/libc-intercept.c
>> Modified:
>> compiler-rt/trunk/lib/esan/CMakeLists.txt
>> compiler-rt/trunk/lib/esan/esan.cpp
>> compiler-rt/trunk/lib/esan/esan.h
>> compiler-rt/trunk/test/esan/TestCases/verbose-simple.c
>>
>> Modified: compiler-rt/trunk/lib/esan/CMakeLists.txt
>> URL:
>> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/esan/CMakeLists.txt?rev=267293&r1=267292&r2=267293&view=diff
>>
>> ==============================================================================
>> --- compiler-rt/trunk/lib/esan/CMakeLists.txt (original)
>> +++ compiler-rt/trunk/lib/esan/CMakeLists.txt Sat Apr 23 11:41:24 2016
>> @@ -9,7 +9,8 @@ include_directories(..)
>>
>> set(ESAN_SOURCES
>> esan.cpp
>> - esan_interface.cpp)
>> + esan_interface.cpp
>> + esan_interceptors.cpp)
>>
>> foreach (arch ${ESAN_SUPPORTED_ARCH})
>> add_compiler_rt_runtime(clang_rt.esan
>>
>> Modified: compiler-rt/trunk/lib/esan/esan.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/esan/esan.cpp?rev=267293&r1=267292&r2=267293&view=diff
>>
>> ==============================================================================
>> --- compiler-rt/trunk/lib/esan/esan.cpp (original)
>> +++ compiler-rt/trunk/lib/esan/esan.cpp Sat Apr 23 11:41:24 2016
>> @@ -95,6 +95,8 @@ void initializeLibrary(ToolType Tool) {
>> Die();
>> }
>>
>> + initializeInterceptors();
>> +
>> EsanIsInitialized = true;
>> }
>>
>>
>> Modified: compiler-rt/trunk/lib/esan/esan.h
>> URL:
>> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/esan/esan.h?rev=267293&r1=267292&r2=267293&view=diff
>>
>> ==============================================================================
>> --- compiler-rt/trunk/lib/esan/esan.h (original)
>> +++ compiler-rt/trunk/lib/esan/esan.h Sat Apr 23 11:41:24 2016
>> @@ -38,6 +38,7 @@ extern ToolType WhichTool;
>> void initializeLibrary(ToolType Tool);
>> int finalizeLibrary();
>> void processRangeAccess(uptr PC, uptr Addr, int Size, bool IsWrite);
>> +void initializeInterceptors();
>>
>> } // namespace __esan
>>
>>
>> Added: compiler-rt/trunk/lib/esan/esan_interceptors.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/esan/esan_interceptors.cpp?rev=267293&view=auto
>>
>> ==============================================================================
>> --- compiler-rt/trunk/lib/esan/esan_interceptors.cpp (added)
>> +++ compiler-rt/trunk/lib/esan/esan_interceptors.cpp Sat Apr 23 11:41:24
>> 2016
>> @@ -0,0 +1,338 @@
>> +//===-- esan_interceptors.cpp
>> ---------------------------------------------===//
>> +//
>> +// The LLVM Compiler Infrastructure
>> +//
>> +// This file is distributed under the University of Illinois Open Source
>> +// License. See LICENSE.TXT for details.
>> +//
>>
>> +//===----------------------------------------------------------------------===//
>> +//
>> +// This file is a part of EfficiencySanitizer, a family of performance
>> tuners.
>> +//
>> +// Interception routines for the esan run-time.
>>
>> +//===----------------------------------------------------------------------===//
>> +
>> +#include "esan.h"
>> +#include "interception/interception.h"
>> +#include "sanitizer_common/sanitizer_common.h"
>> +#include "sanitizer_common/sanitizer_libc.h"
>> +#include "sanitizer_common/sanitizer_stacktrace.h"
>> +
>> +using namespace __esan; // NOLINT
>> +
>> +#define CUR_PC() (StackTrace::GetCurrentPc())
>> +
>>
>> +//===----------------------------------------------------------------------===//
>> +// Interception via sanitizer common interceptors
>>
>> +//===----------------------------------------------------------------------===//
>> +
>> +// Get the per-platform defines for what is possible to intercept
>> +#include "sanitizer_common/sanitizer_platform_interceptors.h"
>> +
>> +// TODO(bruening): tsan disables several interceptors (getpwent, etc.)
>> claiming
>> +// that interception is a perf hit: should we do the same?
>> +
>> +// We have no need to intercept:
>> +#undef SANITIZER_INTERCEPT_TLS_GET_ADDR
>> +
>> +// TODO(bruening): the common realpath interceptor assumes malloc is
>> +// intercepted! We should try to parametrize that, though we'll
>> +// intercept malloc soon ourselves and can then remove this undef.
>> +#undef SANITIZER_INTERCEPT_REALPATH
>> +
>> +#define COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED (!EsanIsInitialized)
>> +
>> +#define COMMON_INTERCEPT_FUNCTION(name) INTERCEPT_FUNCTION(name)
>> +
>> +#define COMMON_INTERCEPTOR_ENTER(ctx, func, ...)
>> \
>> + do {
>> \
>> + if (UNLIKELY(COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED)) {
>> \
>> + return REAL(func)(__VA_ARGS__);
>> \
>> + }
>> \
>> + (void)ctx;
>> \
>> + } while (false)
>> +
>> +#define COMMON_INTERCEPTOR_ENTER_NOIGNORE(ctx, func, ...)
>> \
>> + COMMON_INTERCEPTOR_ENTER(ctx, func, __VA_ARGS__)
>> +
>> +#define COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ptr, size)
>> \
>> + processRangeAccess(CUR_PC(), (uptr)ptr, size, true)
>> +
>> +#define COMMON_INTERCEPTOR_READ_RANGE(ctx, ptr, size)
>> \
>> + processRangeAccess(CUR_PC(), (uptr)ptr, size, false)
>> +
>> +// This is only called if the app explicitly calls exit(), not on
>> +// a normal exit.
>> +#define COMMON_INTERCEPTOR_ON_EXIT(ctx) finalizeLibrary()
>> +
>> +#define COMMON_INTERCEPTOR_FILE_OPEN(ctx, file, path) {}
>> +#define COMMON_INTERCEPTOR_FILE_CLOSE(ctx, file) {}
>> +#define COMMON_INTERCEPTOR_LIBRARY_LOADED(filename, handle) {}
>> +#define COMMON_INTERCEPTOR_LIBRARY_UNLOADED() {}
>> +#define COMMON_INTERCEPTOR_ACQUIRE(ctx, u) {}
>> +#define COMMON_INTERCEPTOR_RELEASE(ctx, u) {}
>> +#define COMMON_INTERCEPTOR_DIR_ACQUIRE(ctx, path) {}
>> +#define COMMON_INTERCEPTOR_FD_ACQUIRE(ctx, fd) {}
>> +#define COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd) {}
>> +#define COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd) {}
>> +#define COMMON_INTERCEPTOR_FD_SOCKET_ACCEPT(ctx, fd, newfd) {}
>> +#define COMMON_INTERCEPTOR_SET_THREAD_NAME(ctx, name) {}
>> +#define COMMON_INTERCEPTOR_SET_PTHREAD_NAME(ctx, thread, name) {}
>> +#define COMMON_INTERCEPTOR_BLOCK_REAL(name) REAL(name)
>> +#define COMMON_INTERCEPTOR_MUTEX_LOCK(ctx, m) {}
>> +#define COMMON_INTERCEPTOR_MUTEX_UNLOCK(ctx, m) {}
>> +#define COMMON_INTERCEPTOR_MUTEX_REPAIR(ctx, m) {}
>> +#define COMMON_INTERCEPTOR_HANDLE_RECVMSG(ctx, msg) {}
>> +#define COMMON_INTERCEPTOR_USER_CALLBACK_START() {}
>> +#define COMMON_INTERCEPTOR_USER_CALLBACK_END() {}
>> +
>> +#include "sanitizer_common/sanitizer_common_interceptors.inc"
>> +
>>
>> +//===----------------------------------------------------------------------===//
>> +// Syscall interception
>>
>> +//===----------------------------------------------------------------------===//
>> +
>> +// We want the caller's PC b/c unlike the other function interceptors
>> these
>> +// are separate pre and post functions called around the app's syscall().
>> +
>> +#define COMMON_SYSCALL_PRE_READ_RANGE(ptr, size)
>> \
>> + processRangeAccess(GET_CALLER_PC(), (uptr)ptr, size, false)
>> +
>> +#define COMMON_SYSCALL_PRE_WRITE_RANGE(ptr, size) {}
>> +
>> +#define COMMON_SYSCALL_POST_READ_RANGE(ptr, size) {}
>> +
>> +// The actual amount written is in post, not pre.
>> +#define COMMON_SYSCALL_POST_WRITE_RANGE(ptr, size)
>> \
>> + processRangeAccess(GET_CALLER_PC(), (uptr)ptr, size, true)
>> +
>> +#define COMMON_SYSCALL_ACQUIRE(addr) {}
>> +#define COMMON_SYSCALL_RELEASE(addr) { (void)addr; }
>> +#define COMMON_SYSCALL_FD_CLOSE(fd) {}
>> +#define COMMON_SYSCALL_FD_ACQUIRE(fd) {}
>> +#define COMMON_SYSCALL_FD_RELEASE(fd) {}
>> +#define COMMON_SYSCALL_PRE_FORK() {}
>> +#define COMMON_SYSCALL_POST_FORK(res) {}
>> +
>> +#include "sanitizer_common/sanitizer_common_syscalls.inc"
>> +
>>
>> +//===----------------------------------------------------------------------===//
>> +// Custom interceptors
>>
>> +//===----------------------------------------------------------------------===//
>> +
>> +// TODO(bruening): move more of these to the common interception pool as
>> they
>> +// are shared with tsan and asan.
>> +// While our other files match LLVM style, here we match sanitizer style
>> as we
>> +// expect to move these to the common pool.
>> +
>> +INTERCEPTOR(char *, strcpy, char *dst, const char *src) { // NOLINT
>> + void *ctx;
>> + COMMON_INTERCEPTOR_ENTER(ctx, strcpy, dst, src);
>> + uptr srclen = internal_strlen(src);
>> + COMMON_INTERCEPTOR_WRITE_RANGE(ctx, dst, srclen + 1);
>> + COMMON_INTERCEPTOR_READ_RANGE(ctx, src, srclen + 1);
>> + return REAL(strcpy)(dst, src); // NOLINT
>> +}
>> +
>> +INTERCEPTOR(char *, strncpy, char *dst, char *src, uptr n) {
>> + void *ctx;
>> + COMMON_INTERCEPTOR_ENTER(ctx, strncpy, dst, src, n);
>> + uptr srclen = internal_strnlen(src, n);
>> + uptr copied_size = srclen + 1 > n ? n : srclen + 1;
>> + COMMON_INTERCEPTOR_WRITE_RANGE(ctx, dst, copied_size);
>> + COMMON_INTERCEPTOR_READ_RANGE(ctx, src, copied_size);
>> + return REAL(strncpy)(dst, src, n);
>> +}
>> +
>> +#if SANITIZER_FREEBSD || SANITIZER_MAC || SANITIZER_ANDROID
>> +INTERCEPTOR(int, stat, const char *path, void *buf) {
>> + void *ctx;
>> + COMMON_INTERCEPTOR_ENTER(ctx, stat, path, buf);
>> + COMMON_INTERCEPTOR_READ_STRING(ctx, path, 0);
>> + return REAL(stat)(path, buf);
>> +#define ESAN_INTERCEPT_STAT INTERCEPT_FUNCTION(stat)
>> +#else
>> +INTERCEPTOR(int, __xstat, int version, const char *path, void *buf) {
>> + void *ctx;
>> + COMMON_INTERCEPTOR_ENTER(ctx, __xstat, version, path, buf);
>> + COMMON_INTERCEPTOR_READ_STRING(ctx, path, 0);
>> + return REAL(__xstat)(version, path, buf);
>> +}
>> +#define ESAN_INTERCEPT_STAT INTERCEPT_FUNCTION(__xstat)
>> +#endif
>> +
>> +#if SANITIZER_LINUX && !SANITIZER_ANDROID && !SANITIZER_FREEBSD
>> +INTERCEPTOR(int, __xstat64, int version, const char *path, void *buf) {
>> + void *ctx;
>> + COMMON_INTERCEPTOR_ENTER(ctx, __xstat64, version, path, buf);
>> + COMMON_INTERCEPTOR_READ_STRING(ctx, path, 0);
>> + return REAL(__xstat64)(version, path, buf);
>> +}
>> +#define ESAN_MAYBE_INTERCEPT___XSTAT64 INTERCEPT_FUNCTION(__xstat64)
>> +#else
>> +#define ESAN_MAYBE_INTERCEPT___XSTAT64
>> +#endif
>> +
>> +#if SANITIZER_LINUX && !SANITIZER_ANDROID && !SANITIZER_FREEBSD
>> +INTERCEPTOR(int, stat64, const char *path, void *buf) {
>> + void *ctx;
>> + COMMON_INTERCEPTOR_ENTER(ctx, stat64, path, buf);
>> + COMMON_INTERCEPTOR_READ_STRING(ctx, path, 0);
>> + return REAL(stat64)(path, buf);
>> +}
>> +#define ESAN_MAYBE_INTERCEPT_STAT64 INTERCEPT_FUNCTION(stat64)
>> +#else
>> +#define ESAN_MAYBE_INTERCEPT_STAT64
>> +#endif
>> +
>> +#if SANITIZER_FREEBSD || SANITIZER_MAC || SANITIZER_ANDROID
>> +INTERCEPTOR(int, lstat, const char *path, void *buf) {
>> + void *ctx;
>> + COMMON_INTERCEPTOR_ENTER(ctx, lstat, path, buf);
>> + COMMON_INTERCEPTOR_READ_STRING(ctx, path, 0);
>> + return REAL(lstat)(path, buf);
>> +}
>> +#define ESAN_INTERCEPT_LSTAT INTERCEPT_FUNCTION(lstat)
>> +#else
>> +INTERCEPTOR(int, __lxstat, int version, const char *path, void *buf) {
>> + void *ctx;
>> + COMMON_INTERCEPTOR_ENTER(ctx, __lxstat, version, path, buf);
>> + COMMON_INTERCEPTOR_READ_STRING(ctx, path, 0);
>> + return REAL(__lxstat)(version, path, buf);
>> +}
>> +#define ESAN_INTERCEPT_LSTAT INTERCEPT_FUNCTION(__lxstat)
>> +#endif
>> +
>> +#if SANITIZER_LINUX && !SANITIZER_ANDROID && !SANITIZER_FREEBSD
>> +INTERCEPTOR(int, __lxstat64, int version, const char *path, void *buf) {
>> + void *ctx;
>> + COMMON_INTERCEPTOR_ENTER(ctx, __lxstat64, version, path, buf);
>> + COMMON_INTERCEPTOR_READ_STRING(ctx, path, 0);
>> + return REAL(__lxstat64)(version, path, buf);
>> +}
>> +#define ESAN_MAYBE_INTERCEPT___LXSTAT64 INTERCEPT_FUNCTION(__lxstat64)
>> +#else
>> +#define ESAN_MAYBE_INTERCEPT___LXSTAT64
>> +#endif
>> +
>> +#if SANITIZER_LINUX && !SANITIZER_ANDROID && !SANITIZER_FREEBSD
>> +INTERCEPTOR(int, lstat64, const char *path, void *buf) {
>> + void *ctx;
>> + COMMON_INTERCEPTOR_ENTER(ctx, lstat64, path, buf);
>> + COMMON_INTERCEPTOR_READ_STRING(ctx, path, 0);
>> + return REAL(lstat64)(path, buf);
>> +}
>> +#define ESAN_MAYBE_INTERCEPT_LSTAT64 INTERCEPT_FUNCTION(lstat64)
>> +#else
>> +#define ESAN_MAYBE_INTERCEPT_LSTAT64
>> +#endif
>> +
>> +INTERCEPTOR(int, open, const char *name, int flags, int mode) {
>> + void *ctx;
>> + COMMON_INTERCEPTOR_ENTER(ctx, open, name, flags, mode);
>> + COMMON_INTERCEPTOR_READ_STRING(ctx, name, 0);
>> + return REAL(open)(name, flags, mode);
>> +}
>> +
>> +#if SANITIZER_LINUX
>> +INTERCEPTOR(int, open64, const char *name, int flags, int mode) {
>> + void *ctx;
>> + COMMON_INTERCEPTOR_ENTER(ctx, open64, name, flags, mode);
>> + COMMON_INTERCEPTOR_READ_STRING(ctx, name, 0);
>> + return REAL(open64)(name, flags, mode);
>> +}
>> +#define ESAN_MAYBE_INTERCEPT_OPEN64 INTERCEPT_FUNCTION(open64)
>> +#else
>> +#define ESAN_MAYBE_INTERCEPT_OPEN64
>> +#endif
>> +
>> +INTERCEPTOR(int, creat, const char *name, int mode) {
>> + void *ctx;
>> + COMMON_INTERCEPTOR_ENTER(ctx, creat, name, mode);
>> + COMMON_INTERCEPTOR_READ_STRING(ctx, name, 0);
>> + return REAL(creat)(name, mode);
>> +}
>> +
>> +#if SANITIZER_LINUX
>> +INTERCEPTOR(int, creat64, const char *name, int mode) {
>> + void *ctx;
>> + COMMON_INTERCEPTOR_ENTER(ctx, creat64, name, mode);
>> + COMMON_INTERCEPTOR_READ_STRING(ctx, name, 0);
>> + return REAL(creat64)(name, mode);
>> +}
>> +#define ESAN_MAYBE_INTERCEPT_CREAT64 INTERCEPT_FUNCTION(creat64)
>> +#else
>> +#define ESAN_MAYBE_INTERCEPT_CREAT64
>> +#endif
>> +
>> +INTERCEPTOR(int, unlink, char *path) {
>> + void *ctx;
>> + COMMON_INTERCEPTOR_ENTER(ctx, unlink, path);
>> + COMMON_INTERCEPTOR_READ_STRING(ctx, path, 0);
>> + return REAL(unlink)(path);
>> +}
>> +
>> +INTERCEPTOR(uptr, fread, void *ptr, uptr size, uptr nmemb, void *f) {
>> + void *ctx;
>> + COMMON_INTERCEPTOR_ENTER(ctx, fread, ptr, size, nmemb, f);
>> + COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ptr, size * nmemb);
>> + return REAL(fread)(ptr, size, nmemb, f);
>> +}
>> +
>> +INTERCEPTOR(uptr, fwrite, const void *p, uptr size, uptr nmemb, void *f)
>> {
>> + void *ctx;
>> + COMMON_INTERCEPTOR_ENTER(ctx, fwrite, p, size, nmemb, f);
>> + COMMON_INTERCEPTOR_READ_RANGE(ctx, p, size * nmemb);
>> + return REAL(fwrite)(p, size, nmemb, f);
>> +}
>> +
>> +INTERCEPTOR(int, puts, const char *s) {
>> + void *ctx;
>> + COMMON_INTERCEPTOR_ENTER(ctx, puts, s);
>> + COMMON_INTERCEPTOR_READ_RANGE(ctx, s, internal_strlen(s));
>> + return REAL(puts)(s);
>> +}
>> +
>> +INTERCEPTOR(int, rmdir, char *path) {
>> + void *ctx;
>> + COMMON_INTERCEPTOR_ENTER(ctx, rmdir, path);
>> + COMMON_INTERCEPTOR_READ_STRING(ctx, path, 0);
>> + return REAL(rmdir)(path);
>> +}
>> +
>> +namespace __esan {
>> +
>> +void initializeInterceptors() {
>> + InitializeCommonInterceptors();
>> +
>> + INTERCEPT_FUNCTION(strcpy); // NOLINT
>> + INTERCEPT_FUNCTION(strncpy);
>> +
>> + ESAN_INTERCEPT_STAT;
>> + ESAN_MAYBE_INTERCEPT_STAT64;
>> + ESAN_MAYBE_INTERCEPT___XSTAT64;
>> + ESAN_INTERCEPT_LSTAT;
>> + ESAN_MAYBE_INTERCEPT_LSTAT64;
>> + ESAN_MAYBE_INTERCEPT___LXSTAT64;
>> + INTERCEPT_FUNCTION(open);
>> + ESAN_MAYBE_INTERCEPT_OPEN64;
>> + INTERCEPT_FUNCTION(creat);
>> + ESAN_MAYBE_INTERCEPT_CREAT64;
>> + INTERCEPT_FUNCTION(unlink);
>> + INTERCEPT_FUNCTION(fread);
>> + INTERCEPT_FUNCTION(fwrite);
>> + INTERCEPT_FUNCTION(puts);
>> + INTERCEPT_FUNCTION(rmdir);
>> +
>> + // TODO(bruening): we should intercept calloc() and other memory
>> allocation
>> + // routines that zero memory and update our shadow memory
>> appropriately.
>> +
>> + // TODO(bruening): intercept routines that other sanitizers intercept
>> that
>> + // are not in the common pool or here yet, ideally by adding to the
>> common
>> + // pool. Examples include wcslen and bcopy.
>> +
>> + // TODO(bruening): there are many more libc routines that read or
>> write data
>> + // structures that no sanitizer is intercepting: sigaction, strtol,
>> etc.
>> +}
>> +
>> +} // namespace __esan
>>
>> Added: compiler-rt/trunk/test/esan/TestCases/libc-intercept.c
>> URL:
>> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/test/esan/TestCases/libc-intercept.c?rev=267293&view=auto
>>
>> ==============================================================================
>> --- compiler-rt/trunk/test/esan/TestCases/libc-intercept.c (added)
>> +++ compiler-rt/trunk/test/esan/TestCases/libc-intercept.c Sat Apr 23
>> 11:41:24 2016
>> @@ -0,0 +1,20 @@
>> +// RUN: %clang_esan_frag -O0 %s -o %t 2>&1
>> +// RUN: %env_esan_opts=verbosity=3 %run %t 2>&1 | FileCheck %s
>> +
>> +#include <string.h>
>> +
>> +int main(int argc, char **argv) {
>> + char Buf[2048];
>> + const char Str[] = "TestStringOfParticularLength"; // 29 chars.
>> + strcpy(Buf, Str);
>> + strncpy(Buf, Str, 17);
>> + return strncmp(Buf, Str, 17);
>> + // CHECK: in esan::initializeLibrary
>> + // CHECK: in esan::processRangeAccess {{.*}} 29
>> + // CHECK: in esan::processRangeAccess {{.*}} 29
>> + // CHECK: in esan::processRangeAccess {{.*}} 17
>> + // CHECK: in esan::processRangeAccess {{.*}} 17
>> + // CHECK: in esan::processRangeAccess {{.*}} 17
>> + // CHECK: in esan::processRangeAccess {{.*}} 17
>> + // CHECK: in esan::finalizeLibrary
>> +}
>>
>> Modified: compiler-rt/trunk/test/esan/TestCases/verbose-simple.c
>> URL:
>> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/test/esan/TestCases/verbose-simple.c?rev=267293&r1=267292&r2=267293&view=diff
>>
>> ==============================================================================
>> --- compiler-rt/trunk/test/esan/TestCases/verbose-simple.c (original)
>> +++ compiler-rt/trunk/test/esan/TestCases/verbose-simple.c Sat Apr 23
>> 11:41:24 2016
>> @@ -1,8 +1,6 @@
>> // RUN: %clang_esan_frag -O0 %s -o %t 2>&1
>> // RUN: %env_esan_opts=verbosity=1 %run %t 2>&1 | FileCheck %s
>>
>> -#include <stdlib.h>
>> -#include <string.h>
>> int main(int argc, char **argv) {
>> // CHECK: in esan::initializeLibrary
>> // CHECK-NEXT: in esan::finalizeLibrary
>>
>>
>> _______________________________________________
>> llvm-commits mailing list
>> llvm-commits at lists.llvm.org
>> http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits
>>
>
>
>
> --
> Teresa Johnson | Software Engineer | tejohnson at google.com |
> 408-460-2413
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20160425/d1d70236/attachment.html>
More information about the llvm-commits
mailing list