You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
268 lines
14 KiB
268 lines
14 KiB
##############################################################
|
|
#
|
|
# This file includes all the test targets as well as all the
|
|
# non-default build rules and test recipes.
|
|
#
|
|
##############################################################
|
|
|
|
|
|
##############################################################
|
|
#
|
|
# Test targets
|
|
#
|
|
##############################################################
|
|
|
|
###### Place all generic definitions here ######
|
|
|
|
# This defines tests which run tools of the same name. This is simply for convenience to avoid
|
|
# defining the test name twice (once in TOOL_ROOTS and again in TEST_ROOTS).
|
|
# Tests defined here should not be defined in TOOL_ROOTS and TEST_ROOTS.
|
|
TEST_TOOL_ROOTS := icache dcache allcache dcache_xscale_config footprint memalign address_mapping address_mapping_probe \
|
|
memory_limit malloc_stress
|
|
|
|
# This defines the tests to be run that were not already defined in TEST_TOOL_ROOTS.
|
|
TEST_ROOTS := memory_allocation_access_protection new_delete address_mapping_oom address_mapping_zero check_memory_access
|
|
|
|
# This defines the tools which will be run during the the tests, and were not already defined in
|
|
# TEST_TOOL_ROOTS.
|
|
TOOL_ROOTS := memory_allocation_from_app_access_protection_tool memory_allocation_from_tool_access_protection_tool \
|
|
new_delete_tool check_memory_access_tool
|
|
|
|
# This defines all the applications that will be run during the tests.
|
|
APP_ROOTS := access_protection_app new_delete_app mmap_reader_app check_memory_access_app
|
|
|
|
# This defines any additional object files that need to be compiled.
|
|
OBJECT_ROOTS :=
|
|
|
|
# This defines any additional dlls (shared objects), other than the pintools, that need to be compiled.
|
|
DLL_ROOTS :=
|
|
|
|
# This defines any static libraries (archives), that need to be built.
|
|
LIB_ROOTS :=
|
|
|
|
###### Place architecture-specific definitions here ######
|
|
|
|
ifeq ($(TARGET),intel64)
|
|
TEST_TOOL_ROOTS += big_malloc
|
|
endif
|
|
|
|
###### Place OS-specific definitions here ######
|
|
|
|
# Linux
|
|
ifeq ($(TARGET_OS),linux)
|
|
TEST_TOOL_ROOTS += memalloc memalloc2 restrict_memory_vdso
|
|
TEST_ROOTS += restrict_memory restrict_memory_stack
|
|
APP_ROOTS += print_vdso print_vvar print_stack
|
|
endif
|
|
|
|
# Windows
|
|
ifeq ($(TARGET_OS),windows)
|
|
TEST_TOOL_ROOTS += memalloc memalloc2
|
|
endif
|
|
|
|
###### Handle exceptions here ######
|
|
|
|
# see mantis 4497
|
|
ifeq ($(TARGET_DOCKER),1)
|
|
TEST_TOOL_ROOTS := $(filter-out restrict_memory_vdso, $(TEST_TOOL_ROOTS))
|
|
TEST_ROOTS := $(filter-out restrict_memory_stack, $(TEST_ROOTS))
|
|
endif
|
|
|
|
###### Define the sanity subset ######
|
|
|
|
# This defines the list of tests that should run in sanity. It should include all the tests listed in
|
|
# TEST_TOOL_ROOTS and TEST_ROOTS excluding only unstable tests.
|
|
SANITY_SUBSET := $(TEST_TOOL_ROOTS) $(TEST_ROOTS)
|
|
|
|
|
|
##############################################################
|
|
#
|
|
# Test recipes
|
|
#
|
|
##############################################################
|
|
|
|
# This section contains recipes for tests other than the default.
|
|
# See makefile.default.rules for the default test rules.
|
|
# All tests in this section should adhere to the naming convention: <testname>.test
|
|
|
|
check_memory_access.test: $(OBJDIR)check_memory_access_tool$(PINTOOL_SUFFIX) $(OBJDIR)check_memory_access_app$(EXE_SUFFIX)
|
|
$(PIN) -t $(OBJDIR)check_memory_access_tool$(PINTOOL_SUFFIX) -- $(OBJDIR)check_memory_access_app$(EXE_SUFFIX)
|
|
|
|
# Checks the correctness of the APIs: PIN_CheckReadAccess and PIN_CheckWriteAccess.
|
|
memory_allocation_access_protection.test: $(OBJDIR)memory_allocation_from_tool_access_protection_tool$(PINTOOL_SUFFIX) $(OBJDIR)memory_allocation_from_app_access_protection_tool$(PINTOOL_SUFFIX) $(OBJDIR)access_protection_app$(EXE_SUFFIX)
|
|
$(PIN) -t $(OBJDIR)memory_allocation_from_tool_access_protection_tool$(PINTOOL_SUFFIX) \
|
|
-o $(OBJDIR)memory_allocation_from_tool_access_protection.out -- $(OBJDIR)access_protection_app$(EXE_SUFFIX) 2
|
|
$(QGREP) "0011" $(OBJDIR)memory_allocation_from_tool_access_protection.out
|
|
$(PIN) -t $(OBJDIR)memory_allocation_from_app_access_protection_tool$(PINTOOL_SUFFIX) \
|
|
-o $(OBJDIR)memory_allocation_from_app_access_protection.out -- $(OBJDIR)access_protection_app$(EXE_SUFFIX) 1
|
|
$(QGREP) "00" $(OBJDIR)memory_allocation_from_app_access_protection.out
|
|
$(QGREP) "11" $(OBJDIR)memory_allocation_from_app_access_protection.out
|
|
$(RM) $(OBJDIR)memory_allocation_from_app_access_protection.out
|
|
$(RM) $(OBJDIR)memory_allocation_from_tool_access_protection.out
|
|
|
|
# In this test the tool does repeated mallocs in it's Fini function until it gets a NULL return value
|
|
# It tests that PIN's malloc supplied to the tool correctly returns NULL when out of memory
|
|
# A separate test is still needed to get PIN to internally exhaust memory and see that PIN
|
|
# outputs the "Out of memory" message to the pin logfile before exiting.
|
|
memalloc.test: $(OBJDIR)memalloc$(PINTOOL_SUFFIX) $(TESTAPP)
|
|
$(RM) -f $(OBJDIR)memalloc.out
|
|
$(PIN) -t $(OBJDIR)memalloc$(PINTOOL_SUFFIX) -o $(OBJDIR)memalloc.out -- $(TESTAPP) makefile $(OBJDIR)memalloc.makefile.copy
|
|
$(QGREP) NULL $(OBJDIR)memalloc.out
|
|
$(RM) $(OBJDIR)memalloc.out $(OBJDIR)memalloc.makefile.copy
|
|
|
|
memalloc2.test: $(OBJDIR)memalloc2$(PINTOOL_SUFFIX) $(TESTAPP)
|
|
$(RM) -f $(OBJDIR)memalloc2.out
|
|
$(PIN) -t $(OBJDIR)memalloc2$(PINTOOL_SUFFIX) -o $(OBJDIR)memalloc2.out -- $(TESTAPP) makefile $(OBJDIR)memalloc2.makefile.copy
|
|
$(QGREP) OutOfMem $(OBJDIR)memalloc2.out
|
|
$(RM) $(OBJDIR)memalloc2.out $(OBJDIR)memalloc2.makefile.copy
|
|
|
|
new_delete.test: $(OBJDIR)new_delete_tool$(PINTOOL_SUFFIX) $(OBJDIR)new_delete_app$(EXE_SUFFIX)
|
|
$(PIN) -xyzzy -statistic -logfile $(OBJDIR)new_delete.log -t $(OBJDIR)new_delete_tool$(PINTOOL_SUFFIX) \
|
|
-- $(OBJDIR)new_delete_app$(EXE_SUFFIX)
|
|
numToolBytes=`$(GREP) 'mem::bytes::RawMmap/tool ' ./$(OBJDIR)new_delete.log | $(SED) -e 's/.*norm: *[0-9\.]*//' | $(SED) -e 's/\/.*//' | $(SED) -e 's/,//g'`; \
|
|
$(BASHTEST) `$(EXPR) $$numToolBytes \< 2400000` -eq "1"
|
|
$(RM) $(OBJDIR)new_delete.log
|
|
|
|
memalign.test: $(OBJDIR)memalign$(PINTOOL_SUFFIX) $(TESTAPP)
|
|
$(RM) -f $(OBJDIR)memalign.out
|
|
$(PIN) -t $(OBJDIR)memalign$(PINTOOL_SUFFIX) -o $(OBJDIR)memalign.out \
|
|
-- $(TESTAPP) makefile $(OBJDIR)memalign.makefile.copy
|
|
$(RM) $(OBJDIR)memalign.out $(OBJDIR)memalign.makefile.copy
|
|
|
|
# The following variables are used when testing the various memory range knobs (see tests below).
|
|
ZERO_BASED_REGION := 0:0x80000000
|
|
|
|
ifeq ($(TARGET),ia32)
|
|
MEMORY_BOUNDARY_TO_CHECK := 0xBadBeef:0x1BadBeef
|
|
CC_BOUNDARY_TO_CHECK := 0x1BadBeef:0x3BadBeef
|
|
PIN_IMAGE_RANGE := 0x50000000:0x60000000
|
|
PIN_IMAGE_RANGE_PARAM := -pin_image_memory_range $(PIN_IMAGE_RANGE)
|
|
PIN_RESTRICT_RANGE_PARAM := -restrict_memory 0x1048000:0x1058000
|
|
endif
|
|
ifeq ($(TARGET),intel64)
|
|
MEMORY_BOUNDARY_TO_CHECK := 0x20BadBeef:0x21BadBeef
|
|
CC_BOUNDARY_TO_CHECK := 0x30BadBeef:0x32BadBeef
|
|
PIN_IMAGE_RANGE := 0x500000000:0x600000000
|
|
PIN_IMAGE_RANGE_PARAM := -pin_image_memory_range $(PIN_IMAGE_RANGE)
|
|
PIN_RESTRICT_RANGE_PARAM := -restrict_memory 0x304000000:0x304010000
|
|
endif
|
|
ifeq ($(TARGET_OS),mac)
|
|
ifeq ($(TARGET),intel64)
|
|
# On macOS* 64 bit the lowest 4GB cannot be allocated so we're using
|
|
# the region 0:0x180000000 which is actually 0x100000000:0x180000000
|
|
ZERO_BASED_REGION := 0:0x180000000
|
|
endif
|
|
endif
|
|
# -pin_image_memory_range is not supported on Windows.
|
|
ifeq ($(TARGET_OS),windows)
|
|
PIN_IMAGE_RANGE := 0:0
|
|
PIN_IMAGE_RANGE_PARAM :=
|
|
endif
|
|
|
|
# The following tests check the memory range knobs.
|
|
address_mapping.test: $(OBJDIR)address_mapping$(PINTOOL_SUFFIX) $(OBJDIR)mmap_reader_app$(EXE_SUFFIX)
|
|
$(RM) -f $(OBJDIR)address_mapping.out $(OBJDIR)mmap_reader_app.out
|
|
$(PIN) -xyzzy -cc_memory_range $(CC_BOUNDARY_TO_CHECK) -pin_memory_range $(MEMORY_BOUNDARY_TO_CHECK) \
|
|
$(PIN_IMAGE_RANGE_PARAM) \
|
|
-t $(OBJDIR)address_mapping$(PINTOOL_SUFFIX) -o $(OBJDIR)address_mapping.out -c $(CC_BOUNDARY_TO_CHECK) \
|
|
-b $(MEMORY_BOUNDARY_TO_CHECK) -- $(OBJDIR)mmap_reader_app$(EXE_SUFFIX) > $(OBJDIR)mmap_reader_app.out
|
|
$(QGREP) "Test successful" $(OBJDIR)address_mapping.out
|
|
if [ "$(PIN_IMAGE_RANGE)" != "0:0" ]; then \
|
|
$(QGREP) "\<0*$(word 2, $(subst x, , $(subst :, ,$(PIN_IMAGE_RANGE))))-.*/pin" $(OBJDIR)mmap_reader_app.out && \
|
|
$(QGREP) -- "-0*$(word 4, $(subst x, , $(subst :, ,$(PIN_IMAGE_RANGE))))\>" $(OBJDIR)mmap_reader_app.out; fi
|
|
$(RM) $(OBJDIR)address_mapping.out $(OBJDIR)mmap_reader_app.out
|
|
|
|
# The following tests check the memory range knobs.
|
|
address_mapping_zero.test: $(OBJDIR)address_mapping$(PINTOOL_SUFFIX) $(OBJDIR)mmap_reader_app$(EXE_SUFFIX)
|
|
$(RM) -f $(OBJDIR)address_mapping_zero.out $(OBJDIR)mmap_reader_app_zero.out
|
|
$(PIN) -xyzzy -pin_memory_range $(ZERO_BASED_REGION) \
|
|
-t $(OBJDIR)address_mapping$(PINTOOL_SUFFIX) -o $(OBJDIR)address_mapping_zero.out -c $(ZERO_BASED_REGION) \
|
|
-b $(ZERO_BASED_REGION) -- $(OBJDIR)mmap_reader_app$(EXE_SUFFIX) > $(OBJDIR)mmap_reader_app_zero.out
|
|
$(QGREP) "Test successful" $(OBJDIR)address_mapping_zero.out
|
|
$(RM) $(OBJDIR)address_mapping_zero.out $(OBJDIR)mmap_reader_app_zero.out
|
|
|
|
address_mapping_oom.test: $(OBJDIR)address_mapping$(PINTOOL_SUFFIX) $(TESTAPP)
|
|
$(RM) -f $(OBJDIR)address_mapping_oom.out
|
|
! ( $(PIN) -xyzzy -pin_memory_range $(MEMORY_BOUNDARY_TO_CHECK) -cc_memory_range 0:0 \
|
|
-t $(OBJDIR)address_mapping$(PINTOOL_SUFFIX) -o $(OBJDIR)address_mapping_oom.out -m 1 -b $(MEMORY_BOUNDARY_TO_CHECK) \
|
|
-- $(TESTAPP) makefile $(OBJDIR)address_mapping_oom.makefile.copy )
|
|
$(QGREP) "Failed to allocate dynamic memory" $(OBJDIR)address_mapping_oom.out
|
|
$(RM) $(OBJDIR)address_mapping_oom.out $(OBJDIR)address_mapping_oom.makefile.copy
|
|
|
|
address_mapping_probe.test: $(OBJDIR)address_mapping_probe$(PINTOOL_SUFFIX) $(TESTAPP)
|
|
$(RM) -f $(OBJDIR)address_mapping_probe.out
|
|
$(PIN) -xyzzy -probe -pin_memory_range $(MEMORY_BOUNDARY_TO_CHECK) -cc_memory_range 0:0 \
|
|
-t $(OBJDIR)address_mapping_probe$(PINTOOL_SUFFIX) -o $(OBJDIR)address_mapping_probe.out \
|
|
-b $(MEMORY_BOUNDARY_TO_CHECK) -- $(TESTAPP) makefile $(OBJDIR)address_mapping_probe.makefile.copy
|
|
$(QGREP) "Test successful" $(OBJDIR)address_mapping_probe.out
|
|
$(RM) $(OBJDIR)address_mapping_probe.out $(OBJDIR)address_mapping_probe.makefile.copy
|
|
|
|
NUMBEROFTHREADS := 8
|
|
|
|
malloc_stress.test: $(OBJDIR)malloc_stress$(PINTOOL_SUFFIX) $(HELLO_APP)
|
|
$(PIN) -t $(OBJDIR)malloc_stress$(PINTOOL_SUFFIX) -o $(OBJDIR)malloc_stress.log -n $(NUMBEROFTHREADS) -- $(HELLO_APP) > $(OBJDIR)malloc_stress.out 2>&1
|
|
$(QGREP) "All Threads Created" $(OBJDIR)malloc_stress.log
|
|
$(QGREP) "All threads joined" $(OBJDIR)malloc_stress.log
|
|
$(BASHTEST) `$(CGREP) "Creating thread" $(OBJDIR)malloc_stress.log` -eq $(NUMBEROFTHREADS)
|
|
$(RM) $(OBJDIR)malloc_stress.log $(OBJDIR)malloc_stress.out
|
|
|
|
restrict_memory.test: $(OBJDIR)mmap_reader_app$(EXE_SUFFIX)
|
|
$(RM) -f $(OBJDIR)restrict_memory.out
|
|
$(PIN) $(PIN_RESTRICT_RANGE_PARAM) -- $(OBJDIR)mmap_reader_app$(EXE_SUFFIX) > $(OBJDIR)restrict_memory.out
|
|
! ( $(GREP) "/pin\>" $(OBJDIR)restrict_memory.out | $(QGREP) \
|
|
"\<0*$(word 3, $(subst x, , $(subst :, ,$(PIN_RESTRICT_RANGE_PARAM))))-" )
|
|
$(RM) $(OBJDIR)restrict_memory.out
|
|
|
|
restrict_memory_vdso.test: $(OBJDIR)restrict_memory_vdso$(PINTOOL_SUFFIX) $(OBJDIR)print_vdso$(EXE_SUFFIX) $(OBJDIR)print_vvar$(EXE_SUFFIX) $(DISABLE_ASLR)
|
|
$(RM) -f $(OBJDIR)restrict_memory_vdso.out $(OBJDIR)the_vdso.txt $(OBJDIR)the_vvar.txt
|
|
$(DISABLE_ASLR) $(PIN) -- $(OBJDIR)print_vdso$(EXE_SUFFIX) > $(OBJDIR)the_vdso.txt
|
|
$(DISABLE_ASLR) $(PIN) -restrict-memory `cat $(OBJDIR)the_vdso.txt` \
|
|
-t $(OBJDIR)restrict_memory_vdso$(PINTOOL_SUFFIX) -- $(OBJDIR)print_vdso$(EXE_SUFFIX) \
|
|
> $(OBJDIR)restrict_memory_vdso.out
|
|
$(DISABLE_ASLR) $(PIN) -- $(OBJDIR)print_vvar$(EXE_SUFFIX) > $(OBJDIR)the_vvar.txt
|
|
if [ -s $(OBJDIR)the_vvar.txt ]; then $(DISABLE_ASLR) $(PIN) -restrict-memory `cat $(OBJDIR)the_vvar.txt` \
|
|
-t $(OBJDIR)restrict_memory_vdso$(PINTOOL_SUFFIX) -- $(OBJDIR)print_vvar$(EXE_SUFFIX) \
|
|
> $(OBJDIR)restrict_memory_vdso.out; fi
|
|
$(DISABLE_ASLR) $(PIN) -restrict-memory 0x30000:0x31000 -t $(OBJDIR)restrict_memory_vdso$(PINTOOL_SUFFIX) \
|
|
-success -- $(OBJDIR)print_vdso$(EXE_SUFFIX) > $(OBJDIR)restrict_memory_vdso.out
|
|
$(DISABLE_ASLR) $(PIN) -t $(OBJDIR)restrict_memory_vdso$(PINTOOL_SUFFIX) -success \
|
|
-- $(OBJDIR)print_vdso$(EXE_SUFFIX) > $(OBJDIR)restrict_memory_vdso.out
|
|
$(RM) $(OBJDIR)restrict_memory_vdso.out $(OBJDIR)the_vdso.txt $(OBJDIR)the_vvar.txt
|
|
|
|
restrict_memory_stack.test: $(OBJDIR)print_stack$(EXE_SUFFIX) $(DISABLE_ASLR)
|
|
$(RM) -f $(OBJDIR)restrict_memory_stack.out $(OBJDIR)the_stack.txt
|
|
$(DISABLE_ASLR) $(PIN) -- $(OBJDIR)print_stack$(EXE_SUFFIX) > $(OBJDIR)the_stack.txt
|
|
# The program below will crash if area adjacent to the stack is not maped correctly
|
|
$(DISABLE_ASLR) $(PIN) -xyzzy -reserve_memory $(OBJDIR)the_stack.txt \
|
|
-- $(OBJDIR)print_stack$(EXE_SUFFIX) > $(OBJDIR)restrict_memory_stack.out
|
|
$(RM) $(OBJDIR)restrict_memory_stack.out $(OBJDIR)the_stack.txt
|
|
|
|
memory_limit.test: $(OBJDIR)memory_limit$(PINTOOL_SUFFIX) $(TESTAPP)
|
|
$(RM) -f $(OBJDIR)$(@:.test=.out)
|
|
! ( $(PIN) -pin_memory_size 0x10000000 -t $(OBJDIR)$(@:.test=)$(PINTOOL_SUFFIX) -b 0x10000000 -o $(OBJDIR)$(@:.test=.out) \
|
|
-- $(TESTAPP) makefile $(OBJDIR)$(@:.test=.makefile.copy) )
|
|
$(QGREP) "Failed to allocate dynamic memory with size" $(OBJDIR)$(@:.test=.out)
|
|
$(RM) -f $(OBJDIR)$(@:.test=.out) $(OBJDIR)$(@:.test=.makefile.copy)
|
|
|
|
|
|
##############################################################
|
|
#
|
|
# Build rules
|
|
#
|
|
##############################################################
|
|
|
|
# This section contains the build rules for all binaries that have special build rules.
|
|
# See makefile.default.rules for the default build rules.
|
|
|
|
ifeq ($(TARGET_OS),windows)
|
|
ACCESS_PROTECTION_APP_EXPORTS := /EXPORT:NotifyPinAfterMmap
|
|
endif
|
|
|
|
###### Special applications' build rules ######
|
|
|
|
$(OBJDIR)access_protection_app$(EXE_SUFFIX): access_protection_app.cpp
|
|
$(APP_CXX) $(APP_CXXFLAGS_NOOPT) $(COMP_EXE)$@ $< $(APP_LDFLAGS_NOOPT) $(ACCESS_PROTECTION_APP_EXPORTS) $(APP_LIBS)
|
|
|
|
$(OBJDIR)new_delete_app$(EXE_SUFFIX): new_delete_app.cpp $(THREADLIB)
|
|
$(APP_CXX) $(COMPONENT_INCLUDES) $(APP_CXXFLAGS) $(COMP_EXE)$@ $^ $(APP_LDFLAGS) $(APP_LPATHS) $(APP_LIBS) $(APP_LIB_ATOMIC) $(CXX_LPATHS) $(CXX_LIBS)
|