Eliminate #ifdef ART_USE_QUICK_COMPILER
One of several steps towards having a single compiler build.
In this CL, we introduce a compiler_backend command-line option
to select between Quick, Quick w/ GBC, Portable and Iceland
back ends. The Iceland option is temporary, and will go away once
we combine with Portable. The Quick variants are with
and without GBC conversion. In time, those will converge to a
single option.
All uses of "#if defined(ART_USE_QUICK_COMPILER)" are eliminated. All
previous uses in the Quick compiler have been converted to runtime
tests. On the llvm side, ART_USE_QUICK_COMPILER was previously
used to differentiate between Portable and Iceland builds. Those
usages have been replaced with ART_USE_PORTABLE_COMPILER, and in
a following CL will also be converted to run-time tests.
As of this CL, we're still generating separate libraries for
Quick and Portable/Iceland. Next up is elminating the target-specific
libraries for Quick-arm, Quick-x86 and Quick-mips. Once that is
complete, we will consoldate Quick and Portable into a single build.
To build either Iceland or Portable, touch USE_PORTABLE_COMPILER or
USE_LLVM_COMPILER as usual. Otherwise, the build will default
to Quick (non-GBC).
Change-Id: Ic86c56f51710c9b06d4430b71a429ae12903cc47
diff --git a/Android.mk b/Android.mk
index 3e17072..162becb 100644
--- a/Android.mk
+++ b/Android.mk
@@ -87,9 +87,6 @@
ifeq ($(ART_USE_LLVM_COMPILER),true)
include $(build_path)/Android.libart-compiler-llvm.mk
endif
-ifeq ($(ART_USE_GREENLAND_COMPILER),true)
-include $(build_path)/Android.libart-compiler-greenland.mk
-endif
include $(build_path)/Android.executable.mk
include $(build_path)/Android.oat.mk
diff --git a/build/Android.common.mk b/build/Android.common.mk
index 178af64..c18d46f 100644
--- a/build/Android.common.mk
+++ b/build/Android.common.mk
@@ -24,7 +24,6 @@
ART_USE_PORTABLE_COMPILER := true
endif
ifeq ($(ART_USE_PORTABLE_COMPILER),true)
-WITH_ART_USE_QUICK_COMPILER := true
WITH_ART_USE_LLVM_COMPILER := true
endif
@@ -39,48 +38,8 @@
ART_USE_LLVM_COMPILER := true
endif
-ART_USE_DEXLANG_FRONTEND := false
-ifeq ($(ART_USE_LLVM_COMPILER),true)
- ifneq ($(wildcard art/USE_DEXLANG_FRONTEND),)
- $(info Enabling ART_USE_DEXLANG_FRONTEND because of existence of art/USE_DEXLANG_FRONTEND)
- ART_USE_DEXLANG_FRONTEND := true
- endif
- ifeq ($(WITH_ART_USE_DEXLANG_FRONTEND),true)
- $(info Enabling ART_USE_DEXLANG_FRONTEND because WITH_ART_USE_DEXLANG_FRONTEND=true)
- ART_USE_DEXLANG_FRONTEND := true
- endif
-endif
-
-ART_USE_GREENLAND_COMPILER := false
-ifneq ($(wildcard art/USE_GREENLAND_COMPILER),)
-$(info Enabling ART_USE_GREENLAND_COMPILER because of existence of art/USE_GREENLAND_COMPILER)
-ART_USE_GREENLAND_COMPILER := true
-endif
-ifeq ($(WITH_ART_USE_GREENLAND_COMPILER),true)
-$(info Enabling ART_USE_GREENLAND_COMPILER because WITH_ART_USE_GREENLAND_COMPILER=true)
-ART_USE_GREENLAND_COMPILER := true
-endif
-
-ART_USE_QUICK_COMPILER := false
-ifneq ($(wildcard art/USE_QUICK_COMPILER),)
-ART_USE_QUICK_COMPILER := true
-$(info Enabling ART_USE_QUICK_COMPILER because of existence of art/USE_QUICK_COMPILER)
-endif
-ifeq ($(WITH_ART_USE_QUICK_COMPILER),true)
-ART_USE_QUICK_COMPILER := true
-$(info Enabling ART_USE_QUICK_COMPILER because WITH_ART_USE_QUICK_COMPILER=true)
-endif
-
-ifeq ($(words $(filter true,$(ART_USE_LLVM_COMPILER) $(ART_USE_GREENLAND_COMPILER) $(ART_USE_QUICK_COMPILER))),0)
-ART_REQUIRE_LLVM := false
-else #!0
-ART_REQUIRE_LLVM := true
-endif #!0
-
-ifeq ($(ART_REQUIRE_LLVM),true)
LLVM_ROOT_PATH := external/llvm
include $(LLVM_ROOT_PATH)/llvm.mk
-endif
# directory used for gtests on device
ART_NATIVETEST_DIR := /data/nativetest/art
@@ -275,18 +234,6 @@
src/compiler_llvm/runtime_support_llvm.cc
endif
-ifeq ($(ART_USE_GREENLAND_COMPILER),true)
-LIBART_COMMON_SRC_FILES += \
- src/greenland/inferred_reg_category_map.cc \
- src/greenland/runtime_entry_points.cc \
- src/greenland/runtime/support_alloc.cc \
- src/greenland/runtime/support_cast.cc \
- src/greenland/runtime/support_dexcache.cc \
- src/greenland/runtime/support_exception.cc \
- src/greenland/runtime/support_field.cc \
- src/greenland/runtime/support_thread.cc
-endif
-
LIBART_COMMON_SRC_FILES += \
src/oat/runtime/context.cc \
src/oat/runtime/support_alloc.cc \
diff --git a/build/Android.executable.mk b/build/Android.executable.mk
index ac1d64e..d06b200 100644
--- a/build/Android.executable.mk
+++ b/build/Android.executable.mk
@@ -20,17 +20,9 @@
ART_EXECUTABLES_CFLAGS :=
ifeq ($(ART_USE_LLVM_COMPILER),true)
ART_EXECUTABLES_CFLAGS += -DART_USE_LLVM_COMPILER=1
- ifeq ($(ART_USE_DEXLANG_FRONTEND),true)
- ART_EXECUTABLES_CFLAGS += -DART_USE_DEXLANG_FRONTEND=1
- endif
endif
-
-ifeq ($(ART_USE_GREENLAND_COMPILER),true)
- ART_EXECUTABLES_CFLAGS += -DART_USE_GREENLAND_COMPILER=1
-endif
-
-ifeq ($(ART_USE_QUICK_COMPILER),true)
- ART_EXECUTABLES_CFLAGS += -DART_USE_QUICK_COMPILER=1
+ifeq ($(ART_USE_PORTABLE_COMPILER),true)
+ ART_EXECUTABLES_CFLAGS += -DART_USE_PORTABLE_COMPILER=1
endif
# $(1): executable ("d" will be appended for debug version)
diff --git a/build/Android.gtest.mk b/build/Android.gtest.mk
index de8c502..f469dbd 100644
--- a/build/Android.gtest.mk
+++ b/build/Android.gtest.mk
@@ -22,17 +22,9 @@
ART_TEST_CFLAGS :=
ifeq ($(ART_USE_LLVM_COMPILER),true)
ART_TEST_CFLAGS += -DART_USE_LLVM_COMPILER=1
- ifeq ($(ART_USE_DEXLANG_FRONTEND),true)
- ART_TEST_CFLAGS += -DART_USE_DEXLANG_FRONTEND=1
- endif
endif
-
-ifeq ($(ART_USE_GREENLAND_COMPILER),true)
- ART_TEST_CFLAGS += -DART_USE_GREENLAND_COMPILER=1
-endif
-
-ifeq ($(ART_USE_QUICK_COMPILER),true)
- ART_TEST_CFLAGS += -DART_USE_QUICK_COMPILER=1
+ifeq ($(ART_USE_PORTABLE_COMPILER),true)
+ ART_TEST_CFLAGS += -DART_USE_PORTABLE_COMPILER=1
endif
# $(1): target or host
diff --git a/build/Android.libart-compiler-greenland.mk b/build/Android.libart-compiler-greenland.mk
deleted file mode 100644
index 9baef69..0000000
--- a/build/Android.libart-compiler-greenland.mk
+++ /dev/null
@@ -1,206 +0,0 @@
-#
-# Copyright (C) 2012 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-
-LIBART_COMPILER_GREENLAND_CFLAGS := -DART_USE_GREENLAND_COMPILER=1
-
-LIBART_COMPILER_GREENLAND_SRC_FILES += \
- src/greenland/inferred_reg_category_map.cc \
- src/greenland/dalvik_reg.cc \
- src/greenland/dex_lang.cc \
- src/greenland/gbc_context.cc \
- src/greenland/greenland.cc \
- src/greenland/intrinsic_helper.cc \
- src/greenland/register_allocator.cc \
- src/greenland/target_codegen_machine.cc \
- src/greenland/target_registry.cc \
- src/oat/jni/calling_convention.cc \
- src/oat/jni/jni_compiler.cc \
- src/oat/jni/arm/calling_convention_arm.cc \
- src/oat/jni/mips/calling_convention_mips.cc \
- src/oat/jni/x86/calling_convention_x86.cc
-
-LIBART_COMPILER_GREENLAND_arm_SRC_FILES += \
- src/greenland/arm/arm_codegen_machine.cc \
- src/greenland/arm/arm_invoke_stub_compiler.cc
-
-LIBART_COMPILER_GREENLAND_mips_SRC_FILES += \
- src/greenland/mips/mips_codegen_machine.cc \
- src/greenland/mips/mips_invoke_stub_compiler.cc
-
-LIBART_COMPILER_GREENLAND_x86_SRC_FILES += \
- src/greenland/x86/x86_codegen_machine.cc \
- src/greenland/x86/x86_lir_emitter.cc \
- src/greenland/x86/x86_lir_info.cc \
- src/greenland/x86/x86_invoke_stub_compiler.cc
-
-########################################################################
-
-include $(CLEAR_VARS)
-LOCAL_CPP_EXTENSION := $(ART_CPP_EXTENSION)
-LOCAL_MODULE := target_lir_builder_generator
-LOCAL_MODULE_TAGS := optional
-LOCAL_IS_HOST_MODULE := true
-LOCAL_SRC_FILES := src/greenland/tools/target_lir_builder_generator.cc
-LOCAL_CFLAGS := $(ART_HOST_CFLAGS) $(ART_HOST_DEBUG_CFLAGS)
-LOCAL_C_INCLUDES := $(ART_C_INCLUDES)
-include $(BUILD_HOST_EXECUTABLE)
-TARGET_LIR_BUILDER_GENERATOR := $(LOCAL_BUILT_MODULE)
-
-########################################################################
-
-# $(1): target or host
-# $(2): ndebug or debug
-define build-libart-compiler-greenland
- ifneq ($(1),target)
- ifneq ($(1),host)
- $$(error expected target or host for argument 1, received $(1))
- endif
- endif
- ifneq ($(2),ndebug)
- ifneq ($(2),debug)
- $$(error expected ndebug or debug for argument 2, received $(2))
- endif
- endif
-
- art_target_or_host := $(1)
- art_ndebug_or_debug := $(2)
-
- include $(CLEAR_VARS)
- ifeq ($$(art_target_or_host),target)
- include external/stlport/libstlport.mk
- endif
- LOCAL_CPP_EXTENSION := $(ART_CPP_EXTENSION)
- ifeq ($$(art_ndebug_or_debug),ndebug)
- LOCAL_MODULE := libart-compiler-greenland
- else # debug
- LOCAL_MODULE := libartd-compiler-greenland
- endif
-
- LOCAL_MODULE_TAGS := optional
- LOCAL_MODULE_CLASS := SHARED_LIBRARIES
-
- LOCAL_SRC_FILES := $(LIBART_COMPILER_GREENLAND_SRC_FILES)
- LOCAL_CFLAGS := $(LIBART_COMPILER_GREENLAND_CFLAGS)
- ifeq ($$(art_target_or_host),target)
- LOCAL_CFLAGS += $(ART_TARGET_CFLAGS)
- else # host
- LOCAL_IS_HOST_MODULE := true
- LOCAL_CFLAGS += $(ART_HOST_CFLAGS)
- endif
-
- LOCAL_C_INCLUDES += $(ART_C_INCLUDES)
-
- ifeq ($$(art_target_or_host),target)
- ENUM_INCLUDE_LIR_TARGETS := arm
- LOCAL_SRC_FILES += \
- $(LIBART_COMPILER_GREENLAND_$(TARGET_ARCH)_SRC_FILES)
- else
- ENUM_INCLUDE_LIR_TARGETS := arm mips x86
- LOCAL_SRC_FILES += \
- $(LIBART_COMPILER_GREENLAND_arm_SRC_FILES) \
- $(LIBART_COMPILER_GREENLAND_mips_SRC_FILES) \
- $(LIBART_COMPILER_GREENLAND_x86_SRC_FILES)
- endif
-
- GENERATED_SRC_DIR := $$(call intermediates-dir-for,$$(LOCAL_MODULE_CLASS),$$(LOCAL_MODULE),$$(LOCAL_IS_HOST_MODULE),)
- ENUM_TARGEET_LIR_BUILDER_INC_FILES := $$(foreach lir_target, $$(ENUM_INCLUDE_LIR_TARGETS), $$(lir_target)_lir_builder_base.inc)
- ENUM_TARGET_LIR_BUILDER_OUT_GEN := $$(addprefix $$(GENERATED_SRC_DIR)/, $$(ENUM_TARGEET_LIR_BUILDER_INC_FILES))
-
-$$(ENUM_TARGET_LIR_BUILDER_OUT_GEN): PRIVATE_LIR_TARGET = $$(subst _lir_builder_base.inc,,$$(notdir $$@))
-$$(ENUM_TARGET_LIR_BUILDER_OUT_GEN): %.inc : $$(TARGET_LIR_BUILDER_GENERATOR)
- @echo "target Generated: $$@"
- $$(hide) $$(TARGET_LIR_BUILDER_GENERATOR) $$(PRIVATE_LIR_TARGET) > $$@
-
-LOCAL_GENERATED_SOURCES += $$(ENUM_TARGET_LIR_BUILDER_OUT_GEN)
-
- LOCAL_STATIC_LIBRARIES += \
- libLLVMBitWriter \
- libLLVMBitReader \
- libLLVMScalarOpts \
- libLLVMInstCombine \
- libLLVMTransformUtils \
- libLLVMAnalysis \
- libLLVMTarget \
- libLLVMCore \
- libLLVMSupport
- LOCAL_SHARED_LIBRARIES := liblog libnativehelper
- ifeq ($$(art_target_or_host),target)
- LOCAL_SHARED_LIBRARIES += libcutils libstlport libz libdl
- LOCAL_SHARED_LIBRARIES += libdynamic_annotations # tsan support
- LOCAL_SHARED_LIBRARIES += libcorkscrew # native stack trace support
- else # host
- LOCAL_STATIC_LIBRARIES += libcutils
- LOCAL_SHARED_LIBRARIES += libz-host
- LOCAL_SHARED_LIBRARIES += libdynamic_annotations-host # tsan support
- LOCAL_LDLIBS := -ldl -lpthread
- ifeq ($(HOST_OS),linux)
- LOCAL_LDLIBS += -lrt
- endif
- endif
- ifeq ($$(art_ndebug_or_debug),debug)
- ifeq ($$(art_target_or_host),target)
- LOCAL_CFLAGS += $(ART_TARGET_DEBUG_CFLAGS)
- else # host
- LOCAL_CFLAGS += $(ART_HOST_DEBUG_CFLAGS)
- endif
- LOCAL_SHARED_LIBRARIES += libartd
- else
- ifeq ($$(art_target_or_host),target)
- LOCAL_CFLAGS += $(ART_TARGET_NON_DEBUG_CFLAGS)
- else # host
- LOCAL_CFLAGS += $(ART_HOST_NON_DEBUG_CFLAGS)
- endif
- LOCAL_SHARED_LIBRARIES += libart
- endif
- ifeq ($$(art_target_or_host),target)
- include $(LLVM_GEN_INTRINSICS_MK)
- include $(LLVM_DEVICE_BUILD_MK)
- include $(BUILD_SHARED_LIBRARY)
- else # host
- include $(LLVM_GEN_INTRINSICS_MK)
- include $(LLVM_HOST_BUILD_MK)
- include $(BUILD_HOST_SHARED_LIBRARY)
- endif
-
- ifeq ($$(art_target_or_host),target)
- ifeq ($$(art_ndebug_or_debug),debug)
- $(TARGET_OUT_EXECUTABLES)/dex2oatd: $$(LOCAL_INSTALLED_MODULE)
- else
- $(TARGET_OUT_EXECUTABLES)/dex2oat: $$(LOCAL_INSTALLED_MODULE)
- endif
- else # host
- ifeq ($$(art_ndebug_or_debug),debug)
- $(HOST_OUT_EXECUTABLES)/dex2oatd: $$(LOCAL_INSTALLED_MODULE)
- else
- $(HOST_OUT_EXECUTABLES)/dex2oat: $$(LOCAL_INSTALLED_MODULE)
- endif
- endif
-endef
-
-
-ifeq ($(ART_BUILD_TARGET_NDEBUG),true)
- $(eval $(call build-libart-compiler-greenland,target,ndebug))
-endif
-ifeq ($(ART_BUILD_TARGET_DEBUG),true)
- $(eval $(call build-libart-compiler-greenland,target,debug))
-endif
-ifeq ($(ART_BUILD_HOST_NDEBUG),true)
- $(eval $(call build-libart-compiler-greenland,host,ndebug))
-endif
-ifeq ($(ART_BUILD_HOST_DEBUG),true)
- $(eval $(call build-libart-compiler-greenland,host,debug))
-endif
diff --git a/build/Android.libart-compiler-llvm.mk b/build/Android.libart-compiler-llvm.mk
index 332b809..48731f4 100644
--- a/build/Android.libart-compiler-llvm.mk
+++ b/build/Android.libart-compiler-llvm.mk
@@ -16,11 +16,8 @@
LIBART_COMPILER_LLVM_CFLAGS := -DART_USE_LLVM_COMPILER
-ifeq ($(ART_USE_DEXLANG_FRONTEND),true)
- LIBART_COMPILER_LLVM_CFLAGS += -DART_USE_DEXLANG_FRONTEND
-endif
-ifeq ($(ART_USE_QUICK_COMPILER),true)
- LIBART_COMPILER_LLVM_CFLAGS += -DART_USE_QUICK_COMPILER
+ifeq ($(ART_USE_PORTABLE_COMPILER),true)
+ ART_TEST_CFLAGS += -DART_USE_PORTABLE_COMPILER=1
endif
LIBART_COMPILER_LLVM_SRC_FILES += \
@@ -38,37 +35,28 @@
src/compiler_llvm/stub_compiler.cc \
src/greenland/inferred_reg_category_map.cc
-ifeq ($(ART_USE_DEXLANG_FRONTEND),true)
+ifeq ($(ART_USE_PORTABLE_COMPILER),true)
LIBART_COMPILER_LLVM_SRC_FILES += \
+ src/compiler/Dataflow.cc \
+ src/compiler/Frontend.cc \
+ src/compiler/IntermediateRep.cc \
+ src/compiler/Ralloc.cc \
+ src/compiler/SSATransformation.cc \
+ src/compiler/Utility.cc \
+ src/compiler/codegen/RallocUtil.cc \
+ src/compiler/codegen/arm/ArchUtility.cc \
+ src/compiler/codegen/arm/ArmRallocUtil.cc \
+ src/compiler/codegen/arm/Assemble.cc \
+ src/compiler/codegen/arm/armv7-a/Codegen.cc \
+ src/compiler_llvm/dalvik_reg.cc \
src/compiler_llvm/gbc_expander.cc \
- src/greenland/dalvik_reg.cc \
- src/greenland/dex_lang.cc \
+ src/compiler_llvm/method_compiler.cc \
src/greenland/intrinsic_helper.cc \
src/greenland/ir_builder.cc
else
- ifeq ($(ART_USE_QUICK_COMPILER),true)
- LIBART_COMPILER_LLVM_SRC_FILES += \
- src/compiler/Dataflow.cc \
- src/compiler/Frontend.cc \
- src/compiler/IntermediateRep.cc \
- src/compiler/Ralloc.cc \
- src/compiler/SSATransformation.cc \
- src/compiler/Utility.cc \
- src/compiler/codegen/RallocUtil.cc \
- src/compiler/codegen/arm/ArchUtility.cc \
- src/compiler/codegen/arm/ArmRallocUtil.cc \
- src/compiler/codegen/arm/Assemble.cc \
- src/compiler/codegen/arm/armv7-a/Codegen.cc \
- src/compiler_llvm/dalvik_reg.cc \
- src/compiler_llvm/gbc_expander.cc \
- src/compiler_llvm/method_compiler.cc \
- src/greenland/intrinsic_helper.cc \
- src/greenland/ir_builder.cc
- else
- LIBART_COMPILER_LLVM_SRC_FILES += \
- src/compiler_llvm/dalvik_reg.cc \
- src/compiler_llvm/method_compiler.cc
- endif
+ LIBART_COMPILER_LLVM_SRC_FILES += \
+ src/compiler_llvm/dalvik_reg.cc \
+ src/compiler_llvm/method_compiler.cc
endif
# $(1): target or host
diff --git a/build/Android.libart-compiler.mk b/build/Android.libart-compiler.mk
index 994bcca..323017a 100644
--- a/build/Android.libart-compiler.mk
+++ b/build/Android.libart-compiler.mk
@@ -26,13 +26,9 @@
src/oat/jni/jni_compiler.cc \
src/oat/jni/arm/calling_convention_arm.cc \
src/oat/jni/mips/calling_convention_mips.cc \
- src/oat/jni/x86/calling_convention_x86.cc
-
-ifeq ($(ART_USE_QUICK_COMPILER), true)
-LIBART_COMPILER_COMMON_SRC_FILES += \
+ src/oat/jni/x86/calling_convention_x86.cc \
src/greenland/ir_builder.cc \
src/greenland/intrinsic_helper.cc
-endif
LIBART_COMPILER_arm_SRC_FILES += \
$(LIBART_COMPILER_COMMON_SRC_FILES) \
@@ -118,17 +114,15 @@
endif
LOCAL_SHARED_LIBRARIES += libart
endif
- ifeq ($(ART_USE_QUICK_COMPILER), true)
- LOCAL_SHARED_LIBRARIES += libbcc
- endif
+ LOCAL_SHARED_LIBRARIES += libbcc
# TODO: temporary hack for testing.
ifeq ($$(libart_compiler_arch),mips)
LOCAL_CFLAGS += -D__mips_hard_float
endif
- ifeq ($(ART_USE_QUICK_COMPILER), true)
- LOCAL_CFLAGS += -DART_USE_QUICK_COMPILER
+ ifeq ($(ART_USE_PORTABLE_COMPILER),true)
+ ART_TEST_CFLAGS += -DART_USE_PORTABLE_COMPILER=1
endif
LOCAL_C_INCLUDES += $(ART_C_INCLUDES)
@@ -139,19 +133,15 @@
LOCAL_LDLIBS := -ldl -lpthread
endif
ifeq ($$(art_target_or_host),target)
- ifeq ($(ART_USE_QUICK_COMPILER), true)
- LOCAL_SHARED_LIBRARIES += libcutils
- include $(LLVM_GEN_INTRINSICS_MK)
- include $(LLVM_DEVICE_BUILD_MK)
- endif
+ LOCAL_SHARED_LIBRARIES += libcutils
+ include $(LLVM_GEN_INTRINSICS_MK)
+ include $(LLVM_DEVICE_BUILD_MK)
include $(BUILD_SHARED_LIBRARY)
else # host
LOCAL_IS_HOST_MODULE := true
- ifeq ($(ART_USE_QUICK_COMPILER), true)
- LOCAL_STATIC_LIBRARIES += libcutils
- include $(LLVM_GEN_INTRINSICS_MK)
- include $(LLVM_HOST_BUILD_MK)
- endif
+ LOCAL_STATIC_LIBRARIES += libcutils
+ include $(LLVM_GEN_INTRINSICS_MK)
+ include $(LLVM_HOST_BUILD_MK)
include $(BUILD_HOST_SHARED_LIBRARY)
endif
diff --git a/build/Android.libart.mk b/build/Android.libart.mk
index 43ce31a..435056a 100644
--- a/build/Android.libart.mk
+++ b/build/Android.libart.mk
@@ -17,17 +17,9 @@
LIBART_CFLAGS :=
ifeq ($(ART_USE_LLVM_COMPILER),true)
LIBART_CFLAGS += -DART_USE_LLVM_COMPILER=1
- ifeq ($(ART_USE_DEXLANG_FRONTEND),true)
- LIBART_CFLAGS += -DART_USE_DEXLANG_FRONTEND=1
- endif
endif
-
-ifeq ($(ART_USE_GREENLAND_COMPILER),true)
- LIBART_CFLAGS += -DART_USE_GREENLAND_COMPILER=1
-endif
-
-ifeq ($(ART_USE_QUICK_COMPILER),true)
- LIBART_CFLAGS += -DART_USE_QUICK_COMPILER=1
+ifeq ($(ART_USE_PORTABLE_COMPILER),true)
+ ART_TEST_CFLAGS += -DART_USE_PORTABLE_COMPILER=1
endif
# $(1): target or host
@@ -115,17 +107,12 @@
LOCAL_LDLIBS += -lrt
endif
endif
+ include $(LLVM_GEN_INTRINSICS_MK)
ifeq ($$(art_target_or_host),target)
- ifeq ($(ART_REQUIRE_LLVM),true)
- include $(LLVM_GEN_INTRINSICS_MK)
- include $(LLVM_DEVICE_BUILD_MK)
- endif
+ include $(LLVM_DEVICE_BUILD_MK)
include $(BUILD_SHARED_LIBRARY)
else # host
- ifeq ($(ART_REQUIRE_LLVM),true)
- include $(LLVM_GEN_INTRINSICS_MK)
- include $(LLVM_HOST_BUILD_MK)
- endif
+ include $(LLVM_HOST_BUILD_MK)
include $(BUILD_HOST_SHARED_LIBRARY)
endif
endef
diff --git a/src/common_test.h b/src/common_test.h
index 560edeb..964db64 100644
--- a/src/common_test.h
+++ b/src/common_test.h
@@ -353,6 +353,16 @@
#elif defined(__i386__)
instruction_set = kX86;
#endif
+
+ // TODO: make selectable
+#if defined(ART_USE_PORTABLE_COMPILER)
+ CompilerBackend compiler_backend = kPortable;
+#elif defined(ART_USE_LLVM_COMPILER)
+ CompilerBackend compiler_backend = kIceland; // TODO: remove
+#else
+ CompilerBackend compiler_backend = kQuick;
+#endif
+
runtime_->SetJniDlsymLookupStub(Compiler::CreateJniDlsymLookupStub(instruction_set));
runtime_->SetAbstractMethodErrorStubArray(Compiler::CreateAbstractMethodErrorStub(instruction_set));
for (int i = 0; i < Runtime::kLastTrampolineMethodType; i++) {
@@ -374,7 +384,7 @@
}
class_linker_->FixupDexCaches(runtime_->GetResolutionMethod());
image_classes_.reset(new std::set<std::string>);
- compiler_.reset(new Compiler(instruction_set, true, 2, false, image_classes_.get(),
+ compiler_.reset(new Compiler(compiler_backend, instruction_set, true, 2, false, image_classes_.get(),
true, true));
runtime_->GetHeap()->VerifyHeap(); // Check for heap corruption before the test
diff --git a/src/compiler.cc b/src/compiler.cc
index 8d7f5b6..fdeb986 100644
--- a/src/compiler.cc
+++ b/src/compiler.cc
@@ -231,7 +231,7 @@
DISALLOW_COPY_AND_ASSIGN(AOTCompilationStats);
};
-static std::string MakeCompilerSoName(InstructionSet instruction_set) {
+static std::string MakeCompilerSoName(CompilerBackend compiler_backend, InstructionSet instruction_set) {
// TODO: is the ARM/Thumb2 instruction set distinction really buying us anything,
// or just causing hassle like this?
if (instruction_set == kThumb2) {
@@ -249,13 +249,12 @@
const char* suffix = (kIsDebugBuild ? "d" : "");
// Work out the filename for the compiler library.
-#if defined(ART_USE_LLVM_COMPILER)
- std::string library_name(StringPrintf("art%s-compiler-llvm", suffix));
-#elif defined(ART_USE_GREENLAND_COMPILER)
- std::string library_name(StringPrintf("art%s-compiler-greenland", suffix));
-#else
- std::string library_name(StringPrintf("art%s-compiler-%s", suffix, instruction_set_name.c_str()));
-#endif
+ std::string library_name;
+ if ((compiler_backend == kPortable) || (compiler_backend == kIceland)) {
+ library_name = StringPrintf("art%s-compiler-llvm", suffix);
+ } else {
+ library_name = StringPrintf("art%s-compiler-%s", suffix, instruction_set_name.c_str());
+ }
std::string filename(StringPrintf(OS_SHARED_LIB_FORMAT_STR, library_name.c_str()));
#if defined(__APPLE__)
@@ -291,16 +290,15 @@
return fn;
}
-Compiler::Compiler(InstructionSet instruction_set, bool image, size_t thread_count,
- bool support_debugging, const std::set<std::string>* image_classes,
+Compiler::Compiler(CompilerBackend compiler_backend, InstructionSet instruction_set, bool image,
+ size_t thread_count, bool support_debugging, const std::set<std::string>* image_classes,
bool dump_stats, bool dump_timings)
- : instruction_set_(instruction_set),
+ : compiler_backend_(compiler_backend),
+ instruction_set_(instruction_set),
compiled_classes_lock_("compiled classes lock"),
compiled_methods_lock_("compiled method lock"),
compiled_invoke_stubs_lock_("compiled invoke stubs lock"),
-#if defined(ART_USE_LLVM_COMPILER)
compiled_proxy_stubs_lock_("compiled proxy stubs lock"),
-#endif
image_(image),
thread_count_(thread_count),
support_debugging_(support_debugging),
@@ -315,7 +313,7 @@
jni_compiler_(NULL),
create_invoke_stub_(NULL)
{
- std::string compiler_so_name(MakeCompilerSoName(instruction_set_));
+ std::string compiler_so_name(MakeCompilerSoName(compiler_backend_, instruction_set_));
compiler_library_ = dlopen(compiler_so_name.c_str(), RTLD_LAZY);
if (compiler_library_ == NULL) {
LOG(FATAL) << "Couldn't find compiler library " << compiler_so_name << ": " << dlerror();
@@ -324,36 +322,29 @@
CHECK_PTHREAD_CALL(pthread_key_create, (&tls_key_, NULL), "compiler tls key");
-#if defined(ART_USE_LLVM_COMPILER) || defined(ART_USE_GREENLAND_COMPILER)
- // Initialize compiler_context_
+ // TODO: more work needed to combine initializations and allow per-method backend selection
typedef void (*InitCompilerContextFn)(Compiler&);
-
- InitCompilerContextFn init_compiler_context =
- FindFunction<void (*)(Compiler&)>(compiler_so_name,
- compiler_library_,
- "ArtInitCompilerContext");
+ InitCompilerContextFn init_compiler_context;
+ if ((compiler_backend_ == kPortable) || (compiler_backend_ == kIceland)){
+ // Initialize compiler_context_
+ init_compiler_context = FindFunction<void (*)(Compiler&)>(compiler_so_name,
+ compiler_library_, "ArtInitCompilerContext");
+ compiler_ = FindFunction<CompilerFn>(compiler_so_name, compiler_library_, "ArtCompileMethod");
+ } else {
+ init_compiler_context = FindFunction<void (*)(Compiler&)>(compiler_so_name,
+ compiler_library_, "ArtInitQuickCompilerContext");
+ compiler_ = FindFunction<CompilerFn>(compiler_so_name, compiler_library_, "ArtQuickCompileMethod");
+ }
init_compiler_context(*this);
-#elif defined(ART_USE_QUICK_COMPILER)
- // Initialize compiler_context_
- typedef void (*InitCompilerContextFn)(Compiler&);
- InitCompilerContextFn init_compiler_context =
- FindFunction<void (*)(Compiler&)>(compiler_so_name,
- compiler_library_,
- "ArtInitQuickCompilerContext");
-
- init_compiler_context(*this);
-#endif
-
- compiler_ = FindFunction<CompilerFn>(compiler_so_name, compiler_library_, "ArtCompileMethod");
jni_compiler_ = FindFunction<JniCompilerFn>(compiler_so_name, compiler_library_, "ArtJniCompileMethod");
create_invoke_stub_ = FindFunction<CreateInvokeStubFn>(compiler_so_name, compiler_library_, "ArtCreateInvokeStub");
-#if defined(ART_USE_LLVM_COMPILER)
- create_proxy_stub_ = FindFunction<CreateProxyStubFn>(
- compiler_so_name, compiler_library_, "ArtCreateProxyStub");
-#endif
+ if ((compiler_backend_ == kPortable) || (compiler_backend_ == kIceland)) {
+ create_proxy_stub_ = FindFunction<CreateProxyStubFn>(
+ compiler_so_name, compiler_library_, "ArtCreateProxyStub");
+ }
CHECK(!Runtime::Current()->IsStarted());
if (!image_) {
@@ -375,12 +366,10 @@
MutexLock mu(self, compiled_invoke_stubs_lock_);
STLDeleteValues(&compiled_invoke_stubs_);
}
-#if defined(ART_USE_LLVM_COMPILER)
{
MutexLock mu(self, compiled_proxy_stubs_lock_);
STLDeleteValues(&compiled_proxy_stubs_);
}
-#endif
{
MutexLock mu(self, compiled_methods_lock_);
STLDeleteElements(&code_to_patch_);
@@ -390,34 +379,21 @@
STLDeleteElements(&methods_to_patch_);
}
CHECK_PTHREAD_CALL(pthread_key_delete, (tls_key_), "delete tls key");
-#if defined(ART_USE_LLVM_COMPILER)
- // Uninitialize compiler_context_
typedef void (*UninitCompilerContextFn)(Compiler&);
-
- std::string compiler_so_name(MakeCompilerSoName(instruction_set_));
-
- UninitCompilerContextFn uninit_compiler_context =
- FindFunction<void (*)(Compiler&)>(compiler_so_name,
- compiler_library_,
- "ArtUnInitCompilerContext");
-
- uninit_compiler_context(*this);
-#elif defined(ART_USE_QUICK_COMPILER)
+ std::string compiler_so_name(MakeCompilerSoName(compiler_backend_, instruction_set_));
+ UninitCompilerContextFn uninit_compiler_context;
// Uninitialize compiler_context_
- typedef void (*UninitCompilerContextFn)(Compiler&);
-
- std::string compiler_so_name(MakeCompilerSoName(instruction_set_));
-
- UninitCompilerContextFn uninit_compiler_context =
- FindFunction<void (*)(Compiler&)>(compiler_so_name,
- compiler_library_,
- "ArtUnInitQuickCompilerContext");
-
+ // TODO: rework to combine initialization/uninitialization
+ if ((compiler_backend_ == kPortable) || (compiler_backend_ == kIceland)) {
+ uninit_compiler_context = FindFunction<void (*)(Compiler&)>(compiler_so_name,
+ compiler_library_, "ArtUnInitCompilerContext");
+ } else {
+ uninit_compiler_context = FindFunction<void (*)(Compiler&)>(compiler_so_name,
+ compiler_library_, "ArtUnInitQuickCompilerContext");
+ }
uninit_compiler_context(*this);
-#endif
if (compiler_library_ != NULL) {
VLOG(compiler) << "dlclose(" << compiler_library_ << ")";
-#if !defined(ART_USE_QUICK_COMPILER)
/*
* FIXME: Temporary workaround
* Apparently, llvm is adding dctors to atexit, but if we unload
@@ -430,7 +406,6 @@
* What's the right thing to do here?
*/
dlclose(compiler_library_);
-#endif
}
}
@@ -839,15 +814,15 @@
// invoked, so this can be passed to the out-of-line runtime support code.
direct_code = 0;
direct_method = 0;
-#if !defined(ART_USE_LLVM_COMPILER)
- if (sharp_type != kStatic && sharp_type != kDirect && sharp_type != kInterface) {
- return;
+ if ((compiler_backend_ == kPortable) || (compiler_backend_ == kIceland)) {
+ if (sharp_type != kStatic && sharp_type != kDirect) {
+ return;
+ }
+ } else {
+ if (sharp_type != kStatic && sharp_type != kDirect && sharp_type != kInterface) {
+ return;
+ }
}
-#else
- if (sharp_type != kStatic && sharp_type != kDirect) {
- return;
- }
-#endif
bool method_code_in_boot = method->GetDeclaringClass()->GetClassLoader() == NULL;
if (!method_code_in_boot) {
return;
@@ -1472,8 +1447,7 @@
InsertInvokeStub(key, compiled_invoke_stub);
}
-#if defined(ART_USE_LLVM_COMPILER)
- if (!is_static) {
+ if (((compiler_backend_ == kPortable) || (compiler_backend_ == kIceland)) && !is_static) {
const CompiledInvokeStub* compiled_proxy_stub = FindProxyStub(shorty);
if (compiled_proxy_stub == NULL) {
compiled_proxy_stub = (*create_proxy_stub_)(*this, shorty, shorty_len);
@@ -1481,7 +1455,6 @@
InsertProxyStub(shorty, compiled_proxy_stub);
}
}
-#endif
if (self->IsExceptionPending()) {
ScopedObjectAccess soa(self);
@@ -1518,7 +1491,6 @@
}
}
-#if defined(ART_USE_LLVM_COMPILER)
const CompiledInvokeStub* Compiler::FindProxyStub(const char* shorty) const {
MutexLock mu(Thread::Current(), compiled_proxy_stubs_lock_);
ProxyStubTable::const_iterator it = compiled_proxy_stubs_.find(shorty);
@@ -1541,7 +1513,6 @@
compiled_proxy_stubs_.Put(shorty, compiled_proxy_stub);
}
}
-#endif
CompiledClass* Compiler::GetCompiledClass(ClassReference ref) const {
MutexLock mu(Thread::Current(), compiled_classes_lock_);
@@ -1563,17 +1534,15 @@
return it->second;
}
-#if defined(ART_USE_LLVM_COMPILER) || defined(ART_USE_QUICK_COMPILER)
void Compiler::SetBitcodeFileName(std::string const& filename) {
typedef void (*SetBitcodeFileNameFn)(Compiler&, std::string const&);
SetBitcodeFileNameFn set_bitcode_file_name =
- FindFunction<SetBitcodeFileNameFn>(MakeCompilerSoName(instruction_set_),
+ FindFunction<SetBitcodeFileNameFn>(MakeCompilerSoName(compiler_backend_, instruction_set_),
compiler_library_,
"compilerLLVMSetBitcodeFileName");
set_bitcode_file_name(*this, filename);
}
-#endif
} // namespace art
diff --git a/src/compiler.h b/src/compiler.h
index 5e9dbd7..e3a9f3b 100644
--- a/src/compiler.h
+++ b/src/compiler.h
@@ -40,9 +40,15 @@
class OatCompilationUnit;
class TimingLogger;
+enum CompilerBackend {
+ kQuick,
+ kQuickGBC,
+ kPortable,
+ kIceland // Temporary - remove soon
+};
+
// Thread-local storage compiler worker threads
class CompilerTls {
-#if defined(ART_USE_QUICK_COMPILER)
public:
CompilerTls() : llvm_info_(NULL) {}
~CompilerTls() {}
@@ -53,7 +59,6 @@
private:
void* llvm_info_;
-#endif
};
class Compiler {
@@ -63,9 +68,9 @@
// enabled. "image_classes" lets the compiler know what classes it
// can assume will be in the image, with NULL implying all available
// classes.
- explicit Compiler(InstructionSet instruction_set, bool image, size_t thread_count,
- bool support_debugging, const std::set<std::string>* image_classes,
- bool dump_stats, bool dump_timings);
+ explicit Compiler(CompilerBackend compiler_backend, InstructionSet instruction_set, bool image,
+ size_t thread_count, bool support_debugging,
+ const std::set<std::string>* image_classes, bool dump_stats, bool dump_timings);
~Compiler();
@@ -84,6 +89,10 @@
return instruction_set_;
}
+ CompilerBackend GetCompilerBackend() const {
+ return compiler_backend_;
+ }
+
bool IsImage() const {
return image_;
}
@@ -119,9 +128,7 @@
const CompiledInvokeStub* FindInvokeStub(const std::string& key) const
LOCKS_EXCLUDED(compiled_invoke_stubs_lock_);
-#if defined(ART_USE_LLVM_COMPILER)
const CompiledInvokeStub* FindProxyStub(const char* shorty) const;
-#endif
// Callbacks from compiler to see what runtime checks must be generated.
@@ -175,9 +182,7 @@
size_t literal_offset)
LOCKS_EXCLUDED(compiled_methods_lock_);
-#if defined(ART_USE_LLVM_COMPILER) || defined(ART_USE_QUICK_COMPILER)
void SetBitcodeFileName(std::string const& filename);
-#endif
void SetCompilerContext(void* compiler_context) {
compiler_context_ = compiler_context;
@@ -298,13 +303,13 @@
void InsertInvokeStub(const std::string& key, const CompiledInvokeStub* compiled_invoke_stub)
LOCKS_EXCLUDED(compiled_invoke_stubs_lock_);
-#if defined(ART_USE_LLVM_COMPILER)
void InsertProxyStub(const char* shorty, const CompiledInvokeStub* compiled_proxy_stub);
-#endif
std::vector<const PatchInformation*> code_to_patch_;
std::vector<const PatchInformation*> methods_to_patch_;
+ CompilerBackend compiler_backend_;
+
InstructionSet instruction_set_;
typedef SafeMap<const ClassReference, CompiledClass*> ClassTable;
@@ -322,12 +327,10 @@
mutable Mutex compiled_invoke_stubs_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
InvokeStubTable compiled_invoke_stubs_ GUARDED_BY(compiled_invoke_stubs_lock_);
-#if defined(ART_USE_LLVM_COMPILER)
typedef SafeMap<std::string, const CompiledInvokeStub*> ProxyStubTable;
// Proxy stubs created for proxy invocation delegation
mutable Mutex compiled_proxy_stubs_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
ProxyStubTable compiled_proxy_stubs_ GUARDED_BY(compiled_proxy_stubs_lock_);
-#endif
bool image_;
size_t thread_count_;
@@ -341,10 +344,8 @@
const std::set<std::string>* image_classes_;
-#if defined(ART_USE_LLVM_COMPILER)
typedef void (*CompilerCallbackFn)(Compiler& compiler);
typedef MutexLock* (*CompilerMutexLockFn)(Compiler& compiler);
-#endif
void* compiler_library_;
@@ -367,7 +368,6 @@
pthread_key_t tls_key_;
-#if defined(ART_USE_LLVM_COMPILER)
typedef CompiledInvokeStub* (*CreateProxyStubFn)
(Compiler& compiler, const char* shorty, uint32_t shorty_len);
CreateProxyStubFn create_proxy_stub_;
@@ -382,7 +382,6 @@
typedef const AbstractMethod::InvokeStub* (*CompilerGetMethodInvokeStubAddrFn)
(const Compiler& compiler, const CompiledInvokeStub* cm, const AbstractMethod* method);
CompilerGetMethodInvokeStubAddrFn compiler_get_method_invoke_stub_addr_;
-#endif
DISALLOW_COPY_AND_ASSIGN(Compiler);
diff --git a/src/compiler/Compiler.h b/src/compiler/Compiler.h
index 7eb32c2..11214cf 100644
--- a/src/compiler/Compiler.h
+++ b/src/compiler/Compiler.h
@@ -20,20 +20,16 @@
#include "dex_file.h"
#include "dex_instruction.h"
-#if defined(ART_USE_QUICK_COMPILER)
namespace llvm {
class Module;
class LLVMContext;
}
-#endif
namespace art {
-#if defined(ART_USE_QUICK_COMPILER)
namespace greenland {
class IntrinsicHelper;
class IRBuilder;
}
-#endif
#define COMPILER_TRACED(X)
#define COMPILER_TRACEE(X)
@@ -141,10 +137,8 @@
kDebugShowNops,
kDebugCountOpcodes,
kDebugDumpCheckStats,
-#if defined(ART_USE_QUICK_COMPILER)
kDebugDumpBitcodeFile,
kDebugVerifyBitcode,
-#endif
};
enum OatMethodAttributes {
@@ -177,7 +171,6 @@
kReversePostOrderTraversal, // Depth-First-Search / reverse Post-Order
};
-#if defined(ART_USE_QUICK_COMPILER)
class LLVMInfo {
public:
LLVMInfo();
@@ -205,7 +198,6 @@
UniquePtr<art::greenland::IntrinsicHelper> intrinsic_helper_;
UniquePtr<art::greenland::IRBuilder> ir_builder_;
};
-#endif
struct CompilationUnit;
struct BasicBlock;
diff --git a/src/compiler/CompilerIR.h b/src/compiler/CompilerIR.h
index 5a10831..d08af07 100644
--- a/src/compiler/CompilerIR.h
+++ b/src/compiler/CompilerIR.h
@@ -23,10 +23,8 @@
#include "CompilerUtility.h"
#include "oat_compilation_unit.h"
#include "safe_map.h"
-#if defined(ART_USE_QUICK_COMPILER)
#include "greenland/ir_builder.h"
#include "llvm/Module.h"
-#endif
namespace art {
@@ -262,9 +260,7 @@
bool catchEntry;
bool explicitThrow;
bool conditionalBranch;
-#if defined(ART_USE_QUICK_COMPILER)
bool hasReturn;
-#endif
uint16_t startOffset;
uint16_t nestingDepth;
BBType blockType;
@@ -384,7 +380,6 @@
numArenaBlocks(0),
mstats(NULL),
checkstats(NULL),
-#if defined(ART_USE_QUICK_COMPILER)
genBitcode(false),
context(NULL),
module(NULL),
@@ -397,7 +392,6 @@
tempName(0),
numShadowFrameEntries(0),
shadowMap(NULL),
-#endif
#ifndef NDEBUG
liveSReg(0),
#endif
@@ -547,7 +541,6 @@
int numArenaBlocks;
Memstats* mstats;
Checkstats* checkstats;
-#if defined(ART_USE_QUICK_COMPILER)
bool genBitcode;
LLVMInfo* llvm_info;
llvm::LLVMContext* context;
@@ -567,7 +560,6 @@
int numShadowFrameEntries;
int* shadowMap;
std::set<llvm::BasicBlock*> llvmBlocks;
-#endif
#ifndef NDEBUG
/*
* Sanity checking for the register temp tracking. The same ssa
diff --git a/src/compiler/Dataflow.cc b/src/compiler/Dataflow.cc
index 0058575..c59b637 100644
--- a/src/compiler/Dataflow.cc
+++ b/src/compiler/Dataflow.cc
@@ -1854,12 +1854,10 @@
case Instruction::CMPG_FLOAT:
case Instruction::CMPG_DOUBLE:
case Instruction::CMP_LONG:
-#if defined(ART_USE_QUICK_COMPILER)
if (cUnit->genBitcode) {
// Bitcode doesn't allow this optimization.
break;
}
-#endif
if (mir->next != NULL) {
MIR* mirNext = mir->next;
Instruction::Code brOpcode = mirNext->dalvikInsn.opcode;
diff --git a/src/compiler/Frontend.cc b/src/compiler/Frontend.cc
index c19751d..c5d5c21 100644
--- a/src/compiler/Frontend.cc
+++ b/src/compiler/Frontend.cc
@@ -21,7 +21,6 @@
#include "object.h"
#include "runtime.h"
-#if defined(ART_USE_QUICK_COMPILER)
#include <llvm/Support/Threading.h>
namespace {
@@ -32,11 +31,9 @@
llvm::llvm_start_multithreaded();
}
}
-#endif
namespace art {
-#if defined(ART_USE_QUICK_COMPILER)
LLVMInfo::LLVMInfo() {
#if !defined(ART_USE_LLVM_COMPILER)
pthread_once(&llvm_multi_init, InitializeLLVMForQuick);
@@ -62,7 +59,6 @@
delete reinterpret_cast<LLVMInfo*>(compiler.GetCompilerContext());
compiler.SetCompilerContext(NULL);
}
-#endif
/* Default optimizer/debug setting for the compiler. */
static uint32_t kCompilerOptimizerDisableFlags = 0 | // Disable specific optimizations
@@ -94,10 +90,8 @@
//(1 << kDebugShowNops) |
//(1 << kDebugCountOpcodes) |
//(1 << kDebugDumpCheckStats) |
-#if defined(ART_USE_QUICK_COMPILER)
//(1 << kDebugDumpBitcodeFile) |
//(1 << kDebugVerifyBitcode) |
-#endif
0;
inline bool contentIsInsn(const u2* codePtr) {
@@ -788,14 +782,12 @@
}
CompiledMethod* compileMethod(Compiler& compiler,
+ const CompilerBackend compilerBackend,
const DexFile::CodeItem* code_item,
uint32_t access_flags, InvokeType invoke_type,
uint32_t method_idx, jobject class_loader,
- const DexFile& dex_file
-#if defined(ART_USE_QUICK_COMPILER)
- , LLVMInfo* llvm_info,
- bool gbcOnly
-#endif
+ const DexFile& dex_file,
+ LLVMInfo* llvm_info
)
{
VLOG(compiler) << "Compiling " << PrettyMethod(method_idx, dex_file) << "...";
@@ -824,16 +816,18 @@
cUnit->numIns = code_item->ins_size_;
cUnit->numRegs = code_item->registers_size_ - cUnit->numIns;
cUnit->numOuts = code_item->outs_size_;
-#if defined(ART_USE_QUICK_COMPILER)
DCHECK((cUnit->instructionSet == kThumb2) ||
(cUnit->instructionSet == kX86) ||
(cUnit->instructionSet == kMips));
- cUnit->llvm_info = llvm_info;
- if (cUnit->instructionSet == kThumb2) {
- // TODO: remove this once x86 is tested
+ if ((compilerBackend == kQuickGBC) || (compilerBackend == kPortable)) {
cUnit->genBitcode = true;
}
-#endif
+ DCHECK_NE(compilerBackend, kIceland); // TODO: remove when Portable/Iceland merge complete
+ // TODO: remove this once x86 is tested
+ if (cUnit->genBitcode && (cUnit->instructionSet != kThumb2)) {
+ UNIMPLEMENTED(WARNING) << "GBC generation untested for non-Thumb targets";
+ }
+ cUnit->llvm_info = llvm_info;
/* Adjust this value accordingly once inlining is performed */
cUnit->numDalvikRegisters = code_item->registers_size_;
// TODO: set this from command line
@@ -848,13 +842,9 @@
cUnit->printMe = VLOG_IS_ON(compiler) ||
(cUnit->enableDebug & (1 << kDebugVerbose));
}
-#if defined(ART_USE_QUICK_COMPILER)
- if (cUnit->genBitcode) {
#ifndef NDEBUG
+ if (cUnit->genBitcode) {
cUnit->enableDebug |= (1 << kDebugVerifyBitcode);
-#endif
- //cUnit->printMe = true;
- //cUnit->enableDebug |= (1 << kDebugDumpBitcodeFile);
}
#endif
@@ -1098,21 +1088,14 @@
}
if (cUnit->qdMode) {
-#if !defined(ART_USE_QUICK_COMPILER)
// Bitcode generation requires full dataflow analysis
- cUnit->disableDataflow = true;
-#endif
+ cUnit->disableDataflow = !cUnit->genBitcode;
// Disable optimization which require dataflow/ssa
- cUnit->disableOpt |=
-#if !defined(ART_USE_QUICK_COMPILER)
- (1 << kNullCheckElimination) |
-#endif
- (1 << kBBOpt) |
- (1 << kPromoteRegs);
+ cUnit->disableOpt |= (1 << kBBOpt) | (1 << kPromoteRegs) | (1 << kNullCheckElimination);
if (cUnit->printMe) {
LOG(INFO) << "QD mode enabled: "
<< PrettyMethod(method_idx, dex_file)
- << " too big: " << cUnit->numBlocks;
+ << " num blocks: " << cUnit->numBlocks;
}
}
@@ -1168,12 +1151,11 @@
/* Allocate Registers using simple local allocation scheme */
oatSimpleRegAlloc(cUnit.get());
-#if defined(ART_USE_QUICK_COMPILER)
/* Go the LLVM path? */
if (cUnit->genBitcode) {
// MIR->Bitcode
oatMethodMIR2Bitcode(cUnit.get());
- if (gbcOnly) {
+ if (compilerBackend == kPortable) {
// all done
oatArenaReset(cUnit.get());
return NULL;
@@ -1181,7 +1163,6 @@
// Bitcode->LIR
oatMethodBitcode2LIR(cUnit.get());
} else {
-#endif
if (specialCase != kNoHandler) {
/*
* Custom codegen for special cases. If for any reason the
@@ -1195,9 +1176,7 @@
if (cUnit->firstLIRInsn == NULL) {
oatMethodMIR2LIR(cUnit.get());
}
-#if defined(ART_USE_QUICK_COMPILER)
}
-#endif
// Debugging only
if (cUnit->enableDebug & (1 << kDebugDumpCFG)) {
@@ -1268,55 +1247,30 @@
return result;
}
-#if defined(ART_USE_QUICK_COMPILER)
CompiledMethod* oatCompileMethod(Compiler& compiler,
+ const CompilerBackend backend,
const DexFile::CodeItem* code_item,
uint32_t access_flags, InvokeType invoke_type,
uint32_t method_idx, jobject class_loader,
- const DexFile& dex_file)
+ const DexFile& dex_file,
+ LLVMInfo* llvmInfo)
{
- return compileMethod(compiler, code_item, access_flags, invoke_type, method_idx, class_loader,
- dex_file, NULL, false);
+ return compileMethod(compiler, backend, code_item, access_flags, invoke_type, method_idx, class_loader,
+ dex_file, llvmInfo);
}
-/*
- * Given existing llvm module, context, intrinsic_helper and IRBuilder,
- * add the bitcode for the method described by code_item to the module.
- */
-void oatCompileMethodToGBC(Compiler& compiler,
- const DexFile::CodeItem* code_item,
- uint32_t access_flags, InvokeType invoke_type,
- uint32_t method_idx, jobject class_loader,
- const DexFile& dex_file,
- LLVMInfo* llvm_info)
-{
- compileMethod(compiler, code_item, access_flags, invoke_type, method_idx, class_loader,
- dex_file, llvm_info, true);
-}
-#else
-CompiledMethod* oatCompileMethod(Compiler& compiler,
- const DexFile::CodeItem* code_item,
- uint32_t access_flags, InvokeType invoke_type,
- uint32_t method_idx, jobject class_loader,
- const DexFile& dex_file)
-{
- return compileMethod(compiler, code_item, access_flags, invoke_type, method_idx, class_loader,
- dex_file);
-}
-#endif
-
} // namespace art
-#if !defined(ART_USE_LLVM_COMPILER)
extern "C" art::CompiledMethod*
- ArtCompileMethod(art::Compiler& compiler,
- const art::DexFile::CodeItem* code_item,
- uint32_t access_flags, art::InvokeType invoke_type,
- uint32_t method_idx, jobject class_loader,
- const art::DexFile& dex_file)
+ ArtQuickCompileMethod(art::Compiler& compiler,
+ const art::DexFile::CodeItem* code_item,
+ uint32_t access_flags, art::InvokeType invoke_type,
+ uint32_t method_idx, jobject class_loader,
+ const art::DexFile& dex_file)
{
CHECK_EQ(compiler.GetInstructionSet(), art::oatInstructionSet());
- return art::oatCompileMethod(compiler, code_item, access_flags, invoke_type,
- method_idx, class_loader, dex_file);
+ // TODO: check method fingerprint here to determine appropriate backend type. Until then, use build default
+ art::CompilerBackend backend = compiler.GetCompilerBackend();
+ return art::oatCompileMethod(compiler, backend, code_item, access_flags, invoke_type,
+ method_idx, class_loader, dex_file, NULL /* use thread llvmInfo */);
}
-#endif
diff --git a/src/compiler/Ralloc.cc b/src/compiler/Ralloc.cc
index bf69ce4..ca25b38 100644
--- a/src/compiler/Ralloc.cc
+++ b/src/compiler/Ralloc.cc
@@ -485,19 +485,12 @@
}
}
-#if defined(ART_USE_QUICK_COMPILER)
if (!cUnit->genBitcode) {
/* Remap names */
oatDataFlowAnalysisDispatcher(cUnit, remapNames,
kPreOrderDFSTraversal,
false /* isIterative */);
}
-#else
- /* Remap names */
- oatDataFlowAnalysisDispatcher(cUnit, remapNames,
- kPreOrderDFSTraversal,
- false /* isIterative */);
-#endif
/* Do type & size inference pass */
oatDataFlowAnalysisDispatcher(cUnit, inferTypeAndSize,
diff --git a/src/compiler/codegen/MethodBitcode.cc b/src/compiler/codegen/MethodBitcode.cc
index cf07ea4..7920883 100644
--- a/src/compiler/codegen/MethodBitcode.cc
+++ b/src/compiler/codegen/MethodBitcode.cc
@@ -14,7 +14,6 @@
* limitations under the License.
*/
-#if defined(ART_USE_QUICK_COMPILER)
#include "object_utils.h"
#include <llvm/Support/ToolOutputFile.h>
@@ -3537,5 +3536,3 @@
} // namespace art
-
-#endif // ART_USE_QUICK_COMPILER
diff --git a/src/compiler_llvm/compilation_unit.cc b/src/compiler_llvm/compilation_unit.cc
index ba71aee..a27ea6e 100644
--- a/src/compiler_llvm/compilation_unit.cc
+++ b/src/compiler_llvm/compilation_unit.cc
@@ -154,7 +154,7 @@
llvm::FunctionPass*
CreateGBCExpanderPass(const greenland::IntrinsicHelper& intrinsic_helper,
IRBuilder& irb);
-#elif defined(ART_USE_QUICK_COMPILER)
+#elif defined(ART_USE_PORTABLE_COMPILER)
llvm::FunctionPass*
CreateGBCExpanderPass(const greenland::IntrinsicHelper& intrinsic_helper, IRBuilder& irb,
Compiler* compiler, OatCompilationUnit* oat_compilation_unit);
@@ -166,7 +166,7 @@
CompilationUnit::CompilationUnit(const CompilerLLVM* compiler_llvm,
size_t cunit_idx)
: compiler_llvm_(compiler_llvm), cunit_idx_(cunit_idx) {
-#if !defined(ART_USE_QUICK_COMPILER)
+#if !defined(ART_USE_PORTABLE_COMPILER)
context_.reset(new llvm::LLVMContext());
module_ = new llvm::Module("art", *context_);
#else
@@ -210,7 +210,7 @@
CompilationUnit::~CompilationUnit() {
#if defined(ART_USE_DEXLANG_FRONTEND)
delete dex_lang_ctx_;
-#elif defined(ART_USE_QUICK_COMPILER)
+#elif defined(ART_USE_PORTABLE_COMPILER)
llvm::LLVMContext* llvm_context = context_.release(); // Managed by llvm_info_
CHECK(llvm_context != NULL);
#endif
@@ -330,7 +330,7 @@
// regular FunctionPass.
#if defined(ART_USE_DEXLANG_FRONTEND)
fpm.add(CreateGBCExpanderPass(dex_lang_ctx_->GetIntrinsicHelper(), *irb_.get()));
-#elif defined(ART_USE_QUICK_COMPILER)
+#elif defined(ART_USE_PORTABLE_COMPILER)
fpm.add(CreateGBCExpanderPass(*llvm_info_->GetIntrinsicHelper(), *irb_.get(),
compiler_, oat_compilation_unit_));
#endif
@@ -340,7 +340,7 @@
llvm::FunctionPassManager fpm2(module_);
#if defined(ART_USE_DEXLANG_FRONTEND)
fpm2.add(CreateGBCExpanderPass(dex_lang_ctx_->GetIntrinsicHelper(), *irb_.get()));
-#elif defined(ART_USE_QUICK_COMPILER)
+#elif defined(ART_USE_PORTABLE_COMPILER)
fpm2.add(CreateGBCExpanderPass(*llvm_info_->GetIntrinsicHelper(), *irb_.get(),
compiler_, oat_compilation_unit_));
#endif
diff --git a/src/compiler_llvm/compilation_unit.h b/src/compiler_llvm/compilation_unit.h
index 6ad7ee1..0b40388 100644
--- a/src/compiler_llvm/compilation_unit.h
+++ b/src/compiler_llvm/compilation_unit.h
@@ -28,7 +28,7 @@
#include "runtime_support_func.h"
#include "safe_map.h"
-#if defined(ART_USE_QUICK_COMPILER)
+#if defined(ART_USE_PORTABLE_COMPILER)
# include "compiler/Dalvik.h"
# include "compiler.h"
# include "oat_compilation_unit.h"
@@ -90,7 +90,7 @@
bitcode_filename_ = bitcode_filename;
}
-#if defined(ART_USE_QUICK_COMPILER)
+#if defined(ART_USE_PORTABLE_COMPILER)
LLVMInfo* GetQuickContext() const {
return llvm_info_.get();
}
@@ -124,7 +124,7 @@
#if defined(ART_USE_DEXLANG_FRONTEND)
greenland::DexLang::Context* dex_lang_ctx_;
#endif
-#if defined(ART_USE_QUICK_COMPILER)
+#if defined(ART_USE_PORTABLE_COMPILER)
UniquePtr<LLVMInfo> llvm_info_;
Compiler* compiler_;
OatCompilationUnit* oat_compilation_unit_;
diff --git a/src/compiler_llvm/compiler_llvm.cc b/src/compiler_llvm/compiler_llvm.cc
index a964b40..aa5ec82 100644
--- a/src/compiler_llvm/compiler_llvm.cc
+++ b/src/compiler_llvm/compiler_llvm.cc
@@ -38,14 +38,15 @@
#include <llvm/Support/TargetSelect.h>
#include <llvm/Support/Threading.h>
-#if defined(ART_USE_QUICK_COMPILER)
+#if defined(ART_USE_PORTABLE_COMPILER)
namespace art {
-void oatCompileMethodToGBC(Compiler& compiler,
- const DexFile::CodeItem* code_item,
- uint32_t access_flags, InvokeType invoke_type,
- uint32_t method_idx, jobject class_loader,
- const DexFile& dex_file,
- LLVMInfo* llvm_info);
+void oatCompileMethod(Compiler& compiler,
+ const CompilerBackend compilerBackend,
+ const DexFile::CodeItem* code_item,
+ uint32_t access_flags, InvokeType invoke_type,
+ uint32_t method_idx, jobject class_loader,
+ const DexFile& dex_file,
+ LLVMInfo* llvm_info);
}
#endif
@@ -152,7 +153,7 @@
return new CompiledMethod(cunit->GetInstructionSet(),
cunit->GetCompiledCode());
-#elif defined(ART_USE_QUICK_COMPILER)
+#elif defined(ART_USE_PORTABLE_COMPILER)
std::string methodName(PrettyMethod(oat_compilation_unit->GetDexMethodIndex(),
*oat_compilation_unit->GetDexFile()));
if (insn_set_ == kX86) {
@@ -162,16 +163,17 @@
return method_compiler->Compile();
} else {
- // Use quick
- oatCompileMethodToGBC(*compiler_,
- oat_compilation_unit->GetCodeItem(),
- oat_compilation_unit->access_flags_,
- invoke_type,
- oat_compilation_unit->GetDexMethodIndex(),
- oat_compilation_unit->GetClassLoader(),
- *oat_compilation_unit->GetDexFile(),
- cunit->GetQuickContext()
- );
+ // TODO: consolidate ArtCompileMethods
+ oatCompileMethod(*compiler_,
+ kPortable,
+ oat_compilation_unit->GetCodeItem(),
+ oat_compilation_unit->access_flags_,
+ invoke_type,
+ oat_compilation_unit->GetDexMethodIndex(),
+ oat_compilation_unit->GetClassLoader(),
+ *oat_compilation_unit->GetDexFile(),
+ cunit->GetQuickContext()
+ );
cunit->SetCompiler(compiler_);
cunit->SetOatCompilationUnit(oat_compilation_unit);
diff --git a/src/compiler_llvm/compiler_llvm.h b/src/compiler_llvm/compiler_llvm.h
index 39223ef..0867e56 100644
--- a/src/compiler_llvm/compiler_llvm.h
+++ b/src/compiler_llvm/compiler_llvm.h
@@ -77,7 +77,7 @@
CompiledMethod* CompileDexMethod(OatCompilationUnit* oat_compilation_unit,
InvokeType invoke_type);
-#if defined(ART_USE_LLVM_COMPILER) && defined(ART_USE_QUICK_COMPILER)
+#if defined(ART_USE_PORTABLE_COMPILER)
CompiledMethod* CompileGBCMethod(OatCompilationUnit* oat_compilation_unit, std::string* func);
#endif
diff --git a/src/compiler_llvm/gbc_expander.cc b/src/compiler_llvm/gbc_expander.cc
index 484dd77..18cef41 100644
--- a/src/compiler_llvm/gbc_expander.cc
+++ b/src/compiler_llvm/gbc_expander.cc
@@ -370,7 +370,7 @@
func_ = &func;
changed_ = false; // Assume unchanged
-#if defined(ART_USE_QUICK_COMPILER)
+#if defined(ART_USE_PORTABLE_COMPILER)
basic_blocks_.resize(code_item_->insns_size_in_code_units_);
basic_block_landing_pads_.resize(code_item_->tries_size_, NULL);
basic_block_unwind_ = NULL;
@@ -1032,7 +1032,7 @@
bool is_div, JType op_jty) {
llvm::Value* dividend = call_inst.getArgOperand(0);
llvm::Value* divisor = call_inst.getArgOperand(1);
-#if defined(ART_USE_QUICK_COMPILER)
+#if defined(ART_USE_PORTABLE_COMPILER)
uint32_t dex_pc = LV2UInt(call_inst.getMetadata("DexOff")->getOperand(0));
EmitGuard_DivZeroException(dex_pc, divisor, op_jty);
#endif
@@ -1145,7 +1145,7 @@
};
llvm::Value* entry_addr = irb_.CreateGEP(shadow_frame_, gep_index);
-#if defined(ART_USE_QUICK_COMPILER)
+#if defined(ART_USE_PORTABLE_COMPILER)
if (obj->getType() != irb_.getJObjectTy()) {
obj = irb_.getJNull();
}
@@ -1155,7 +1155,7 @@
}
void GBCExpanderPass::Expand_PopShadowFrame() {
-#if defined(ART_USE_QUICK_COMPILER)
+#if defined(ART_USE_PORTABLE_COMPILER)
if (old_shadow_frame_ == NULL) {
return;
}
@@ -1191,7 +1191,7 @@
// alloca instructions)
EmitStackOverflowCheck(&*first_non_alloca);
-#if defined(ART_USE_QUICK_COMPILER)
+#if defined(ART_USE_PORTABLE_COMPILER)
irb_.Runtime().EmitTestSuspend();
#endif
@@ -2385,7 +2385,7 @@
}
void GBCExpanderPass::EmitUpdateDexPC(uint32_t dex_pc) {
-#if defined(ART_USE_QUICK_COMPILER)
+#if defined(ART_USE_PORTABLE_COMPILER)
if (shadow_frame_ == NULL) {
return;
}
@@ -2477,7 +2477,7 @@
// Get return type
char ret_shorty = shorty[0];
-#if defined(ART_USE_QUICK_COMPILER)
+#if defined(ART_USE_PORTABLE_COMPILER)
ret_shorty = art::remapShorty(ret_shorty);
#endif
llvm::Type* ret_type = irb_.getJType(ret_shorty, kAccurate);
@@ -2492,7 +2492,7 @@
}
for (uint32_t i = 1; i < shorty_size; ++i) {
-#if defined(ART_USE_QUICK_COMPILER)
+#if defined(ART_USE_PORTABLE_COMPILER)
char shorty_type = art::remapShorty(shorty[i]);
args_type.push_back(irb_.getJType(shorty_type, kAccurate));
#else
@@ -2627,7 +2627,7 @@
// Emit the code to return default value (zero) for the given return type.
char ret_shorty = oat_compilation_unit_->GetShorty()[0];
-#if defined(ART_USE_QUICK_COMPILER)
+#if defined(ART_USE_PORTABLE_COMPILER)
ret_shorty = art::remapShorty(ret_shorty);
#endif
if (ret_shorty == 'V') {
diff --git a/src/compiler_llvm/stub_compiler.cc b/src/compiler_llvm/stub_compiler.cc
index 3ac5f2a..4854c9f 100644
--- a/src/compiler_llvm/stub_compiler.cc
+++ b/src/compiler_llvm/stub_compiler.cc
@@ -151,7 +151,7 @@
llvm::Value* code_addr = irb_.CreateLoad(code_field_addr, kTBAAJRuntime);
llvm::CallInst* retval = irb_.CreateCall(code_addr, args);
-#if defined(ART_USE_QUICK_COMPILER)
+#if defined(ART_USE_PORTABLE_COMPILER)
for (size_t i = 1; i < shorty_size; ++i) {
switch(shorty[i]) {
case 'Z':
@@ -216,7 +216,7 @@
llvm::Function* func =
llvm::Function::Create(accurate_func_type, llvm::Function::ExternalLinkage,
func_name, module_);
-#if defined(ART_USE_QUICK_COMPILER)
+#if defined(ART_USE_PORTABLE_COMPILER)
switch(shorty[0]) {
case 'Z':
case 'C':
diff --git a/src/dex2oat.cc b/src/dex2oat.cc
index 20872e1..a8f42af 100644
--- a/src/dex2oat.cc
+++ b/src/dex2oat.cc
@@ -83,11 +83,9 @@
UsageError(" to the file descriptor specified by --oat-fd.");
UsageError(" Example: --oat-location=/data/art-cache/system@app@Calculator.apk.oat");
UsageError("");
-#if defined(ART_USE_LLVM_COMPILER)
UsageError(" --bitcode=<file.bc>: specifies the optional bitcode filename.");
UsageError(" Example: --bitcode=/system/framework/boot.bc");
UsageError("");
-#endif
UsageError(" --image=<file.art>: specifies the output image filename.");
UsageError(" Example: --image=/system/framework/boot.art");
UsageError("");
@@ -111,6 +109,10 @@
UsageError(" Example: --instruction-set=x86");
UsageError(" Default: arm");
UsageError("");
+ UsageError(" --compiler-backend=(Quick|QuickGBC|Portable): select compiler backend");
+ UsageError(" set.");
+ UsageError(" Example: --instruction-set=Portable");
+ UsageError(" Default: Quick");
UsageError(" --runtime-arg <argument>: used to specify various arguments for the runtime,");
UsageError(" such as initial heap size, maximum heap size, and verbose output.");
UsageError(" Use a separate --runtime-arg switch for each argument.");
@@ -122,14 +124,15 @@
class Dex2Oat {
public:
- static bool Create(Dex2Oat** p_dex2oat, Runtime::Options& options, InstructionSet instruction_set,
- size_t thread_count, bool support_debugging)
+ static bool Create(Dex2Oat** p_dex2oat, Runtime::Options& options, CompilerBackend compiler_backend,
+ InstructionSet instruction_set, size_t thread_count, bool support_debugging)
SHARED_TRYLOCK_FUNCTION(true, Locks::mutator_lock_) {
if (!CreateRuntime(options, instruction_set)) {
*p_dex2oat = NULL;
return false;
}
- *p_dex2oat = new Dex2Oat(Runtime::Current(), instruction_set, thread_count, support_debugging);
+ *p_dex2oat = new Dex2Oat(Runtime::Current(), compiler_backend, instruction_set, thread_count,
+ support_debugging);
return true;
}
@@ -209,9 +212,7 @@
const std::string* host_prefix,
const std::vector<const DexFile*>& dex_files,
File* oat_file,
-#if defined(ART_USE_LLVM_COMPILER)
const std::string& bitcode_filename,
-#endif
bool image,
const std::set<std::string>* image_classes,
bool dump_stats,
@@ -234,7 +235,8 @@
Runtime::Current()->SetCompileTimeClassPath(class_loader, class_path_files);
}
- UniquePtr<Compiler> compiler(new Compiler(instruction_set_,
+ UniquePtr<Compiler> compiler(new Compiler(compiler_backend_,
+ instruction_set_,
image,
thread_count_,
support_debugging_,
@@ -242,9 +244,9 @@
dump_stats,
dump_timings));
-#if defined(ART_USE_LLVM_COMPILER)
- compiler->SetBitcodeFileName(bitcode_filename);
-#endif
+ if ((compiler_backend_ == kPortable) || (compiler_backend_ == kIceland)) {
+ compiler->SetBitcodeFileName(bitcode_filename);
+ }
Thread::Current()->TransitionFromRunnableToSuspended(kNative);
@@ -295,9 +297,10 @@
}
private:
- explicit Dex2Oat(Runtime* runtime, InstructionSet instruction_set, size_t thread_count,
- bool support_debugging)
- : instruction_set_(instruction_set),
+ explicit Dex2Oat(Runtime* runtime, CompilerBackend compiler_backend, InstructionSet instruction_set,
+ size_t thread_count, bool support_debugging)
+ : compiler_backend_(compiler_backend),
+ instruction_set_(instruction_set),
runtime_(runtime),
thread_count_(thread_count),
support_debugging_(support_debugging),
@@ -431,6 +434,8 @@
return false;
}
+ const CompilerBackend compiler_backend_;
+
const InstructionSet instruction_set_;
Runtime* runtime_;
@@ -487,9 +492,7 @@
std::string oat_filename;
std::string oat_location;
int oat_fd = -1;
-#if defined(ART_USE_LLVM_COMPILER)
std::string bitcode_filename;
-#endif
const char* image_classes_filename = NULL;
std::string image_filename;
std::string boot_image_filename;
@@ -498,6 +501,13 @@
std::vector<const char*> runtime_args;
int thread_count = sysconf(_SC_NPROCESSORS_CONF);
bool support_debugging = false;
+#if defined(ART_USE_PORTABLE_COMPILER)
+ CompilerBackend compiler_backend = kPortable;
+#elif defined(ART_USE_LLVM_COMPILER)
+ CompilerBackend compiler_backend = kIceland;
+#else
+ CompilerBackend compiler_backend = kQuick;
+#endif
#if defined(__arm__)
InstructionSet instruction_set = kThumb2;
#elif defined(__i386__)
@@ -543,10 +553,8 @@
}
} else if (option.starts_with("--oat-location=")) {
oat_location = option.substr(strlen("--oat-location=")).data();
-#if defined(ART_USE_LLVM_COMPILER)
} else if (option.starts_with("--bitcode=")) {
bitcode_filename = option.substr(strlen("--bitcode=")).data();
-#endif
} else if (option.starts_with("--image=")) {
image_filename = option.substr(strlen("--image=")).data();
} else if (option.starts_with("--image-classes=")) {
@@ -571,6 +579,18 @@
} else if (instruction_set_str == "x86") {
instruction_set = kX86;
}
+ } else if (option.starts_with("--compiler-backend=")) {
+ StringPiece backend_str = option.substr(strlen("--compiler-backend=")).data();
+ if (backend_str == "Quick") {
+ compiler_backend = kQuick;
+ } else if (backend_str == "QuickGBC") {
+ compiler_backend = kQuickGBC;
+ } else if (backend_str == "Iceland") {
+ // TODO: remove this when Portable/Iceland merge complete
+ compiler_backend = kIceland;
+ } else if (backend_str == "Portable") {
+ compiler_backend = kPortable;
+ }
} else if (option == "--runtime-arg") {
if (++i >= argc) {
Usage("Missing required argument for --runtime-arg");
@@ -704,7 +724,7 @@
}
Dex2Oat* p_dex2oat;
- if (!Dex2Oat::Create(&p_dex2oat, options, instruction_set, thread_count, support_debugging)) {
+ if (!Dex2Oat::Create(&p_dex2oat, options, compiler_backend, instruction_set, thread_count, support_debugging)) {
LOG(ERROR) << "Failed to create dex2oat";
return EXIT_FAILURE;
}
@@ -755,9 +775,7 @@
host_prefix.get(),
dex_files,
oat_file.get(),
-#if defined(ART_USE_LLVM_COMPILER)
bitcode_filename,
-#endif
image,
image_classes.get(),
dump_stats,
diff --git a/src/greenland/ir_builder.h b/src/greenland/ir_builder.h
index baa0ae7..ba8e5e1 100644
--- a/src/greenland/ir_builder.h
+++ b/src/greenland/ir_builder.h
@@ -33,7 +33,6 @@
namespace art {
namespace greenland {
-#if defined(ART_USE_QUICK_COMPILER)
class InserterWithDexOffset
: public llvm::IRBuilderDefaultInserter<true> {
public:
@@ -54,9 +53,6 @@
};
typedef llvm::IRBuilder<true, llvm::NoFolder, InserterWithDexOffset> LLVMIRBuilder;
-#else
-typedef llvm::IRBuilder<true> LLVMIRBuilder;
-#endif
class IRBuilder : public LLVMIRBuilder {
public:
diff --git a/src/oat_file.cc b/src/oat_file.cc
index 4e05325..145d2e2 100644
--- a/src/oat_file.cc
+++ b/src/oat_file.cc
@@ -70,11 +70,7 @@
bool OatFile::Map(File& file,
byte* requested_base,
-#if defined(ART_USE_LLVM_COMPILER)
- RelocationBehavior reloc,
-#else
RelocationBehavior /*UNUSED*/,
-#endif
bool writable) {
OatHeader oat_header;
bool success = file.ReadFully(&oat_header, sizeof(oat_header));
diff --git a/src/oat_test.cc b/src/oat_test.cc
index 64c502d..bb6305a 100644
--- a/src/oat_test.cc
+++ b/src/oat_test.cc
@@ -65,7 +65,15 @@
jobject class_loader = NULL;
if (compile) {
- compiler_.reset(new Compiler(kThumb2, false, 2, false, NULL, true, true));
+ // TODO: make selectable
+#if defined(ART_USE_PORTABLE_COMPILER)
+ CompilerBackend compiler_backend = kPortable;
+#elif defined(ART_USE_LLVM_COMPILER)
+ CompilerBackend compiler_backend = kIceland; // TODO: remove
+#else
+ CompilerBackend compiler_backend = kQuick;
+#endif
+ compiler_.reset(new Compiler(compiler_backend, kThumb2, false, 2, false, NULL, true, true));
compiler_->CompileAll(class_loader, class_linker->GetBootClassPath());
}
diff --git a/src/thread.cc b/src/thread.cc
index 67773a5..da6ae74 100644
--- a/src/thread.cc
+++ b/src/thread.cc
@@ -292,9 +292,6 @@
SetUpAlternateSignalStack();
InitCpu();
InitFunctionPointers();
-#ifdef ART_USE_GREENLAND_COMPILER
- InitRuntimeEntryPoints(&runtime_entry_points_);
-#endif
InitCardTable();
InitTid();
diff --git a/src/thread.h b/src/thread.h
index abfd719..a5f218a 100644
--- a/src/thread.h
+++ b/src/thread.h
@@ -35,9 +35,6 @@
#include "stack_indirect_reference_table.h"
#include "trace.h"
#include "UniquePtr.h"
-#ifdef ART_USE_GREENLAND_COMPILER
-#include "greenland/runtime_entry_points.h"
-#endif
namespace art {
@@ -782,9 +779,6 @@
// Runtime support function pointers
// TODO: move this near the top, since changing its offset requires all oats to be recompiled!
EntryPoints entrypoints_;
-#ifdef ART_USE_GREENLAND_COMPILER
- RuntimeEntryPoints runtime_entry_points_;
-#endif
private:
// How many times has our pthread key's destructor been called?
diff --git a/src/trace.cc b/src/trace.cc
index d0132e1..753b80f 100644
--- a/src/trace.cc
+++ b/src/trace.cc
@@ -241,6 +241,7 @@
void Trace::SaveAndUpdateCode(AbstractMethod* method) {
#if defined(ART_USE_LLVM_COMPILER)
+ UNUSED(method);
UNIMPLEMENTED(FATAL);
#else
void* trace_stub = GetLogTraceEntryPoint();
diff --git a/src/verifier/method_verifier.cc b/src/verifier/method_verifier.cc
index 67507bc..bd77a3c 100644
--- a/src/verifier/method_verifier.cc
+++ b/src/verifier/method_verifier.cc
@@ -32,7 +32,7 @@
#include "runtime.h"
#include "stringpiece.h"
-#if defined(ART_USE_LLVM_COMPILER) || defined(ART_USE_GREENLAND_COMPILER)
+#if defined(ART_USE_LLVM_COMPILER)
#include "greenland/backend_types.h"
#include "greenland/inferred_reg_category_map.h"
#endif
@@ -962,7 +962,7 @@
return true;
}
-#if !defined(ART_USE_LLVM_COMPILER) && !defined(ART_USE_GREENLAND_COMPILER)
+#if !defined(ART_USE_LLVM_COMPILER)
static const std::vector<uint8_t>* CreateLengthPrefixedDexGcMap(const std::vector<uint8_t>& gc_map) {
std::vector<uint8_t>* length_prefixed_gc_map = new std::vector<uint8_t>;
length_prefixed_gc_map->push_back((gc_map.size() & 0xff000000) >> 24);
@@ -1012,7 +1012,7 @@
Compiler::MethodReference ref(dex_file_, method_idx_);
-#if !defined(ART_USE_LLVM_COMPILER) && !defined(ART_USE_GREENLAND_COMPILER)
+#if !defined(ART_USE_LLVM_COMPILER)
/* Generate a register map and add it to the method. */
UniquePtr<const std::vector<uint8_t> > map(GenerateGcMap());
@@ -1026,7 +1026,7 @@
const std::vector<uint8_t>* dex_gc_map = CreateLengthPrefixedDexGcMap(*(map.get()));
verifier::MethodVerifier::SetDexGcMap(ref, *dex_gc_map);
-#else // defined(ART_USE_LLVM_COMPILER) || defined(ART_USE_GREENLAND_COMPILER)
+#else // defined(ART_USE_LLVM_COMPILER)
/* Generate Inferred Register Category for LLVM-based Code Generator */
const InferredRegCategoryMap* table = GenerateInferredRegCategoryMap();
verifier::MethodVerifier::SetInferredRegCategoryMap(ref, *table);
@@ -3262,7 +3262,7 @@
Mutex* MethodVerifier::rejected_classes_lock_ = NULL;
MethodVerifier::RejectedClassesTable* MethodVerifier::rejected_classes_ = NULL;
-#if defined(ART_USE_LLVM_COMPILER) || defined(ART_USE_GREENLAND_COMPILER)
+#if defined(ART_USE_LLVM_COMPILER)
Mutex* MethodVerifier::inferred_reg_category_maps_lock_ = NULL;
MethodVerifier::InferredRegCategoryMapTable* MethodVerifier::inferred_reg_category_maps_ = NULL;
#endif
@@ -3281,7 +3281,7 @@
rejected_classes_ = new MethodVerifier::RejectedClassesTable;
}
-#if defined(ART_USE_LLVM_COMPILER) || defined(ART_USE_GREENLAND_COMPILER)
+#if defined(ART_USE_LLVM_COMPILER)
inferred_reg_category_maps_lock_ = new Mutex("verifier GC maps lock");
{
MutexLock mu(self, *inferred_reg_category_maps_lock_);
@@ -3309,7 +3309,7 @@
delete rejected_classes_lock_;
rejected_classes_lock_ = NULL;
-#if defined(ART_USE_LLVM_COMPILER) || defined(ART_USE_GREENLAND_COMPILER)
+#if defined(ART_USE_LLVM_COMPILER)
{
MutexLock mu(self, *inferred_reg_category_maps_lock_);
STLDeleteValues(inferred_reg_category_maps_);
@@ -3334,7 +3334,7 @@
return (rejected_classes_->find(ref) != rejected_classes_->end());
}
-#if defined(ART_USE_LLVM_COMPILER) || defined(ART_USE_GREENLAND_COMPILER)
+#if defined(ART_USE_LLVM_COMPILER)
const greenland::InferredRegCategoryMap* MethodVerifier::GenerateInferredRegCategoryMap() {
uint32_t insns_size = code_item_->insns_size_in_code_units_;
uint16_t regs_size = code_item_->registers_size_;
diff --git a/src/verifier/method_verifier.h b/src/verifier/method_verifier.h
index 6765c10..42283a2 100644
--- a/src/verifier/method_verifier.h
+++ b/src/verifier/method_verifier.h
@@ -39,7 +39,7 @@
struct ReferenceMap2Visitor;
-#if defined(ART_USE_LLVM_COMPILER) || defined(ART_USE_GREENLAND_COMPILER)
+#if defined(ART_USE_LLVM_COMPILER)
namespace greenland {
class InferredRegCategoryMap;
} // namespace greenland
@@ -143,7 +143,7 @@
// The verifier
class MethodVerifier {
-#if defined(ART_USE_LLVM_COMPILER) || defined(ART_USE_GREENLAND_COMPILER)
+#if defined(ART_USE_LLVM_COMPILER)
typedef greenland::InferredRegCategoryMap InferredRegCategoryMap;
#endif
@@ -203,7 +203,7 @@
static void Init();
static void Shutdown();
-#if defined(ART_USE_LLVM_COMPILER) || defined(ART_USE_GREENLAND_COMPILER)
+#if defined(ART_USE_LLVM_COMPILER)
static const InferredRegCategoryMap* GetInferredRegCategoryMap(Compiler::MethodReference ref)
LOCKS_EXCLUDED(inferred_reg_category_maps_lock_);
#endif
@@ -554,7 +554,7 @@
// Get a type representing the declaring class of the method.
const RegType& GetDeclaringClass() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-#if defined(ART_USE_LLVM_COMPILER) || defined(ART_USE_GREENLAND_COMPILER)
+#if defined(ART_USE_LLVM_COMPILER)
/*
* Generate the inferred register category for LLVM-based code generator.
* Returns a pointer to a two-dimension Class array, or NULL on failure.
@@ -589,7 +589,7 @@
static Mutex* rejected_classes_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
static RejectedClassesTable* rejected_classes_;
-#if defined(ART_USE_LLVM_COMPILER) || defined(ART_USE_GREENLAND_COMPILER)
+#if defined(ART_USE_LLVM_COMPILER)
// All the inferred register category maps that the verifier has created.
typedef SafeMap<const Compiler::MethodReference,
const InferredRegCategoryMap*> InferredRegCategoryMapTable;