diff options
40 files changed, 274 insertions, 635 deletions
diff --git a/Android.mk b/Android.mk index 08a1a105b8..1c946292ef 100644 --- a/Android.mk +++ b/Android.mk @@ -245,19 +245,6 @@ endif test-art-host-dexdump: $(addprefix $(HOST_OUT_EXECUTABLES)/, dexdump2 dexlist) ANDROID_HOST_OUT=$(realpath $(HOST_OUT)) art/test/dexdump/run-all-tests -# Valgrind. -.PHONY: valgrind-test-art-host -valgrind-test-art-host: valgrind-test-art-host-gtest - $(hide) $(call ART_TEST_PREREQ_FINISHED,$@) - -.PHONY: valgrind-test-art-host32 -valgrind-test-art-host32: valgrind-test-art-host-gtest32 - $(hide) $(call ART_TEST_PREREQ_FINISHED,$@) - -.PHONY: valgrind-test-art-host64 -valgrind-test-art-host64: valgrind-test-art-host-gtest64 - $(hide) $(call ART_TEST_PREREQ_FINISHED,$@) - ######################################################################## # target test rules @@ -332,19 +319,6 @@ test-art-target-jit$(2ND_ART_PHONY_TEST_TARGET_SUFFIX): test-art-target-run-test $(hide) $(call ART_TEST_PREREQ_FINISHED,$@) endif -# Valgrind. -.PHONY: valgrind-test-art-target -valgrind-test-art-target: valgrind-test-art-target-gtest - $(hide) $(call ART_TEST_PREREQ_FINISHED,$@) - -.PHONY: valgrind-test-art-target32 -valgrind-test-art-target32: valgrind-test-art-target-gtest32 - $(hide) $(call ART_TEST_PREREQ_FINISHED,$@) - -.PHONY: valgrind-test-art-target64 -valgrind-test-art-target64: valgrind-test-art-target-gtest64 - $(hide) $(call ART_TEST_PREREQ_FINISHED,$@) - ####################### # Fake packages for ART diff --git a/build/Android.bp b/build/Android.bp index 2a5598fb7a..3a1d5839f5 100644 --- a/build/Android.bp +++ b/build/Android.bp @@ -127,8 +127,6 @@ art_global_defaults { }, include_dirs: [ - "external/valgrind/include", - "external/valgrind", "external/vixl/src", ], diff --git a/build/Android.gtest.mk b/build/Android.gtest.mk index 7272661860..9f42727a2f 100644 --- a/build/Android.gtest.mk +++ b/build/Android.gtest.mk @@ -408,15 +408,9 @@ endif ART_TEST_HOST_GTEST$(ART_PHONY_TEST_HOST_SUFFIX)_RULES := ART_TEST_HOST_GTEST$(2ND_ART_PHONY_TEST_HOST_SUFFIX)_RULES := ART_TEST_HOST_GTEST_RULES := -ART_TEST_HOST_VALGRIND_GTEST$(ART_PHONY_TEST_HOST_SUFFIX)_RULES := -ART_TEST_HOST_VALGRIND_GTEST$(2ND_ART_PHONY_TEST_HOST_SUFFIX)_RULES := -ART_TEST_HOST_VALGRIND_GTEST_RULES := ART_TEST_TARGET_GTEST$(ART_PHONY_TEST_TARGET_SUFFIX)_RULES := ART_TEST_TARGET_GTEST$(2ND_ART_PHONY_TEST_TARGET_SUFFIX)_RULES := ART_TEST_TARGET_GTEST_RULES := -ART_TEST_TARGET_VALGRIND_GTEST$(ART_PHONY_TEST_TARGET_SUFFIX)_RULES := -ART_TEST_TARGET_VALGRIND_GTEST$(2ND_ART_PHONY_TEST_TARGET_SUFFIX)_RULES := -ART_TEST_TARGET_VALGRIND_GTEST_RULES := ART_TEST_HOST_GTEST_DEPENDENCIES := ART_GTEST_TARGET_ANDROID_ROOT := '/system' @@ -424,40 +418,6 @@ ifneq ($(ART_TEST_ANDROID_ROOT),) ART_GTEST_TARGET_ANDROID_ROOT := $(ART_TEST_ANDROID_ROOT) endif -ART_VALGRIND_TARGET_DEPENDENCIES := - -# Has to match list in external/valgrind/Android.build_one.mk -ART_VALGRIND_SUPPORTED_ARCH := arm arm64 x86_64 - -# Valgrind is not supported for x86 -ifneq (,$(filter $(ART_VALGRIND_SUPPORTED_ARCH),$(TARGET_ARCH))) -art_vg_arch := $(if $(filter x86_64,$(TARGET_ARCH)),amd64,$(TARGET_ARCH)) -ART_VALGRIND_TARGET_DEPENDENCIES += \ - $(TARGET_OUT_EXECUTABLES)/valgrind \ - $(TARGET_OUT_SHARED_LIBRARIES)/valgrind/memcheck-$(art_vg_arch)-linux \ - $(TARGET_OUT_SHARED_LIBRARIES)/valgrind/vgpreload_core-$(art_vg_arch)-linux.so \ - $(TARGET_OUT_SHARED_LIBRARIES)/valgrind/vgpreload_memcheck-$(art_vg_arch)-linux.so \ - $(TARGET_OUT_SHARED_LIBRARIES)/valgrind/default.supp -art_vg_arch := -endif - -ifdef TARGET_2ND_ARCH -ifneq (,$(filter $(ART_VALGRIND_SUPPORTED_ARCH),$(TARGET_2ND_ARCH))) -ART_VALGRIND_TARGET_DEPENDENCIES += \ - $(TARGET_OUT_SHARED_LIBRARIES)/valgrind/memcheck-$(TARGET_2ND_ARCH)-linux \ - $(TARGET_OUT_SHARED_LIBRARIES)/valgrind/vgpreload_core-$(TARGET_2ND_ARCH)-linux.so \ - $(TARGET_OUT_SHARED_LIBRARIES)/valgrind/vgpreload_memcheck-$(TARGET_2ND_ARCH)-linux.so -endif -endif - -include $(CLEAR_VARS) -LOCAL_MODULE := valgrind-target-suppressions.txt -LOCAL_MODULE_CLASS := ETC -LOCAL_MODULE_TAGS := optional -LOCAL_SRC_FILES := test/valgrind-target-suppressions.txt -LOCAL_MODULE_PATH := $(ART_TARGET_TEST_OUT) -include $(BUILD_PREBUILT) - # Define a make rule for a target device gtest. # $(1): gtest name - the name of the test we're building such as leb128_test. # $(2): path relative to $OUT to the test binary @@ -487,11 +447,10 @@ define define-art-gtest-rule-target $$($(3)TARGET_OUT_SHARED_LIBRARIES)/libjavacore.so \ $$($(3)TARGET_OUT_SHARED_LIBRARIES)/libopenjdkd.so \ $$(TARGET_OUT_JAVA_LIBRARIES)/core-libart-testdex.jar \ - $$(TARGET_OUT_JAVA_LIBRARIES)/core-oj-testdex.jar \ - $$(ART_TARGET_TEST_OUT)/valgrind-target-suppressions.txt + $$(TARGET_OUT_JAVA_LIBRARIES)/core-oj-testdex.jar -$$(gtest_rule) valgrind-$$(gtest_rule): PRIVATE_TARGET_EXE := $$(gtest_target_exe) -$$(gtest_rule) valgrind-$$(gtest_rule): PRIVATE_MAYBE_CHROOT_COMMAND := $$(maybe_chroot_command) +$$(gtest_rule): PRIVATE_TARGET_EXE := $$(gtest_target_exe) +$$(gtest_rule): PRIVATE_MAYBE_CHROOT_COMMAND := $$(maybe_chroot_command) # File witnessing the success of the gtest, the presence of which means the gtest's success. gtest_witness := \ @@ -516,37 +475,7 @@ $$(gtest_rule): test-art-target-sync ART_TEST_TARGET_GTEST_RULES += $$(gtest_rule) ART_TEST_TARGET_GTEST_$(1)_RULES += $$(gtest_rule) -# File witnessing the success of the Valgrind gtest, the presence of which means the gtest's -# success. -valgrind_gtest_witness := \ - $$(maybe_art_test_chroot)$(ART_TARGET_TEST_DIR)/$(TARGET_$(3)ARCH)/valgrind-$$(gtest_rule)-$$$$PPID - -valgrind-$$(gtest_rule): PRIVATE_VALGRIND_GTEST_WITNESS := $$(valgrind_gtest_witness) - -.PHONY: valgrind-$$(gtest_rule) -valgrind-$$(gtest_rule): $(ART_VALGRIND_TARGET_DEPENDENCIES) test-art-target-sync - $(hide) adb shell touch $$(PRIVATE_VALGRIND_GTEST_WITNESS) - $(hide) adb shell rm $$(PRIVATE_VALGRIND_GTEST_WITNESS) - $(hide) adb shell $$(PRIVATE_MAYBE_CHROOT_COMMAND) chmod 755 $$(PRIVATE_TARGET_EXE) - $(hide) $$(call ART_TEST_SKIP,$$@) && \ - (adb shell "$$(PRIVATE_MAYBE_CHROOT_COMMAND) env $(GCOV_ENV) LD_LIBRARY_PATH=$(4) \ - ANDROID_ROOT=$(ART_GTEST_TARGET_ANDROID_ROOT) \ - $(ART_GTEST_TARGET_ANDROID_ROOT)/bin/valgrind \ - --leak-check=full --error-exitcode=1 --workaround-gcc296-bugs=yes \ - --suppressions=$(ART_TARGET_TEST_DIR)/valgrind-target-suppressions.txt \ - --num-callers=50 --show-mismatched-frees=no $$(PRIVATE_TARGET_EXE) \ - && touch $$(PRIVATE_VALGRIND_GTEST_WITNESS)" \ - && (adb pull $$(PRIVATE_VALGRIND_GTEST_WITNESS) /tmp/ && $$(call ART_TEST_PASSED,$$@)) \ - || $$(call ART_TEST_FAILED,$$@)) - $(hide) rm -f /tmp/$$@-$$$$PPID - - ART_TEST_TARGET_VALGRIND_GTEST$$($(3)ART_PHONY_TEST_TARGET_SUFFIX)_RULES += \ - valgrind-$$(gtest_rule) - ART_TEST_TARGET_VALGRIND_GTEST_RULES += valgrind-$$(gtest_rule) - ART_TEST_TARGET_VALGRIND_GTEST_$(1)_RULES += valgrind-$$(gtest_rule) - # Clear locally defined variables. - valgrind_gtest_witness := gtest_witness := maybe_chroot_command := maybe_art_test_chroot := @@ -555,16 +484,6 @@ valgrind-$$(gtest_rule): $(ART_VALGRIND_TARGET_DEPENDENCIES) test-art-target-syn gtest_rule := endef # define-art-gtest-rule-target -ART_VALGRIND_DEPENDENCIES := \ - $(HOST_OUT_EXECUTABLES)/valgrind \ - $(HOST_OUT)/lib64/valgrind/memcheck-amd64-linux \ - $(HOST_OUT)/lib64/valgrind/memcheck-x86-linux \ - $(HOST_OUT)/lib64/valgrind/default.supp \ - $(HOST_OUT)/lib64/valgrind/vgpreload_core-amd64-linux.so \ - $(HOST_OUT)/lib64/valgrind/vgpreload_core-x86-linux.so \ - $(HOST_OUT)/lib64/valgrind/vgpreload_memcheck-amd64-linux.so \ - $(HOST_OUT)/lib64/valgrind/vgpreload_memcheck-x86-linux.so - # Define make rules for a host gtests. # $(1): gtest name - the name of the test we're building such as leb128_test. # $(2): path relative to $OUT to the test binary @@ -616,19 +535,6 @@ endif ART_TEST_HOST_GTEST_$(1)_RULES += $$(gtest_rule) -.PHONY: valgrind-$$(gtest_rule) -valgrind-$$(gtest_rule): $$(gtest_exe) $$(gtest_deps) $(ART_VALGRIND_DEPENDENCIES) - $(hide) $$(call ART_TEST_SKIP,$$@) && \ - VALGRIND_LIB=$(HOST_OUT)/lib64/valgrind \ - $(HOST_OUT_EXECUTABLES)/valgrind --leak-check=full --error-exitcode=1 \ - --suppressions=art/test/valgrind-suppressions.txt --num-callers=50 \ - $$< && \ - $$(call ART_TEST_PASSED,$$@) || $$(call ART_TEST_FAILED,$$@) - - ART_TEST_HOST_VALGRIND_GTEST$$($(3)ART_PHONY_TEST_HOST_SUFFIX)_RULES += valgrind-$$(gtest_rule) - ART_TEST_HOST_VALGRIND_GTEST_RULES += valgrind-$$(gtest_rule) - ART_TEST_HOST_VALGRIND_GTEST_$(1)_RULES += valgrind-$$(gtest_rule) - # Clear locally defined variables. gtest_deps := gtest_exe := @@ -661,7 +567,6 @@ define define-art-gtest-target ifndef ART_TEST_TARGET_GTEST_$$(art_gtest_name)_RULES ART_TEST_TARGET_GTEST_$$(art_gtest_name)_RULES := - ART_TEST_TARGET_VALGRIND_GTEST_$$(art_gtest_name)_RULES := endif $$(eval $$(call define-art-gtest-rule-target,$$(art_gtest_name),$$(art_gtest_filename),$(2),$$($(2)library_path))) @@ -681,7 +586,6 @@ define define-art-gtest-host art_gtest_name := $$(notdir $$(basename $$(art_gtest_filename))) ifndef ART_TEST_HOST_GTEST_$$(art_gtest_name)_RULES ART_TEST_HOST_GTEST_$$(art_gtest_name)_RULES := - ART_TEST_HOST_VALGRIND_GTEST_$$(art_gtest_name)_RULES := endif $$(eval $$(call define-art-gtest-rule-host,$$(art_gtest_name),$$(art_gtest_filename),$(2))) @@ -700,13 +604,8 @@ define define-art-gtest-target-both test-art-target-gtest-$$(art_gtest_name): $$(ART_TEST_TARGET_GTEST_$$(art_gtest_name)_RULES) $$(hide) $$(call ART_TEST_PREREQ_FINISHED,$$@) -.PHONY: valgrind-test-art-target-gtest-$$(art_gtest_name) -valgrind-test-art-target-gtest-$$(art_gtest_name): $$(ART_TEST_TARGET_VALGRIND_GTEST_$$(art_gtest_name)_RULES) - $$(hide) $$(call ART_TEST_PREREQ_FINISHED,$$@) - # Clear now unused variables. ART_TEST_TARGET_GTEST_$$(art_gtest_name)_RULES := - ART_TEST_TARGET_VALGRIND_GTEST_$$(art_gtest_name)_RULES := art_gtest_name := endef # define-art-gtest-target-both @@ -719,13 +618,8 @@ define define-art-gtest-host-both test-art-host-gtest-$$(art_gtest_name): $$(ART_TEST_HOST_GTEST_$$(art_gtest_name)_RULES) $$(hide) $$(call ART_TEST_PREREQ_FINISHED,$$@) -.PHONY: valgrind-test-art-host-gtest-$$(art_gtest_name) -valgrind-test-art-host-gtest-$$(art_gtest_name): $$(ART_TEST_HOST_VALGRIND_GTEST_$$(art_gtest_name)_RULES) - $$(hide) $$(call ART_TEST_PREREQ_FINISHED,$$@) - # Clear now unused variables. ART_TEST_HOST_GTEST_$$(art_gtest_name)_RULES := - ART_TEST_HOST_VALGRIND_GTEST_$$(art_gtest_name)_RULES := art_gtest_name := endef # define-art-gtest-host-both @@ -751,12 +645,11 @@ RUNTIME_TARGET_GTEST_MAKE_TARGETS := $(foreach file, $(ART_TARGET_GTEST_FILES), $(eval RUNTIME_TARGET_GTEST_MAKE_TARGETS += $$(notdir $$(patsubst %/,%,$$(dir $$(file))))_$$(notdir $$(basename $$(file))))) COMPILER_TARGET_GTEST_MAKE_TARGETS := -# Define all the combinations of host/target, valgrind and suffix such as: -# test-art-host-gtest or valgrind-test-art-host-gtest64 +# Define all the combinations of host/target and suffix such as: +# test-art-host-gtest or test-art-host-gtest64 # $(1): host or target # $(2): HOST or TARGET -# $(3): valgrind- or undefined -# $(4): undefined, 32 or 64 +# $(3): undefined, 32 or 64 define define-test-art-gtest-combination ifeq ($(1),host) ifneq ($(2),HOST) @@ -771,12 +664,8 @@ define define-test-art-gtest-combination endif endif - rule_name := $(3)test-art-$(1)-gtest$(4) - ifeq ($(3),valgrind-) - dependencies := $$(ART_TEST_$(2)_VALGRIND_GTEST$(4)_RULES) - else - dependencies := $$(ART_TEST_$(2)_GTEST$(4)_RULES) - endif + rule_name := test-art-$(1)-gtest$(3) + dependencies := $$(ART_TEST_$(2)_GTEST$(3)_RULES) .PHONY: $$(rule_name) $$(rule_name): $$(dependencies) dx d8-compat-dx desugar @@ -787,21 +676,15 @@ $$(rule_name): $$(dependencies) dx d8-compat-dx desugar dependencies := endef # define-test-art-gtest-combination -$(eval $(call define-test-art-gtest-combination,target,TARGET,,)) -$(eval $(call define-test-art-gtest-combination,target,TARGET,valgrind-,)) -$(eval $(call define-test-art-gtest-combination,target,TARGET,,$(ART_PHONY_TEST_TARGET_SUFFIX))) -$(eval $(call define-test-art-gtest-combination,target,TARGET,valgrind-,$(ART_PHONY_TEST_TARGET_SUFFIX))) +$(eval $(call define-test-art-gtest-combination,target,TARGET,)) +$(eval $(call define-test-art-gtest-combination,target,TARGET,$(ART_PHONY_TEST_TARGET_SUFFIX))) ifdef 2ND_ART_PHONY_TEST_TARGET_SUFFIX -$(eval $(call define-test-art-gtest-combination,target,TARGET,,$(2ND_ART_PHONY_TEST_TARGET_SUFFIX))) -$(eval $(call define-test-art-gtest-combination,target,TARGET,valgrind-,$(2ND_ART_PHONY_TEST_TARGET_SUFFIX))) +$(eval $(call define-test-art-gtest-combination,target,TARGET,$(2ND_ART_PHONY_TEST_TARGET_SUFFIX))) endif -$(eval $(call define-test-art-gtest-combination,host,HOST,,)) -$(eval $(call define-test-art-gtest-combination,host,HOST,valgrind-,)) -$(eval $(call define-test-art-gtest-combination,host,HOST,,$(ART_PHONY_TEST_HOST_SUFFIX))) -$(eval $(call define-test-art-gtest-combination,host,HOST,valgrind-,$(ART_PHONY_TEST_HOST_SUFFIX))) +$(eval $(call define-test-art-gtest-combination,host,HOST,)) +$(eval $(call define-test-art-gtest-combination,host,HOST,$(ART_PHONY_TEST_HOST_SUFFIX))) ifneq ($(HOST_PREFER_32_BIT),true) -$(eval $(call define-test-art-gtest-combination,host,HOST,,$(2ND_ART_PHONY_TEST_HOST_SUFFIX))) -$(eval $(call define-test-art-gtest-combination,host,HOST,valgrind-,$(2ND_ART_PHONY_TEST_HOST_SUFFIX))) +$(eval $(call define-test-art-gtest-combination,host,HOST,$(2ND_ART_PHONY_TEST_HOST_SUFFIX))) endif # Clear locally defined variables. @@ -818,15 +701,9 @@ COMPILER_GTEST_HOST_SRC_FILES := ART_TEST_HOST_GTEST$(ART_PHONY_TEST_HOST_SUFFIX)_RULES := ART_TEST_HOST_GTEST$(2ND_ART_PHONY_TEST_HOST_SUFFIX)_RULES := ART_TEST_HOST_GTEST_RULES := -ART_TEST_HOST_VALGRIND_GTEST$(ART_PHONY_TEST_HOST_SUFFIX)_RULES := -ART_TEST_HOST_VALGRIND_GTEST$(2ND_ART_PHONY_TEST_HOST_SUFFIX)_RULES := -ART_TEST_HOST_VALGRIND_GTEST_RULES := ART_TEST_TARGET_GTEST$(ART_PHONY_TEST_TARGET_SUFFIX)_RULES := ART_TEST_TARGET_GTEST$(2ND_ART_PHONY_TEST_TARGET_SUFFIX)_RULES := ART_TEST_TARGET_GTEST_RULES := -ART_TEST_TARGET_VALGRIND_GTEST$(ART_PHONY_TEST_TARGET_SUFFIX)_RULES := -ART_TEST_TARGET_VALGRIND_GTEST$(2ND_ART_PHONY_TEST_TARGET_SUFFIX)_RULES := -ART_TEST_TARGET_VALGRIND_GTEST_RULES := ART_GTEST_TARGET_ANDROID_ROOT := ART_GTEST_class_linker_test_DEX_DEPS := ART_GTEST_class_table_test_DEX_DEPS := @@ -865,8 +742,6 @@ ART_GTEST_transaction_test_DEX_DEPS := ART_GTEST_dex2oat_environment_tests_DEX_DEPS := ART_GTEST_heap_verification_test_DEX_DEPS := ART_GTEST_verifier_deps_test_DEX_DEPS := -ART_VALGRIND_DEPENDENCIES := -ART_VALGRIND_TARGET_DEPENDENCIES := $(foreach dir,$(GTEST_DEX_DIRECTORIES), $(eval ART_TEST_TARGET_GTEST_$(dir)_DEX :=)) $(foreach dir,$(GTEST_DEX_DIRECTORIES), $(eval ART_TEST_HOST_GTEST_$(dir)_DEX :=)) ART_TEST_HOST_GTEST_MainStripped_DEX := diff --git a/build/Android.oat.mk b/build/Android.oat.mk index 517ac5c28d..ba3ef053de 100644 --- a/build/Android.oat.mk +++ b/build/Android.oat.mk @@ -37,11 +37,9 @@ else endif # Use dex2oat debug version for better error reporting -# $(1): compiler - optimizing, interpreter or interpreter-access-checks. +# $(1): compiler - optimizing, interpreter or interp-ac (interpreter-access-checks). # $(2): 2ND_ or undefined, 2ND_ for 32-bit host builds. -# $(3): wrapper, e.g., valgrind. -# $(4): dex2oat suffix, e.g, valgrind requires 32 right now. -# $(5): multi-image. +# $(3): multi-image. # NB depending on HOST_CORE_DEX_LOCATIONS so we are sure to have the dex files in frameworks for # run-test --no-image define create-core-oat-host-rules @@ -65,11 +63,11 @@ define create-core-oat-host-rules endif ifneq ($(filter-out interpreter interp-ac optimizing,$(1)),) #Technically this test is not precise, but hopefully good enough. - $$(error found $(1) expected interpreter, interpreter-access-checks, or optimizing) + $$(error found $(1) expected interpreter, interp-ac, or optimizing) endif - # If $(5) is true, generate a multi-image. - ifeq ($(5),true) + # If $(3) is true, generate a multi-image. + ifeq ($(3),true) core_multi_infix := -multi core_multi_param := --multi-image --no-inline-from=core-oj-hostdex.jar core_multi_group := _multi @@ -79,22 +77,18 @@ define create-core-oat-host-rules core_multi_group := endif - core_image_name := $($(2)HOST_CORE_IMG_OUT_BASE)$$(core_infix)$$(core_multi_infix)$(3)$(CORE_IMG_SUFFIX) - core_oat_name := $($(2)HOST_CORE_OAT_OUT_BASE)$$(core_infix)$$(core_multi_infix)$(3)$(CORE_OAT_SUFFIX) + core_image_name := $($(2)HOST_CORE_IMG_OUT_BASE)$$(core_infix)$$(core_multi_infix)$(CORE_IMG_SUFFIX) + core_oat_name := $($(2)HOST_CORE_OAT_OUT_BASE)$$(core_infix)$$(core_multi_infix)$(CORE_OAT_SUFFIX) # Using the bitness suffix makes it easier to add as a dependency for the run-test mk. ifeq ($(2),) - $(3)HOST_CORE_IMAGE_$(1)$$(core_multi_group)_64 := $$(core_image_name) + HOST_CORE_IMAGE_$(1)$$(core_multi_group)_64 := $$(core_image_name) else - $(3)HOST_CORE_IMAGE_$(1)$$(core_multi_group)_32 := $$(core_image_name) + HOST_CORE_IMAGE_$(1)$$(core_multi_group)_32 := $$(core_image_name) endif - $(3)HOST_CORE_IMG_OUTS += $$(core_image_name) - $(3)HOST_CORE_OAT_OUTS += $$(core_oat_name) + HOST_CORE_IMG_OUTS += $$(core_image_name) + HOST_CORE_OAT_OUTS += $$(core_oat_name) - # If we have a wrapper, make the target phony. - ifneq ($(3),) -.PHONY: $$(core_image_name) - endif $$(core_image_name): PRIVATE_CORE_COMPILE_OPTIONS := $$(core_compile_options) $$(core_image_name): PRIVATE_CORE_IMG_NAME := $$(core_image_name) $$(core_image_name): PRIVATE_CORE_OAT_NAME := $$(core_oat_name) @@ -102,7 +96,7 @@ $$(core_image_name): PRIVATE_CORE_MULTI_PARAM := $$(core_multi_param) $$(core_image_name): $$(HOST_CORE_DEX_LOCATIONS) $$(core_dex2oat_dependency) @echo "host dex2oat: $$@" @mkdir -p $$(dir $$@) - $$(hide) $(3) $$(DEX2OAT)$(4) --runtime-arg -Xms$(DEX2OAT_IMAGE_XMS) \ + $$(hide) $$(DEX2OAT) --runtime-arg -Xms$(DEX2OAT_IMAGE_XMS) \ --runtime-arg -Xmx$(DEX2OAT_IMAGE_XMX) \ --image-classes=$$(PRELOADED_CLASSES) $$(addprefix --dex-file=,$$(HOST_CORE_DEX_FILES)) \ $$(addprefix --dex-location=,$$(HOST_CORE_DEX_LOCATIONS)) --oat-file=$$(PRIVATE_CORE_OAT_NAME) \ @@ -124,35 +118,27 @@ $$(core_oat_name): $$(core_image_name) core_infix := endef # create-core-oat-host-rules -# $(1): compiler - optimizing, interpreter or interpreter-access-checks. -# $(2): wrapper. -# $(3): dex2oat suffix. -# $(4): multi-image. +# $(1): compiler - optimizing, interpreter or interp-ac (interpreter-access-checks). +# $(2): multi-image. define create-core-oat-host-rule-combination - $(call create-core-oat-host-rules,$(1),,$(2),$(3),$(4)) + $(call create-core-oat-host-rules,$(1),,$(2)) ifneq ($(HOST_PREFER_32_BIT),true) - $(call create-core-oat-host-rules,$(1),2ND_,$(2),$(3),$(4)) + $(call create-core-oat-host-rules,$(1),2ND_,$(2)) endif endef -$(eval $(call create-core-oat-host-rule-combination,optimizing,,,false)) -$(eval $(call create-core-oat-host-rule-combination,interpreter,,,false)) -$(eval $(call create-core-oat-host-rule-combination,interp-ac,,,false)) -$(eval $(call create-core-oat-host-rule-combination,optimizing,,,true)) -$(eval $(call create-core-oat-host-rule-combination,interpreter,,,true)) -$(eval $(call create-core-oat-host-rule-combination,interp-ac,,,true)) - -valgrindHOST_CORE_IMG_OUTS := -valgrindHOST_CORE_OAT_OUTS := -$(eval $(call create-core-oat-host-rule-combination,optimizing,valgrind,32,false)) -$(eval $(call create-core-oat-host-rule-combination,interpreter,valgrind,32,false)) -$(eval $(call create-core-oat-host-rule-combination,interp-ac,valgrind,32,false)) - -valgrind-test-art-host-dex2oat-host: $(valgrindHOST_CORE_IMG_OUTS) +$(eval $(call create-core-oat-host-rule-combination,optimizing,false)) +$(eval $(call create-core-oat-host-rule-combination,interpreter,false)) +$(eval $(call create-core-oat-host-rule-combination,interp-ac,false)) +$(eval $(call create-core-oat-host-rule-combination,optimizing,true)) +$(eval $(call create-core-oat-host-rule-combination,interpreter,true)) +$(eval $(call create-core-oat-host-rule-combination,interp-ac,true)) test-art-host-dex2oat-host: $(HOST_CORE_IMG_OUTS) +# $(1): compiler - optimizing, interpreter or interp-ac (interpreter-access-checks). +# $(2): 2ND_ or undefined define create-core-oat-target-rules core_compile_options := core_image_name := @@ -176,36 +162,32 @@ define create-core-oat-target-rules endif ifneq ($(filter-out interpreter interp-ac optimizing,$(1)),) # Technically this test is not precise, but hopefully good enough. - $$(error found $(1) expected interpreter, interpreter-access-checks, or optimizing) + $$(error found $(1) expected interpreter, interp-ac, or optimizing) endif - core_image_name := $($(2)TARGET_CORE_IMG_OUT_BASE)$$(core_infix)$(3)$(CORE_IMG_SUFFIX) - core_oat_name := $($(2)TARGET_CORE_OAT_OUT_BASE)$$(core_infix)$(3)$(CORE_OAT_SUFFIX) + core_image_name := $($(2)TARGET_CORE_IMG_OUT_BASE)$$(core_infix)$(CORE_IMG_SUFFIX) + core_oat_name := $($(2)TARGET_CORE_OAT_OUT_BASE)$$(core_infix)$(CORE_OAT_SUFFIX) # Using the bitness suffix makes it easier to add as a dependency for the run-test mk. ifeq ($(2),) ifdef TARGET_2ND_ARCH - $(3)TARGET_CORE_IMAGE_$(1)_64 := $$(core_image_name) + TARGET_CORE_IMAGE_$(1)_64 := $$(core_image_name) else - $(3)TARGET_CORE_IMAGE_$(1)_32 := $$(core_image_name) + TARGET_CORE_IMAGE_$(1)_32 := $$(core_image_name) endif else - $(3)TARGET_CORE_IMAGE_$(1)_32 := $$(core_image_name) + TARGET_CORE_IMAGE_$(1)_32 := $$(core_image_name) endif - $(3)TARGET_CORE_IMG_OUTS += $$(core_image_name) - $(3)TARGET_CORE_OAT_OUTS += $$(core_oat_name) + TARGET_CORE_IMG_OUTS += $$(core_image_name) + TARGET_CORE_OAT_OUTS += $$(core_oat_name) - # If we have a wrapper, make the target phony. - ifneq ($(3),) -.PHONY: $$(core_image_name) - endif $$(core_image_name): PRIVATE_CORE_COMPILE_OPTIONS := $$(core_compile_options) $$(core_image_name): PRIVATE_CORE_IMG_NAME := $$(core_image_name) $$(core_image_name): PRIVATE_CORE_OAT_NAME := $$(core_oat_name) $$(core_image_name): $$(TARGET_CORE_DEX_FILES) $$(core_dex2oat_dependency) @echo "target dex2oat: $$@" @mkdir -p $$(dir $$@) - $$(hide) $(4) $$(DEX2OAT)$(5) --runtime-arg -Xms$(DEX2OAT_IMAGE_XMS) \ + $$(hide) $$(DEX2OAT) --runtime-arg -Xms$(DEX2OAT_IMAGE_XMS) \ --runtime-arg -Xmx$(DEX2OAT_IMAGE_XMX) \ --image-classes=$$(PRELOADED_CLASSES) $$(addprefix --dex-file=,$$(TARGET_CORE_DEX_FILES)) \ $$(addprefix --dex-location=,$$(TARGET_CORE_DEX_LOCATIONS)) --oat-file=$$(PRIVATE_CORE_OAT_NAME) \ @@ -228,30 +210,18 @@ $$(core_oat_name): $$(core_image_name) core_infix := endef # create-core-oat-target-rules -# $(1): compiler - optimizing, interpreter or interpreter-access-checks. -# $(2): wrapper. -# $(3): dex2oat suffix. +# $(1): compiler - optimizing, interpreter or interp-ac (interpreter-access-checks). define create-core-oat-target-rule-combination - $(call create-core-oat-target-rules,$(1),,$(2),$(3)) + $(call create-core-oat-target-rules,$(1),) ifdef TARGET_2ND_ARCH - $(call create-core-oat-target-rules,$(1),2ND_,$(2),$(3)) + $(call create-core-oat-target-rules,$(1),2ND_) endif endef -$(eval $(call create-core-oat-target-rule-combination,optimizing,,)) -$(eval $(call create-core-oat-target-rule-combination,interpreter,,)) -$(eval $(call create-core-oat-target-rule-combination,interp-ac,,)) - -valgrindTARGET_CORE_IMG_OUTS := -valgrindTARGET_CORE_OAT_OUTS := -$(eval $(call create-core-oat-target-rule-combination,optimizing,valgrind,32)) -$(eval $(call create-core-oat-target-rule-combination,interpreter,valgrind,32)) -$(eval $(call create-core-oat-target-rule-combination,interp-ac,valgrind,32)) - -valgrind-test-art-host-dex2oat-target: $(valgrindTARGET_CORE_IMG_OUTS) - -valgrind-test-art-host-dex2oat: valgrind-test-art-host-dex2oat-host valgrind-test-art-host-dex2oat-target +$(eval $(call create-core-oat-target-rule-combination,optimizing)) +$(eval $(call create-core-oat-target-rule-combination,interpreter)) +$(eval $(call create-core-oat-target-rule-combination,interp-ac)) # Define a default core image that can be used for things like gtests that # need some image to run, but don't otherwise care which image is used. diff --git a/cmdline/unit.h b/cmdline/unit.h index ad6a03d12f..f73981fbd3 100644 --- a/cmdline/unit.h +++ b/cmdline/unit.h @@ -21,8 +21,9 @@ namespace art { // Used for arguments that simply indicate presence (e.g. "-help") without any values. struct Unit { - // Avoid 'Conditional jump or move depends on uninitialised value(s)' errors - // when running valgrind by specifying a user-defined constructor. + // Historical note: We specified a user-defined constructor to avoid + // 'Conditional jump or move depends on uninitialised value(s)' errors + // when running Valgrind. Unit() {} Unit(const Unit&) = default; ~Unit() {} diff --git a/compiler/dex/inline_method_analyser.cc b/compiler/dex/inline_method_analyser.cc index dc044c1210..fe8b766d0f 100644 --- a/compiler/dex/inline_method_analyser.cc +++ b/compiler/dex/inline_method_analyser.cc @@ -724,7 +724,8 @@ bool InlineMethodAnalyser::ComputeSpecialAccessorInfo(ArtMethod* method, return false; } DCHECK_GE(field->GetOffset().Int32Value(), 0); - // Do not interleave function calls with bit field writes to placate valgrind. Bug: 27552451. + // Historical note: We made sure not to interleave function calls with bit field writes to + // placate Valgrind. Bug: 27552451. uint32_t field_offset = field->GetOffset().Uint32Value(); bool is_volatile = field->IsVolatile(); result->field_idx = field_idx; diff --git a/compiler/optimizing/instruction_simplifier.cc b/compiler/optimizing/instruction_simplifier.cc index 63704a470e..d532eeeb52 100644 --- a/compiler/optimizing/instruction_simplifier.cc +++ b/compiler/optimizing/instruction_simplifier.cc @@ -637,8 +637,8 @@ void InstructionSimplifierVisitor::VisitCheckCast(HCheckCast* check_cast) { return; } - // Note: The `outcome` is initialized to please valgrind - the compiler can reorder - // the return value check with the `outcome` check, b/27651442 . + // Historical note: The `outcome` was initialized to please Valgrind - the compiler can reorder + // the return value check with the `outcome` check, b/27651442. bool outcome = false; if (TypeCheckHasKnownOutcome(check_cast->GetTargetClassRTI(), object, &outcome)) { if (outcome) { @@ -683,8 +683,8 @@ void InstructionSimplifierVisitor::VisitInstanceOf(HInstanceOf* instruction) { return; } - // Note: The `outcome` is initialized to please valgrind - the compiler can reorder - // the return value check with the `outcome` check, b/27651442 . + // Historical note: The `outcome` was initialized to please Valgrind - the compiler can reorder + // the return value check with the `outcome` check, b/27651442. bool outcome = false; if (TypeCheckHasKnownOutcome(instruction->GetTargetClassRTI(), object, &outcome)) { MaybeRecordStat(stats_, MethodCompilationStat::kRemovedInstanceOf); diff --git a/dex2oat/dex2oat.cc b/dex2oat/dex2oat.cc index 6b65aca943..00c893a8b5 100644 --- a/dex2oat/dex2oat.cc +++ b/dex2oat/dex2oat.cc @@ -657,7 +657,7 @@ class Dex2Oat FINAL { // the runtime. LogCompletionTime(); - if (!kIsDebugBuild && !(RUNNING_ON_MEMORY_TOOL && kMemoryToolDetectsLeaks)) { + if (!kIsDebugBuild && !(kRunningOnMemoryTool && kMemoryToolDetectsLeaks)) { // We want to just exit on non-debug builds, not bringing the runtime down // in an orderly fashion. So release the following fields. driver_.release(); @@ -3119,9 +3119,9 @@ static dex2oat::ReturnCode Dex2oat(int argc, char** argv) { int main(int argc, char** argv) { int result = static_cast<int>(art::Dex2oat(argc, argv)); // Everything was done, do an explicit exit here to avoid running Runtime destructors that take - // time (bug 10645725) unless we're a debug or instrumented build or running on valgrind. Note: - // The Dex2Oat class should not destruct the runtime in this case. - if (!art::kIsDebugBuild && !art::kIsPGOInstrumentation && (RUNNING_ON_MEMORY_TOOL == 0)) { + // time (bug 10645725) unless we're a debug or instrumented build or running on a memory tool. + // Note: The Dex2Oat class should not destruct the runtime in this case. + if (!art::kIsDebugBuild && !art::kIsPGOInstrumentation && !art::kRunningOnMemoryTool) { _exit(result); } return result; diff --git a/dex2oat/dex2oat_test.cc b/dex2oat/dex2oat_test.cc index 96d7dba225..a060fd2e36 100644 --- a/dex2oat/dex2oat_test.cc +++ b/dex2oat/dex2oat_test.cc @@ -472,8 +472,8 @@ class Dex2oatSwapUseTest : public Dex2oatSwapTest { }; TEST_F(Dex2oatSwapUseTest, CheckSwapUsage) { - // Native memory usage isn't correctly tracked under sanitization. - TEST_DISABLED_FOR_MEMORY_TOOL_ASAN(); + // Native memory usage isn't correctly tracked when running under ASan. + TEST_DISABLED_FOR_MEMORY_TOOL(); // The `native_alloc_2_ >= native_alloc_1_` assertion below may not // hold true on some x86 systems; disable this test while we @@ -1054,8 +1054,6 @@ TEST_F(Dex2oatWatchdogTest, TestWatchdogOK) { } TEST_F(Dex2oatWatchdogTest, TestWatchdogTrigger) { - TEST_DISABLED_FOR_MEMORY_TOOL_VALGRIND(); // b/63052624 - // The watchdog is independent of dex2oat and will not delete intermediates. It is possible // that the compilation succeeds and the file is completely written by the time the watchdog // kills dex2oat (but the dex2oat threads must have been scheduled pretty badly). diff --git a/dex2oat/linker/image_writer.cc b/dex2oat/linker/image_writer.cc index dc0709013c..5f5930fdb6 100644 --- a/dex2oat/linker/image_writer.cc +++ b/dex2oat/linker/image_writer.cc @@ -2094,7 +2094,8 @@ void ImageWriter::CopyAndFixupNativeData(size_t oat_index) { size_t size = ArtMethod::Size(target_ptr_size_); size_t alignment = ArtMethod::Alignment(target_ptr_size_); memcpy(dest, pair.first, LengthPrefixedArray<ArtMethod>::ComputeSize(0, size, alignment)); - // Clear padding to avoid non-deterministic data in the image (and placate valgrind). + // Clear padding to avoid non-deterministic data in the image. + // Historical note: We also did that to placate Valgrind. reinterpret_cast<LengthPrefixedArray<ArtMethod>*>(dest)->ClearPadding(size, alignment); break; } diff --git a/libartbase/base/arena_allocator.h b/libartbase/base/arena_allocator.h index 4dccd033d6..a9ccae1b07 100644 --- a/libartbase/base/arena_allocator.h +++ b/libartbase/base/arena_allocator.h @@ -148,34 +148,9 @@ class ArenaAllocatorStatsImpl { typedef ArenaAllocatorStatsImpl<kArenaAllocatorCountAllocations> ArenaAllocatorStats; -template <bool kAvailable, bool kValgrind> -class ArenaAllocatorMemoryToolCheckImpl { - // This is the generic template but since there is a partial specialization - // for kValgrind == false, this can be instantiated only for kValgrind == true. - static_assert(kValgrind, "This template can be instantiated only for Valgrind."); - static_assert(kAvailable, "Valgrind implies memory tool availability."); - - public: - ArenaAllocatorMemoryToolCheckImpl() : is_running_on_valgrind_(RUNNING_ON_MEMORY_TOOL) { } - bool IsRunningOnMemoryTool() { return is_running_on_valgrind_; } - - private: - const bool is_running_on_valgrind_; -}; - -template <bool kAvailable> -class ArenaAllocatorMemoryToolCheckImpl<kAvailable, false> { - public: - ArenaAllocatorMemoryToolCheckImpl() { } - bool IsRunningOnMemoryTool() { return kAvailable; } -}; - -typedef ArenaAllocatorMemoryToolCheckImpl<kMemoryToolIsAvailable, kMemoryToolIsValgrind> - ArenaAllocatorMemoryToolCheck; - -class ArenaAllocatorMemoryTool : private ArenaAllocatorMemoryToolCheck { +class ArenaAllocatorMemoryTool { public: - using ArenaAllocatorMemoryToolCheck::IsRunningOnMemoryTool; + bool IsRunningOnMemoryTool() { return kMemoryToolIsAvailable; } void MakeDefined(void* ptr, size_t size) { if (UNLIKELY(IsRunningOnMemoryTool())) { diff --git a/libartbase/base/arena_allocator_test.cc b/libartbase/base/arena_allocator_test.cc index e358710ca6..6323a2b97c 100644 --- a/libartbase/base/arena_allocator_test.cc +++ b/libartbase/base/arena_allocator_test.cc @@ -16,6 +16,7 @@ #include "arena_allocator-inl.h" #include "arena_bit_vector.h" +#include "base/common_art_test.h" #include "gtest/gtest.h" #include "malloc_arena_pool.h" #include "memory_tool.h" @@ -146,11 +147,8 @@ TEST_F(ArenaAllocatorTest, AllocAlignment) { } TEST_F(ArenaAllocatorTest, ReallocReuse) { - // Realloc does not reuse arenas when running under sanitization. So we cannot do those - if (RUNNING_ON_MEMORY_TOOL != 0) { - printf("WARNING: TEST DISABLED FOR MEMORY_TOOL\n"); - return; - } + // Realloc does not reuse arenas when running under sanitization. + TEST_DISABLED_FOR_MEMORY_TOOL(); { // Case 1: small aligned allocation, aligned extend inside arena. diff --git a/libartbase/base/common_art_test.h b/libartbase/base/common_art_test.h index 3998be516d..d9bea3d97a 100644 --- a/libartbase/base/common_art_test.h +++ b/libartbase/base/common_art_test.h @@ -210,23 +210,11 @@ using CommonArtTestWithParam = CommonArtTestBase<testing::TestWithParam<Param>>; } #define TEST_DISABLED_FOR_MEMORY_TOOL() \ - if (RUNNING_ON_MEMORY_TOOL > 0) { \ + if (kRunningOnMemoryTool) { \ printf("WARNING: TEST DISABLED FOR MEMORY TOOL\n"); \ return; \ } -#define TEST_DISABLED_FOR_MEMORY_TOOL_VALGRIND() \ - if (RUNNING_ON_MEMORY_TOOL > 0 && kMemoryToolIsValgrind) { \ - printf("WARNING: TEST DISABLED FOR MEMORY TOOL VALGRIND\n"); \ - return; \ - } - -#define TEST_DISABLED_FOR_MEMORY_TOOL_ASAN() \ - if (RUNNING_ON_MEMORY_TOOL > 0 && !kMemoryToolIsValgrind) { \ - printf("WARNING: TEST DISABLED FOR MEMORY TOOL ASAN\n"); \ - return; \ - } - #define TEST_DISABLED_FOR_HEAP_POISONING() \ if (kPoisonHeapReferences) { \ printf("WARNING: TEST DISABLED FOR HEAP POISONING\n"); \ diff --git a/libartbase/base/malloc_arena_pool.cc b/libartbase/base/malloc_arena_pool.cc index 144b06ceb9..15a5d71a6b 100644 --- a/libartbase/base/malloc_arena_pool.cc +++ b/libartbase/base/malloc_arena_pool.cc @@ -53,7 +53,7 @@ MallocArena::MallocArena(size_t size) { memory_ = unaligned_memory_; } else { memory_ = AlignUp(unaligned_memory_, ArenaAllocator::kArenaAlignment); - if (UNLIKELY(RUNNING_ON_MEMORY_TOOL > 0)) { + if (kRunningOnMemoryTool) { size_t head = memory_ - unaligned_memory_; size_t tail = overallocation - head; MEMORY_TOOL_MAKE_NOACCESS(unaligned_memory_, head); @@ -66,7 +66,7 @@ MallocArena::MallocArena(size_t size) { MallocArena::~MallocArena() { constexpr size_t overallocation = RequiredOverallocation(); - if (overallocation != 0u && UNLIKELY(RUNNING_ON_MEMORY_TOOL > 0)) { + if (overallocation != 0u && kRunningOnMemoryTool) { size_t head = memory_ - unaligned_memory_; size_t tail = overallocation - head; MEMORY_TOOL_MAKE_UNDEFINED(unaligned_memory_, head); @@ -132,7 +132,7 @@ size_t MallocArenaPool::GetBytesAllocated() const { } void MallocArenaPool::FreeArenaChain(Arena* first) { - if (UNLIKELY(RUNNING_ON_MEMORY_TOOL > 0)) { + if (kRunningOnMemoryTool) { for (Arena* arena = first; arena != nullptr; arena = arena->next_) { MEMORY_TOOL_MAKE_UNDEFINED(arena->memory_, arena->bytes_allocated_); } diff --git a/libartbase/base/mem_map.cc b/libartbase/base/mem_map.cc index c455fed829..9ba1d6c139 100644 --- a/libartbase/base/mem_map.cc +++ b/libartbase/base/mem_map.cc @@ -460,7 +460,7 @@ MemMap* MemMap::MapFileAtAddress(uint8_t* expected_ptr, (expected_ptr == nullptr) ? nullptr : (expected_ptr - page_offset); size_t redzone_size = 0; - if (RUNNING_ON_MEMORY_TOOL && kMemoryToolAddsRedzones && expected_ptr == nullptr) { + if (kRunningOnMemoryTool && kMemoryToolAddsRedzones && expected_ptr == nullptr) { redzone_size = kPageSize; page_aligned_byte_count += redzone_size; } @@ -649,9 +649,11 @@ void MemMap::MadviseDontNeedAndZero() { bool MemMap::Sync() { bool result; if (redzone_size_ != 0) { - // To avoid valgrind errors, temporarily lift the lower-end noaccess protection before passing - // it to msync() as it only accepts page-aligned base address, and exclude the higher-end - // noaccess protection from the msync range. b/27552451. + // To avoid errors when running on a memory tool, temporarily lift the lower-end noaccess + // protection before passing it to msync() as it only accepts page-aligned base address, + // and exclude the higher-end noaccess protection from the msync range. b/27552451. + // TODO: Valgrind is no longer supported, but Address Sanitizer is: + // check whether this special case is needed for ASan. uint8_t* base_begin = reinterpret_cast<uint8_t*>(base_begin_); MEMORY_TOOL_MAKE_DEFINED(base_begin, begin_ - base_begin); result = msync(BaseBegin(), End() - base_begin, MS_SYNC) == 0; diff --git a/libartbase/base/mem_map_test.cc b/libartbase/base/mem_map_test.cc index d956126df1..4a78bdcabe 100644 --- a/libartbase/base/mem_map_test.cc +++ b/libartbase/base/mem_map_test.cc @@ -471,31 +471,33 @@ TEST_F(MemMapTest, MapAnonymousExactAddr32bitHighAddr) { // cannot allocate in the 2GB-4GB region. TEST_DISABLED_FOR_MIPS(); + // This test may not work under Valgrind. + // TODO: Valgrind is no longer supported, but Address Sanitizer is: + // check whether this test works with ASan. + TEST_DISABLED_FOR_MEMORY_TOOL(); + CommonInit(); - // This test may not work under valgrind. - if (RUNNING_ON_MEMORY_TOOL == 0) { - constexpr size_t size = 0x100000; - // Try all addresses starting from 2GB to 4GB. - size_t start_addr = 2 * GB; - std::string error_msg; - std::unique_ptr<MemMap> map; - for (; start_addr <= std::numeric_limits<uint32_t>::max() - size; start_addr += size) { - map.reset(MemMap::MapAnonymous("MapAnonymousExactAddr32bitHighAddr", - reinterpret_cast<uint8_t*>(start_addr), - size, - PROT_READ | PROT_WRITE, - /*low_4gb*/true, - false, - &error_msg)); - if (map != nullptr) { - break; - } + constexpr size_t size = 0x100000; + // Try all addresses starting from 2GB to 4GB. + size_t start_addr = 2 * GB; + std::string error_msg; + std::unique_ptr<MemMap> map; + for (; start_addr <= std::numeric_limits<uint32_t>::max() - size; start_addr += size) { + map.reset(MemMap::MapAnonymous("MapAnonymousExactAddr32bitHighAddr", + reinterpret_cast<uint8_t*>(start_addr), + size, + PROT_READ | PROT_WRITE, + /*low_4gb*/true, + false, + &error_msg)); + if (map != nullptr) { + break; } - ASSERT_TRUE(map.get() != nullptr) << error_msg; - ASSERT_GE(reinterpret_cast<uintptr_t>(map->End()), 2u * GB); - ASSERT_TRUE(error_msg.empty()); - ASSERT_EQ(BaseBegin(map.get()), reinterpret_cast<void*>(start_addr)); } + ASSERT_TRUE(map.get() != nullptr) << error_msg; + ASSERT_GE(reinterpret_cast<uintptr_t>(map->End()), 2u * GB); + ASSERT_TRUE(error_msg.empty()); + ASSERT_EQ(BaseBegin(map.get()), reinterpret_cast<void*>(start_addr)); } TEST_F(MemMapTest, MapAnonymousOverflow) { diff --git a/libartbase/base/memory_tool.h b/libartbase/base/memory_tool.h index e1df99fed4..d381f010f5 100644 --- a/libartbase/base/memory_tool.h +++ b/libartbase/base/memory_tool.h @@ -19,53 +19,53 @@ #include <stddef.h> +namespace art { + #if !defined(__has_feature) -#define __has_feature(x) 0 +# define __has_feature(x) 0 #endif #if __has_feature(address_sanitizer) -#include <sanitizer/asan_interface.h> -#define ADDRESS_SANITIZER +# include <sanitizer/asan_interface.h> +# define ADDRESS_SANITIZER -#ifdef ART_ENABLE_ADDRESS_SANITIZER -#define MEMORY_TOOL_MAKE_NOACCESS(p, s) __asan_poison_memory_region(p, s) -#define MEMORY_TOOL_MAKE_UNDEFINED(p, s) __asan_unpoison_memory_region(p, s) -#define MEMORY_TOOL_MAKE_DEFINED(p, s) __asan_unpoison_memory_region(p, s) +# ifdef ART_ENABLE_ADDRESS_SANITIZER +# define MEMORY_TOOL_MAKE_NOACCESS(p, s) __asan_poison_memory_region(p, s) +# define MEMORY_TOOL_MAKE_UNDEFINED(p, s) __asan_unpoison_memory_region(p, s) +# define MEMORY_TOOL_MAKE_DEFINED(p, s) __asan_unpoison_memory_region(p, s) constexpr bool kMemoryToolIsAvailable = true; -#else -#define MEMORY_TOOL_MAKE_NOACCESS(p, s) do { (void)(p); (void)(s); } while (0) -#define MEMORY_TOOL_MAKE_UNDEFINED(p, s) do { (void)(p); (void)(s); } while (0) -#define MEMORY_TOOL_MAKE_DEFINED(p, s) do { (void)(p); (void)(s); } while (0) +# else +# define MEMORY_TOOL_MAKE_NOACCESS(p, s) do { (void)(p); (void)(s); } while (0) +# define MEMORY_TOOL_MAKE_UNDEFINED(p, s) do { (void)(p); (void)(s); } while (0) +# define MEMORY_TOOL_MAKE_DEFINED(p, s) do { (void)(p); (void)(s); } while (0) constexpr bool kMemoryToolIsAvailable = false; -#endif +# endif extern "C" void __asan_handle_no_return(); -#define ATTRIBUTE_NO_SANITIZE_ADDRESS __attribute__((no_sanitize_address)) -#define MEMORY_TOOL_HANDLE_NO_RETURN __asan_handle_no_return() -#define RUNNING_ON_MEMORY_TOOL 1U -constexpr bool kMemoryToolIsValgrind = false; +# define ATTRIBUTE_NO_SANITIZE_ADDRESS __attribute__((no_sanitize_address)) +# define MEMORY_TOOL_HANDLE_NO_RETURN __asan_handle_no_return() +constexpr bool kRunningOnMemoryTool = true; constexpr bool kMemoryToolDetectsLeaks = true; constexpr bool kMemoryToolAddsRedzones = true; constexpr size_t kMemoryToolStackGuardSizeScale = 2; #else -#include <memcheck/memcheck.h> -#include <valgrind.h> -#define MEMORY_TOOL_MAKE_NOACCESS(p, s) VALGRIND_MAKE_MEM_NOACCESS(p, s) -#define MEMORY_TOOL_MAKE_UNDEFINED(p, s) VALGRIND_MAKE_MEM_UNDEFINED(p, s) -#define MEMORY_TOOL_MAKE_DEFINED(p, s) VALGRIND_MAKE_MEM_DEFINED(p, s) -#define ATTRIBUTE_NO_SANITIZE_ADDRESS -#define MEMORY_TOOL_HANDLE_NO_RETURN do { } while (0) -#define RUNNING_ON_MEMORY_TOOL RUNNING_ON_VALGRIND -constexpr bool kMemoryToolIsAvailable = true; -constexpr bool kMemoryToolIsValgrind = true; -constexpr bool kMemoryToolDetectsLeaks = true; -constexpr bool kMemoryToolAddsRedzones = true; +# define MEMORY_TOOL_MAKE_NOACCESS(p, s) do { (void)(p); (void)(s); } while (0) +# define MEMORY_TOOL_MAKE_UNDEFINED(p, s) do { (void)(p); (void)(s); } while (0) +# define MEMORY_TOOL_MAKE_DEFINED(p, s) do { (void)(p); (void)(s); } while (0) +# define ATTRIBUTE_NO_SANITIZE_ADDRESS +# define MEMORY_TOOL_HANDLE_NO_RETURN do { } while (0) +constexpr bool kRunningOnMemoryTool = false; +constexpr bool kMemoryToolIsAvailable = false; +constexpr bool kMemoryToolDetectsLeaks = false; +constexpr bool kMemoryToolAddsRedzones = false; constexpr size_t kMemoryToolStackGuardSizeScale = 1; #endif +} // namespace art + #endif // ART_LIBARTBASE_BASE_MEMORY_TOOL_H_ diff --git a/libartbase/base/scoped_arena_containers.h b/libartbase/base/scoped_arena_containers.h index 44d7ebbc96..6c78bad21b 100644 --- a/libartbase/base/scoped_arena_containers.h +++ b/libartbase/base/scoped_arena_containers.h @@ -236,7 +236,7 @@ class ArenaDelete { protected: // Used for variable sized objects such as RegisterLine. ALWAYS_INLINE void ProtectMemory(T* ptr, size_t size) const { - if (RUNNING_ON_MEMORY_TOOL > 0) { + if (kRunningOnMemoryTool) { // Writing to the memory will fail ift we already destroyed the pointer with // DestroyOnlyDelete since we make it no access. memset(ptr, kMagicFill, size); diff --git a/libdexfile/dex/dex_file_tracking_registrar.cc b/libdexfile/dex/dex_file_tracking_registrar.cc index 78ea9c16cb..551bea108c 100644 --- a/libdexfile/dex/dex_file_tracking_registrar.cc +++ b/libdexfile/dex/dex_file_tracking_registrar.cc @@ -130,7 +130,8 @@ inline void SetRegistrationRange(const void* begin, size_t size, bool should_poi MEMORY_TOOL_MAKE_NOACCESS(begin, size); } else { // Note: MEMORY_TOOL_MAKE_UNDEFINED has the same functionality with Address - // Sanitizer. The difference has not been tested with Valgrind + // Sanitizer. + // Historical note: The difference has not been tested with Valgrind. MEMORY_TOOL_MAKE_DEFINED(begin, size); } } diff --git a/patchoat/patchoat.cc b/patchoat/patchoat.cc index 3c0b3e42c9..108c753c12 100644 --- a/patchoat/patchoat.cc +++ b/patchoat/patchoat.cc @@ -611,7 +611,7 @@ bool PatchOat::Patch(const std::string& image_location, } } - if (!kIsDebugBuild && !(RUNNING_ON_MEMORY_TOOL && kMemoryToolDetectsLeaks)) { + if (!kIsDebugBuild && !(kRunningOnMemoryTool && kMemoryToolDetectsLeaks)) { // We want to just exit on non-debug builds, not bringing the runtime down // in an orderly fashion. So release the following fields. runtime.release(); @@ -691,7 +691,7 @@ bool PatchOat::Verify(const std::string& image_location, } } - if (!kIsDebugBuild && !(RUNNING_ON_MEMORY_TOOL && kMemoryToolDetectsLeaks)) { + if (!kIsDebugBuild && !(kRunningOnMemoryTool && kMemoryToolDetectsLeaks)) { // We want to just exit on non-debug builds, not bringing the runtime down // in an orderly fashion. So release the following fields. runtime.release(); diff --git a/runtime/base/mem_map_arena_pool.cc b/runtime/base/mem_map_arena_pool.cc index 9ac7886e5d..702f0e453b 100644 --- a/runtime/base/mem_map_arena_pool.cc +++ b/runtime/base/mem_map_arena_pool.cc @@ -125,7 +125,7 @@ size_t MemMapArenaPool::GetBytesAllocated() const { } void MemMapArenaPool::FreeArenaChain(Arena* first) { - if (UNLIKELY(RUNNING_ON_MEMORY_TOOL > 0)) { + if (kRunningOnMemoryTool) { for (Arena* arena = first; arena != nullptr; arena = arena->next_) { MEMORY_TOOL_MAKE_UNDEFINED(arena->memory_, arena->bytes_allocated_); } diff --git a/runtime/exec_utils_test.cc b/runtime/exec_utils_test.cc index 68edfa8b72..a9c1ea2ae0 100644 --- a/runtime/exec_utils_test.cc +++ b/runtime/exec_utils_test.cc @@ -36,8 +36,10 @@ TEST_F(ExecUtilsTest, ExecSuccess) { command.push_back("/usr/bin/id"); } std::string error_msg; - if (!(RUNNING_ON_MEMORY_TOOL && kMemoryToolDetectsLeaks)) { - // Running on valgrind fails due to some memory that leaks in thread alternate signal stacks. + if (!(kRunningOnMemoryTool && kMemoryToolDetectsLeaks)) { + // Running on Valgrind fails due to some memory that leaks in thread alternate signal stacks. + // TODO: Valgrind is no longer supported, but Address Sanitizer is: + // check whether the following code works with ASan. EXPECT_TRUE(Exec(command, &error_msg)); } EXPECT_EQ(0U, error_msg.size()) << error_msg; @@ -50,8 +52,10 @@ TEST_F(ExecUtilsTest, ExecError) { std::vector<std::string> command; command.push_back("bogus"); std::string error_msg; - if (!(RUNNING_ON_MEMORY_TOOL && kMemoryToolDetectsLeaks)) { - // Running on valgrind fails due to some memory that leaks in thread alternate signal stacks. + if (!(kRunningOnMemoryTool && kMemoryToolDetectsLeaks)) { + // Running on Valgrind fails due to some memory that leaks in thread alternate signal stacks. + // TODO: Valgrind is no longer supported, but Address Sanitizer is: + // check whether the following code works with ASan. EXPECT_FALSE(Exec(command, &error_msg)); EXPECT_FALSE(error_msg.empty()); } @@ -72,8 +76,10 @@ TEST_F(ExecUtilsTest, EnvSnapshotAdditionsAreNotVisible) { } command.push_back(kModifiedVariable); std::string error_msg; - if (!(RUNNING_ON_MEMORY_TOOL && kMemoryToolDetectsLeaks)) { - // Running on valgrind fails due to some memory that leaks in thread alternate signal stacks. + if (!(kRunningOnMemoryTool && kMemoryToolDetectsLeaks)) { + // Running on Valgrind fails due to some memory that leaks in thread alternate signal stacks. + // TODO: Valgrind is no longer supported, but Address Sanitizer is: + // check whether the following code works with ASan. EXPECT_FALSE(Exec(command, &error_msg)); EXPECT_NE(0U, error_msg.size()) << error_msg; } @@ -97,8 +103,10 @@ TEST_F(ExecUtilsTest, EnvSnapshotDeletionsAreNotVisible) { } command.push_back(kDeletedVariable); std::string error_msg; - if (!(RUNNING_ON_MEMORY_TOOL && kMemoryToolDetectsLeaks)) { - // Running on valgrind fails due to some memory that leaks in thread alternate signal stacks. + if (!(kRunningOnMemoryTool && kMemoryToolDetectsLeaks)) { + // Running on Valgrind fails due to some memory that leaks in thread alternate signal stacks. + // TODO: Valgrind is no longer supported, but Address Sanitizer is: + // check whether the following code works with ASan. EXPECT_TRUE(Exec(command, &error_msg)); EXPECT_EQ(0U, error_msg.size()) << error_msg; } diff --git a/runtime/gc/allocator/rosalloc.h b/runtime/gc/allocator/rosalloc.h index 150fe956ae..30213d55c5 100644 --- a/runtime/gc/allocator/rosalloc.h +++ b/runtime/gc/allocator/rosalloc.h @@ -625,7 +625,7 @@ class RosAlloc { // If true, check that the returned memory is actually zero. static constexpr bool kCheckZeroMemory = kIsDebugBuild; - // Valgrind protects memory, so do not check memory when running under valgrind. In a normal + // Do not check memory when running under a memory tool. In a normal // build with kCheckZeroMemory the whole test should be optimized away. // TODO: Unprotect before checks. ALWAYS_INLINE bool ShouldCheckZeroMemory(); @@ -768,7 +768,7 @@ class RosAlloc { // greater than or equal to this value, release pages. const size_t page_release_size_threshold_; - // Whether this allocator is running under Valgrind. + // Whether this allocator is running on a memory tool. bool is_running_on_memory_tool_; // The base address of the memory region that's managed by this allocator. diff --git a/runtime/gc/heap-inl.h b/runtime/gc/heap-inl.h index 948d23303c..675686830e 100644 --- a/runtime/gc/heap-inl.h +++ b/runtime/gc/heap-inl.h @@ -272,7 +272,7 @@ inline mirror::Object* Heap::TryToAllocate(Thread* self, } case kAllocatorTypeRosAlloc: { if (kInstrumented && UNLIKELY(is_running_on_memory_tool_)) { - // If running on valgrind or asan, we should be using the instrumented path. + // If running on ASan, we should be using the instrumented path. size_t max_bytes_tl_bulk_allocated = rosalloc_space_->MaxBytesBulkAllocatedFor(alloc_size); if (UNLIKELY(IsOutOfMemoryOnAllocation(allocator_type, max_bytes_tl_bulk_allocated, @@ -303,7 +303,7 @@ inline mirror::Object* Heap::TryToAllocate(Thread* self, } case kAllocatorTypeDlMalloc: { if (kInstrumented && UNLIKELY(is_running_on_memory_tool_)) { - // If running on valgrind, we should be using the instrumented path. + // If running on ASan, we should be using the instrumented path. ret = dlmalloc_space_->Alloc(self, alloc_size, bytes_allocated, diff --git a/runtime/gc/heap.cc b/runtime/gc/heap.cc index 25ed652b41..8e3bbde224 100644 --- a/runtime/gc/heap.cc +++ b/runtime/gc/heap.cc @@ -2248,7 +2248,8 @@ class ZygoteCompactingCollector FINAL : public collector::SemiSpace { // Add a new bin with the remaining space. AddBin(size - alloc_size, pos + alloc_size); } - // Copy the object over to its new location. Don't use alloc_size to avoid valgrind error. + // Copy the object over to its new location. + // Historical note: We did not use `alloc_size` to avoid a Valgrind error. memcpy(reinterpret_cast<void*>(forward_address), obj, obj_size); if (kUseBakerReadBarrier) { obj->AssertReadBarrierState(); diff --git a/runtime/gc/space/large_object_space.cc b/runtime/gc/space/large_object_space.cc index 512cde484d..a24ca32314 100644 --- a/runtime/gc/space/large_object_space.cc +++ b/runtime/gc/space/large_object_space.cc @@ -45,8 +45,9 @@ class MemoryToolLargeObjectMapSpace FINAL : public LargeObjectMapSpace { } ~MemoryToolLargeObjectMapSpace() OVERRIDE { - // Keep valgrind happy if there is any large objects such as dex cache arrays which aren't - // freed since they are held live by the class linker. + // Historical note: We were deleting large objects to keep Valgrind happy if there were + // any large objects such as Dex cache arrays which aren't freed since they are held live + // by the class linker. MutexLock mu(Thread::Current(), lock_); for (auto& m : large_objects_) { delete m.second.mem_map; diff --git a/runtime/gc/space/memory_tool_malloc_space-inl.h b/runtime/gc/space/memory_tool_malloc_space-inl.h index 8282f3dda7..c022171082 100644 --- a/runtime/gc/space/memory_tool_malloc_space-inl.h +++ b/runtime/gc/space/memory_tool_malloc_space-inl.h @@ -30,11 +30,14 @@ namespace space { namespace memory_tool_details { template <size_t kMemoryToolRedZoneBytes, bool kUseObjSizeForUsable> -inline mirror::Object* AdjustForValgrind(void* obj_with_rdz, size_t num_bytes, - size_t bytes_allocated, size_t usable_size, - size_t bytes_tl_bulk_allocated, - size_t* bytes_allocated_out, size_t* usable_size_out, - size_t* bytes_tl_bulk_allocated_out) { +inline mirror::Object* AdjustForMemoryTool(void* obj_with_rdz, + size_t num_bytes, + size_t bytes_allocated, + size_t usable_size, + size_t bytes_tl_bulk_allocated, + size_t* bytes_allocated_out, + size_t* usable_size_out, + size_t* bytes_tl_bulk_allocated_out) { if (bytes_allocated_out != nullptr) { *bytes_allocated_out = bytes_allocated; } @@ -84,24 +87,31 @@ template <typename S, bool kUseObjSizeForUsable> mirror::Object* MemoryToolMallocSpace<S, - kMemoryToolRedZoneBytes, - kAdjustForRedzoneInAllocSize, - kUseObjSizeForUsable>::AllocWithGrowth( - Thread* self, size_t num_bytes, size_t* bytes_allocated_out, size_t* usable_size_out, + kMemoryToolRedZoneBytes, + kAdjustForRedzoneInAllocSize, + kUseObjSizeForUsable>::AllocWithGrowth( + Thread* self, + size_t num_bytes, + size_t* bytes_allocated_out, + size_t* usable_size_out, size_t* bytes_tl_bulk_allocated_out) { size_t bytes_allocated; size_t usable_size; size_t bytes_tl_bulk_allocated; - void* obj_with_rdz = S::AllocWithGrowth(self, num_bytes + 2 * kMemoryToolRedZoneBytes, - &bytes_allocated, &usable_size, + void* obj_with_rdz = S::AllocWithGrowth(self, + num_bytes + 2 * kMemoryToolRedZoneBytes, + &bytes_allocated, + &usable_size, &bytes_tl_bulk_allocated); if (obj_with_rdz == nullptr) { return nullptr; } - return memory_tool_details::AdjustForValgrind<kMemoryToolRedZoneBytes, kUseObjSizeForUsable>( - obj_with_rdz, num_bytes, - bytes_allocated, usable_size, + return memory_tool_details::AdjustForMemoryTool<kMemoryToolRedZoneBytes, kUseObjSizeForUsable>( + obj_with_rdz, + num_bytes, + bytes_allocated, + usable_size, bytes_tl_bulk_allocated, bytes_allocated_out, usable_size_out, @@ -113,27 +123,35 @@ template <typename S, bool kAdjustForRedzoneInAllocSize, bool kUseObjSizeForUsable> mirror::Object* MemoryToolMallocSpace<S, - kMemoryToolRedZoneBytes, - kAdjustForRedzoneInAllocSize, - kUseObjSizeForUsable>::Alloc( - Thread* self, size_t num_bytes, size_t* bytes_allocated_out, size_t* usable_size_out, + kMemoryToolRedZoneBytes, + kAdjustForRedzoneInAllocSize, + kUseObjSizeForUsable>::Alloc( + Thread* self, + size_t num_bytes, + size_t* bytes_allocated_out, + size_t* usable_size_out, size_t* bytes_tl_bulk_allocated_out) { size_t bytes_allocated; size_t usable_size; size_t bytes_tl_bulk_allocated; - void* obj_with_rdz = S::Alloc(self, num_bytes + 2 * kMemoryToolRedZoneBytes, - &bytes_allocated, &usable_size, &bytes_tl_bulk_allocated); + void* obj_with_rdz = S::Alloc(self, + num_bytes + 2 * kMemoryToolRedZoneBytes, + &bytes_allocated, + &usable_size, + &bytes_tl_bulk_allocated); if (obj_with_rdz == nullptr) { return nullptr; } - return memory_tool_details::AdjustForValgrind<kMemoryToolRedZoneBytes, - kUseObjSizeForUsable>(obj_with_rdz, num_bytes, - bytes_allocated, usable_size, - bytes_tl_bulk_allocated, - bytes_allocated_out, - usable_size_out, - bytes_tl_bulk_allocated_out); + return memory_tool_details::AdjustForMemoryTool<kMemoryToolRedZoneBytes, kUseObjSizeForUsable>( + obj_with_rdz, + num_bytes, + bytes_allocated, + usable_size, + bytes_tl_bulk_allocated, + bytes_allocated_out, + usable_size_out, + bytes_tl_bulk_allocated_out); } template <typename S, @@ -141,24 +159,31 @@ template <typename S, bool kAdjustForRedzoneInAllocSize, bool kUseObjSizeForUsable> mirror::Object* MemoryToolMallocSpace<S, - kMemoryToolRedZoneBytes, - kAdjustForRedzoneInAllocSize, - kUseObjSizeForUsable>::AllocThreadUnsafe( - Thread* self, size_t num_bytes, size_t* bytes_allocated_out, size_t* usable_size_out, + kMemoryToolRedZoneBytes, + kAdjustForRedzoneInAllocSize, + kUseObjSizeForUsable>::AllocThreadUnsafe( + Thread* self, + size_t num_bytes, + size_t* bytes_allocated_out, + size_t* usable_size_out, size_t* bytes_tl_bulk_allocated_out) { size_t bytes_allocated; size_t usable_size; size_t bytes_tl_bulk_allocated; - void* obj_with_rdz = S::AllocThreadUnsafe(self, num_bytes + 2 * kMemoryToolRedZoneBytes, - &bytes_allocated, &usable_size, + void* obj_with_rdz = S::AllocThreadUnsafe(self, + num_bytes + 2 * kMemoryToolRedZoneBytes, + &bytes_allocated, + &usable_size, &bytes_tl_bulk_allocated); if (obj_with_rdz == nullptr) { return nullptr; } - return memory_tool_details::AdjustForValgrind<kMemoryToolRedZoneBytes, kUseObjSizeForUsable>( - obj_with_rdz, num_bytes, - bytes_allocated, usable_size, + return memory_tool_details::AdjustForMemoryTool<kMemoryToolRedZoneBytes, kUseObjSizeForUsable>( + obj_with_rdz, + num_bytes, + bytes_allocated, + usable_size, bytes_tl_bulk_allocated, bytes_allocated_out, usable_size_out, @@ -170,12 +195,14 @@ template <typename S, bool kAdjustForRedzoneInAllocSize, bool kUseObjSizeForUsable> size_t MemoryToolMallocSpace<S, - kMemoryToolRedZoneBytes, - kAdjustForRedzoneInAllocSize, - kUseObjSizeForUsable>::AllocationSize( + kMemoryToolRedZoneBytes, + kAdjustForRedzoneInAllocSize, + kUseObjSizeForUsable>::AllocationSize( mirror::Object* obj, size_t* usable_size) { - size_t result = S::AllocationSize(reinterpret_cast<mirror::Object*>( - reinterpret_cast<uint8_t*>(obj) - (kAdjustForRedzoneInAllocSize ? kMemoryToolRedZoneBytes : 0)), + size_t result = S::AllocationSize( + reinterpret_cast<mirror::Object*>( + reinterpret_cast<uint8_t*>(obj) + - (kAdjustForRedzoneInAllocSize ? kMemoryToolRedZoneBytes : 0)), usable_size); if (usable_size != nullptr) { if (kUseObjSizeForUsable) { @@ -192,10 +219,9 @@ template <typename S, bool kAdjustForRedzoneInAllocSize, bool kUseObjSizeForUsable> size_t MemoryToolMallocSpace<S, - kMemoryToolRedZoneBytes, - kAdjustForRedzoneInAllocSize, - kUseObjSizeForUsable>::Free( - Thread* self, mirror::Object* ptr) { + kMemoryToolRedZoneBytes, + kAdjustForRedzoneInAllocSize, + kUseObjSizeForUsable>::Free(Thread* self, mirror::Object* ptr) { void* obj_after_rdz = reinterpret_cast<void*>(ptr); uint8_t* obj_with_rdz = reinterpret_cast<uint8_t*>(obj_after_rdz) - kMemoryToolRedZoneBytes; @@ -220,10 +246,10 @@ template <typename S, bool kAdjustForRedzoneInAllocSize, bool kUseObjSizeForUsable> size_t MemoryToolMallocSpace<S, - kMemoryToolRedZoneBytes, - kAdjustForRedzoneInAllocSize, - kUseObjSizeForUsable>::FreeList( - Thread* self, size_t num_ptrs, mirror::Object** ptrs) { + kMemoryToolRedZoneBytes, + kAdjustForRedzoneInAllocSize, + kUseObjSizeForUsable>::FreeList( + Thread* self, size_t num_ptrs, mirror::Object** ptrs) { size_t freed = 0; for (size_t i = 0; i < num_ptrs; i++) { freed += Free(self, ptrs[i]); @@ -238,11 +264,12 @@ template <typename S, bool kUseObjSizeForUsable> template <typename... Params> MemoryToolMallocSpace<S, - kMemoryToolRedZoneBytes, - kAdjustForRedzoneInAllocSize, - kUseObjSizeForUsable>::MemoryToolMallocSpace( - MemMap* mem_map, size_t initial_size, Params... params) : S(mem_map, initial_size, params...) { - // Don't want to change the valgrind states of the mem map here as the allocator is already + kMemoryToolRedZoneBytes, + kAdjustForRedzoneInAllocSize, + kUseObjSizeForUsable>::MemoryToolMallocSpace( + MemMap* mem_map, size_t initial_size, Params... params) + : S(mem_map, initial_size, params...) { + // Don't want to change the memory tool states of the mem map here as the allocator is already // initialized at this point and that may interfere with what the allocator does internally. Note // that the tail beyond the initial size is mprotected. } @@ -252,9 +279,9 @@ template <typename S, bool kAdjustForRedzoneInAllocSize, bool kUseObjSizeForUsable> size_t MemoryToolMallocSpace<S, - kMemoryToolRedZoneBytes, - kAdjustForRedzoneInAllocSize, - kUseObjSizeForUsable>::MaxBytesBulkAllocatedFor(size_t num_bytes) { + kMemoryToolRedZoneBytes, + kAdjustForRedzoneInAllocSize, + kUseObjSizeForUsable>::MaxBytesBulkAllocatedFor(size_t num_bytes) { return S::MaxBytesBulkAllocatedFor(num_bytes + 2 * kMemoryToolRedZoneBytes); } diff --git a/runtime/gc/space/rosalloc_space.cc b/runtime/gc/space/rosalloc_space.cc index e7865363a1..b0402e4b83 100644 --- a/runtime/gc/space/rosalloc_space.cc +++ b/runtime/gc/space/rosalloc_space.cc @@ -77,7 +77,7 @@ RosAllocSpace* RosAllocSpace::CreateFromMemMap(MemMap* mem_map, const std::strin // Everything is set so record in immutable structure and leave uint8_t* begin = mem_map->Begin(); - // TODO: Fix RosAllocSpace to support Valgrind/ASan. There is currently some issues with + // TODO: Fix RosAllocSpace to support ASan. There is currently some issues with // AllocationSize caused by redzones. b/12944686 if (running_on_memory_tool) { return new MemoryToolMallocSpace<RosAllocSpace, kDefaultMemoryToolRedZoneBytes, false, true>( @@ -382,12 +382,12 @@ size_t RosAllocSpace::AllocationSizeNonvirtual(mirror::Object* obj, size_t* usab size_t size = obj->SizeOf<kVerifyNone>(); bool add_redzones = false; if (kMaybeIsRunningOnMemoryTool) { - add_redzones = RUNNING_ON_MEMORY_TOOL ? kMemoryToolAddsRedzones : 0; + add_redzones = kRunningOnMemoryTool && kMemoryToolAddsRedzones; if (add_redzones) { size += 2 * kDefaultMemoryToolRedZoneBytes; } } else { - DCHECK_EQ(RUNNING_ON_MEMORY_TOOL, 0U); + DCHECK(!kRunningOnMemoryTool); } size_t size_by_size = rosalloc_->UsableSize(size); if (kIsDebugBuild) { diff --git a/runtime/gc/space/rosalloc_space.h b/runtime/gc/space/rosalloc_space.h index 9d16b87b7d..4c17233360 100644 --- a/runtime/gc/space/rosalloc_space.h +++ b/runtime/gc/space/rosalloc_space.h @@ -159,8 +159,8 @@ class RosAllocSpace : public MallocSpace { void* CreateAllocator(void* base, size_t morecore_start, size_t initial_size, size_t maximum_size, bool low_memory_mode) OVERRIDE { - return CreateRosAlloc(base, morecore_start, initial_size, maximum_size, low_memory_mode, - RUNNING_ON_MEMORY_TOOL != 0); + return CreateRosAlloc( + base, morecore_start, initial_size, maximum_size, low_memory_mode, kRunningOnMemoryTool); } static allocator::RosAlloc* CreateRosAlloc(void* base, size_t morecore_start, size_t initial_size, size_t maximum_size, bool low_memory_mode, diff --git a/runtime/interpreter/unstarted_runtime_test.cc b/runtime/interpreter/unstarted_runtime_test.cc index 655713e8c6..01e74962ba 100644 --- a/runtime/interpreter/unstarted_runtime_test.cc +++ b/runtime/interpreter/unstarted_runtime_test.cc @@ -867,11 +867,6 @@ TEST_F(UnstartedRuntimeTest, Cos) { } TEST_F(UnstartedRuntimeTest, Pow) { - // Valgrind seems to get this wrong, actually. Disable for valgrind. - if (RUNNING_ON_MEMORY_TOOL != 0 && kMemoryToolIsValgrind) { - return; - } - Thread* self = Thread::Current(); ScopedObjectAccess soa(self); diff --git a/runtime/jit/jit.cc b/runtime/jit/jit.cc index b7b779ce31..f31a24ec2a 100644 --- a/runtime/jit/jit.cc +++ b/runtime/jit/jit.cc @@ -333,7 +333,7 @@ void Jit::DeleteThreadPool() { } // When running sanitized, let all tasks finish to not leak. Otherwise just clear the queue. - if (!RUNNING_ON_MEMORY_TOOL) { + if (!kRunningOnMemoryTool) { pool->StopWorkers(self); pool->RemoveAllTasks(self); } diff --git a/runtime/native_stack_dump.cc b/runtime/native_stack_dump.cc index 14f3f45f9e..b3a47c3053 100644 --- a/runtime/native_stack_dump.cc +++ b/runtime/native_stack_dump.cc @@ -289,8 +289,10 @@ void DumpNativeStack(std::ostream& os, ArtMethod* current_method, void* ucontext_ptr, bool skip_frames) { - // b/18119146 - if (RUNNING_ON_MEMORY_TOOL != 0) { + // Historical note: This was disabled when running under Valgrind (b/18119146). + // TODO: Valgrind is no longer supported, but Address Sanitizer is: + // check whether this test works with ASan. + if (kRunningOnMemoryTool) { return; } diff --git a/runtime/runtime.cc b/runtime/runtime.cc index 1e327fc8ed..6d10a224e9 100644 --- a/runtime/runtime.cc +++ b/runtime/runtime.cc @@ -240,7 +240,7 @@ Runtime::Runtime() exit_(nullptr), abort_(nullptr), stats_enabled_(false), - is_running_on_memory_tool_(RUNNING_ON_MEMORY_TOOL), + is_running_on_memory_tool_(kRunningOnMemoryTool), instrumentation_(), main_thread_group_(nullptr), system_thread_group_(nullptr), @@ -1362,8 +1362,8 @@ bool Runtime::Init(RuntimeArgumentMap&& runtime_options_in) { case InstructionSet::kMips: case InstructionSet::kMips64: implicit_null_checks_ = true; - // Installing stack protection does not play well with valgrind. - implicit_so_checks_ = !(RUNNING_ON_MEMORY_TOOL && kMemoryToolIsValgrind); + // Historical note: Installing stack protection was not playing well with Valgrind. + implicit_so_checks_ = true; break; default: // Keep the defaults. @@ -1378,8 +1378,8 @@ bool Runtime::Init(RuntimeArgumentMap&& runtime_options_in) { // These need to be in a specific order. The null point check handler must be // after the suspend check and stack overflow check handlers. // - // Note: the instances attach themselves to the fault manager and are handled by it. The manager - // will delete the instance on Shutdown(). + // Note: the instances attach themselves to the fault manager and are handled by it. The + // manager will delete the instance on Shutdown(). if (implicit_suspend_checks_) { new SuspensionHandler(&fault_manager); } diff --git a/runtime/runtime_callbacks_test.cc b/runtime/runtime_callbacks_test.cc index 72d9919971..54769f9c49 100644 --- a/runtime/runtime_callbacks_test.cc +++ b/runtime/runtime_callbacks_test.cc @@ -339,8 +339,8 @@ class RuntimeSigQuitCallbackRuntimeCallbacksTest : public RuntimeCallbacksTest { }; TEST_F(RuntimeSigQuitCallbackRuntimeCallbacksTest, SigQuit) { - // SigQuit induces a dump. ASAN isn't happy with libunwind reading memory. - TEST_DISABLED_FOR_MEMORY_TOOL_ASAN(); + // SigQuit induces a dump. ASan isn't happy with libunwind reading memory. + TEST_DISABLED_FOR_MEMORY_TOOL(); // The runtime needs to be started for the signal handler. Thread* self = Thread::Current(); diff --git a/runtime/thread.cc b/runtime/thread.cc index a8133a1fda..210e1b0c51 100644 --- a/runtime/thread.cc +++ b/runtime/thread.cc @@ -1116,21 +1116,10 @@ bool Thread::InitStackHwm() { Runtime* runtime = Runtime::Current(); bool implicit_stack_check = !runtime->ExplicitStackOverflowChecks() && !runtime->IsAotCompiler(); - // Valgrind on arm doesn't give the right values here. Do not install the guard page, and - // effectively disable stack overflow checks (we'll get segfaults, potentially) by setting - // stack_begin to 0. - const bool valgrind_on_arm = - (kRuntimeISA == InstructionSet::kArm || kRuntimeISA == InstructionSet::kArm64) && - kMemoryToolIsValgrind && - RUNNING_ON_MEMORY_TOOL != 0; - if (valgrind_on_arm) { - tlsPtr_.stack_begin = nullptr; - } - ResetDefaultStackEnd(); // Install the protected region if we are doing implicit overflow checks. - if (implicit_stack_check && !valgrind_on_arm) { + if (implicit_stack_check) { // The thread might have protected region at the bottom. We need // to install our own region so we need to move the limits // of the stack to make room for it. diff --git a/test/137-cfi/cfi.cc b/test/137-cfi/cfi.cc index 7ada47d304..a91d348441 100644 --- a/test/137-cfi/cfi.cc +++ b/test/137-cfi/cfi.cc @@ -114,8 +114,6 @@ extern "C" JNIEXPORT jboolean JNICALL Java_Main_unwindInProcess( jint, jboolean) { #if __linux__ - // TODO: What to do on Valgrind? - std::unique_ptr<Backtrace> bt(Backtrace::Create(BACKTRACE_CURRENT_PROCESS, GetTid())); if (!bt->Unwind(0, nullptr)) { printf("Cannot unwind in process.\n"); @@ -191,7 +189,6 @@ extern "C" JNIEXPORT jboolean JNICALL Java_Main_unwindOtherProcess( jboolean, jint pid_int) { #if __linux__ - // TODO: What to do on Valgrind? pid_t pid = static_cast<pid_t>(pid_int); // OK, this is painful. debuggerd uses ptrace to unwind other processes. diff --git a/test/testrunner/target_config.py b/test/testrunner/target_config.py index 71f4cc0731..68efcaf5a3 100644 --- a/test/testrunner/target_config.py +++ b/test/testrunner/target_config.py @@ -266,14 +266,16 @@ target_config = { } }, 'art-gtest-valgrind32': { - # Disabled: x86 valgrind does not understand SSE4.x + # Disabled: Valgrind is no longer supported. + # Historical note: This was already disabled, as x86 valgrind did not understand SSE4.x # 'make' : 'valgrind-test-art-host32', 'env': { 'ART_USE_READ_BARRIER' : 'false' } }, 'art-gtest-valgrind64': { - 'make' : 'valgrind-test-art-host64', + # Disabled: Valgrind is no longer supported. + # 'make' : 'valgrind-test-art-host64', 'env': { 'ART_USE_READ_BARRIER' : 'false' } diff --git a/test/valgrind-suppressions.txt b/test/valgrind-suppressions.txt deleted file mode 100644 index a97d03c2d4..0000000000 --- a/test/valgrind-suppressions.txt +++ /dev/null @@ -1,87 +0,0 @@ -{ - b/27596582 - Memcheck:Cond - fun:index - fun:expand_dynamic_string_token - fun:_dl_map_object - fun:map_doit - fun:_dl_catch_error - fun:do_preload - fun:dl_main - fun:_dl_sysdep_start - fun:_dl_start_final - fun:_dl_start - obj:/lib/x86_64-linux-gnu/ld-2.19.so -} - -{ - b/31275764 - Memcheck:Leak - match-leak-kinds: definite - fun:malloc - ... - fun:_ZN3art7Runtime17InitNativeMethodsEv -} - -# SigQuit runs libbacktrace -{ - BackTraceReading64 - Memcheck:Addr8 - fun:access_mem_unrestricted - fun:_Uelf64_memory_read - fun:_Uelf64_valid_object_memory - fun:map_create_list - fun:unw_map_local_create - fun:_ZN14UnwindMapLocal5BuildEv - fun:_ZN12BacktraceMap6CreateEib -} -{ - BackTraceReading32 - Memcheck:Addr4 - fun:access_mem_unrestricted - fun:_Uelf32_memory_read - fun:_Uelf32_valid_object_memory - fun:map_create_list - fun:unw_map_local_create - fun:_ZN14UnwindMapLocal5BuildEv - fun:_ZN12BacktraceMap6CreateEib -} -{ - BackTraceReading64 - Memcheck:Addr8 - fun:access_mem_unrestricted - fun:_Uelf64_memory_read - fun:_Uelf64_get_load_base - fun:map_create_list - fun:unw_map_local_create - fun:_ZN14UnwindMapLocal5BuildEv - fun:_ZN12BacktraceMap6CreateEib -} -{ - BackTraceReading32 - Memcheck:Addr4 - fun:access_mem_unrestricted - fun:_Uelf32_memory_read - fun:_Uelf32_get_load_base - fun:map_create_list - fun:unw_map_local_create - fun:_ZN14UnwindMapLocal5BuildEv - fun:_ZN12BacktraceMap6CreateEib -} - -{ - process_vm_readv - Memcheck:Param - process_vm_readv(lvec[...]) - fun:process_vm_readv -} - -# Suppressions for IsAddressMapped check in MemMapTest -{ - MemMapTest_IsAddressMapped - Memcheck:Param - msync(start) - ... - fun:_ZN3art10MemMapTest15IsAddressMappedEPv - ... -} diff --git a/test/valgrind-target-suppressions.txt b/test/valgrind-target-suppressions.txt deleted file mode 100644 index 0d63a1c7aa..0000000000 --- a/test/valgrind-target-suppressions.txt +++ /dev/null @@ -1,76 +0,0 @@ -# Valgrind does not recognize the ashmen ioctl() calls on ARM64, so it assumes that a size -# parameter is a pointer. -{ - ashmem ioctl - Memcheck:Param - ioctl(generic) - ... - fun:ioctl - fun:ashmem_create_region -} - -# It seems that on ARM64 Valgrind considers the canary value used by the Clang stack protector to -# be an uninitialized value. -{ - jemalloc chunk_alloc_cache - Memcheck:Cond - fun:je_chunk_alloc_cache -} - -# The VectorImpl class does not hold a pointer to the allocated SharedBuffer structure, but to the -# beginning of the data, which is effectively an interior pointer. Valgrind has limitations when -# dealing with interior pointers. -{ - VectorImpl - Memcheck:Leak - match-leak-kinds:possible - fun:malloc - # The wildcards make this rule work both for 32-bit and 64-bit environments. - fun:_ZN7android12SharedBuffer5allocE? - fun:_ZN7android10VectorImpl5_growE?? -} - -# Clang/LLVM uses memcpy for *x = *y, even though x == y (which is undefined behavior). Ignore. -# b/29279679, https://llvm.org/bugs/show_bug.cgi?id=11763 -{ - MemCpySelfAssign - Memcheck:Overlap - fun:memcpy - ... - fun:je_malloc_tsd_boot0 -} - -# Setenv is known-leaking when overwriting mappings. This is triggered by re-initializing -# ANDROID_DATA. Ignore all setenv leaks. -{ - SetenvAndroidDataReinit - Memcheck:Leak - match-leak-kinds: definite - fun:malloc - fun:setenv -} - -{ - b/31275764 - Memcheck:Leak - match-leak-kinds: definite - fun:malloc - ... - fun:_ZN3art7Runtime17InitNativeMethodsEv -} - -# art::MemMap::MapInternal() uses msync() to check for the existence of memory mappings. -{ - art::MemMap::MapInternal() - Memcheck:Param - msync(start) - fun:msync - fun:_ZN3art6MemMap11MapInternalEPvmiiilb -} - -{ - process_vm_readv - Memcheck:Param - process_vm_readv(lvec[...]) - fun:process_vm_readv -} @@ -77,7 +77,6 @@ Usage: art [OPTIONS] [--] [ART_OPTIONS] CLASS Supported OPTIONS include: --32 Use the 32-bit Android Runtime. --64 Use the 64-bit Android Runtime. - --callgrind Launch the Android Runtime in callgrind. -d Use the debug ART library (libartd.so). --debug Equivalent to -d. --gdb Launch the Android Runtime in gdb. @@ -269,9 +268,6 @@ while [[ "$1" = "-"* ]]; do --64) ART_BINARY=dalvikvm64 ;; - --callgrind) - LAUNCH_WRAPPER="valgrind --tool=callgrind" - ;; -d) ;& # Fallthrough --debug) |