This is an archive of the discontinued LLVM Phabricator instance.

Differential D19832

[esan] Use do-while rather than braces for empty interceptors
ClosedPublic

Authored by bruening on May 2 2016, 1:38 PM.

Download Raw Diff

Details

Reviewers

Commits

rG2a141322853f: [esan] Use do-while rather than braces for empty interceptors
rCRT268426: [esan] Use do-while rather than braces for empty interceptors
rL268426: [esan] Use do-while rather than braces for empty interceptors

Summary

Replaces {} with a do..while sequence in esan's empty interceptors to allow
natural use with a trailing semicolon. The sequence uses each argument to
avoid warnings.

Diff Detail

Repository: rL LLVM

Event Timeline

bruening updated this revision to Diff 55888.May 2 2016, 1:38 PM

bruening retitled this revision from to [esan] Use do-while rather than braces for empty interceptors.

bruening updated this object.

bruening added a reviewer: filcab.

bruening added subscribers: zhaoqin, llvm-commits.

Herald added a subscriber: kubamracek. · View Herald TranscriptMay 2 2016, 1:38 PM

LGTM

This revision is now accepted and ready to land.May 3 2016, 10:02 AM

Closed by commit rL268426: [esan] Use do-while rather than braces for empty interceptors (authored by bruening). · Explain WhyMay 3 2016, 12:50 PM

This revision was automatically updated to reflect the committed changes.

Revision Contents

Path

Size

compiler-rt/

trunk/

lib/

esan/

esan_interceptors.cpp

157 lines

Diff 56049

compiler-rt/trunk/lib/esan/esan_interceptors.cpp

	Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Lines

	#define COMMON_INTERCEPTOR_READ_RANGE(ctx, ptr, size) \			#define COMMON_INTERCEPTOR_READ_RANGE(ctx, ptr, size) \
	processRangeAccess(CUR_PC(), (uptr)ptr, size, false)			processRangeAccess(CUR_PC(), (uptr)ptr, size, false)

	// This is only called if the app explicitly calls exit(), not on			// This is only called if the app explicitly calls exit(), not on
	// a normal exit.			// a normal exit.
	#define COMMON_INTERCEPTOR_ON_EXIT(ctx) finalizeLibrary()			#define COMMON_INTERCEPTOR_ON_EXIT(ctx) finalizeLibrary()

	#define COMMON_INTERCEPTOR_FILE_OPEN(ctx, file, path) {}			#define COMMON_INTERCEPTOR_FILE_OPEN(ctx, file, path) \
	#define COMMON_INTERCEPTOR_FILE_CLOSE(ctx, file) {}			do { \
	#define COMMON_INTERCEPTOR_LIBRARY_LOADED(filename, handle) {}			(void)(ctx); \
	#define COMMON_INTERCEPTOR_LIBRARY_UNLOADED() {}			(void)(file); \
	#define COMMON_INTERCEPTOR_ACQUIRE(ctx, u) {}			(void)(path); \
	#define COMMON_INTERCEPTOR_RELEASE(ctx, u) {}			} while (false)
	#define COMMON_INTERCEPTOR_DIR_ACQUIRE(ctx, path) {}			#define COMMON_INTERCEPTOR_FILE_CLOSE(ctx, file) \
	#define COMMON_INTERCEPTOR_FD_ACQUIRE(ctx, fd) {}			do { \
	#define COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd) {}			(void)(ctx); \
	#define COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd) {}			(void)(file); \
	#define COMMON_INTERCEPTOR_FD_SOCKET_ACCEPT(ctx, fd, newfd) {}			} while (false)
	#define COMMON_INTERCEPTOR_SET_THREAD_NAME(ctx, name) {}			#define COMMON_INTERCEPTOR_LIBRARY_LOADED(filename, handle) \
	#define COMMON_INTERCEPTOR_SET_PTHREAD_NAME(ctx, thread, name) {}			do { \
				(void)(filename); \
				(void)(handle); \
				} while (false)
				#define COMMON_INTERCEPTOR_LIBRARY_UNLOADED() \
				do { \
				} while (false)
				#define COMMON_INTERCEPTOR_ACQUIRE(ctx, u) \
				do { \
				(void)(ctx); \
				(void)(u); \
				} while (false)
				#define COMMON_INTERCEPTOR_RELEASE(ctx, u) \
				do { \
				(void)(ctx); \
				(void)(u); \
				} while (false)
				#define COMMON_INTERCEPTOR_DIR_ACQUIRE(ctx, path) \
				do { \
				(void)(ctx); \
				(void)(path); \
				} while (false)
				#define COMMON_INTERCEPTOR_FD_ACQUIRE(ctx, fd) \
				do { \
				(void)(ctx); \
				(void)(fd); \
				} while (false)
				#define COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd) \
				do { \
				(void)(ctx); \
				(void)(fd); \
				} while (false)
				#define COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd) \
				do { \
				(void)(ctx); \
				(void)(fd); \
				} while (false)
				#define COMMON_INTERCEPTOR_FD_SOCKET_ACCEPT(ctx, fd, newfd) \
				do { \
				(void)(ctx); \
				(void)(fd); \
				(void)(newfd); \
				} while (false)
				#define COMMON_INTERCEPTOR_SET_THREAD_NAME(ctx, name) \
				do { \
				(void)(ctx); \
				(void)(name); \
				} while (false)
				#define COMMON_INTERCEPTOR_SET_PTHREAD_NAME(ctx, thread, name) \
				do { \
				(void)(ctx); \
				(void)(thread); \
				(void)(name); \
				} while (false)
	#define COMMON_INTERCEPTOR_BLOCK_REAL(name) REAL(name)			#define COMMON_INTERCEPTOR_BLOCK_REAL(name) REAL(name)
	#define COMMON_INTERCEPTOR_MUTEX_LOCK(ctx, m) {}			#define COMMON_INTERCEPTOR_MUTEX_LOCK(ctx, m) \
	#define COMMON_INTERCEPTOR_MUTEX_UNLOCK(ctx, m) {}			do { \
	#define COMMON_INTERCEPTOR_MUTEX_REPAIR(ctx, m) {}			(void)(ctx); \
	#define COMMON_INTERCEPTOR_HANDLE_RECVMSG(ctx, msg) {}			(void)(m); \
	#define COMMON_INTERCEPTOR_USER_CALLBACK_START() {}			} while (false)
	#define COMMON_INTERCEPTOR_USER_CALLBACK_END() {}			#define COMMON_INTERCEPTOR_MUTEX_UNLOCK(ctx, m) \
				do { \
				(void)(ctx); \
				(void)(m); \
				} while (false)
				#define COMMON_INTERCEPTOR_MUTEX_REPAIR(ctx, m) \
				do { \
				(void)(ctx); \
				(void)(m); \
				} while (false)
				#define COMMON_INTERCEPTOR_HANDLE_RECVMSG(ctx, msg) \
				do { \
				(void)(ctx); \
				(void)(msg); \
				} while (false)
				#define COMMON_INTERCEPTOR_USER_CALLBACK_START() \
				do { \
				} while (false)
				#define COMMON_INTERCEPTOR_USER_CALLBACK_END() \
				do { \
				} while (false)

	#include "sanitizer_common/sanitizer_common_interceptors.inc"			#include "sanitizer_common/sanitizer_common_interceptors.inc"

	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//
	// Syscall interception			// Syscall interception
	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//

	// We want the caller's PC b/c unlike the other function interceptors these			// 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().			// are separate pre and post functions called around the app's syscall().

	#define COMMON_SYSCALL_PRE_READ_RANGE(ptr, size) \			#define COMMON_SYSCALL_PRE_READ_RANGE(ptr, size) \
	processRangeAccess(GET_CALLER_PC(), (uptr)ptr, size, false)			processRangeAccess(GET_CALLER_PC(), (uptr)ptr, size, false)

	#define COMMON_SYSCALL_PRE_WRITE_RANGE(ptr, size) {}			#define COMMON_SYSCALL_PRE_WRITE_RANGE(ptr, size) \
				do { \
				(void)(ptr); \
				(void)(size); \
				} while (false)

	#define COMMON_SYSCALL_POST_READ_RANGE(ptr, size) {}			#define COMMON_SYSCALL_POST_READ_RANGE(ptr, size) \
				do { \
				(void)(ptr); \
				(void)(size); \
				} while (false)

	// The actual amount written is in post, not pre.			// The actual amount written is in post, not pre.
	#define COMMON_SYSCALL_POST_WRITE_RANGE(ptr, size) \			#define COMMON_SYSCALL_POST_WRITE_RANGE(ptr, size) \
	processRangeAccess(GET_CALLER_PC(), (uptr)ptr, size, true)			processRangeAccess(GET_CALLER_PC(), (uptr)ptr, size, true)

	#define COMMON_SYSCALL_ACQUIRE(addr) {}			#define COMMON_SYSCALL_ACQUIRE(addr) \
	#define COMMON_SYSCALL_RELEASE(addr) { (void)addr; }			do { \
	#define COMMON_SYSCALL_FD_CLOSE(fd) {}			(void)(addr); \
	#define COMMON_SYSCALL_FD_ACQUIRE(fd) {}			} while (false)
	#define COMMON_SYSCALL_FD_RELEASE(fd) {}			#define COMMON_SYSCALL_RELEASE(addr) \
	#define COMMON_SYSCALL_PRE_FORK() {}			do { \
	#define COMMON_SYSCALL_POST_FORK(res) {}			(void)(addr); \
				} while (false)
				#define COMMON_SYSCALL_FD_CLOSE(fd) \
				do { \
				(void)(fd); \
				} while (false)
				#define COMMON_SYSCALL_FD_ACQUIRE(fd) \
				do { \
				(void)(fd); \
				} while (false)
				#define COMMON_SYSCALL_FD_RELEASE(fd) \
				do { \
				(void)(fd); \
				} while (false)
				#define COMMON_SYSCALL_PRE_FORK() \
				do { \
				} while (false)
				#define COMMON_SYSCALL_POST_FORK(res) \
				do { \
				(void)(res); \
				} while (false)

	#include "sanitizer_common/sanitizer_common_syscalls.inc"			#include "sanitizer_common/sanitizer_common_syscalls.inc"

	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//
	// Custom interceptors			// Custom interceptors
	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//

	// TODO(bruening): move more of these to the common interception pool as they			// TODO(bruening): move more of these to the common interception pool as they
	▲ Show 20 Lines • Show All 215 Lines • Show Last 20 Lines